@types/d3-scale

call signature

(a: T, b: T): (t: number) => U;

• Construct a new interpolator function, based on the provided interpolation boundaries.

  Parameter a

  Start boundary of the interpolation interval.

  Parameter b

  End boundary of the interpolation interval.

method align

align: { (): number; (align: number): this };

• Returns the current alignment which defaults to 0.5.

• Sets the alignment to the specified value which must be in the range [0, 1].

  The default is 0.5.

  The alignment determines how any leftover unused space in the range is distributed. A value of 0.5 indicates that the outer patter should be equally distributed before the first band and after the last band; i.e., the bands should be centered within the range. A value of 0 or 1 may be used to shift the bands to one side, say to position them adjacent to an axis.

  Parameter align

  Value for alignment setting in [0, 1] interval.

method bandwidth

bandwidth: () => number;

• Returns the width of each band.

method copy

copy: () => this;

• Returns an exact copy of this scale. Changes to this scale will not affect the returned scale, and vice versa.

method domain

domain: { (): Domain[]; (domain: Iterable<Domain>): this };

• Returns to scale's current domain

• Sets the domain to the specified array of values. The first element in domain will be mapped to the first band, the second domain value to the second band, and so on. Domain values are stored internally in an InternMap from primitive value to index; the resulting index is then used to determine the band. Thus, a band scale’s values must be coercible to a primitive value, and the primitive domain value uniquely identifies the corresponding band.

  Parameter domain

  Array of domain values.

method padding

padding: { (): number; (padding: number): this };

• Returns the inner padding.

• A convenience method for setting the inner and outer padding to the same padding value.

  Parameter padding

  Value for inner and outer padding in [0, 1] interval.

method paddingInner

paddingInner: { (): number; (padding: number): this };

• Returns the current inner padding which defaults to 0.

• Sets the inner padding to the specified value which must be in the range [0, 1]. The inner padding determines the ratio of the range that is reserved for blank space between bands.

  The default setting is 0.

  Parameter padding

  Value for inner padding in [0, 1] interval.

method paddingOuter

paddingOuter: { (): number; (padding: number): this };

• Returns the current outer padding which defaults to 0.

• Sets the outer padding to the specified value which must be in the range [0, 1]. The outer padding determines the ratio of the range that is reserved for blank space before the first band and after the last band.

  The default setting is 0.

  Parameter padding

  Value for outer padding in [0, 1] interval.

method range

range: { (): [number, number]; (range: Iterable<NumberValue>): this };

• Returns the scale’s current range, which defaults to [0, 1].

• Sets the scale’s range to the specified two-element array of numbers. If the elements in the given array are not numbers, they will be coerced to numbers. The default range is [0, 1].

  Parameter range

  A two-element array of numeric values.

method rangeRound

rangeRound: (range: Iterable<NumberValue>) => this;

• Sets the scale’s range to the specified two-element array of numbers while also enabling rounding. If the elements in the given array are not numbers, they will be coerced to numbers.

  Rounding is sometimes useful for avoiding antialiasing artifacts, though also consider the shape-rendering “crispEdges” styles.

  Parameter range

  A two-element array of numeric values.

method round

round: { (): boolean; (round: boolean): this };

• Returns the current rounding status for the scale: enabled (= true) or disabled (= false).

• Enables or disables rounding accordingly. If rounding is enabled, the start and stop of each band will be integers. Rounding is sometimes useful for avoiding antialiasing artifacts, though also consider the shape-rendering “crispEdges” styles. Note that if the width of the domain is not a multiple of the cardinality of the range, there may be leftover unused space, even without padding! Use band.align to specify how the leftover space is distributed.

  Parameter round

  Enable rounding (= true), disable rounding (= false).

method step

step: () => number;

• Returns the distance between the starts of adjacent bands.

call signature

(x: Domain): number | undefined;

• Given a value in the input domain, returns the start of the corresponding band derived from the output range. If the given value is not in the scale’s domain, returns undefined.

  Parameter x

  A value from the domain.

method clamp

clamp: { (): boolean; (clamp: boolean): this };

• Returns whether or not the scale currently clamps values to within the range.

• Enables or disables clamping, respectively. If clamping is disabled and the scale is passed a value outside the domain, the scale may return a value outside the range through extrapolation.

  If clamping is enabled, the return value of the scale is always within the scale’s range. Clamping similarly applies to the "invert" method.

  Parameter clamp

  A flag to enable (true) or disable (false) clamping.

method copy

copy: () => this;

• Returns an exact copy of this scale. Changes to this scale will not affect the returned scale, and vice versa.

method domain

domain: { (): number[]; (domain: Iterable<NumberValue>): this };

• Returns a copy of the scale’s current domain.

• Sets the scale’s domain to the specified array of numbers. The array must contain two or more elements. If the elements in the given array are not numbers, they will be coerced to numbers

  Although continuous scales typically have two values each in their domain and range, specifying more than two values produces a piecewise scale.

  Internally, a piecewise scale performs a binary search for the range interpolator corresponding to the given domain value. Thus, the domain must be in ascending or descending order. If the domain and range have different lengths N and M, only the first min(N,M) elements in each are observed.

  Parameter domain

  Array of numeric domain values.

method invert

invert: (value: NumberValue) => number;

• Given a value from the range, returns the corresponding value from the domain. Inversion is useful for interaction, say to determine the data value corresponding to the position of the mouse.

  If the given value is outside the range, and clamping is not enabled, the mapping may be extrapolated such that the returned value is outside the domain.

  IMPORTANT: This method is only supported if the range is numeric. If the range is not numeric, returns NaN.

  For a valid value y in the range, continuous(continuous.invert(y)) approximately equals y; similarly, for a valid value x in the domain, continuous.invert(continuous(x)) approximately equals x. The scale and its inverse may not be exact due to the limitations of floating point precision.

  Parameter value

  A numeric value from the range.

method nice

nice: (count?: number) => this;

• Extends the domain so that it starts and ends on nice round values. This method typically modifies the scale’s domain, and may only extend the bounds to the nearest round value. An optional tick count argument allows greater control over the step size used to extend the bounds, guaranteeing that the returned ticks will exactly cover the domain. Nicing is useful if the domain is computed from data, say using extent, and may be irregular. For example, for a domain of [0.201479…, 0.996679…], a nice domain might be [0.2, 1.0]. If the domain has more than two values, nicing the domain only affects the first and last value.

  Nicing a scale only modifies the current domain; it does not automatically nice domains that are subsequently set using continuous.domain. You must re-nice the scale after setting the new domain, if desired.

  Parameter count

  An optional number of ticks expected to be used.

method range

range: { (): Range[]; (range: Iterable<Range>): this };

• Returns a copy of the scale’s current range.

• Sets the scale’s range to the specified array of values.

  The array must contain two or more elements. Unlike the domain, elements in the given array need not be numbers; any value that is supported by the underlying interpolator will work, though note that numeric ranges are required for invert.

  Parameter range

  Array of range values.

method rangeRound

rangeRound: (range: Iterable<NumberValue>) => this;

• Sets the scale’s range to the specified array of values while also setting the scale’s interpolator to interpolateRound.

  The rounding interpolator is sometimes useful for avoiding antialiasing artifacts, though also consider the shape-rendering “crispEdges” styles. Note that this interpolator can only be used with numeric ranges.

  The array must contain two or more elements. Unlike the domain, elements in the given array need not be numbers; any value that is supported by the underlying interpolator will work, though note that numeric ranges are required for invert.

  Parameter range

  Array of range values.

method tickFormat

tickFormat: (count?: number, specifier?: string) => (d: NumberValue) => string;

• Returns a number format function suitable for displaying a tick value, automatically computing the appropriate precision based on the fixed interval between tick values. The specified count should have the same value as the count that is used to generate the tick values.

  Parameter count

  Approximate number of ticks to be used when calculating precision for the number format function.

  Parameter specifier

  An optional valid format specifier string which allows a custom format where the precision of the format is automatically set by the scale as appropriate for the tick interval. If specifier uses the format type "s", the scale will return a SI-prefix format based on the largest value in the domain. If the specifier already specifies a precision, this method is equivalent to locale.format.

method ticks

ticks: (count?: number) => number[];

• Returns approximately count representative values from the scale’s domain.

  If count is not specified, it defaults to 10.

  The returned tick values are uniformly spaced, have human-readable values (such as multiples of powers of 10), and are guaranteed to be within the extent of the domain. Ticks are often used to display reference lines, or tick marks, in conjunction with the visualized data. The specified count is only a hint; the scale may return more or fewer values depending on the domain. See also d3-array’s ticks.

  Parameter count

  Optional approximate number of ticks to be returned. If count is not specified, it defaults to 10.

call signature

(value: NumberValue): Output | Unknown;

• Given a value from the domain, returns the corresponding value from the range, subject to interpolation, if any.

  If the given value is outside the domain, and clamping is not enabled, the mapping may be extrapolated such that the returned value is outside the range.

  Note: The interpolation function applied by the scale may change the output type from the range type as part of the interpolation.

  Parameter value

  A numeric value from the domain.

method clamp

clamp: { (): boolean; (clamp: boolean): this };

• Returns whether or not the scale currently clamps values to within the range.

• Enables or disables clamping, respectively. If clamping is disabled and the scale is passed a value outside the domain, the scale may return a value outside the range through extrapolation.

  If clamping is enabled, the return value of the scale is always within the interpolator scale’s range.

  Parameter clamp

  A flag to enable (true) or disable (false) clamping.

method copy

copy: () => this;

• Returns an exact copy of this scale. Changes to this scale will not affect the returned scale, and vice versa.

method domain

domain: { (): [number, number, number]; (domain: Iterable<NumberValue>): this };

• Returns a copy of the scale’s current domain.

• Sets the scale’s domain to the specified array of numbers. The domain must be numeric and must contain exactly three values. The default domain is [0, 0.5, 1]. If the elements in the given array are not numbers, they will be coerced to numbers

  Parameter domain

  Array of three numeric domain values.

method interpolator

interpolator: {
    (): (t: number) => Output;
    (interpolator?: (t: number) => Output): this;
};

• Returns the scale’s current interpolator.

• Sets the scale’s interpolator to the specified function.

  Parameter interpolator

  The scale’s interpolator.

method range

range: { (): () => [Output, Output, Output]; (range: Iterable<Output>): this };

• See continuous.range.

• See continuous.range. The given two-element array is converted to an interpolator function using d3.interpolate and d3.piecewise.

  Parameter range

  Range values.

method rangeRound

rangeRound: (range: Iterable<NumberValue>) => this;

• See continuous.rangeRound. If range is specified, implicitly uses d3.interpolateRound as the interpolator.

  Parameter range

  Range values.

method unknown

unknown: {
    (): UnknownReturnType<Unknown, undefined>;
    <NewUnknown>(value: NewUnknown): ScaleDiverging<Output, NewUnknown>;
};

• Returns the current unknown value, which defaults to undefined.

• Sets the output value of the scale for undefined (or NaN) input values and returns this scale.

  Parameter value

  The output value of the scale for undefined (or NaN) input values.

call signature

(value: NumberValue): Output | Unknown;

• Given a value from the domain, returns the corresponding value subject to interpolation.

  If the given value is outside the domain, and clamping is not enabled, the mapping may be extrapolated such that the returned value is outside the range.

  Parameter value

  A numeric value from the domain.

method copy

copy: () => this;

• Returns an exact copy of this scale. Changes to this scale will not affect the returned scale, and vice versa.

method domain

domain: { (): number[]; (domain: Iterable<NumberValue>): this };

• Returns a copy of the scale’s current domain.

• Sets the scale’s domain to the specified array of numbers. The array must contain two or more elements. If the elements in the given array are not numbers, they will be coerced to numbers

  Although continuous scales typically have two values each in their domain and range, specifying more than two values produces a piecewise scale.

  Internally, a piecewise scale performs a binary search for the range interpolator corresponding to the given domain value. Thus, the domain must be in ascending or descending order. If the domain and range have different lengths N and M, only the first min(N,M) elements in each are observed.

  Parameter domain

  Array of numeric domain values.

method invert

invert: (value: NumberValue) => number;

• Given a value from the range, returns the corresponding value from the domain. Inversion is useful for interaction, say to determine the data value corresponding to the position of the mouse.

  If the given value is outside the range, and clamping is not enabled, the mapping may be extrapolated such that the returned value is outside the domain.

  IMPORTANT: This method is only supported if the range is numeric. If the range is not numeric, returns NaN.

  For a valid value y in the range, continuous(continuous.invert(y)) approximately equals y; similarly, for a valid value x in the domain, continuous.invert(continuous(x)) approximately equals x. The scale and its inverse may not be exact due to the limitations of floating point precision.

  Parameter value

  A numeric value from the range.

method nice

nice: (count?: number) => this;

• Extends the domain so that it starts and ends on nice round values. This method typically modifies the scale’s domain, and may only extend the bounds to the nearest round value. An optional tick count argument allows greater control over the step size used to extend the bounds, guaranteeing that the returned ticks will exactly cover the domain. Nicing is useful if the domain is computed from data, say using extent, and may be irregular. For example, for a domain of [0.201479…, 0.996679…], a nice domain might be [0.2, 1.0]. If the domain has more than two values, nicing the domain only affects the first and last value.

  Nicing a scale only modifies the current domain; it does not automatically nice domains that are subsequently set using continuous.domain. You must re-nice the scale after setting the new domain, if desired.

  Parameter count

  An optional number of ticks expected to be used.

method range

range: { (): number[]; (range: Iterable<NumberValue>): this };

• Returns a copy of the scale’s current range.

• Sets the scale’s range to the specified array of values.

  The array must contain two or more elements. Unlike the domain, elements in the given array need not be numbers; any value that is supported by the underlying interpolator will work, though note that numeric ranges are required for invert.

  Parameter range

  Array of range values.

method tickFormat

tickFormat: (count?: number, specifier?: string) => (d: NumberValue) => string;

• Returns a number format function suitable for displaying a tick value, automatically computing the appropriate precision based on the fixed interval between tick values. The specified count should have the same value as the count that is used to generate the tick values.

  Parameter count

  Approximate number of ticks to be used when calculating precision for the number format function.

  Parameter specifier

  An optional valid format specifier string which allows a custom format where the precision of the format is automatically set by the scale as appropriate for the tick interval. If specifier uses the format type "s", the scale will return a SI-prefix format based on the largest value in the domain. If the specifier already specifies a precision, this method is equivalent to locale.format.

method ticks

ticks: (count?: number) => number[];

• Returns approximately count representative values from the scale’s domain.

  If count is not specified, it defaults to 10.

  The returned tick values are uniformly spaced, have human-readable values (such as multiples of powers of 10), and are guaranteed to be within the extent of the domain. Ticks are often used to display reference lines, or tick marks, in conjunction with the visualized data. The specified count is only a hint; the scale may return more or fewer values depending on the domain. See also d3-array’s ticks.

  Parameter count

  Optional approximate number of ticks to be returned. If count is not specified, it defaults to 10.

method unknown

unknown: {
    (): UnknownReturnType<Unknown, undefined>;
    <NewUnknown>(value: NewUnknown): ScaleIdentity<NewUnknown>;
};

• Returns the current unknown value, which defaults to undefined.

• Sets the output value of the scale for undefined (or NaN) input values and returns this scale.

  Parameter value

  The output value of the scale for undefined (or NaN) input values.

call signature

(value: NumberValue): number | Unknown;

• Given a value from the domain, returns the corresponding value from the range, subject to interpolation, if any.

  If the given value is outside the domain, and clamping is not enabled, the mapping may be extrapolated such that the returned value is outside the range.

  Note: The interpolation function applied by the scale may change the output type from the range type as part of the interpolation.

  Parameter value

  A numeric value from the domain.

method interpolate

interpolate: {
    (): InterpolatorFactory<any, any>;
    (interpolate: InterpolatorFactory<Range, Output>): this;
    <NewOutput>(interpolate: InterpolatorFactory<Range, NewOutput>): ScaleLinear<
        Range,
        NewOutput,
        Unknown
    >;
};

• Returns the scale’s current interpolator factory, which defaults to interpolate.

• Sets the scale’s range interpolator factory. This interpolator factory is used to create interpolators for each adjacent pair of values from the range; these interpolators then map a normalized domain parameter t in [0, 1] to the corresponding value in the range.

  Note: the default interpolator may reuse return values. For example, if the range values are objects, then the value interpolator always returns the same object, modifying it in-place. If the scale is used to set an attribute or style, this is typically acceptable (and desirable for performance); however, if you need to store the scale’s return value, you must specify your own interpolator or make a copy as appropriate.

  As part of the interpolation process the interpolated value from the range may be converted to a corresponding output value.

  Parameter interpolate

  An interpolation factory. The generics for Range and Output of the scale must correspond to the interpolation factory applied to the scale.

• Sets the scale’s range interpolator factory. This interpolator factory is used to create interpolators for each adjacent pair of values from the range; these interpolators then map a normalized domain parameter t in [0, 1] to the corresponding value in the range.

  Note: the default interpolator may reuse return values. For example, if the range values are objects, then the value interpolator always returns the same object, modifying it in-place. If the scale is used to set an attribute or style, this is typically acceptable (and desirable for performance); however, if you need to store the scale’s return value, you must specify your own interpolator or make a copy as appropriate.

  As part of the interpolation process the interpolated value from the range may be converted to a corresponding output value.

  The generic "NewOutput" can be used to change the scale to have a different output element type corresponding to the new interpolation factory.

  Parameter interpolate

  An interpolation factory. The generics for Range and Output of the scale must correspond to the interpolation factory applied to the scale.

method unknown

unknown: {
    (): UnknownReturnType<Unknown, undefined>;
    <NewUnknown>(value: NewUnknown): ScaleLinear<Range, Output, NewUnknown>;
};

• Returns the current unknown value, which defaults to undefined.

• Sets the output value of the scale for undefined (or NaN) input values and returns this scale.

  Parameter value

  The output value of the scale for undefined (or NaN) input values.

method base

base: { (): number; (base: number): this };

• Returns the current base, which defaults to 10.

• Sets the base for this logarithmic scale to the specified value.

method domain

domain: { (): number[]; (domain: Iterable<NumberValue>): this };

• Returns a copy of the scale’s current domain.

• Sets the scale’s domain to the specified array of numbers. The array must contain two or more elements. If the elements in the given array are not numbers, they will be coerced to numbers

  As log(0) = -∞, a log scale domain must be strictly-positive or strictly-negative; the domain must not include or cross zero. A log scale with a positive domain has a well-defined behavior for positive values, and a log scale with a negative domain has a well-defined behavior for negative values. (For a negative domain, input and output values are implicitly multiplied by -1.) The behavior of the scale is undefined if you pass a negative value to a log scale with a positive domain or vice versa.

  Although continuous scales typically have two values each in their domain and range, specifying more than two values produces a piecewise scale.

  Internally, a piecewise scale performs a binary search for the range interpolator corresponding to the given domain value. Thus, the domain must be in ascending or descending order. If the domain and range have different lengths N and M, only the first min(N,M) elements in each are observed.

  Parameter domain

  Array of numeric domain values.

method interpolate

interpolate: {
    (): InterpolatorFactory<any, any>;
    (interpolate: InterpolatorFactory<Range, Output>): this;
    <NewOutput>(
        interpolate: InterpolatorFactory<Range, NewOutput>
    ): ScaleLogarithmic<Range, NewOutput, Unknown>;
};

• Returns the scale’s current interpolator factory, which defaults to interpolate.

• Sets the scale’s range interpolator factory. This interpolator factory is used to create interpolators for each adjacent pair of values from the range; these interpolators then map a normalized domain parameter t in [0, 1] to the corresponding value in the range.

  Note: the default interpolator may reuse return values. For example, if the range values are objects, then the value interpolator always returns the same object, modifying it in-place. If the scale is used to set an attribute or style, this is typically acceptable (and desirable for performance); however, if you need to store the scale’s return value, you must specify your own interpolator or make a copy as appropriate.

  As part of the interpolation process the interpolated value from the range may be converted to a corresponding output value.

  Parameter interpolate

  An interpolation factory. The generics for Range and Output of the scale must correspond to the interpolation factory applied to the scale.

• Sets the scale’s range interpolator factory. This interpolator factory is used to create interpolators for each adjacent pair of values from the range; these interpolators then map a normalized domain parameter t in [0, 1] to the corresponding value in the range.

  Note: the default interpolator may reuse return values. For example, if the range values are objects, then the value interpolator always returns the same object, modifying it in-place. If the scale is used to set an attribute or style, this is typically acceptable (and desirable for performance); however, if you need to store the scale’s return value, you must specify your own interpolator or make a copy as appropriate.

  As part of the interpolation process the interpolated value from the range may be converted to a corresponding output value.

  The generic "NewOutput" can be used to change the scale to have a different output element type corresponding to the new interpolation factory.

  Parameter interpolate

  An interpolation factory. The generics for Range and Output of the scale must correspond to the interpolation factory applied to the scale.

method nice

nice: () => this;

• Extends the domain to integer powers of base. For example, for a domain of [0.201479…, 0.996679…], and base 10, the nice domain is [0.1, 1]. If the domain has more than two values, nicing the domain only affects the first and last value.

  Nicing a scale only modifies the current domain; it does not automatically nice domains that are subsequently set using continuous.domain. You must re-nice the scale after setting the new domain, if desired.

method tickFormat

tickFormat: (count?: number, specifier?: string) => (d: NumberValue) => string;

• Returns a number format function suitable for displaying a tick value, automatically computing the appropriate precision based on the fixed interval between tick values.

  The specified count typically has the same value as the count that is used to generate the tick values. If there are too many ticks, the formatter may return the empty string for some of the tick labels; however, note that the ticks are still shown. To disable filtering, specify a count of Infinity. When specifying a count, you may also provide a format specifier or format function. For example, to get a tick formatter that will display 20 ticks of a currency, say log.tickFormat(20, "$,f"). If the specifier does not have a defined precision, the precision will be set automatically by the scale, returning the appropriate format. This provides a convenient way of specifying a format whose precision will be automatically set by the scale.

  Parameter count

  Approximate number of ticks to be used when calculating precision for the number format function.

  Parameter specifier

  An optional valid format specifier string which allows a custom format where the precision of the format is automatically set by the scale as appropriate for the tick interval. For example, to get a tick formatter that will display 20 ticks of a currency, say log.tickFormat(20, "$,f"). If the specifier does not have a defined precision, the precision will be set automatically by the scale, returning the appropriate format. This provides a convenient way of specifying a format whose precision will be automatically set by the scale.

method ticks

ticks: (count?: number) => number[];

• Returns approximately count representative values from the scale’s domain.

  If count is not specified, it defaults to 10.

  If the base is an integer, the returned ticks are uniformly spaced within each integer power of base; otherwise, one tick per power of base is returned. The returned ticks are guaranteed to be within the extent of the domain. If the orders of magnitude in the domain is greater than count, then at most one tick per power is returned. Otherwise, the tick values are unfiltered, but note that you can use log.tickFormat to filter the display of tick labels.

  Parameter count

  Optional approximate number of ticks to be returned. If count is not specified, it defaults to 10.

method unknown

unknown: {
    (): UnknownReturnType<Unknown, undefined>;
    <NewUnknown>(value: NewUnknown): ScaleLogarithmic<Range, Output, NewUnknown>;
};

• Returns the current unknown value, which defaults to undefined.

• Sets the output value of the scale for undefined (or NaN) input values and returns this scale.

  Parameter value

  The output value of the scale for undefined (or NaN) input values.

method copy

copy: () => this;

• Returns an exact copy of this ordinal scale. Changes to this scale will not affect the returned scale, and vice versa.

method domain

domain: { (): Domain[]; (domain: Iterable<Domain>): this };

• Returns the scale's current domain.

• Sets the domain to the specified array of values.

  The first element in domain will be mapped to the first element in the range, the second domain value to the second range value, and so on.

  Domain values are stored internally in an InternMap from primitive value to index; the resulting index is then used to retrieve a value from the range. Thus, an ordinal scale’s values must be coercible to a primitive value, and the primitive domain value uniquely identifies the corresponding range value.

  Setting the domain on an ordinal scale is optional if the unknown value is implicit (the default). In this case, the domain will be inferred implicitly from usage by assigning each unique value passed to the scale a new value from the range. Note that an explicit domain is recommended to ensure deterministic behavior, as inferring the domain from usage will be dependent on ordering.

  Parameter domain

  Array of domain values.

method range

range: { (): Range[]; (range: Iterable<Range>): this };

• Returns the scale's current range.

• Sets the range of the ordinal scale to the specified array of values.

  The first element in the domain will be mapped to the first element in range, the second domain value to the second range value, and so on.

  If there are fewer elements in the range than in the domain, the scale will reuse values from the start of the range.

  Parameter range

  Array of range values.

method unknown

unknown: {
    (): UnknownReturnType<Unknown, { name: 'implicit' }>;
    <NewUnknown>(value: NewUnknown): NewUnknown extends { name: 'implicit' }
        ? ScaleOrdinal<Domain, Range, never>
        : ScaleOrdinal<Domain, Range, NewUnknown>;
};

• Returns the current unknown value, which defaults to "implicit".

• Sets the output value of the scale for unknown input values and returns this scale. The implicit value enables implicit domain construction. scaleImplicit can be used as a convenience to set the implicit value.

  Parameter value

  Unknown value to be used or scaleImplicit to set implicit scale generation.

call signature

(x: Domain): Range | Unknown;

• Given a value in the input domain, returns the corresponding value in the output range. If the given value is not in the scale’s domain, returns the unknown; or, if the unknown value is implicit (the default), then the value is implicitly added to the domain and the next-available value in the range is assigned to value, such that this and subsequent invocations of the scale given the same input value return the same output value.

  Parameter x

  A value from the domain.

method align

align: { (): number; (align: number): this };

• Returns the current alignment which defaults to 0.5.

• Sets the alignment to the specified value which must be in the range [0, 1].

  The alignment determines how any leftover unused space in the range is distributed. A value of 0.5 indicates that the leftover space should be equally distributed before the first point and after the last point; i.e., the points should be centered within the range. A value of 0 or 1 may be used to shift the points to one side, say to position them adjacent to an axis.

  The default value is 0.5.

  Parameter align

  Value for alignment setting in [0, 1] interval.

method bandwidth

bandwidth: () => number;

• Return 0.

method copy

copy: () => this;

• Returns an exact copy of this scale. Changes to this scale will not affect the returned scale, and vice versa.

method domain

domain: { (): Domain[]; (domain: Iterable<Domain>): this };

• Returns the scale's current domain.

• Sets the domain to the specified array of values. The first element in domain will be mapped to the first point, the second domain value to the second point, and so on. Domain values are stored internally in an InternMap from primitive value to index; the resulting index is then used to determine the point. Thus, a point scale’s values must be coercible to a primitive value, and the primitive domain value uniquely identifies the corresponding point.

  Parameter domain

  Array of domain values.

method padding

padding: { (): number; (padding: number): this };

• Returns the current outer padding which defaults to 0. The outer padding determines the ratio of the range that is reserved for blank space before the first point and after the last point.

• Sets the outer padding to the specified value which must be in the range [0, 1]. The outer padding determines the ratio of the range that is reserved for blank space before the first point and after the last point.

  The default is 0.

  Parameter padding

  Value for outer padding in [0, 1] interval.

method range

range: { (): [number, number]; (range: Iterable<NumberValue>): this };

• Returns the scale’s current range, which defaults to [0, 1].

• Sets the scale’s range to the specified two-element array of numbers. If the elements in the given array are not numbers, they will be coerced to numbers. The default range is [0, 1].

  Parameter range

  A two-element array of numeric values.

method rangeRound

rangeRound: (range: Iterable<NumberValue>) => this;

• Sets the scale’s range to the specified two-element array of numbers while also enabling rounding. If the elements in the given array are not numbers, they will be coerced to numbers.

  Rounding is sometimes useful for avoiding antialiasing artifacts, though also consider the shape-rendering “crispEdges” styles.

  Parameter range

  A two-element array of numeric values.

method round

round: { (): boolean; (round: boolean): this };

• Returns the current rounding status for the scale: enabled (= true) or disabled (= false).

• Enables or disables rounding accordingly. If rounding is enabled, the position of each point will be integers. Rounding is sometimes useful for avoiding antialiasing artifacts, though also consider the shape-rendering “crispEdges” styles. Note that if the width of the domain is not a multiple of the cardinality of the range, there may be leftover unused space, even without padding! Use point.align to specify how the leftover space is distributed.

  Parameter round

  Enable rounding (= true), disable rounding (= false).

method step

step: () => number;

• Returns the distance between the starts of adjacent points.

call signature

(x: Domain): number | undefined;

• Given a value in the input domain, returns the corresponding point derived from the output range. If the given value is not in the scale’s domain, returns undefined.

  Parameter x

  A value from the domain.

method exponent

exponent: { (): number; (exponent: number): this };

• If exponent is not specified, returns the current exponent, which defaults to 1. (Note that this is effectively a linear scale until you set a different exponent.)

• Sets the current exponent to the given numeric value. (Note that this is effectively a linear scale until you set a different exponent.)

method interpolate

interpolate: {
    (): InterpolatorFactory<any, any>;
    (interpolate: InterpolatorFactory<Range, Output>): this;
    <NewOutput>(interpolate: InterpolatorFactory<Range, NewOutput>): ScalePower<
        Range,
        NewOutput,
        Unknown
    >;
};

• Returns the scale’s current interpolator factory, which defaults to interpolate.

• Sets the scale’s range interpolator factory. This interpolator factory is used to create interpolators for each adjacent pair of values from the range; these interpolators then map a normalized domain parameter t in [0, 1] to the corresponding value in the range.

  Note: the default interpolator may reuse return values. For example, if the range values are objects, then the value interpolator always returns the same object, modifying it in-place. If the scale is used to set an attribute or style, this is typically acceptable (and desirable for performance); however, if you need to store the scale’s return value, you must specify your own interpolator or make a copy as appropriate.

  As part of the interpolation process the interpolated value from the range may be converted to a corresponding output value.

  Parameter interpolate

  An interpolation factory. The generics for Range and Output of the scale must correspond to the interpolation factory applied to the scale.

• Sets the scale’s range interpolator factory. This interpolator factory is used to create interpolators for each adjacent pair of values from the range; these interpolators then map a normalized domain parameter t in [0, 1] to the corresponding value in the range.

  Note: the default interpolator may reuse return values. For example, if the range values are objects, then the value interpolator always returns the same object, modifying it in-place. If the scale is used to set an attribute or style, this is typically acceptable (and desirable for performance); however, if you need to store the scale’s return value, you must specify your own interpolator or make a copy as appropriate.

  As part of the interpolation process the interpolated value from the range may be converted to a corresponding output value.

  The generic "NewOutput" can be used to change the scale to have a different output element type corresponding to the new interpolation factory.

  Parameter interpolate

  An interpolation factory. The generics for Range and Output of the scale must correspond to the interpolation factory applied to the scale.

method unknown

unknown: {
    (): UnknownReturnType<Unknown, undefined>;
    <NewUnknown>(value: NewUnknown): ScalePower<Range, Output, NewUnknown>;
};

• Returns the current unknown value, which defaults to undefined.

• Sets the output value of the scale for undefined (or NaN) input values and returns this scale.

  Parameter value

  The output value of the scale for undefined (or NaN) input values.

method copy

copy: () => this;

• Returns an exact copy of this scale. Changes to this scale will not affect the returned scale, and vice versa.

method domain

domain: { (): number[]; (domain: Iterable<NumberValue>): this };

• Returns the scale’s current domain.

• Sets the domain of the quantile scale to the specified set of discrete numeric values. The array must not be empty, and must contain at least one numeric value; NaN, null and undefined values are ignored and not considered part of the sample population.

  If the elements in the given array are not numbers, they will be coerced to numbers. A copy of the input array is sorted and stored internally.

  Parameter domain

  Array of domain values.

method invertExtent

invertExtent: (value: Range) => [number, number];

• Returns the extent of values in the domain [x0, x1] for the corresponding value in the range: the inverse of quantile. This method is useful for interaction, say to determine the value in the domain that corresponds to the pixel location under the mouse.

  Parameter value

  A value from the range.

method quantiles

quantiles: () => number[];

• Returns the quantile thresholds. If the range contains n discrete values, the returned array will contain n - 1 thresholds. Values less than the first threshold are considered in the first quantile; values greater than or equal to the first threshold but less than the second threshold are in the second quantile, and so on. Internally, the thresholds array is used with bisect to find the output quantile associated with the given input value.

method range

range: { (): Range[]; (range: Iterable<Range>): this };

• Returns the current range.

• Sets the discrete values in the range. The array must not be empty. The number of values in (the cardinality, or length, of) the range array determines the number of quantiles that are computed.

  For example, to compute quartiles, range must be an array of four elements such as [0, 1, 2, 3].

  Parameter range

  Array of range values.

method unknown

unknown: {
    (): UnknownReturnType<Unknown, undefined>;
    <NewUnknown>(value: NewUnknown): ScaleQuantile<Range, NewUnknown>;
};

• Returns the current unknown value, which defaults to undefined.

• Sets the output value of the scale for undefined (or NaN) input values and returns this scale.

  Parameter value

  The output value of the scale for undefined (or NaN) input values.

call signature

(value: NumberValue): Range | Unknown;