malachite_base/unsigned_polynomial/conversion/string/

to_string.rs

// Copyright © 2026 Mikhail Hogrefe
//
// This file is part of Malachite.
//
// Malachite is free software: you can redistribute it and/or modify it under the terms of the GNU
// Lesser General Public License (LGPL) as published by the Free Software Foundation; either version
// 3 of the License, or (at your option) any later version. See <https://www.gnu.org/licenses/>.

use crate::num::basic::unsigneds::PrimitiveUnsigned;
use crate::strings::latex::ToLatex;
use crate::strings::typst::ToTypst;
use crate::unsigned_polynomial::UnsignedPolynomial;
use crate::vars::xyz::XyzVars;
use crate::vars::{Var, VarScheme};
use core::fmt::{Debug, Display, Formatter, Result, Write};

// The languages a polynomial can be written in.
//
// They differ in only three places: how the variable is spelled, whether a coefficient and a
// variable need something between them, and how an exponent is attached. Everything else — which
// terms there are, what order they come in, and which parts of a term are left off — is the same,
// so one function writes all three.
#[derive(Clone, Copy, Eq, PartialEq)]
pub(crate) enum Language {
    Plain,
    Latex,
    Typst,
}

impl<T: PrimitiveUnsigned> UnsignedPolynomial<T> {
    // Writes a `UnsignedPolynomial<T>` whose variable is named by `var`, in one of three languages.
    //
    // The destination is anything that can be written to rather than a `Formatter`, since a
    // `Formatter` cannot be made outside a `fmt` method, and the `to_*_string_with` functions need
    // somewhere to write that is not one.
    pub(crate) fn write_with_var<W: Write, S: VarScheme + ?Sized>(
        &self,
        var: Var<'_, S>,
        language: Language,
        w: &mut W,
    ) -> Result {
        let coefficients = self.coefficients_asc();
        if coefficients.is_empty() {
            return w.write_str("0");
        }
        let mut first = true;
        for (exponent, coefficient) in coefficients.iter().enumerate().rev() {
            if *coefficient == T::ZERO {
                continue;
            }
            if first {
                first = false;
            } else {
                w.write_char('+')?;
            }
            if exponent == 0 {
                write!(w, "{coefficient}")?;
                continue;
            }
            // A coefficient of 1 is left off, as it is when a polynomial is written by hand.
            if *coefficient != T::ONE {
                write!(w, "{coefficient}")?;
                // Typeset, a coefficient sits right up against its variable, which is unambiguous
                // because the one is a number and the other is not. The plain form is read back
                // rather than typeset, and its `*` is what tells the two apart.
                if language == Language::Plain {
                    w.write_char('*')?;
                }
            }
            match language {
                Language::Plain => write!(w, "{var}")?,
                Language::Latex => write!(w, "{}", var.to_latex())?,
                Language::Typst => write!(w, "{}", var.to_typst())?,
            }
            if exponent != 1 {
                // An exponent of one digit holds together on its own; a longer one has to be
                // bracketed, or only its first digit would be raised. The plain form has no scripts
                // to begin with, so it writes the digits and nothing else.
                match language {
                    Language::Plain => write!(w, "^{exponent}")?,
                    _ if exponent < 10 => write!(w, "^{exponent}")?,
                    Language::Latex => write!(w, "^{{{exponent}}}")?,
                    Language::Typst => write!(w, "^({exponent})")?,
                }
            }
        }
        Ok(())
    }
}

impl<T: PrimitiveUnsigned> Display for UnsignedPolynomial<T> {
    /// Converts a [`UnsignedPolynomial`] to a [`String`].
    ///
    /// The variable is called `x`.
    /// [`to_string_with`](crate::polynomial::Polynomial::to_string_with) is the way to call it
    /// something else.
    ///
    /// The terms are written in order of decreasing degree and joined with `+`. A term is its
    /// coefficient, then `*`, then the variable, then `^` and the exponent; but a coefficient of 1
    /// is left off along with its `*`, an exponent of 1 is left off along with its `^`, and the
    /// constant term is its coefficient alone. The zero polynomial, which has no terms at all, is
    /// `0`.
    ///
    /// The syntax is the one [Azurite](https://github.com/mhogrefe/azurite) writes polynomials in,
    /// and holds no characters that [`char_is_reserved`](crate::vars::char_is_reserved) allows in a
    /// variable's name, so a polynomial can be read back whatever its variable is called.
    ///
    /// # Worst-case complexity
    /// $T(n) = O(n \log n \log\log n)$
    ///
    /// $M(n) = O(n \log n)$
    ///
    /// where $T$ is time, $M$ is additional memory, and $n$ is the sum of the bits of the
    /// coefficients.
    ///
    /// # Examples
    /// ```
    /// use core::str::FromStr;
    /// use malachite_base::unsigned_polynomial::UnsignedPolynomial;
    ///
    /// assert_eq!(
    ///     UnsignedPolynomial::<u64>::from_str("x^2+3*x+2")
    ///         .unwrap()
    ///         .to_string(),
    ///     "x^2+3*x+2"
    /// );
    /// assert_eq!(
    ///     UnsignedPolynomial::<u64>::from_str("0")
    ///         .unwrap()
    ///         .to_string(),
    ///     "0"
    /// );
    /// assert_eq!(
    ///     UnsignedPolynomial::<u64>::from_str("5")
    ///         .unwrap()
    ///         .to_string(),
    ///     "5"
    /// );
    /// assert_eq!(
    ///     UnsignedPolynomial::<u64>::from_str("x")
    ///         .unwrap()
    ///         .to_string(),
    ///     "x"
    /// );
    /// assert_eq!(
    ///     UnsignedPolynomial::<u64>::from_str("2*x^3")
    ///         .unwrap()
    ///         .to_string(),
    ///     "2*x^3"
    /// );
    ///
    /// // The terms come out in decreasing degree, whatever order they went in, and an exponent
    /// // of 1 is left off.
    /// assert_eq!(
    ///     UnsignedPolynomial::<u64>::from_str("2+3*x+x^2")
    ///         .unwrap()
    ///         .to_string(),
    ///     "x^2+3*x+2"
    /// );
    /// assert_eq!(
    ///     UnsignedPolynomial::<u64>::from_str("x^1")
    ///         .unwrap()
    ///         .to_string(),
    ///     "x"
    /// );
    /// ```
    #[inline]
    fn fmt(&self, f: &mut Formatter) -> Result {
        self.write_with_var(Var::new(&XyzVars, 0), Language::Plain, f)
    }
}

impl<T: PrimitiveUnsigned> Debug for UnsignedPolynomial<T> {
    /// Converts an [`UnsignedPolynomial`] to a [`String`].
    ///
    /// This is the same as the [`Display::fmt`] implementation, so that a collection of
    /// [`UnsignedPolynomial`]s is written the same way its elements are displayed.
    ///
    /// # Worst-case complexity
    /// $T(n) = O(n \log n \log\log n)$
    ///
    /// $M(n) = O(n \log n)$
    ///
    /// where $T$ is time, $M$ is additional memory, and $n$ is the sum of the bits of the
    /// coefficients.
    ///
    /// # Examples
    /// ```
    /// use core::str::FromStr;
    /// use malachite_base::strings::ToDebugString;
    /// use malachite_base::unsigned_polynomial::UnsignedPolynomial;
    ///
    /// let xs = vec![
    ///     UnsignedPolynomial::<u8>::from_str("x^2+3*x+2").unwrap(),
    ///     UnsignedPolynomial::<u8>::from_str("0").unwrap(),
    ///     UnsignedPolynomial::<u8>::from_str("5").unwrap(),
    /// ];
    /// assert_eq!(xs[0].to_debug_string(), "x^2+3*x+2");
    /// assert_eq!(xs[1].to_debug_string(), "0");
    /// assert_eq!(xs[2].to_debug_string(), "5");
    /// assert_eq!(xs.to_debug_string(), "[x^2+3*x+2, 0, 5]");
    /// ```
    #[inline]
    fn fmt(&self, f: &mut Formatter) -> Result {
        Display::fmt(self, f)
    }
}