Struct Fixed 

pub struct Fixed<F: FixedSigned>(/* private fields */);

Wraps a signed fixed-point number. All operations are saturating so that the underlying representation’s minimum and maximum values are able to stand in for -∞ and +∞.

Implementations

impl<F: FixedSigned> Fixed<F>

pub const MAX: Self

pub const MIN: Self

pub fn from_num<Src: ToFixed>(src: Src) -> Self

Examples found in repository

examples/fixed.rs (line 20)

fn layout_paragraph<'a, P: ParagraphLayout<(), (), (), F>>(
    paragraph: &'a str,
    layout: &P,
    max_width: F,
) -> Vec<&'a str> {
    // Process the paragraph into its items.
    let mut items = Vec::new();
    for c in paragraph.chars() {
        items.push(if c.is_whitespace() && items.len() != 0 {
            Item::Glue {
                width: F::from_num(1),
                stretch: F::from_num(1),
                shrink: F::from_num(0),
                data: (),
            }
        } else {
            Item::Box {
                width: F::from_num(1),
                data: (),
            }
        });
    }
    items.push(Item::Glue {
        width: F::from_num(0),
        stretch: F::MAX,
        shrink: F::from_num(0),
        data: (),
    });
    items.push(Item::Penalty {
        width: F::from_num(0),
        cost: F::MIN,
        flagged: true,
        data: (),
    });

    // Calculate the paragraph's breaks.
    let breaks = layout.layout_paragraph(&items, max_width);

    // Render the laid-out paragraph using the break positions.
    let mut cursor = 0;
    let mut lines = Vec::new();
    let mut start = 0;
    for (i, _) in paragraph.chars().enumerate() {
        if i == breaks[cursor].break_at {
            lines.push(&paragraph[start..i]);
            start = i + 1;
            cursor += 1;
        }
    }
    lines.push(&paragraph[start..]);
    lines
}

fn layout_text() -> Result<String, fmt::Error> {
    let text = "  Far out in the uncharted backwaters of the unfashionable end of the western spiral arm of the Galaxy lies a small unregarded yellow sun. Orbiting this at a distance of roughly ninety-two million miles is an utterly insignificant little blue-green planet whose ape-descended life forms are so amazingly primitive that they still think digital watches are a pretty neat idea.";
    let knuth_plass = KnuthPlass::new().with_threshold(F::MAX);
    let lines = layout_paragraph(&text, &knuth_plass, F::from_num(80));
    let mut result = String::new();
    writeln!(&mut result, "┏{}┓", "━".repeat(80))?;
    for l in lines {
        let pad = 80 - l.chars().count();
        writeln!(&mut result, "┃{}{}┃", l, " ".repeat(pad))?;
    }
    writeln!(&mut result, "┗{}┛", "━".repeat(80))?;
    Ok(result)
}

Trait Implementations

impl<F: FixedSigned> Add for Fixed<F>

type Output = Fixed<F>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<F: FixedSigned> AddAssign for Fixed<F>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<F: Clone + FixedSigned> Clone for Fixed<F>

fn clone(&self) -> Fixed<F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: FixedSigned> Debug for Fixed<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<F: Default + FixedSigned> Default for Fixed<F>

fn default() -> Fixed<F>

Returns the “default value” for a type.

impl<F: FixedSigned> Div for Fixed<F>

type Output = Fixed<F>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self

Performs the / operation.

impl<F: FixedSigned> Mul for Fixed<F>

type Output = Fixed<F>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl<F: FixedSigned> Num for Fixed<F>

const INFINITY: Self = Self::MAX

const NEG_INFINITY: Self = Self::MIN

fn from(i: i16) -> Self

fn abs(self) -> Self

fn powi(self, y: u32) -> Self

fn rat(num: i16, denom: i16) -> Self

impl<F: FixedSigned> PartialEq for Fixed<F>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F: FixedSigned> PartialOrd for Fixed<F>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<F: FixedSigned> Sub for Fixed<F>

type Output = Fixed<F>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<F: FixedSigned> SubAssign for Fixed<F>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<F: Copy + FixedSigned> Copy for Fixed<F>