rename to quantize

Author: mbostock

docs/.vitepress/config.ts

@@ -111,6 +111,7 @@ export default defineConfig({
           {text: "Interval", link: "/transforms/interval"},
           {text: "Map", link: "/transforms/map"},
           {text: "Normalize", link: "/transforms/normalize"},
+          {text: "Quantize", link: "/transforms/quantize"},
           {text: "Select", link: "/transforms/select"},
           {text: "Sort", link: "/transforms/sort"},
           {text: "Stack", link: "/transforms/stack"},

docs/transforms/group.md

@@ -16,7 +16,7 @@ onMounted(() => {
 # Group transform
 
 :::tip
-The group transform is for aggregating ordinal or nominal data. For quantitative or temporal data, use the [bin transform](./bin.md), or use the [interval transform](./interval.md) to make continuous data ordinal.
+The group transform is for aggregating ordinal or nominal data. For quantitative or temporal data, use the [bin transform](./bin.md), or use the [quantize transform](./quantize.md) to make continuous data ordinal.
 :::
 
 The **group transform** groups ordinal or nominal data—discrete values such as name, type, or category. You can then compute summary statistics for each group, such as a count, sum, or proportion. The group transform is most often used to make bar charts with the [bar mark](../marks/bar.md).
@@ -310,14 +310,14 @@ Plot.plot({
 Although barX applies an implicit stackX transform, [textX](../marks/text.md) does not; this example uses an explicit stackX transform in both cases for clarity, and to pass the additional **order** and **reverse** options to place the largest sport on the left. The [filter transform](./filter.md) is applied after the stack transform to hide the labels on the smallest sports where the bars are too thin.
 :::
 
-While you should generally use the [bin transform](./bin.md) for quantitative or temporal data, you can use the [group transform](./group.md) if you also use the [interval transform](./interval.md) to make the data ordinal.
+While you should generally use the [bin transform](./bin.md) for quantitative or temporal data, you can use the [group transform](./group.md) if you also use the [quantize transform](./quantize.md) to make the data ordinal.
 
 :::plot defer
 ```js
 Plot.plot({
   x: {tickFormat: "%Y"},
   marks: [
-    Plot.barY(olympians, Plot.groupX({y: "count"}, Plot.intervalX(d3.utcYear.every(5), {x: "date_of_birth"})))
+    Plot.barY(olympians, Plot.groupX({y: "count"}, Plot.quantizeX(d3.utcYear.every(5), {x: "date_of_birth"})))
   ]
 })
 ```

docs/transforms/quantize.md

@@ -0,0 +1,7 @@
+# Quantize transform
+
+:::tip
+There’s also an [**interval** scale option](../features/scales.md#scale-transforms) for quantizing continuous data.
+:::
+
+TODO Describe the **quantize transform**.

src/index.d.ts

@@ -45,9 +45,9 @@ export * from "./transforms/centroid.js";
 export * from "./transforms/dodge.js";
 export * from "./transforms/group.js";
 export * from "./transforms/hexbin.js";
-export * from "./transforms/interval.js";
 export * from "./transforms/map.js";
 export * from "./transforms/normalize.js";
+export * from "./transforms/quantize.js";
 export * from "./transforms/select.js";
 export * from "./transforms/stack.js";
 export * from "./transforms/tree.js";

src/index.js

@@ -33,10 +33,10 @@ export {centroid, geoCentroid} from "./transforms/centroid.js";
 export {dodgeX, dodgeY} from "./transforms/dodge.js";
 export {group, groupX, groupY, groupZ} from "./transforms/group.js";
 export {hexbin} from "./transforms/hexbin.js";
-export {intervalX, intervalY, intervalMap} from "./transforms/interval.js";
 export {normalize, normalizeX, normalizeY} from "./transforms/normalize.js";
 export {map, mapX, mapY} from "./transforms/map.js";
 export {window, windowX, windowY} from "./transforms/window.js";
+export {quantizeX, quantizeY, quantizeMap} from "./transforms/quantize.js";
 export {select, selectFirst, selectLast, selectMaxX, selectMaxY, selectMinX, selectMinY} from "./transforms/select.js";
 export {stackX, stackX1, stackX2, stackY, stackY1, stackY2} from "./transforms/stack.js";
 export {treeNode, treeLink} from "./transforms/tree.js";

src/transforms/interval.js

@@ -1,28 +1,5 @@
 import {isTemporal, labelof, map, maybeInterval, maybeValue, valueof} from "../options.js";
 import {maybeInsetX, maybeInsetY} from "./inset.js";
-import {mapX, mapY} from "./map.js";
-
-export function intervalX(interval, options) {
-  if (arguments.length === 1) ({interval, ...options} = interval);
-  return mapX(intervalMap(interval), options);
-}
-
-export function intervalY(interval, options) {
-  if (arguments.length === 1) ({interval, ...options} = interval);
-  return mapY(intervalMap(interval), options);
-}
-
-export function intervalMap(interval, type) {
-  interval = maybeInterval(interval, type);
-  return {
-    mapIndex(I, S, T) {
-      T.interval = interval; // hint for scales
-      for (let i = 0, n = I.length; i < n; ++i) {
-        T[I[i]] = interval.floor(S[I[i]]);
-      }
-    }
-  };
-}
 
 // The interval may be specified either as x: {value, interval} or as {x,
 // interval}. The former can be used to specify separate intervals for x and y,

src/transforms/interval.d.ts renamed to src/transforms/quantize.d.ts

@@ -2,8 +2,8 @@ import type {Interval} from "../interval.js";
 import type {Transformed} from "./basic.js";
 import type {Map} from "./map.js";
 
-/** Options for the interval transform. */
-export interface IntervalOptions {
+/** Options for the quantize transform. */
+export interface QuantizeOptions {
   /**
    * How to quantize the continuous data; one of:
    *
@@ -14,7 +14,7 @@ export interface IntervalOptions {
    * For example, for integer bins:
    *
    * ```js
-   * Plot.barY(numbers, Plot.groupX({y: "count"}, Plot.intervalX(1)))
+   * Plot.barY(numbers, Plot.groupX({y: "count"}, Plot.quantizeX(1)))
    * ```
    */
   interval?: Interval;
@@ -24,23 +24,23 @@ export interface IntervalOptions {
  * Derives new **x**, **x1**, and **x2** channels for each corresponding input
  * channel by quantizing to the given *interval*.
  */
-export function intervalX<T>(interval?: Interval, options?: T): Transformed<T>;
-export function intervalX<T>(options?: T & IntervalOptions): Transformed<T>;
+export function quantizeX<T>(interval?: Interval, options?: T): Transformed<T>;
+export function quantizeX<T>(options?: T & QuantizeOptions): Transformed<T>;
 
 /**
  * Derives new **y**, **y1**, and **y2** channels for each corresponding input
  * channel by quantizing to the given *interval*.
  */
-export function intervalY<T>(interval?: Interval, options?: T): Transformed<T>;
-export function intervalY<T>(options?: T & IntervalOptions): Transformed<T>;
+export function quantizeY<T>(interval?: Interval, options?: T): Transformed<T>;
+export function quantizeY<T>(options?: T & QuantizeOptions): Transformed<T>;
 
 /**
  * Given an *interval*, returns a corresponding map implementation for use with
- * the map transform, allowing the normalization of arbitrary channels instead
- * of only **x** and **y**. For example, to interval the **stroke** channel:
+ * the map transform, allowing the quantization of arbitrary channels instead of
+ * only **x** and **y**. For example, to quantize the **stroke** channel:
  *
  * ```js
- * Plot.map({stroke: Plot.intervalMap(10)}, {x: "Date", stroke: "Close", stroke: "Symbol"})
+ * Plot.map({stroke: Plot.quantizeMap(10)}, {x: "Date", stroke: "Close", stroke: "Symbol"})
  * ```
  */
-export function intervalMap(interval: Interval): Map;
+export function quantizeMap(interval: Interval): Map;

src/transforms/quantize.js

@@ -0,0 +1,24 @@
+import {maybeInterval} from "../options.js";
+import {mapX, mapY} from "./map.js";
+
+export function quantizeX(interval, options) {
+  if (arguments.length === 1) ({interval, ...options} = interval);
+  return mapX(quantizeMap(interval), options);
+}
+
+export function quantizeY(interval, options) {
+  if (arguments.length === 1) ({interval, ...options} = interval);
+  return mapY(quantizeMap(interval), options);
+}
+
+export function quantizeMap(interval, type) {
+  interval = maybeInterval(interval, type);
+  return {
+    mapIndex(I, S, T) {
+      T.interval = interval; // hint for scales
+      for (let i = 0, n = I.length; i < n; ++i) {
+        T[I[i]] = interval.floor(S[I[i]]);
+      }
+    }
+  };
+}

test/plots/group-interval.ts

@@ -5,7 +5,7 @@ export async function groupIntervalYear() {
   const olympians = await d3.csv<any>("data/athletes.csv", d3.autoType);
   return Plot.plot({
     x: {tickFormat: "%Y"},
-    marks: [Plot.barY(olympians, Plot.groupX({y: "count"}, Plot.intervalX(d3.utcYear.every(5), {x: "date_of_birth"})))]
+    marks: [Plot.barY(olympians, Plot.groupX({y: "count"}, Plot.quantizeX(d3.utcYear.every(5), {x: "date_of_birth"})))]
   });
 }
 
@@ -17,6 +17,6 @@ export async function groupIntervalYearSparse() {
   });
   return Plot.plot({
     x: {tickFormat: "%Y"},
-    marks: [Plot.barY(olympians, Plot.groupX({y: "count"}, Plot.intervalX(d3.utcYear.every(5), {x: "date_of_birth"})))]
+    marks: [Plot.barY(olympians, Plot.groupX({y: "count"}, Plot.quantizeX(d3.utcYear.every(5), {x: "date_of_birth"})))]
   });
 }