### 10.7 Converting `poly_int`s

A `poly_int<n, T>` can be constructed from up to n individual T coefficients, with the remaining coefficients being implicitly zero. In particular, this means that every `poly_int<n, T>` can be constructed from a single scalar T, or something compatible with T.

Also, a `poly_int<n, T>` can be constructed from a `poly_int<n, U>` if T can be constructed from U.

The following functions provide other forms of conversion, or test whether such a conversion would succeed.

value.is_constant ()

Return true if `poly_int` value is a compile-time constant.

value.is_constant (&c1)

Return true if `poly_int` value is a compile-time constant, storing it in c1 if so. c1 must be able to hold all constant values of value without loss of precision.

value.to_constant ()

Assert that value is a compile-time constant and return its value. When using this function, please add a comment explaining why the condition is known to hold (for example, because an earlier phase of analysis rejected non-constants).

value.to_shwi (&p2)

Return true if ‘poly_int<N, T>value can be represented without loss of precision as a ‘poly_int<N, `HOST_WIDE_INT`>’, storing it in that form in p2 if so.

value.to_uhwi (&p2)

Return true if ‘poly_int<N, T>value can be represented without loss of precision as a ‘poly_int<N, `unsigned HOST_WIDE_INT`>’, storing it in that form in p2 if so.

value.force_shwi ()

Forcibly convert each coefficient of ‘poly_int<N, T>value to `HOST_WIDE_INT`, truncating any that are out of range. Return the result as a ‘poly_int<N, `HOST_WIDE_INT`>’.

value.force_uhwi ()

Forcibly convert each coefficient of ‘poly_int<N, T>value to `unsigned HOST_WIDE_INT`, truncating any that are out of range. Return the result as a ‘poly_int<N, `unsigned HOST_WIDE_INT`>’.

wi::shwi (value, precision)

Return a `poly_int` with the same value as value, but with the coefficients converted from `HOST_WIDE_INT` to `wide_int`. precision specifies the precision of the `wide_int` cofficients; if this is wider than a `HOST_WIDE_INT`, the coefficients of value will be sign-extended to fit.

wi::uhwi (value, precision)

Like `wi::shwi`, except that value has coefficients of type `unsigned HOST_WIDE_INT`. If precision is wider than a `HOST_WIDE_INT`, the coefficients of value will be zero-extended to fit.

wi::sext (value, precision)

Return a `poly_int` of the same type as value, sign-extending every coefficient from the low precision bits. This in effect applies `wi::sext` to each coefficient individually.

wi::zext (value, precision)

Like `wi::sext`, but for zero extension.

poly_wide_int::from (value, precision, sign)

Convert value to a `poly_wide_int` in which each coefficient has precision bits. Extend the coefficients according to sign if the coefficients have fewer bits.

poly_offset_int::from (value, sign)

Convert value to a `poly_offset_int`, extending its coefficients according to sign if they have fewer bits than `offset_int`.

poly_widest_int::from (value, sign)

Convert value to a `poly_widest_int`, extending its coefficients according to sign if they have fewer bits than `widest_int`.