feat: add setMinX setMaxX setMinY setMaxY

Author: lpatiny

src/filters/filters.ts

@@ -21,7 +21,11 @@ export * from './x/ensureGrowing';
 export * from './x/reverseIfNeeded';
 export * from './x/equallySpaced';
 export * from './x/filterX';
+export * from './x/setMaxX';
+export * from './x/setMinX';
 export * from './x/calibrateX';
 export * from './x/xFunction';
 
 export * from './scaling/yFunction';
+export * from './y/setMaxY';
+export * from './y/setMinY';

src/filters/x/__tests__/setMaxX.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+
+import { setMaxX } from '../setMaxX';
+
+describe('setMaxX', () => {
+  it('default values', () => {
+    const data = {
+      x: Float64Array.from([1, 2, 3]),
+      y: Float64Array.from([2, 3, 4]),
+    };
+    const result = setMaxX(data, {});
+    expect(result.data).toStrictEqual({
+      x: Float64Array.from([-1, 0, 1]),
+      y: Float64Array.from([2, 3, 4]),
+    });
+    expect(result.data).not.toBe(data);
+  });
+
+  it('nothing to do', () => {
+    const data = {
+      x: Float64Array.from([1, 2, 3]),
+      y: Float64Array.from([2, 3, 4]),
+    };
+    const result = setMaxX(data, { max: 3 });
+    expect(result.data).toStrictEqual({
+      x: Float64Array.from([1, 2, 3]),
+      y: new Float64Array([2, 3, 4]),
+    });
+    expect(result.data).toBe(data);
+  });
+
+  it('negative value', () => {
+    const data = {
+      x: Float64Array.from([1, 2, 3]),
+      y: Float64Array.from([2, 3, 4]),
+    };
+    const result = setMaxX(data, { max: -1 });
+    expect(result.data).toStrictEqual({
+      x: Float64Array.from([-3, -2, -1]),
+      y: Float64Array.from([2, 3, 4]),
+    });
+  });
+});

src/filters/x/__tests__/setMinX.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+
+import { setMinX } from '../setMinX';
+
+describe('setMinX', () => {
+  it('default values', () => {
+    const data = {
+      x: Float64Array.from([1, 2, 3]),
+      y: Float64Array.from([2, 3, 4]),
+    };
+    const result = setMinX(data, {});
+    expect(result.data).toStrictEqual({
+      x: Float64Array.from([0, 1, 2]),
+      y: Float64Array.from([2, 3, 4]),
+    });
+    expect(result.data).not.toBe(data);
+  });
+
+  it('nothing to do', () => {
+    const data = {
+      x: Float64Array.from([1, 2, 3]),
+      y: Float64Array.from([2, 3, 4]),
+    };
+    const result = setMinX(data, { min: 1 });
+    expect(result.data).toStrictEqual({
+      x: Float64Array.from([1, 2, 3]),
+      y: Float64Array.from([2, 3, 4]),
+    });
+    expect(result.data).toBe(data);
+  });
+
+  it('negative value', () => {
+    const data = {
+      x: Float64Array.from([1, 2, 3]),
+      y: Float64Array.from([2, 3, 4]),
+    };
+    const result = setMinX(data, { min: -1 });
+    expect(result.data).toStrictEqual({
+      x: Float64Array.from([-1, 0, 1]),
+      y: Float64Array.from([2, 3, 4]),
+    });
+  });
+});

src/filters/x/setMaxX.ts

@@ -0,0 +1,35 @@
+import { DataXY } from 'cheminfo-types';
+import { xAdd, xMaxValue } from 'ml-spectra-processing';
+
+export interface SetMaxXFilter {
+  name: 'setMaxX';
+  options?: SetMaxXOptions;
+}
+
+export interface SetMaxXOptions {
+  /**
+   * @default 1
+   */
+  max?: number;
+}
+/**
+ * Filter that allows to
+ * @param data
+ * @param options
+ */
+export function setMaxX(
+  data: DataXY<Float64Array>,
+  options: SetMaxXOptions = {},
+) {
+  const { max = 1 } = options;
+  const existingMax = xMaxValue(data.x);
+  if (existingMax === max) {
+    return { data };
+  }
+  return {
+    data: {
+      x: xAdd(data.x, max - existingMax),
+      y: data.y,
+    },
+  };
+}

src/filters/x/setMinX.ts

@@ -0,0 +1,35 @@
+import { DataXY } from 'cheminfo-types';
+import { xAdd, xMinValue } from 'ml-spectra-processing';
+
+export interface SetMinXFilter {
+  name: 'setMinX';
+  options?: SetMinXOptions;
+}
+
+export interface SetMinXOptions {
+  /**
+   * @default 0
+   */
+  min?: number;
+}
+/**
+ * Filter that allows to
+ * @param data
+ * @param options
+ */
+export function setMinX(
+  data: DataXY<Float64Array>,
+  options: SetMinXOptions = {},
+) {
+  const { min = 0 } = options;
+  const existingMin = xMinValue(data.x);
+  if (existingMin === min) {
+    return { data };
+  }
+  return {
+    data: {
+      x: xAdd(data.x, min - existingMin),
+      y: data.y,
+    },
+  };
+}

src/filters/y/__tests__/setMaxY.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+
+import { setMaxY } from '../setMaxY';
+
+describe('setMaxY', () => {
+  it('default values', () => {
+    const data = {
+      x: Float64Array.from([1, 2, 3]),
+      y: Float64Array.from([2, 3, 4]),
+    };
+    const result = setMaxY(data, {});
+    expect(result.data).toStrictEqual({
+      x: Float64Array.from([1, 2, 3]),
+      y: new Float64Array([-1, 0, 1]),
+    });
+    expect(result.data).not.toBe(data);
+  });
+
+  it('nothing to do', () => {
+    const data = {
+      x: Float64Array.from([1, 2, 3]),
+      y: Float64Array.from([2, 3, 4]),
+    };
+    const result = setMaxY(data, { max: 4 });
+    expect(result.data).toStrictEqual({
+      x: Float64Array.from([1, 2, 3]),
+      y: new Float64Array([2, 3, 4]),
+    });
+    expect(result.data).toBe(data);
+  });
+
+  it('negative value', () => {
+    const data = {
+      x: Float64Array.from([1, 2, 3]),
+      y: Float64Array.from([2, 3, 4]),
+    };
+    const result = setMaxY(data, { max: -1 });
+    expect(result.data).toStrictEqual({
+      x: Float64Array.from([1, 2, 3]),
+      y: new Float64Array([-3, -2, -1]),
+    });
+  });
+});

src/filters/y/__tests__/setMinY.test.ts

@@ -0,0 +1,43 @@
+import { describe, it, expect } from 'vitest';
+
+import { setMinY } from '../setMinY';
+
+describe('setMinY', () => {
+  it('default values', () => {
+    const data = {
+      x: Float64Array.from([1, 2, 3]),
+      y: Float64Array.from([2, 3, 4]),
+    };
+    const result = setMinY(data, {});
+    expect(result.data).toStrictEqual({
+      x: Float64Array.from([1, 2, 3]),
+      y: new Float64Array([0, 1, 2]),
+    });
+    expect(result.data).not.toBe(data);
+  });
+
+  it('nothing to do', () => {
+    const data = {
+      x: Float64Array.from([1, 2, 3]),
+      y: Float64Array.from([2, 3, 4]),
+    };
+    const result = setMinY(data, { min: 2 });
+    expect(result.data).toStrictEqual({
+      x: Float64Array.from([1, 2, 3]),
+      y: new Float64Array([2, 3, 4]),
+    });
+    expect(result.data).toBe(data);
+  });
+
+  it('negative value', () => {
+    const data = {
+      x: Float64Array.from([1, 2, 3]),
+      y: Float64Array.from([2, 3, 4]),
+    };
+    const result = setMinY(data, { min: -1 });
+    expect(result.data).toStrictEqual({
+      x: Float64Array.from([1, 2, 3]),
+      y: new Float64Array([-1, 0, 1]),
+    });
+  });
+});

src/filters/y/setMaxY.ts

@@ -0,0 +1,35 @@
+import { DataXY } from 'cheminfo-types';
+import { xAdd, xMaxValue } from 'ml-spectra-processing';
+
+export interface SetMaxYFilter {
+  name: 'setMaxY';
+  options?: SetMaxYOptions;
+}
+
+export interface SetMaxYOptions {
+  /**
+   * @default 1
+   */
+  max?: number;
+}
+/**
+ * Filter that allows to
+ * @param data
+ * @param options
+ */
+export function setMaxY(
+  data: DataXY<Float64Array>,
+  options: SetMaxYOptions = {},
+) {
+  const { max = 1 } = options;
+  const existingMax = xMaxValue(data.y);
+  if (existingMax === max) {
+    return { data };
+  }
+  return {
+    data: {
+      x: data.x,
+      y: xAdd(data.y, max - existingMax),
+    },
+  };
+}

src/filters/y/setMinY.ts

@@ -0,0 +1,35 @@
+import { DataXY } from 'cheminfo-types';
+import { xAdd, xMinValue } from 'ml-spectra-processing';
+
+export interface SetMinYFilter {
+  name: 'setMinY';
+  options?: SetMinYOptions;
+}
+
+export interface SetMinYOptions {
+  /**
+   * @default 0
+   */
+  min?: number;
+}
+/**
+ * Filter that allows to
+ * @param data
+ * @param options
+ */
+export function setMinY(
+  data: DataXY<Float64Array>,
+  options: SetMinYOptions = {},
+) {
+  const { min = 0 } = options;
+  const existingMin = xMinValue(data.y);
+  if (existingMin === min) {
+    return { data };
+  }
+  return {
+    data: {
+      x: data.x,
+      y: xAdd(data.y, min - existingMin),
+    },
+  };
+}