scale

type Linear struct {
	// Min and Max specify the lower and upper bounds of the input
	// domain. The input domain [Min, Max] will be linearly mapped
	// to the output range [0, 1].
	Min, Max float64

	// Base specifies a base for computing ticks. Ticks will be
	// placed at powers of Base; that is at n*Base^l for n ∈ ℤ and
	// some integer tick level l. As a special case, a base of 0
	// alternates between ticks at n*10^⌊l/2⌋ and ticks at
	// 5n*10^⌊l/2⌋.
	Base int

	// If Clamp is true, the input is clamped to [Min, Max].
	Clamp bool
}

type Log struct {

	// Min and Max specify the lower and upper bounds of the input
	// domain. The input range [Min, Max] will be mapped to the
	// output range [0, 1]. The range [Min, Max] must not include
	// 0.
	Min, Max float64

	// Base specifies the base of the logarithm for computing
	// ticks. Ticks will be placed at Base^((2^l)*n) for tick
	// level l ∈ ℕ and n ∈ ℤ. Typically l is 0, in which case this
	// is simply Base^n.
	Base int

	// If Clamp is true, the input is clamped to [Min, Max].
	Clamp bool
	// contains filtered or unexported fields
}

type QQ struct {
	Src, Dest Quantitative
}

type Quantitative interface {
	// Map maps from a value x in the input domain to [0, 1]. If x
	// is outside the input domain and clamping is enabled, x will
	// first be clamped to the input domain.
	Map(x float64) float64

	// Unmap is the inverse of Map. That is, if x is in the input
	// domain or clamping is disabled, x = Unmap(Map(x)). If
	// clamping is enabled and y is outside [0,1], the results are
	// undefined.
	Unmap(y float64) float64

	// SetClamp sets the clamping mode of this scale.
	SetClamp(bool)

	// Ticks returns major and minor ticks that satisfy the
	// constraints given by o. These ticks will have "nice" values
	// within the input domain. Both arrays are sorted in
	// ascending order and minor includes ticks in major.
	Ticks(o TickOptions) (major, minor []float64)

	// Nice expands the input domain of this scale to "nice"
	// values for covering the input domain satisfying the
	// constraints given by o. After calling Nice(o), the first
	// and last major ticks returned by Ticks(o) will equal the
	// lower and upper bounds of the input domain.
	Nice(o TickOptions)

	// A Quantitative scale is also a Ticker.
	Ticker
}

type RangeErr string

type TickOptions struct {
	// Max is the maximum number of major ticks to return.
	Max int

	// MinLevel and MaxLevel are the minimum and maximum tick
	// levels to accept, respectively. If they are both 0, there is
	// no limit on acceptable tick levels.
	MinLevel, MaxLevel int
}

type Ticker interface {
	// CountTicks returns the number of ticks at level in this
	// scale's input range. This is equivalent to
	// len(TicksAtLevel(level)), but should be much more
	// efficient. CountTicks is a weakly monotonically decreasing
	// function of level.
	CountTicks(level int) int

	// TicksAtLevel returns a slice of "nice" tick values in
	// increasing order at level in this scale's input range.
	// Typically, TicksAtLevel(l+1) is a subset of
	// TicksAtLevel(l). That is, higher levels remove ticks from
	// lower levels.
	TicksAtLevel(level int) interface{}
}