densitty 0.8.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

densitty/smoothing.py

@@ -0,0 +1,315 @@
+"""Creation of 2-D density maps for (x,y) data"""
+
+import dataclasses
+import math
+from typing import Callable, Optional, Sequence
+
+from .axis import Axis
+from .binning import (
+    FullBinsArg,
+    calc_value_range,
+    expand_bins_arg,
+    histogram2d,
+    segment_interval,
+)
+from .util import FloatLike, ValueRange, make_decimal, partial_first, partial_second
+
+BareSmoothingFunc = Callable[[FloatLike, FloatLike], FloatLike]
+
+
+@dataclasses.dataclass
+class SmoothingFuncWithWidth:
+    """Smoothing function plus precalculated widths"""
+
+    func: BareSmoothingFunc
+    # Precalculated widths at certain fractional height (0.5 and 0.001):
+    precalc_widths: dict[FloatLike, tuple[FloatLike, FloatLike]]
+
+    def __call__(self, delta_x: FloatLike, delta_y: FloatLike) -> FloatLike:
+        return self.func(delta_x, delta_y)
+
+
+SmoothingFunc = BareSmoothingFunc | SmoothingFuncWithWidth
+
+
+def gaussian(
+    delta: tuple[FloatLike, FloatLike],
+    inv_cov: tuple[tuple[FloatLike, FloatLike], tuple[FloatLike, FloatLike]],
+):
+    """Unnormalized Gaussian
+    delta: vector of ((x - x0), (y - y0))
+    inv_cov: inverse covariance matrix (aka precision)
+    """
+    exponent = (
+        (delta[0] * delta[0] * inv_cov[0][0])
+        + 2 * (delta[0] * delta[1] * inv_cov[0][1])
+        + (delta[1] * delta[1] * inv_cov[1][1])
+    )
+    return math.exp(-exponent / 2)
+
+
+def gaussian_with_inv_cov(inv_cov) -> SmoothingFunc:
+    """Produce a kernel function for a Gaussian with specified inverse covariance"""
+
+    def out(delta_x: FloatLike, delta_y: FloatLike) -> FloatLike:
+        return gaussian((delta_x, delta_y), inv_cov)
+
+    return out
+
+
+def gaussian_with_sigmas(sigma_x, sigma_y) -> SmoothingFunc:
+    """Produce a kernel function for a Gaussian with specified X & Y widths"""
+    inv_cov = ((sigma_x**-2, 0), (0, sigma_y**-2))
+    return gaussian_with_inv_cov(inv_cov)
+
+
+def triangle(width_x, width_y) -> SmoothingFunc:
+    """Produce a kernel function for a 2-D triangle with specified width/height
+    This is much cheaper computationally than the Gaussian, and gives decent results.
+    It has the nice property that if the widths are multiples of the output "bin" size,
+    the total output weight is independent of the exact alignment of the output bins.
+    """
+
+    def out(delta_x: FloatLike, delta_y: FloatLike) -> FloatLike:
+        x_factor = max(0.0, width_x / 2 - abs(delta_x))
+        y_factor = max(0.0, width_y / 2 - abs(delta_y))
+        return x_factor * y_factor
+
+    return SmoothingFuncWithWidth(
+        out,
+        {
+            0.5: (width_x / 4, width_y / 4),
+            0.001: (width_x / 2, width_y / 2),
+        },
+    )
+
+
+def pick_kernel_bandwidth(
+    points: Sequence[tuple[FloatLike, FloatLike]],
+    bins: tuple[int, int],
+    ranges: Optional[tuple[Optional[ValueRange], Optional[ValueRange]]] = None,
+    smoothness: FloatLike = 3,
+    smooth_fraction: FloatLike = 0.5,
+) -> tuple[float, float]:
+    """Determine an 'optimal' width for a kernel based on histogram binning
+
+    Parameters
+    ----------
+    points: Sequence of X,Y points each should be (float, float)
+    bins: tuple(int, int)
+            expected output number of columns/rows in plot
+            so kernel will at least be on the order of one bin
+    ranges: optional tuple of ValueRanges
+            expected output plot range. Determined from data if unset.
+    smoothness: float
+            Number of points in a histogram bin that is deemed "smooth"
+            1: minumum smoothing. 3 gives reasonable results.
+    smooth_fraction: float (fraction 0.0..1.0)
+            fraction of non-zero bins that must have the desired smoothness
+            0.5 => median non-zero bin
+    """
+    if bins[0] <= 0 or bins[1] <= 0:
+        raise ValueError("Number of bins must be nonzero")
+
+    # we'll reduce the number of bins gradually until we get the right smoothness
+    # track the number of bins in each direction as a float, so we can maintain the
+    # aspect ratio without roundoff error accumulating:
+    float_bins: tuple[float, float] = bins
+
+    # bin_step: how much we reduce the # of bins by each iteration.
+    # 1.0 in the larger direction, a fraction in the smaller direction:
+    if bins[0] > bins[1]:
+        bin_step = (1.0, (bins[1] / bins[0]))
+    else:
+        bin_step = ((bins[0] / bins[1]), 1.0)
+    while bins[0] > 0 and bins[1] > 0:
+        binned, x_axis, y_axis = histogram2d(points, bins, ranges, align=False)
+        nonzero_bins = [b for row in binned for b in row if b > 0]
+        test_pos = int(len(nonzero_bins) * (1.0 - smooth_fraction))
+        test_val = sorted(nonzero_bins)[test_pos]
+        if test_val >= smoothness:
+            break
+        float_bins = (float_bins[0] - bin_step[0], float_bins[1] - bin_step[1])
+        bins = (round(float_bins[0]), round(float_bins[1]))
+    else:
+        # We never managed to get 'smoothness' per bin, so just give up and smooth a lot
+        float_bins = (1, 1)
+
+    x_width = float(x_axis.value_range.max - x_axis.value_range.min) / float_bins[0] / 4
+    y_width = float(y_axis.value_range.max - y_axis.value_range.min) / float_bins[1] / 4
+
+    return (x_width, y_width)
+
+
+def func_span(f: Callable, fractional_height: FloatLike):
+    """Calculate the half-width of function at specified height"""
+    maximum = f(0)
+    target = maximum * fractional_height
+    # variables 'upper' and 'lower' s.t. f(lower) > maximum/3 and f(upper) < maximum/2
+    lower, upper = 0.0, 1.0
+    # Interval might not contain target, so double 'upper' until it does
+    for _ in range(100):
+        if f(upper) <= target:
+            break
+        lower = upper
+        upper *= 2
+    else:
+        raise ValueError("Unable to compute kernel function half-width")
+
+    # If our initial interval did contain target, the interval may be orders of magnitude too large
+    # We'll bisect until 'lower' moves, then bisect 10 times more
+    iter_count = 0
+    for _ in range(100):
+        test = (lower + upper) / 2
+        if f(test) < target:
+            upper = test
+        else:
+            lower = test
+        if lower > 0:
+            iter_count += 1
+            if iter_count >= 10:
+                break
+    else:
+        raise ValueError("Unable to compute kernel function half-width")
+
+    return (lower + upper) / 2
+
+
+def func_width_at_height(f: SmoothingFunc, height_fraction: float) -> tuple[FloatLike, FloatLike]:
+    """Helper to calculate function width at a given fractional height."""
+    if isinstance(f, SmoothingFuncWithWidth) and height_fraction in f.precalc_widths:
+        return f.precalc_widths[height_fraction]
+    x_width = func_span(partial_first(f), height_fraction)
+    y_width = func_span(partial_second(f), height_fraction)
+    if isinstance(f, SmoothingFuncWithWidth):
+        f.precalc_widths[height_fraction] = (x_width, y_width)
+    return x_width, y_width
+
+
+def func_width_half_height(f: SmoothingFunc) -> tuple[FloatLike, FloatLike]:
+    """Provide the (half) width of the function at half height (HWHM)"""
+    return func_width_at_height(f, 0.5)
+
+
+def func_width(f: SmoothingFunc) -> tuple[FloatLike, FloatLike]:
+    """Provide the (half) width of the function where it becomes negligible
+
+    Note: here we're just finding where the function gets down to 1/1000 of max,
+    which neglects that the area scales with the radius from the function center,
+    so for very slowly decaying functions (1/r, say) we may be excluding a lot of total weight.
+    """
+    return func_width_at_height(f, 0.001)
+
+
+def smooth_to_bins(
+    points: Sequence[tuple[FloatLike, FloatLike]],
+    kernel: SmoothingFunc,
+    x_centers: Sequence[FloatLike],
+    y_centers: Sequence[FloatLike],
+) -> Sequence[Sequence[float]]:
+    """Generate smoothed/density values over a grid, given data points and a kernel
+
+    Parameters
+    ----------
+    points:  Sequence of (X,Y) tuples: the data points to smooth
+    kernel:  Smoothing Function
+    x_centers: Sequence of values: Centers of output columns
+    y_centers: Sequence of values: Centers of output rows
+    """
+    # pylint: disable=too-many-locals
+    x_ctr_f = [float(x) for x in x_centers]
+    y_ctr_f = [float(y) for y in y_centers]
+
+    out = [[0.0] * len(x_centers) for _ in range(len(y_centers))]
+
+    # Make the assumption that the bin centers are evenly spaced, so we can
+    # calculate bin position from index and vice versa
+    x_delta = x_ctr_f[1] - x_ctr_f[0]
+    y_delta = y_ctr_f[1] - y_ctr_f[0]
+
+    kernel_width = func_width(kernel)
+    # Find width of the kernel in terms of X/Y indexes of the centers:
+    kernel_width_di = (
+        round(kernel_width[0] / x_delta) + 1,
+        round(kernel_width[1] / y_delta) + 1,
+    )
+    for point in points:
+        p = (float(point[0]), float(point[1]))
+        min_xi = max(round((p[0] - x_ctr_f[0]) / x_delta) - kernel_width_di[0], 0)
+        min_yi = max(round((p[1] - y_ctr_f[0]) / y_delta) - kernel_width_di[1], 0)
+
+        for x_i, bin_x in enumerate(x_ctr_f[min_xi : min_xi + 2 * kernel_width_di[0]], min_xi):
+            for y_i, bin_y in enumerate(y_ctr_f[min_yi : min_yi + 2 * kernel_width_di[1]], min_yi):
+                out[y_i][x_i] += float(kernel((p[0] - bin_x), (p[1] - bin_y)))
+    return out
+
+
+def pad_range(range_unpadded: ValueRange, padding: FloatLike):
+    """Add padding to both sides of a ValueRange"""
+    range_padding = make_decimal(padding)
+    return ValueRange(range_unpadded.min - range_padding, range_unpadded.max + range_padding)
+
+
+def smooth2d(
+    points: Sequence[tuple[FloatLike, FloatLike]],
+    kernel: SmoothingFunc,
+    bins: FullBinsArg = None,
+    ranges: Optional[tuple[Optional[ValueRange], Optional[ValueRange]]] = None,
+    align=True,
+    **axis_args,
+) -> tuple[Sequence[Sequence[float]], Axis, Axis]:
+    """Smooth (x,y) points out into a 2-D Density plot
+
+    Parameters
+    ----------
+    points: Sequence of (X,Y) tuples: the points to smooth into "bins"
+    kernel: SmoothingFunc
+                Smoothing function, takes (delta_x, delta_y) and outputs value
+    bins: int or (int, int) or [float,...] or ([float,...], [float,...])
+                int: number of output rows & columns (default: 10)
+                (int,int): number of columns (X), rows (Y)
+                list[float]: Column/Row centers
+                (list[float], list[float]): column centers for X, column centers for Y
+                Default: binning.DEFAULT_NUM_BINS
+    ranges: Optional (ValueRange, ValueRange)
+                ((x_min, x_max), (y_min, y_max)) for the row/column centers if 'bins' is int
+                Default: take from data min/max, with buffer based on kernel width
+    align: bool (default: True)
+                pick bin edges at 'round' values if # of bins is provided
+    axis_args: Extra arguments to pass through to Axis constructor
+
+    returns: Sequence[Sequence[int]], (x-)Axis, (y-)Axis
+    """
+
+    _, num_bins, bin_centers = expand_bins_arg(bins)
+
+    if bin_centers and ranges:
+        # First and last bin centers imply a range, which may be inconsistent
+        # with the passed-in ranges. Only supply one or the other.
+        raise ValueError("Both 'ranges' and bin centers provided")
+
+    if bin_centers:
+        x_centers, y_centers = bin_centers
+    else:
+        # No centers, just number of bins, and maybe user-specified ranges
+        if ranges:
+            x_range, y_range = ranges
+        else:
+            x_range, y_range = None, None
+        # if we use a range based on the min/max of the data, we also
+        # include some padding based on the half-width of the kernel
+        padding = func_width_half_height(kernel)
+        if not x_range:
+            x_range = calc_value_range(tuple(x for x, _ in points))
+            x_range = pad_range(x_range, padding[0])
+        if not y_range:
+            y_range = calc_value_range(tuple(y for _, y in points))
+            y_range = pad_range(y_range, padding[1])
+
+        x_centers = segment_interval(num_bins[0], x_range, align)
+        y_centers = segment_interval(num_bins[1], y_range, align)
+
+    x_axis = Axis((x_centers[0], x_centers[-1]), values_are_edges=False, **axis_args)
+    y_axis = Axis((y_centers[0], y_centers[-1]), values_are_edges=False, **axis_args)
+
+    return (smooth_to_bins(points, kernel, x_centers, y_centers), x_axis, y_axis)

densitty/truecolor.py

@@ -1,5 +1,6 @@
 """ANSI "True color" (24b, 16M colors) support."""
 
+import operator
 import math
 
 from typing import Optional, Sequence
@@ -37,7 +38,7 @@ def _linear_rgb_to_rgb(channel):
 
 def _vector_transform(v, m):
     """Returns v * m, where v is a vector and m is a matrix (list of columns)."""
-    return [math.sumprod(v, col) for col in m]
+    return [sum(map(operator.mul, v, col)) for col in m]
 
 
 def _rgb_to_lab(rgb: Vec) -> Vec:

densitty/util.py

@@ -1,26 +1,27 @@
 """Utility functions."""
 
-from bisect import bisect_left
-from collections import namedtuple
-from decimal import Decimal
-import math
-from typing import Any, Protocol, Sequence, SupportsFloat
+from __future__ import annotations  # for pre-Python 3.12 compatibility
 
+import math
+import typing
 
-class FloatLike[T](SupportsFloat, Protocol):
-    """A Protocol that supports the arithmetic ops we require, and can convert to float"""
+from bisect import bisect_left
+from decimal import BasicContext, Decimal, DecimalTuple
+from fractions import Fraction
+from typing import Any, Callable, NamedTuple, Sequence
 
-    def __lt__(self, __other: T) -> bool: ...
-    def __add__(self, __other: Any) -> T: ...
-    def __sub__(self, __other: Any) -> T: ...
-    def __mul__(self, __other: Any) -> T: ...
-    def __truediv__(self, __other: Any) -> T: ...
-    def __abs__(self) -> T: ...
+# FloatLike and Vec are defined in the stubs file util.pyi for type checking
+# At runtime, define as Any so older Python versions don't choke:
+if not typing.TYPE_CHECKING:
+    FloatLike = Any
+    Vec = Any
 
 
-ValueRange = namedtuple("ValueRange", ["min", "max"])
+class ValueRange(NamedTuple):
+    """Encapsulates a range from min..max"""
 
-type Vec = Sequence[FloatLike]
+    min: Decimal
+    max: Decimal
 
 
 def clamp(x, min_x, max_x):
@@ -76,44 +77,97 @@ def nearest(stepwise: Sequence, x: float):
     return stepwise[clamped_idx]
 
 
-def decimal_value_range(v: ValueRange | Sequence):
-    """Produce a ValueRange containing Decimal values"""
-    return ValueRange(Decimal(v[0]), Decimal(v[1]))
+def make_decimal(x: FloatLike) -> Decimal:
+    """Turn a float into a decimal with reasonable precision,
+    avoiding things like 1.0000000000000002220446049250313080847263336181640625"""
+    if isinstance(x, Decimal):
+        return x
+    return BasicContext.create_decimal_from_float(float(x))
+
+
+def sanitize_decimals(values: Sequence[Decimal]) -> Sequence[Decimal]:
+    """Strip trailing "0"s if all values in the list have the trailing "0"s
+    So [1.000, 2.000] becomes [1, 2]"""
+    if not values:
+        return []
+
+    as_tuples = [v.as_tuple() for v in values]
+    cur_exponent = as_tuples[0].exponent
+    if not all(t.exponent == cur_exponent for t in as_tuples):
+        # inconsistent exponent: just return them as is
+        return values
+    while cur_exponent < 0 and all(t.digits[-1] == 0 for t in as_tuples):
+        # all values have a trailing 0. Remove, and add a leading 0 to prevent (0,) from vanishing:
+        as_tuples = [
+            DecimalTuple(t.sign, (0,) + t.digits[:-1], cur_exponent + 1) for t in as_tuples
+        ]
+        cur_exponent += 1
+
+    as_decimals = (Decimal(t) for t in as_tuples)
+
+    # zero values may be something like "0E8" or "0E-2". Make them just be "0":
+    return [d if d != 0 else Decimal(0) for d in as_decimals]
+
+
+def make_value_range(v: ValueRange | Sequence[FloatLike]) -> ValueRange:
+    """Produce a ValueRange from from something that may be a sequence of FloatLikes"""
+    return ValueRange(make_decimal(v[0]), make_decimal(v[1]))
+
+
+def partial_first(f: Callable[[FloatLike, FloatLike], FloatLike]) -> Callable:
+    """Equivalent to functools.partial, but works with Python 3.10"""
+
+    def out(x: FloatLike):
+        return f(x, 0)
+
+    return out
+
+
+def partial_second(f: Callable[[FloatLike, FloatLike], FloatLike]) -> Callable:
+    """Equivalent to functools.partial, but works with Python 3.10"""
+
+    def out(x: FloatLike):
+        return f(0, x)
+
+    return out
 
 
 def sfrexp10(value):
     """Returns sign, base-10 fraction (mantissa), and exponent.
-    i.e. (s, f, e) such that value = s * f * 10 ** e with 0 <= f < 1.0
+    i.e. (s, f, e) such that value = s * f * 10 ** e.
+    if f == 0 => value == 0, else 0.1 < f <= 1.0
     """
     if value == 0:
-        return 1, 0, -100
-
-    sign = -1 if value < 0 else 1
+        return 1, Fraction(0), -100
 
-    v = Decimal(abs(value))
-    exponent = v.adjusted() + 1
-    frac = v.scaleb(-exponent)  # scale frac's exponent to be 0
+    if value < 0:
+        sign = -1
+        value = -value
+    else:
+        sign = 1
 
-    return sign, frac, exponent
+    exp = math.ceil(math.log10(float(value)))
+    frac = (Fraction(value) / Fraction(10) ** exp).limit_denominator()
+    return sign, frac, exp
 
 
 round_fractions = (
-    Decimal(1) / Decimal(10),
-    Decimal(1) / Decimal(8),
-    Decimal(1) / Decimal(6),
-    Decimal(1) / Decimal(5),
-    Decimal(1) / Decimal(4),
-    Decimal(1) / Decimal(3),
-    Decimal(2) / Decimal(5),
-    Decimal(1) / Decimal(2),
-    Decimal(2) / Decimal(3),
-    Decimal(4) / Decimal(5),
-    Decimal(1),
+    Fraction(1, 10),
+    Fraction(1, 8),
+    Fraction(1, 6),
+    Fraction(1, 5),
+    Fraction(1, 4),
+    Fraction(1, 3),
+    Fraction(2, 5),
+    Fraction(1, 2),
+    Fraction(2, 3),
+    Fraction(4, 5),
+    Fraction(1, 1),
 )
 
 
 def round_up_ish(value, round_fracs=round_fractions):
-    """'Round' the value up to the next highest value in 'round_vals' times a multiple of 10
+    """'Round' the value up to the next highest value in 'round_fracs' times a multiple of 10
 
     Parameters
     ----------
@@ -121,114 +175,85 @@ def round_up_ish(value, round_fracs=round_fractions):
     round_vals: the allowable values (mantissa in base 10)
     return: the closest round_vals[i] * 10**N equal to or larger than 'value'
     """
-    sign, frac, exp = sfrexp10(value)
+    sign, frac_float, exp = sfrexp10(value)
 
     # if we're passed in a float that can't be represented in binary (say 0.1 or 0.2), it will be
-    # rounded up to the next representable float. Subtract the smallest possible value (ulp) to
-    # so that when we round up, it can match an exact Decimal("0.1") or such:
-    frac -= Decimal(math.ulp(frac))
+    # rounded up to the next representable float. Adjust to closest sensible fraction:
+    frac = Fraction(frac_float).limit_denominator()
 
     idx = bisect_left(round_fracs, frac)  # find index that this would be inserted before (>= frac)
     round_frac = round_fracs[idx]
 
-    return sign * round_frac.scaleb(exp)
+    return sign * round_frac * 10**exp
 
 
 def roundness(value):
     """Metric for how 'round' a value is. 10 is rounder than 1, is rounder than 1.1."""
 
-    # if value is a sequence, combine the roundness of all elements, prioritizing in order:
     if isinstance(value, Sequence):
-        out, weight = 0, 1
-        for v in value:
-            out += roundness(v) * weight
-            weight *= 0.99
-        return out
-
+        # return the average roundness of all elements, with a bonus for the size of the range
+        num = len(value)
+
+        if num > 1:
+            roundnesses = (roundness(v) for v in value)
+            mean = sum(roundnesses) / num
+            # give a bonus to sets that cover a longer interval
+            log_value_range = math.log(value[-1] - value[0])
+        else:
+            mean = roundness(value[0])
+            log_value_range = -1000  # as if we're covering a range of 10^-1000
+
+        # we want a small bonus to "roundness" if the range is bigger.
+        # Keep it small enough that 1..2 won't get expanded to 0.5..2, say
+        # log_value_range increases by ~0.3 for every doubling of range
+        # which is ~ the penalty for using 1/2 vs 1
+        return mean + log_value_range
+
+    # Just a single value, not a sequence:
     if value == 0:
         # 0 is the roundest value
         return 1000  # equivalent to roundness of 1e1000
-    _, frac, exp = sfrexp10(value)
 
-    round_frac = round(frac, 5)  # round to specific # of digits so we can interpret as fraction
+    if value < 0:
+        value = -value
+
+    exp = math.ceil(math.log10(float(value)))
+    frac = (Fraction(value) / Fraction(10) ** exp).limit_denominator()
+    # so frac is 1 for a multiple of 10, and <1 for non-multiples of 10
+
+    # penalties based on the denominator of 'frac' when expressed as a ratio:
     penalties = {
-        1.00000: 0.0,  # no penalty for multiples of 10
-        0.50000: 0.5,  # penalty for multiple of 5 vs multiple of 10
-        0.25000: 0.6,  # penalty for multiple of 4 vs multiple of 10
-        0.75000: 0.6,  #
-        Decimal("0.33333"): 0.7,  # penalty for multiple of 3 vs multiple of 10
-        Decimal("0.66667"): 0.7,  #
-        0.12500: 0.8,  # penalty for multiple of 8 vs multiple of 10
-        0.37500: 0.8,
-        0.62500: 0.8,
-        0.87500: 0.8,
+        1: 0,  # value is power of 10 (1eX)
+        2: 0.3,  # value is 5.0eX
+        5: 0.5,  # value is 2/4/6/8.0 eX
+        10: 1,  # x.1, x.3, x.7, x.9 eX
+        4: 1,  # x.25, x.75 eX
+        3: 1.2,  # x.333, x.666  TODO: figure out how these are being printed and limit digits
+        20: 1.2,  # x.05, x.15, x.35...
+        25: 1.8,  # x.04, x.08, ...
+        50: 1.8,  # x.02, x.06, ...
+        100: 2,  # x.01, ...
     }
 
-    if round_frac in penalties:
-        return exp - penalties[round_frac]
+    if frac.denominator in penalties:
+        return exp - penalties[frac.denominator]
 
-    # Ouch: our fractional part is just not nice, so maximally un-round:
-    return -1000  # equivalent to roundness of 1e-1000
+    # In case we have ticks like 1.001, 1.002, 1.003, try to account for number of digits required:
+    max_digits = 10
+    for digits in range(2, max_digits):
+        if 10**digits % frac.denominator == 0:
+            return exp - digits
 
-
-def most_round(values):
-    """Pick the most round of the input values. Ties go to the earliest."""
-    best_r = -1e100
-    best_v = 0
-    for v in values:
-        r = roundness(v)
-        if r > best_r:
-            best_r, best_v = r, v
-    return best_v
+    return exp - max_digits
 
 
-def pick_step_size(value_range, num_steps_hint, min_steps_per_label=1) -> tuple[Decimal, Decimal]:
-    """Try to pick a step size that gives nice round values for step positions.
-    For coming up with nice tick positions for an axis, and with nice bin sizes for binning.
-    For an axis, it is also useful to produce an interval between labeled ticks.
+def roundness_ordered(values):
+    """Returns values in order of decreasing roundness"""
+    d = {roundness(v): v for v in values}
+    for r in reversed(sorted(d)):
+        yield d[r]
 
-    Parameters
-    ----------
-    value_range: bounds of interval
-    num_steps_hint: approximate number of steps desired for the interval
-    min_steps_per_label: for use with axis/label generation, as labels take more space than ticks
-    return: step size, interval between labeled steps/ticks
-    """
-    num_steps_hint = max(1, num_steps_hint)
-    # if steps are 0,1,2,3,4,5,6... or 0,2,4,6,8,10,... steps_per_label of 5 is sensible,
-    # if steps are 0,5,10,15,20,... steps_per_label of 4 is sensible
-    nominal_step = (value_range.max - value_range.min) / num_steps_hint
-
-    # Figure out the order-of-magnitude (power of 10), aka "decade" of the steps:
-    log_nominal = math.log10(nominal_step)
-    log_decade = math.floor(log_nominal)  # i.e. # of digits
-    decade = Decimal(10) ** log_decade
-
-    # Now figure out where in that decade we are, so we can pick the closest 1/2/5 value
-    log_frac = log_nominal - log_decade  # remainder after decade taken out
-    frac = 10**log_frac  # i.e. fraction through the decade (shift decimal point to front)
-
-    # common-case: label every or every-other, or every 5th, or every 10th
-    if min_steps_per_label <= 2:
-        steps_per_label = min_steps_per_label
-    elif min_steps_per_label <= 5:
-        steps_per_label = 5
-    else:
-        steps_per_label = max(min_steps_per_label, 10)
-
-    if frac < 1.1:
-        step = decade
-    elif frac < 2.2:
-        step = 2 * decade
-        # Steps of .2, don't label every other one
-        if steps_per_label == 2:
-            steps_per_label = 5
-    elif frac < 5.5:
-        step = 5 * decade
-        # ticks every .5, don't label every 5th
-        if steps_per_label == 5:
-            steps_per_label = max(round(min_steps_per_label / 2) * 2, 6)
-    else:
-        step = 10 * decade
 
-    return step, step * steps_per_label
+def most_round(values):
+    """Pick the most round of the input values."""
+    return next(roundness_ordered(values))