@spec log({number(), number()}, keyword()) :: [float()]

Minor breaks for a logarithmic axis over the limits {low, high}, R's minor_breaks_log(): the powers of ten from one below the low limit's to one above the high limit's, then five times each, then each whole multiple from 2 to 9 of each but 5, as detail: asks, in that order, as R gives them.

Where a limit is 0 or below, the powers run from ten times smallest: to the larger limit's size, each kept from smallest: up and given either side of 0, the positive first, with 0 itself after the powers. The result may reach past the limits; which to keep is the caller's. Limits both 0 have no powers to span, and are refused, where R fails.

Options

• :detail - Which values to give, R's detail: the powers of ten (10), those and five times each (5), or every whole multiple of each from 1 to 9 (1); :auto chooses by the powers the limits span, 1 over 8 or fewer, 5 over 15 or fewer, else 10. The default value is :auto.

• :smallest - Where limits reach 0 or below, the smallest size of value given either side of 0, R's smallest, a finite number from 1.0e-100; :auto is a tenth of the largest limit's size, 0.1 at most. The default value is :auto.

Examples

iex> Scales.MinorBreaks.log({1.0, 100.0}, detail: 5)
[0.1, 1.0, 10.0, 100.0, 1000.0, 0.5, 5.0, 50.0, 500.0, 5000.0]

iex> Scales.MinorBreaks.log({-10.0, 10.0}, detail: 10, smallest: 1)
[1.0, 10.0, 100.0, -1.0, -10.0, -100.0, 0.0]

@spec n({number(), number()}, [number(), ...], non_neg_integer()) :: [float()]

count minor breaks to each gap, its ends included, on an axis showing the limits {low, high} with breaks, R's minor_breaks_n(): from the low limit to the first break, between each pair of neighbouring breaks in the order given, and from the last break to the high limit, each gap spread evenly as R's seq() spreads it (Scales.Palette.spread/2), a value laid twice kept the first time.

The result may reach past the limits, as breaks may; which to keep is the caller's. It takes numbers alone: a fraction of a day is no date.

Examples

iex> Scales.MinorBreaks.n({0.5, 9.5}, [2.0, 4.0, 6.0, 8.0], 3)
[0.5, 1.25, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 8.75, 9.5]

@spec regular([float()], {float(), float()}, keyword()) :: [float()]

The minor breaks between breaks on an axis showing the limits {low, high}, R's regular_minor_breaks(): each gap between neighbouring breaks, in the order given, gets a minor break at its middle, the gap's start plus half its width, as R's seq() finds it. Where the limits reach past the breaks at an end, the breaks are first extended by one more step there, the first gap's, so minor breaks can fall between the outermost break and the edge of the axis.

The result holds the breaks themselves and the added steps too, as R's does, and may reach past the limits; which to keep is the caller's. Fewer than two breaks have no gap, and so no minor breaks.

Options

• :reverse (boolean/0) - Whether the breaks run from high to low, as a reversing transformation's do, so the step added before the first break goes above it and the one after the last below it. The default value is false.

Examples

iex> Scales.MinorBreaks.regular([10.0, 20.0, 30.0], {5.0, 35.0})
[0.0, 5.0, 10.0, 15.0, 20.0, 25.0, 30.0, 35.0, 40.0]

iex> Scales.MinorBreaks.regular([30.0, 20.0, 10.0], {5.0, 35.0}, reverse: true)
[40.0, 35.0, 30.0, 25.0, 20.0, 15.0, 10.0, 5.0, 0.0]

@spec width(
  {Scales.Breaks.value(), Scales.Breaks.value()},
  [Scales.Breaks.value(), ...],
  number() | Scales.Breaks.step(),
  keyword()
) :: [Scales.Breaks.value()]

Minor breaks width apart in each gap, on an axis showing the limits {low, high} with breaks, R's minor_breaks_width(): Scales.Breaks.width/3's breaks over the low limit and the first break, each pair of neighbouring breaks in the order given, and the last break and the high limit, a value laid twice kept the first time.

It takes what Scales.Breaks.width/3 takes, numbers, dates, date-times or times of day, with width a number or a step of one unit, and gives the same, where R gives a date's days or a date-time's seconds. Its options are Scales.Breaks.width/3's, offset: 0 or no steps unless given, where R has no default. The result may reach past the limits, as breaks may; which to keep is the caller's.

Examples

iex> Scales.MinorBreaks.width({0.5, 9.5}, [2.0, 4.0, 6.0, 8.0], 2, offset: 0.5)
[0.5, 2.5, 4.5, 6.5, 8.5, 10.5]

iex> Scales.MinorBreaks.width({~D[2026-01-01], ~D[2026-01-25]}, [~D[2026-01-15]], week: 1)
[~D[2025-12-29], ~D[2026-01-05], ~D[2026-01-12], ~D[2026-01-19], ~D[2026-01-26]]