# Function textwrap::core::wrap_optimal_fit[−][src]

`pub fn wrap_optimal_fit<'a, T: Fragment, F: Fn(usize) -> usize>(    fragments: &'a [T],     line_widths: F) -> Vec<&'a [T]>`

Wrap abstract fragments into lines with an optimal-fit algorithm.

The `line_widths` map line numbers (starting from 0) to a target line width. This can be used to implement hanging indentation.

The fragments must already have been split into the desired widths, this function will not (and cannot) attempt to split them further when arranging them into lines.

# Optimal-Fit Algorithm

The algorithm considers all possible break points and picks the breaks which minimizes the gaps at the end of each line. More precisely, the algorithm assigns a cost or penalty to each break point, determined by `cost = gap * gap` where `gap = target_width - line_width`. Shorter lines are thus penalized more heavily since they leave behind a larger gap.

We can illustrate this with the text “To be, or not to be: that is the question”. We will be wrapping it in a narrow column with room for only 10 characters. The greedy algorithm will produce these lines, each annotated with the corresponding penalty:

``````"To be, or"   1² =  1
"not to be:"  0² =  0
"that is"     3² =  9
"the"         7² = 49
"question"    2² =  4
``````

We see that line four with “the” leaves a gap of 7 columns, which gives it a penalty of 49. The sum of the penalties is 63.

There are 10 words, which means that there are `2_u32.pow(9)` or 512 different ways to typeset it. We can compute the sum of the penalties for each possible line break and search for the one with the lowest sum:

``````"To be,"     4² = 16
"or not to"  1² =  1
"be: that"   2² =  4
"is the"     4² = 16
"question"   2² =  4
``````

The sum of the penalties is 41, which is better than what the greedy algorithm produced.

Searching through all possible combinations would normally be prohibitively slow. However, it turns out that the problem can be formulated as the task of finding column minima in a cost matrix. This matrix has a special form (totally monotone) which lets us use a linear-time algorithm called SMAWK to find the optimal break points.

This means that the time complexity remains O(n) where n is the number of words. Compared to `wrap_first_fit`, this function is about 4 times slower.

The optimization of per-line costs over the entire paragraph is inspired by the line breaking algorithm used in TeX, as described in the 1981 article Breaking Paragraphs into Lines by Knuth and Plass. The implementation here is based on Python code by David Eppstein.

Note: Only available when the `smawk` Cargo feature is enabled.