image-js 1.0.0-alpha.3 → 1.0.0

package/src/operations/threshold.ts

@@ -1,81 +1,140 @@
-import { Image } from '../Image';
-import { validateValue } from '../utils/validators';
-import { getOutputImage } from '../utils/getOutputImage';
+import { match } from 'ts-pattern';
 
-import { otsu } from './thresholds/otsu';
-import { triangle } from './thresholds/triangle';
+import type { Image } from '../Image.js';
+import type { Mask } from '../Mask.js';
+import { imageToOutputMask } from '../utils/getOutputImage.js';
 
-// TODO: convert more algorithms to TS.
-export enum ThresholdAlgorithm {
-  // HUANG,
-  // INTERMODES,
-  // ISODATA,
-  // LI,
-  // MAX_ENTROPY,
-  // MEAN,
-  // MIN_ERROR,
-  // MINIMUM,
-  // MOMENTS,
-  OTSU = 'OTSU',
-  // PERCENTILE,
-  // RENYI_ENTROPY,
-  // SHANBHAG,
-  TRIANGLE = 'TRIANGLE'
-  // YEN
-}
+import huang from './thresholds/huang.js';
+import intermodes from './thresholds/intermodes.js';
+import isodata from './thresholds/isodata.js';
+import li from './thresholds/li.js';
+import maxEntropy from './thresholds/maxEntropy.js';
+import mean from './thresholds/mean.js';
+import minError from './thresholds/minError.js';
+import minimum from './thresholds/minimum.js';
+import moments from './thresholds/moments.js';
+import { otsu } from './thresholds/otsu.js';
+import percentile from './thresholds/percentile.js';
+import renyiEntropy from './thresholds/renyiEntropy.js';
+import shanbhag from './thresholds/shanbhag.js';
+import { triangle } from './thresholds/triangle.js';
+import yen from './thresholds/yen.js';
+
+export const ThresholdAlgorithm = {
+  HUANG: 'huang',
+  INTERMODES: 'intermodes',
+  ISODATA: 'isodata',
+  LI: 'li',
+  MAX_ENTROPY: 'maxEntropy',
+  MEAN: 'mean',
+  MIN_ERROR: 'minError',
+  MINIMUM: 'minimum',
+  MOMENTS: 'moments',
+  OTSU: 'otsu',
+  PERCENTILE: 'percentile',
+  RENYI_ENTROPY: 'renyiEntropy',
+  SHANBHAG: 'shanbhag',
+  TRIANGLE: 'triangle',
+  YEN: 'yen',
+} as const;
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export type ThresholdAlgorithm =
+  (typeof ThresholdAlgorithm)[keyof typeof ThresholdAlgorithm];
 
-interface IThresholdOptionsBase {
-  out?: Image;
+interface ThresholdOptionsBase {
+  /**
+   * Number of slots that histogram can have. Slots must be a power of 2.
+   */
+  slots?: number;
+  /**
+   * Image to use as the output.
+   */
+  out?: Mask;
 }
 
-export interface IThresholdOptionsThreshold extends IThresholdOptionsBase {
+export interface ThresholdOptionsThreshold extends ThresholdOptionsBase {
+  /**
+   * Threshold value that should be used. Threshold is a value in range [0,1],
+   * which will be interpreted as a percentage of image.maxValue.
+   */
   threshold: number;
 }
 
-export interface IThresholdOptionsAlgorithm extends IThresholdOptionsBase {
-  algorithm: ThresholdAlgorithm;
+export interface ThresholdOptionsAlgorithm extends ThresholdOptionsBase {
+  /**
+   * Specify a function to computes the threshold value.
+   *   @default `'otsu'`
+   */
+  algorithm?: ThresholdAlgorithm;
 }
 
 export type ThresholdOptions =
-  | IThresholdOptionsThreshold
-  | IThresholdOptionsAlgorithm;
+  | ThresholdOptionsThreshold
+  | ThresholdOptionsAlgorithm;
 
+/**
+ * Compute threshold value for an image using the specified algorithm.
+ * @param image - The grey image.
+ * @param options - Threshold options.
+ * @returns The threshold value for the image.
+ */
 export function computeThreshold(
   image: Image,
-  algorithm: ThresholdAlgorithm
+  options: ThresholdOptionsAlgorithm = {},
 ): number {
+  const { algorithm = 'otsu', slots } = options;
   if (image.channels !== 1) {
-    throw new Error(
-      'threshold can only be computed on images with one channel'
+    throw new TypeError(
+      'threshold can only be computed on images with one channel',
     );
   }
-  const histogram = image.histogram();
+  const histogram = image.histogram({ slots });
+  const scale = slots ? 2 ** image.bitDepth / slots : 1;
 
-  switch (algorithm) {
-    case ThresholdAlgorithm.OTSU:
-      return otsu(histogram, image.size);
-    case ThresholdAlgorithm.TRIANGLE:
-      return triangle(histogram);
-    default:
-      throw new RangeError(`unsupported threshold algorithm: ${algorithm}`);
-  }
+  return match(algorithm)
+    .with('huang', () => huang(histogram) * scale)
+    .with('intermodes', () => intermodes(histogram) * scale)
+    .with('isodata', () => isodata(histogram) * scale)
+    .with('li', () => li(histogram, image.size) * scale)
+    .with('maxEntropy', () => maxEntropy(histogram, image.size) * scale)
+    .with('mean', () => mean(histogram, image.size) * scale)
+    .with('minimum', () => minimum(histogram) * scale)
+    .with('minError', () => minError(histogram, image.size) * scale)
+    .with('moments', () => moments(histogram, image.size) * scale)
+    .with('otsu', () => otsu(histogram, image.size) * scale)
+    .with('percentile', () => percentile(histogram) * scale)
+    .with('renyiEntropy', () => renyiEntropy(histogram, image.size) * scale)
+    .with('shanbhag', () => shanbhag(histogram, image.size) * scale)
+    .with('triangle', () => triangle(histogram) * scale)
+    .with('yen', () => yen(histogram, image.size) * scale)
+    .exhaustive();
 }
 
-// TODO: add support for other threshold types.
 // See: https://docs.opencv.org/4.0.1/d7/d1b/group__imgproc__misc.html#gaa9e58d2860d4afa658ef70a9b1115576
-export function threshold(image: Image, options: ThresholdOptions): Image {
+/**
+ * Create a black and white image based on a threshold value.
+ * @param image - The grey image to convert.
+ * @param options - Threshold options.
+ * @returns The resulting mask.
+ */
+export function threshold(image: Image, options: ThresholdOptions = {}): Mask {
   let thresholdValue: number;
+
   if ('threshold' in options) {
-    thresholdValue = options.threshold;
+    const threshold = options.threshold;
+    if (threshold < 0 || threshold > 1) {
+      throw new RangeError('threshold must be a value between 0 and 1');
+    }
+    thresholdValue = threshold * image.maxValue;
   } else {
-    thresholdValue = computeThreshold(image, options.algorithm);
+    thresholdValue = computeThreshold(image, options);
   }
-
-  validateValue(thresholdValue, image);
-  const result = getOutputImage(image, options);
-  for (let i = 0; i < image.data.length; i++) {
-    result.data[i] = image.data[i] > thresholdValue ? image.maxValue : 0;
+  const result = imageToOutputMask(image, options);
+  for (let i = 0; i < image.size; i++) {
+    result.setBitByIndex(
+      i,
+      image.getValueByIndex(i, 0) > thresholdValue ? 1 : 0,
+    );
   }
-
   return result;
 }

package/src/operations/thresholds/huang.ts

@@ -0,0 +1,84 @@
+/*
+ * * see http://rsb.info.nih.gov/ij/developer/source/ij/process/AutoThresholder.java.html.
+ * Huang: Implements Huang's fuzzy thresholding method: Huang, L-K & Wang, M-J J (1995),
+ * "Image thresholding by minimizing the measure of fuzziness", Pattern Recognition 28(1): 41-51
+ */
+
+/**
+ * Return a threshold for a histogram using Huang algorithm.
+ * @param histogram - Image histogram.
+ * @returns The threshold.
+ */
+export default function huang(histogram: Uint32Array): number {
+  /* Determine the first non-zero bin */
+  let firstBin = 0;
+  for (let ih = 0; ih < histogram.length; ih++) {
+    if (histogram[ih] !== 0) {
+      firstBin = ih;
+      break;
+    }
+  }
+
+  /* Determine the last non-zero bin */
+  let lastBin = histogram.length - 1;
+  for (let ih = histogram.length - 1; ih >= firstBin; ih--) {
+    if (histogram[ih] !== 0) {
+      lastBin = ih;
+      break;
+    }
+  }
+
+  const term = 1 / (lastBin - firstBin);
+  const mu0 = new Array(histogram.length);
+  let sumPix = 0;
+  let numPix = 0;
+  for (let ih = firstBin; ih < histogram.length; ih++) {
+    sumPix += ih * histogram[ih];
+    numPix += histogram[ih];
+    mu0[ih] = sumPix / numPix;
+  }
+
+  const mu1 = new Array(histogram.length);
+  sumPix = 0;
+  numPix = 0;
+  for (let ih = lastBin; ih > 0; ih--) {
+    sumPix += ih * histogram[ih];
+    numPix += histogram[ih];
+    mu1[ih - 1] = sumPix / numPix;
+  }
+
+  /* Determine the threshold that minimizes the fuzzy entropy*/
+  let threshold = -1;
+  let minEnt = Number.MAX_VALUE;
+  for (let it = 0; it < histogram.length; it++) {
+    let ent = 0;
+    let muX;
+    for (let ih = 0; ih <= it; ih++) {
+      /* Equation (4) in Ref. 1 */
+      muX = 1 / (1 + term * Math.abs(ih - mu0[it]));
+      if (!(muX < 1e-6 || muX > 0.999999)) {
+        /* Equation (6) & (8) in Ref. 1 */
+        ent +=
+          histogram[ih] *
+          (-muX * Math.log(muX) - (1 - muX) * Math.log(1 - muX));
+      }
+    }
+
+    for (let ih = it + 1; ih < histogram.length; ih++) {
+      /* Equation (4) in Ref. 1 */
+      muX = 1 / (1 + term * Math.abs(ih - mu1[it]));
+      if (!(muX < 1e-6 || muX > 0.999999)) {
+        /* Equation (6) & (8) in Ref. 1 */
+        ent +=
+          histogram[ih] *
+          (-muX * Math.log(muX) - (1 - muX) * Math.log(1 - muX));
+      }
+    }
+
+    if (ent < minEnt) {
+      minEnt = ent;
+      threshold = it;
+    }
+  }
+  return threshold;
+}

package/src/operations/thresholds/intermodes.ts

@@ -0,0 +1,61 @@
+/*
+ *
+ * see https://github.com/fiji/Auto_Threshold/blob/master/src/main/java/fiji/threshold/Auto_Threshold.java
+ * Intermodes: This assumes a bimodal histogram. Implements the thresholding Prewitt, JMS & Mendelsohn, ML (1966),
+ * "The analysis of cell images", Annals of the NewYork Academy of Sciences 128: 1035-1053
+ *
+ */
+
+import { assert } from '../../utils/validators/assert.js';
+
+/**
+ * Return a threshold for a histogram using Intermodes algorithm.
+ * @param histogram - Image histogram.
+ * @returns The threshold.
+ */
+export default function intermodes(histogram: Uint32Array): number {
+  const iHisto = histogram.slice();
+  let iter = 0;
+  while (!bimodalTest(iHisto)) {
+    // smooth with a 3 point running mean filter
+    let previous = 0;
+    let current = 0;
+    let next = iHisto[0];
+    for (let i = 0; i < histogram.length - 1; i++) {
+      previous = current;
+      current = next;
+      next = iHisto[i + 1];
+      iHisto[i] = (previous + current + next) / 3;
+    }
+    iHisto[histogram.length - 1] = (current + next) / 3;
+    iter++;
+    assert(iter < 1000, 'Intermodes threshold not found after 1000 iterations');
+  }
+
+  // The threshold is the mean between the two peaks.
+  let tt = 0;
+  for (let i = 1; i < histogram.length - 1; i++) {
+    if (iHisto[i - 1] < iHisto[i] && iHisto[i + 1] < iHisto[i]) {
+      tt += i;
+    }
+  }
+  return Math.floor(tt / 2);
+}
+
+function bimodalTest(iHisto: Uint32Array): boolean {
+  let b = false;
+  let modes = 0;
+
+  for (let k = 1; k < iHisto.length - 1; k++) {
+    if (iHisto[k - 1] < iHisto[k] && iHisto[k + 1] < iHisto[k]) {
+      modes++;
+      if (modes > 2) {
+        return false;
+      }
+    }
+  }
+  if (modes === 2) {
+    b = true;
+  }
+  return b;
+}

package/src/operations/thresholds/isodata.ts

@@ -0,0 +1,53 @@
+/*
+ * see https://github.com/fiji/Auto_Threshold/blob/master/src/main/java/fiji/threshold/Auto_Threshold.java
+ * Isodata: Ridler, TW & Calvard, S (1978), "Picture thresholding using an iterative selection method"
+ * IEEE Transactions on Systems, Man and Cybernetics 8: 630-632.
+ *
+ */
+
+import { assert } from '../../utils/validators/assert.js';
+
+/**
+ * Return a threshold for a histogram using Isodata algorithm.
+ * @param histogram - Image histogram.
+ * @returns The threshold.
+ */
+export default function isodata(histogram: Uint32Array): number {
+  let l; // the average grey value of pixels with intensities < g
+  let toth; // the the average grey value of pixels with intensities > g
+  let totl; // the total the average grey value of pixels with intensities < g
+  let h; // the average grey value of pixels with intensities > g
+  let g = 0; // threshold value
+
+  for (let i = 1; i < histogram.length; i++) {
+    if (histogram[i] > 0) {
+      g = i + 1;
+      break;
+    }
+  }
+
+  while (true) {
+    l = 0;
+    totl = 0;
+    for (let i = 0; i < g; i++) {
+      totl = totl + histogram[i];
+      l = l + histogram[i] * i;
+    }
+    h = 0;
+    toth = 0;
+    for (let i = g + 1; i < histogram.length; i++) {
+      toth += histogram[i];
+      h += histogram[i] * i;
+    }
+    if (totl > 0 && toth > 0) {
+      l /= totl;
+      h /= toth;
+      if (g === Math.round((l + h) / 2)) {
+        break;
+      }
+    }
+    g++;
+    assert(g <= histogram.length - 2, 'Threshold not found');
+  }
+  return g;
+}

package/src/operations/thresholds/li.ts

@@ -0,0 +1,80 @@
+/*
+ * see http://rsb.info.nih.gov/ij/developer/source/ij/process/AutoThresholder.java.html
+ * The method is present in: Implements Li's Minimum Cross Entropy thresholding method
+ * This implementation is based on the iterative version (Ref. 2nd reference below) of the algorithm.
+ *  1) Li, CH & Lee, CK (1993), "Minimum Cross Entropy Thresholding", Pattern Recognition 26(4): 61 625
+ *  2) Li, CH & Tam, PKS (1998), "An Iterative Algorithm for Minimum Cross Entropy Thresholding",
+ *     Pattern Recognition Letters 18(8): 771-776
+ *  3) Sezgin, M & Sankur, B (2004), "Survey over Image Thresholding Techniques and Quantitative Performance
+ *     Evaluation",Journal of Electronic Imaging 13(1): 146-165
+ * @param histogram - the histogram of the image
+ * @param total - the number of pixels in the image
+ * @returns {number} - the threshold
+ */
+
+/**
+ * Return a threshold for a histogram using Li algorithm.
+ * @param histogram - Image histogram.
+ * @param total - Number of pixels in the image.
+ * @returns The threshold.
+ */
+export default function li(histogram: Uint32Array, total: number): number {
+  let threshold;
+  let sumBack; /* sum of the background pixels at a given threshold */
+  let sumObj; /* sum of the object pixels at a given threshold */
+  let numBack; /* number of background pixels at a given threshold */
+  let numObj; /* number of object pixels at a given threshold */
+  let oldThresh;
+  let newThresh;
+  let meanBack; /* mean of the background pixels at a given threshold */
+  let meanObj; /* mean of the object pixels at a given threshold */
+  let mean; /* mean gray-level in the image */
+  const tolerance = 0.5; /* threshold tolerance */
+  let temp;
+
+  /* Calculate the mean gray-level */
+  mean = 0;
+  for (let ih = 0; ih < histogram.length; ih++) {
+    mean += ih * histogram[ih];
+  }
+
+  mean /= total;
+  /* Initial estimate */
+  newThresh = mean;
+
+  do {
+    oldThresh = newThresh;
+    threshold = (oldThresh + 0.5) | 0; /* range */
+
+    /* Calculate the means of background and object pixels */
+    /* Background */
+    sumBack = 0;
+    numBack = 0;
+
+    for (let ih = 0; ih <= threshold; ih++) {
+      sumBack += ih * histogram[ih];
+      numBack += histogram[ih];
+    }
+    meanBack = numBack === 0 ? 0 : sumBack / numBack;
+
+    /* Object */
+    sumObj = 0;
+    numObj = 0;
+    for (let ih = threshold + 1; ih < histogram.length; ih++) {
+      sumObj += ih * histogram[ih];
+      numObj += histogram[ih];
+    }
+    meanObj = numObj === 0 ? 0 : sumObj / numObj;
+    temp = (meanBack - meanObj) / (Math.log(meanBack) - Math.log(meanObj));
+
+    if (temp < -Number.EPSILON) {
+      newThresh = (temp - 0.5) | 0;
+    } else {
+      newThresh = (temp + 0.5) | 0;
+    }
+    /*  Stop the iterations when the difference between the
+         new and old threshold values is less than the tolerance */
+  } while (Math.abs(newThresh - oldThresh) > tolerance);
+
+  return threshold;
+}

package/src/operations/thresholds/maxEntropy.ts

@@ -0,0 +1,88 @@
+/*
+ * see http://rsb.info.nih.gov/ij/developer/source/ij/process/AutoThresholder.java.html
+ * The method is present in: Implements Kapur-Sahoo-Wong (Maximum Entropy) thresholding method:
+ * Kapur, JN; Sahoo, PK & Wong, ACK (1985), "A New Method for Gray-Level Picture Thresholding Using the Entropy of the Histogram",
+ * Graphical Models and Image Processing 29(3): 273-285
+ * @param histogram - the histogram of the image
+ *        total - the number of pixels in the image
+ * @returns {number} - the threshold
+ */
+
+/**
+ * Return a threshold for a histogram using maximal enthropy algorithm.
+ * @param histogram - Image histogram.
+ * @param total - Number of pixels in the image.
+ * @returns The threshold.
+ */
+export default function maxEntropy(
+  histogram: Uint32Array,
+  total: number,
+): number {
+  const normHisto = new Array<number>(histogram.length); // normalized histogram
+  for (let ih = 0; ih < histogram.length; ih++) {
+    normHisto[ih] = histogram[ih] / total;
+  }
+
+  const P1 = new Array<number>(histogram.length); // cumulative normalized histogram
+  const P2 = new Array<number>(histogram.length);
+  P1[0] = normHisto[0];
+  P2[0] = 1 - P1[0];
+
+  for (let ih = 1; ih < histogram.length; ih++) {
+    P1[ih] = P1[ih - 1] + normHisto[ih];
+    P2[ih] = 1 - P1[ih];
+  }
+
+  /* Determine the first non-zero bin */
+  let firstBin = 0;
+  for (let ih = 0; ih < histogram.length; ih++) {
+    if (Math.abs(P1[ih]) >= Number.EPSILON) {
+      firstBin = ih;
+      break;
+    }
+  }
+
+  /* Determine the last non-zero bin */
+  let lastBin = histogram.length - 1;
+  for (let ih = histogram.length - 1; ih >= firstBin; ih--) {
+    if (Math.abs(P2[ih]) >= Number.EPSILON) {
+      lastBin = ih;
+      break;
+    }
+  }
+
+  // Calculate the total entropy each gray-level
+  // and find the threshold that maximizes it
+  let threshold = -1;
+  let totEnt; // total entropy
+  let maxEnt = Number.MIN_VALUE; // max entropy
+  let entBack; // entropy of the background pixels at a given threshold
+  let entObj; // entropy of the object pixels at a given threshold
+
+  for (let it = firstBin; it <= lastBin; it++) {
+    /* Entropy of the background pixels */
+    entBack = 0;
+    for (let ih = 0; ih <= it; ih++) {
+      if (histogram[ih] !== 0) {
+        entBack -= (normHisto[ih] / P1[it]) * Math.log(normHisto[ih] / P1[it]);
+      }
+    }
+
+    /* Entropy of the object pixels */
+    entObj = 0;
+    for (let ih = it + 1; ih < histogram.length; ih++) {
+      if (histogram[ih] !== 0) {
+        entObj -= (normHisto[ih] / P2[it]) * Math.log(normHisto[ih] / P2[it]);
+      }
+    }
+
+    /* Total entropy */
+    totEnt = entBack + entObj;
+
+    if (maxEnt < totEnt) {
+      maxEnt = totEnt;
+      threshold = it;
+    }
+  }
+  return threshold;
+}

package/src/operations/thresholds/mean.ts

@@ -0,0 +1,22 @@
+/*
+ * The method is present in: Uses the mean of grey levels as the threshold. It is described in:
+ * Glasbey, CA (1993), "An analysis of histogram-based thresholding algorithms",
+ * CVGIP: Graphical Models and Image Processing 55: 532-537
+ * @param histogram - the histogram of the image
+ * @param total - the number of pixels in the image
+ * @returns {number} - the threshold
+ */
+
+/**
+ * Return a threshold for a histogram by making its average.
+ * @param histogram - Image histogram.
+ * @param total - Number of pixels in the image.
+ * @returns The threshold.
+ */
+export default function mean(histogram: Uint32Array, total: number): number {
+  let sum = 0;
+  for (let i = 0; i < histogram.length; i++) {
+    sum += i * histogram[i];
+  }
+  return Math.floor(sum / total);
+}

package/src/operations/thresholds/minError.ts

@@ -0,0 +1,101 @@
+/*
+ * see http://rsb.info.nih.gov/ij/developer/source/ij/process/AutoThresholder.java.html
+ * The method is present in: An iterative implementation of Kittler and Illingworth's Minimum Error
+ * thresholding:Kittler, J & Illingworth, J (1986), "Minimum error thresholding", Pattern Recognition 19: 41-47
+ * @param histogram - the histogram of the image
+ * @param total - the number of pixels in the image
+ * @returns {number} - the threshold
+ */
+
+/**
+ * Return a threshold for a histogram using Li algorithm.
+ * @param histogram - Image histogram.
+ * @param total - Number of pixels in the image.
+ * @returns The threshold.
+ */
+export default function minError(
+  histogram: Uint32Array,
+  total: number,
+): number {
+  let threshold;
+  let Tprev = -2;
+  let mu, nu, p, q, sigma2, tau2, w0, w1, w2, sqterm, temp;
+
+  /* Calculate the mean gray-level */
+  let mean = 0;
+  for (let ih = 0; ih < histogram.length; ih++) {
+    mean += ih * histogram[ih];
+  }
+
+  mean /= total;
+
+  threshold = mean;
+
+  while (threshold !== Tprev) {
+    // Calculate some statistics.
+    const sumA1 = sumA(histogram, threshold);
+    const sumA2 = sumA(histogram, histogram.length - 1);
+    const sumB1 = sumB(histogram, threshold);
+    const sumB2 = sumB(histogram, histogram.length - 1);
+    const sumC1 = sumC(histogram, threshold);
+    const sumC2 = sumC(histogram, histogram.length - 1);
+
+    mu = sumB1 / sumA1;
+    nu = (sumB2 - sumB1) / (sumA2 - sumA1);
+    p = sumA1 / sumA2;
+    q = (sumA2 - sumA1) / sumA2;
+    sigma2 = sumC1 / sumA1 - mu * mu;
+    tau2 = (sumC2 - sumC1) / (sumA2 - sumA1) - nu * nu;
+
+    // The terms of the quadratic equation to be solved.
+    w0 = 1 / sigma2 - 1 / tau2;
+    w1 = mu / sigma2 - nu / tau2;
+    w2 =
+      (mu * mu) / sigma2 -
+      (nu * nu) / tau2 +
+      Math.log10((sigma2 * (q * q)) / (tau2 * (p * p)));
+
+    // If the next threshold would be imaginary, return with the current one.
+    sqterm = w1 * w1 - w0 * w2;
+    if (sqterm < 0) {
+      return threshold;
+    }
+
+    // The updated threshold is the integer part of the solution of the quadratic equation.
+    Tprev = threshold;
+    temp = (w1 + Math.sqrt(sqterm)) / w0;
+
+    if (Number.isNaN(temp)) {
+      threshold = Tprev;
+    } else {
+      threshold = Math.floor(temp);
+    }
+  }
+  return threshold;
+}
+
+// aux func
+
+function sumA(y: Uint32Array, j: number): number {
+  let x = 0;
+  for (let i = 0; i <= j; i++) {
+    x += y[i];
+  }
+  return x;
+}
+
+function sumB(y: Uint32Array, j: number): number {
+  let x = 0;
+  for (let i = 0; i <= j; i++) {
+    x += i * y[i];
+  }
+  return x;
+}
+
+function sumC(y: Uint32Array, j: number): number {
+  let x = 0;
+  for (let i = 0; i <= j; i++) {
+    x += i * i * y[i];
+  }
+  return x;
+}