svelteplot 0.7.1-pr-280.9 → 0.7.1-pr-280.11

package/dist/transforms/density.d.ts

@@ -2,11 +2,12 @@
  * implementation based on science.js by Jason Davies
  */
 import type { TransformArg } from '../types';
-type DensityOptions = {
+type Kernel = 'uniform' | 'triangular' | 'epanechnikov' | 'quartic' | 'triweight' | 'gaussian' | 'cosine' | ((u: number) => number);
+type DensityOptions<T> = {
     /**
      * The kernel function to use for smoothing.
      */
-    kernel?: 'uniform' | 'triangular' | 'epanechnikov' | 'quartic' | 'triweight' | 'gaussian' | 'cosine' | ((u: number) => number);
+    kernel?: Kernel;
     /**
      * The bandwidth to use for smoothing. Can be a fixed number or a function that computes the bandwidth based on the data.
      */
@@ -19,22 +20,18 @@ type DensityOptions = {
      *
      */
     trim?: boolean;
+    weight?: (d: T) => number;
 };
 /**
  * One-dimensional kernel density estimation
  */
-export declare function densityX<T>(args: TransformArg<T>, options: DensityOptions & {
+export declare function densityX<T>(args: TransformArg<T>, options: DensityOptions<T> & {
     channel?: 'y' | 'y1' | 'y2';
 }): TransformArg<T>;
 /**
  * One-dimensional kernel density estimation
  */
-export declare function densityY<T>(args: TransformArg<T>, options: DensityOptions & {
+export declare function densityY<T>(args: TransformArg<T>, options: DensityOptions<T> & {
     channel?: 'x' | 'x1' | 'x2';
 }): TransformArg<T>;
-/**
- * TODO: Two-dimensional kernel density estimation
- *
- */
-export declare function density<T>({ data, ...options }: TransformArg<T>, { kernel, bandwidth }: DensityOptions): TransformArg<T>;
 export {};

package/dist/transforms/density.js

@@ -14,28 +14,7 @@ import { maybeInterval } from '../helpers/autoTicks';
 import { groupFacetsAndZ } from '../helpers/group';
 import isDataRecord from '../helpers/isDataRecord';
 import { resolveChannel } from '../helpers/resolve';
-// 2D Gaussian kernel function
-function gaussian2D(dx, dy, bwX, bwY) {
-    return (Math.exp(-0.5 * ((dx * dx) / (bwX * bwX) + (dy * dy) / (bwY * bwY))) /
-        (2 * Math.PI * bwX * bwY));
-}
-// kde2d function
-function kde2d(data, evalXs, evalYs, bwX, bwY) {
-    const n = data.length;
-    const density = [];
-    for (let xi = 0; xi < evalXs.length; xi++) {
-        for (let yi = 0; yi < evalYs.length; yi++) {
-            let sum = 0;
-            for (let i = 0; i < n; i++) {
-                const dx = evalXs[xi] - data[i][0];
-                const dy = evalYs[yi] - data[i][1];
-                sum += gaussian2D(dx, dy, bwX, bwY);
-            }
-            // Store: [x, y, density]
-            density.push([evalXs[xi], evalYs[yi], sum / n]);
-        }
-    }
-}
+import { ORIGINAL_NAME_KEYS } from '../constants.js';
 // see https://github.com/jasondavies/science.js/blob/master/src/stats/kernel.js
 const KERNEL = {
     uniform(u) {
@@ -112,6 +91,7 @@ function bandwidthSilverman(x) {
     return lo * Math.pow(x.length, -0.2);
 }
 const VALUE = Symbol('value');
+const WEIGHT = Symbol('weight');
 function roundToTerminating(x, sig = 2) {
     if (!isFinite(x) || x === 0)
         return x;
@@ -120,7 +100,7 @@ function roundToTerminating(x, sig = 2) {
     const factor = 10 ** decimals; // denominator 10^decimals → terminating decimal
     return Math.round(x * factor) / factor;
 }
-function density1d(independent, { data, ...channels }, options = {}) {
+function density1d(independent, { data, weight, ...channels }, options = {}) {
     const densityChannel = independent === 'x' ? 'y' : 'x';
     const { kernel, bandwidth, interval, trim, channel } = {
         kernel: 'epanechnikov',
@@ -136,8 +116,15 @@ function density1d(independent, { data, ...channels }, options = {}) {
     const isRawDataArray = Array.isArray(data) && !isDataRecord(data[0]) && channels[independent] == null;
     // compute bandwidth before grouping
     const resolvedData = (isRawDataArray
-        ? data.map((d) => ({ [VALUE]: d }))
-        : data.map((d) => ({ [VALUE]: resolveChannel(independent, d, channels), ...d }))).filter((d) => isValid(d[VALUE]));
+        ? data.map((d) => ({
+            [VALUE]: d,
+            [WEIGHT]: typeof weight === 'function' ? weight(d) : 1
+        }))
+        : data.map((d) => ({
+            [VALUE]: resolveChannel(independent, d, channels),
+            [WEIGHT]: typeof weight === 'function' ? weight(d) : 1,
+            ...d
+        }))).filter((d) => isValid(d[VALUE]) && isValid(d[WEIGHT]) && d[WEIGHT] >= 0);
     const values = resolvedData.map((d) => d[VALUE]);
     // compute bandwidth from full data
     const bw = typeof bandwidth === 'function'
@@ -155,7 +142,8 @@ function density1d(independent, { data, ...channels }, options = {}) {
     // let maxX = -Infinity;
     const res = groupFacetsAndZ(resolvedData, channels, (items, groupProps) => {
         const values = items.map((d) => d[VALUE]);
-        let kdeValues = kde1d(values, atValues, k, bw)
+        const weights = items.map((d) => d[WEIGHT]);
+        let kdeValues = kde1d(values, weights, atValues, k, bw)
             .filter(([x, density]) => x != null && !isNaN(density))
             .sort((a, b) => a[0] - b[0]);
         if (!trim) {
@@ -177,23 +165,22 @@ function density1d(independent, { data, ...channels }, options = {}) {
         [independent]: CHANNELS[independent],
         [channel]: CHANNELS[densityChannel],
         ...res,
+        [ORIGINAL_NAME_KEYS[densityChannel]]: 'Density',
+        [ORIGINAL_NAME_KEYS[independent]]: typeof channels[independent] === 'string' ? channels[independent] : undefined,
         sort: [{ channel: CHANNELS[independent], order: 'ascending' }],
         data: outData
     };
 }
-/**
- * TODO: Two-dimensional kernel density estimation
- *
- */
-export function density({ data, ...options }, { kernel, bandwidth }) { }
-function kde1d(values, atValues, kernel, bw) {
+function kde1d(values, weights, atValues, kernel, bw) {
     const n = values.length;
+    const weightSum = weights.reduce((a, b) => a + b, 0);
     return atValues.map((x) => {
         let sum = 0;
         for (let i = 0; i < n; i++) {
-            sum += kernel((x - values[i]) / bw);
+            const u = (x - values[i]) / bw;
+            sum += weights[i] * kernel(u);
         }
-        return [x, sum / (n * bw)];
+        return [x, sum / (weightSum * bw)];
     });
 }
 function maybeKernel(kernel) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "svelteplot",
-    "version": "0.7.1-pr-280.9",
+    "version": "0.7.1-pr-280.11",
     "license": "ISC",
     "author": {
         "name": "Gregor Aisch",