@turf/quadrat-analysis 7.0.0-alpha.2 → 7.0.0

package/README.md

@@ -93,26 +93,21 @@ Type: [Object][3]
 
 [8]: https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array
 
-<!-- This file is automatically generated. Please don't edit it directly:
-if you find an error, edit the source file (likely index.js), and re-run
-./scripts/generate-readmes in the turf project. -->
+<!-- This file is automatically generated. Please don't edit it directly. If you find an error, edit the source file of the module in question (likely index.js or index.ts), and re-run "yarn docs" from the root of the turf project. -->
 
 ---
 
-This module is part of the [Turfjs project](http://turfjs.org/), an open source
-module collection dedicated to geographic algorithms. It is maintained in the
-[Turfjs/turf](https://github.com/Turfjs/turf) repository, where you can create
-PRs and issues.
+This module is part of the [Turfjs project](https://turfjs.org/), an open source module collection dedicated to geographic algorithms. It is maintained in the [Turfjs/turf](https://github.com/Turfjs/turf) repository, where you can create PRs and issues.
 
 ### Installation
 
-Install this module individually:
+Install this single module individually:
 
 ```sh
 $ npm install @turf/quadrat-analysis
 ```
 
-Or install the Turf module that includes it as a function:
+Or install the all-encompassing @turf/turf module that includes all modules as functions:
 
 ```sh
 $ npm install @turf/turf

package/dist/cjs/index.cjs

@@ -0,0 +1,121 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// index.ts
+var _area = require('@turf/area');
+var _bbox = require('@turf/bbox');
+var _bboxpolygon = require('@turf/bbox-polygon');
+var _invariant = require('@turf/invariant');
+var _squaregrid = require('@turf/square-grid');
+function quadratAnalysis(pointFeatureSet, options) {
+  options = options || {};
+  const studyBbox = options.studyBbox || _bbox.bbox.call(void 0, pointFeatureSet);
+  const confidenceLevel = options.confidenceLevel || 20;
+  const points = pointFeatureSet.features;
+  const numOfPoints = points.length;
+  const sizeOfArea = _area.area.call(void 0, _bboxpolygon.bboxPolygon.call(void 0, studyBbox));
+  const lengthOfSide = Math.sqrt(sizeOfArea / numOfPoints * 2);
+  const grid = _squaregrid.squareGrid.call(void 0, studyBbox, lengthOfSide, {
+    units: "meters"
+  });
+  const quadrats = grid.features;
+  const quadratIdDict = {};
+  for (let i = 0; i < quadrats.length; i++) {
+    quadratIdDict[i] = {
+      box: _bbox.bbox.call(void 0, quadrats[i]),
+      cnt: 0
+    };
+  }
+  let sumOfPoint = 0;
+  for (const pt of points) {
+    for (const key of Object.keys(quadratIdDict)) {
+      const box = quadratIdDict[key].box;
+      if (inBBox(_invariant.getCoord.call(void 0, pt), box)) {
+        quadratIdDict[key].cnt += 1;
+        sumOfPoint += 1;
+        break;
+      }
+    }
+  }
+  let maxCnt = 0;
+  for (const key of Object.keys(quadratIdDict)) {
+    const cnt = quadratIdDict[key].cnt;
+    if (cnt > maxCnt) {
+      maxCnt = cnt;
+    }
+  }
+  const expectedDistribution = [];
+  const numOfQuadrat = Object.keys(quadratIdDict).length;
+  const lambda = sumOfPoint / numOfQuadrat;
+  let cumulativeProbility = 0;
+  for (let x = 0; x < maxCnt + 1; x++) {
+    cumulativeProbility += Math.exp(-lambda) * Math.pow(lambda, x) / factorial(x);
+    expectedDistribution.push(cumulativeProbility);
+  }
+  const observedDistribution = [];
+  let cumulativeObservedQuads = 0;
+  for (let x = 0; x < maxCnt + 1; x++) {
+    for (const key of Object.keys(quadratIdDict)) {
+      if (quadratIdDict[key].cnt === x) {
+        cumulativeObservedQuads += 1;
+      }
+    }
+    const p = cumulativeObservedQuads / numOfQuadrat;
+    observedDistribution.push(p);
+  }
+  let maxDifference = 0;
+  for (let x = 0; x < maxCnt + 1; x++) {
+    const difference = Math.abs(
+      expectedDistribution[x] - observedDistribution[x]
+    );
+    if (difference > maxDifference) {
+      maxDifference = difference;
+    }
+  }
+  const k = K_TABLE[confidenceLevel];
+  const criticalValue = k / Math.sqrt(numOfQuadrat);
+  const result = {
+    criticalValue,
+    isRandom: true,
+    maxAbsoluteDifference: maxDifference,
+    observedDistribution
+  };
+  if (maxDifference > criticalValue) {
+    result.isRandom = false;
+  }
+  return result;
+}
+__name(quadratAnalysis, "quadratAnalysis");
+var K_TABLE = {
+  20: 1.07275,
+  15: 1.13795,
+  10: 1.22385,
+  5: 1.3581,
+  2: 1.51743,
+  1: 1.62762
+};
+function inBBox(pt, bbox) {
+  return bbox[0] <= pt[0] && bbox[1] <= pt[1] && bbox[2] >= pt[0] && bbox[3] >= pt[1];
+}
+__name(inBBox, "inBBox");
+function factorial(num) {
+  const f = [];
+  function inner(n) {
+    if (n === 0 || n === 1) {
+      return 1;
+    }
+    if (f[n] > 0) {
+      return f[n];
+    }
+    return f[n] = inner(n - 1) * n;
+  }
+  __name(inner, "inner");
+  return inner(num);
+}
+__name(factorial, "factorial");
+var turf_quadrat_analysis_default = quadratAnalysis;
+
+
+
+exports.default = turf_quadrat_analysis_default; exports.quadratAnalysis = quadratAnalysis;
+//# sourceMappingURL=index.cjs.map

package/dist/cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../index.ts"],"names":[],"mappings":"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","sourcesContent":["import { BBox, FeatureCollection, Point } from \"geojson\";\nimport { area } from \"@turf/area\";\nimport { bbox as turfBBox } from \"@turf/bbox\";\nimport { bboxPolygon } from \"@turf/bbox-polygon\";\nimport { getCoord } from \"@turf/invariant\";\nimport { squareGrid } from \"@turf/square-grid\";\n\ninterface QuadratAnalysisResult {\n  criticalValue: number;\n  maxAbsoluteDifference: number;\n  isRandom: boolean;\n  observedDistribution: number[];\n}\n\n/**\n * Quadrat analysis lays a set of equal-size areas(quadrat) over the study area and counts\n * the number of features in each quadrat and creates a frequency table.\n * The table lists the number of quadrats containing no features,\n * the number containing one feature, two features, and so on,\n * all the way up to the quadrat containing the most features.\n * The method then creates the frequency table for the random distribution, usually based on a Poisson distribution.\n * The method uses the distribution to calculate the probability for 0 feature occuring,\n * 1 feature occuring, 2 features, and so on,\n * and lists these probabilities in the frequency table.\n * By comparing the two frequency tables, you can see whether the features create a pattern.\n * If the table for the observed distribution has more quadrats containing many features than the\n * table for the random distribution dose, then the features create a clustered pattern.\n *\n * It is hard to judge the frequency tables are similar or different just by looking at them.\n * So, we can use serval statistical tests to find out how much the frequency tables differ.\n * We use Kolmogorov-Smirnov test.This method calculates cumulative probabilities for both distributions,\n * and then compares the cumulative probabilities at each class level and selects the largest absolute difference D.\n * Then, the test compares D to the critical value for a confidence level you specify.\n * If D is greater than the critical value, the difference between  the observed distribution and\n * the random distribution is significant. The greater the value the bigger the difference.\n *\n * Traditionally, squares are used for the shape of the quadrats, in a regular grid(square-grid).\n * Some researchers suggest that the quadrat size equal twice the size of mean area per feature,\n * which is simply the area of the study area divided by the number of features.\n *\n *\n * @name quadratAnalysis\n * @param {FeatureCollection<Point>} pointFeatureSet point set to study\n * @param {Object} [options={}] optional parameters\n * @param {bbox} [options.studyBbox] bbox representing the study area\n * @param {number} [options.confidenceLevel=20] a confidence level.\n * The unit is percentage . 5 means 95%, value must be in {@link K_TABLE}\n * @returns {Object} result {@link QuadratAnalysisResult}\n * @example\n *\n * var bbox = [-65, 40, -63, 42];\n * var dataset = turf.randomPoint(100, { bbox: bbox });\n * var result = turf.quadratAnalysis(dataset);\n *\n */\nfunction quadratAnalysis(\n  pointFeatureSet: FeatureCollection<Point>,\n  options: {\n    studyBbox?: [number, number, number, number];\n    confidenceLevel?: 20 | 15 | 10 | 5 | 2 | 1;\n  }\n): QuadratAnalysisResult {\n  options = options || {};\n  const studyBbox = options.studyBbox || turfBBox(pointFeatureSet);\n  const confidenceLevel = options.confidenceLevel || 20;\n  const points = pointFeatureSet.features;\n\n  // create square-grid\n  const numOfPoints = points.length;\n  const sizeOfArea = area(bboxPolygon(studyBbox));\n  const lengthOfSide = Math.sqrt((sizeOfArea / numOfPoints) * 2);\n  const grid = squareGrid(studyBbox, lengthOfSide, {\n    units: \"meters\",\n  });\n  const quadrats = grid.features;\n\n  // count the number of features in each quadrat\n  const quadratIdDict: { [key: string]: { box: BBox; cnt: number } } = {};\n  for (let i = 0; i < quadrats.length; i++) {\n    quadratIdDict[i] = {\n      box: turfBBox(quadrats[i]),\n      cnt: 0,\n    };\n  }\n\n  let sumOfPoint = 0;\n  for (const pt of points) {\n    for (const key of Object.keys(quadratIdDict)) {\n      const box = quadratIdDict[key].box;\n      if (inBBox(getCoord(pt), box)) {\n        quadratIdDict[key].cnt += 1;\n        sumOfPoint += 1;\n        break;\n      }\n    }\n  }\n\n  // the most amount of features in quadrat\n  let maxCnt = 0;\n  for (const key of Object.keys(quadratIdDict)) {\n    const cnt = quadratIdDict[key].cnt;\n    if (cnt > maxCnt) {\n      maxCnt = cnt;\n    }\n  }\n\n  const expectedDistribution = [];\n  const numOfQuadrat = Object.keys(quadratIdDict).length;\n  const lambda = sumOfPoint / numOfQuadrat;\n\n  // get the cumulative probability of the random distribution\n  let cumulativeProbility = 0.0;\n  for (let x = 0; x < maxCnt + 1; x++) {\n    cumulativeProbility +=\n      (Math.exp(-lambda) * Math.pow(lambda, x)) / factorial(x);\n    expectedDistribution.push(cumulativeProbility);\n  }\n\n  // get the cumulative probability of the observed distribution\n  const observedDistribution = [];\n  let cumulativeObservedQuads = 0;\n  for (let x = 0; x < maxCnt + 1; x++) {\n    for (const key of Object.keys(quadratIdDict)) {\n      if (quadratIdDict[key].cnt === x) {\n        cumulativeObservedQuads += 1;\n      }\n    }\n    const p = cumulativeObservedQuads / numOfQuadrat;\n    observedDistribution.push(p);\n  }\n\n  // get the largest absolute difference between two distributions\n  let maxDifference = 0;\n  for (let x = 0; x < maxCnt + 1; x++) {\n    const difference = Math.abs(\n      expectedDistribution[x] - observedDistribution[x]\n    );\n    if (difference > maxDifference) {\n      maxDifference = difference;\n    }\n  }\n\n  const k = K_TABLE[confidenceLevel];\n\n  // statistical test\n  const criticalValue = k / Math.sqrt(numOfQuadrat);\n  const result: QuadratAnalysisResult = {\n    criticalValue,\n    isRandom: true,\n    maxAbsoluteDifference: maxDifference,\n    observedDistribution,\n  };\n\n  if (maxDifference > criticalValue) {\n    result.isRandom = false;\n  }\n\n  return result;\n}\n\n/**\n * the confidence level\n * @type {Object} K_TABLE\n * @property {number} 20\n * @property {number} 15\n * @property {number} 10\n * @property {number} 5\n * @property {number} 2\n * @property {number} 1\n */\nconst K_TABLE = {\n  20: 1.07275,\n  15: 1.13795,\n  10: 1.22385,\n  5: 1.3581,\n  2: 1.51743,\n  1: 1.62762,\n};\n\n/**\n * the return type of the quadratAnalysis\n * @typedef {Object} QuadratAnalysisResult\n * @property {number} criticalValue\n * @property {number} maxAbsoluteDifference\n * @property {boolean} isRandom\n * @property {Array.<number>} observedDistribution the cumulative distribution of observed features,\n * the index represents the number of features in the quadrat.\n */\n\n/**\n * inBBox from @turf/boolean-point-in-polygon\n *\n * @private\n * @param {Array<number>} pt point [x,y]\n * @param {BBox} bbox BBox [west, south, east, north]\n * @returns {boolean} true/false if point is inside BBox\n */\nfunction inBBox(pt: number[], bbox: BBox) {\n  return (\n    bbox[0] <= pt[0] && bbox[1] <= pt[1] && bbox[2] >= pt[0] && bbox[3] >= pt[1]\n  );\n}\n\n/**\n * https://stackoverflow.com/questions/3959211/fast-factorial-function-in-javascript\n * @private\n * @param {number} num Number\n * @returns {number} the factorial of num\n */\nfunction factorial(num: number) {\n  const f: number[] = [];\n  function inner(n: number): number {\n    if (n === 0 || n === 1) {\n      return 1;\n    }\n    if (f[n] > 0) {\n      return f[n];\n    }\n    return (f[n] = inner(n - 1) * n);\n  }\n  return inner(num);\n}\n\nexport { QuadratAnalysisResult, quadratAnalysis };\nexport default quadratAnalysis;\n"]}

package/dist/cjs/index.d.cts

@@ -0,0 +1,55 @@
+import { FeatureCollection, Point } from 'geojson';
+
+interface QuadratAnalysisResult {
+    criticalValue: number;
+    maxAbsoluteDifference: number;
+    isRandom: boolean;
+    observedDistribution: number[];
+}
+/**
+ * Quadrat analysis lays a set of equal-size areas(quadrat) over the study area and counts
+ * the number of features in each quadrat and creates a frequency table.
+ * The table lists the number of quadrats containing no features,
+ * the number containing one feature, two features, and so on,
+ * all the way up to the quadrat containing the most features.
+ * The method then creates the frequency table for the random distribution, usually based on a Poisson distribution.
+ * The method uses the distribution to calculate the probability for 0 feature occuring,
+ * 1 feature occuring, 2 features, and so on,
+ * and lists these probabilities in the frequency table.
+ * By comparing the two frequency tables, you can see whether the features create a pattern.
+ * If the table for the observed distribution has more quadrats containing many features than the
+ * table for the random distribution dose, then the features create a clustered pattern.
+ *
+ * It is hard to judge the frequency tables are similar or different just by looking at them.
+ * So, we can use serval statistical tests to find out how much the frequency tables differ.
+ * We use Kolmogorov-Smirnov test.This method calculates cumulative probabilities for both distributions,
+ * and then compares the cumulative probabilities at each class level and selects the largest absolute difference D.
+ * Then, the test compares D to the critical value for a confidence level you specify.
+ * If D is greater than the critical value, the difference between  the observed distribution and
+ * the random distribution is significant. The greater the value the bigger the difference.
+ *
+ * Traditionally, squares are used for the shape of the quadrats, in a regular grid(square-grid).
+ * Some researchers suggest that the quadrat size equal twice the size of mean area per feature,
+ * which is simply the area of the study area divided by the number of features.
+ *
+ *
+ * @name quadratAnalysis
+ * @param {FeatureCollection<Point>} pointFeatureSet point set to study
+ * @param {Object} [options={}] optional parameters
+ * @param {bbox} [options.studyBbox] bbox representing the study area
+ * @param {number} [options.confidenceLevel=20] a confidence level.
+ * The unit is percentage . 5 means 95%, value must be in {@link K_TABLE}
+ * @returns {Object} result {@link QuadratAnalysisResult}
+ * @example
+ *
+ * var bbox = [-65, 40, -63, 42];
+ * var dataset = turf.randomPoint(100, { bbox: bbox });
+ * var result = turf.quadratAnalysis(dataset);
+ *
+ */
+declare function quadratAnalysis(pointFeatureSet: FeatureCollection<Point>, options: {
+    studyBbox?: [number, number, number, number];
+    confidenceLevel?: 20 | 15 | 10 | 5 | 2 | 1;
+}): QuadratAnalysisResult;
+
+export { type QuadratAnalysisResult, quadratAnalysis as default, quadratAnalysis };

package/dist/{js → esm}/index.d.ts

@@ -1,5 +1,6 @@
-import { FeatureCollection, Point } from "geojson";
-export interface QuadratAnalysisResult {
+import { FeatureCollection, Point } from 'geojson';
+
+interface QuadratAnalysisResult {
     criticalValue: number;
     maxAbsoluteDifference: number;
     isRandom: boolean;
@@ -46,7 +47,9 @@ export interface QuadratAnalysisResult {
  * var result = turf.quadratAnalysis(dataset);
  *
  */
-export default function quadratAnalysis(pointFeatureSet: FeatureCollection<Point>, options: {
+declare function quadratAnalysis(pointFeatureSet: FeatureCollection<Point>, options: {
     studyBbox?: [number, number, number, number];
     confidenceLevel?: 20 | 15 | 10 | 5 | 2 | 1;
 }): QuadratAnalysisResult;
+
+export { type QuadratAnalysisResult, quadratAnalysis as default, quadratAnalysis };

package/dist/esm/index.js

@@ -0,0 +1,121 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// index.ts
+import { area } from "@turf/area";
+import { bbox as turfBBox } from "@turf/bbox";
+import { bboxPolygon } from "@turf/bbox-polygon";
+import { getCoord } from "@turf/invariant";
+import { squareGrid } from "@turf/square-grid";
+function quadratAnalysis(pointFeatureSet, options) {
+  options = options || {};
+  const studyBbox = options.studyBbox || turfBBox(pointFeatureSet);
+  const confidenceLevel = options.confidenceLevel || 20;
+  const points = pointFeatureSet.features;
+  const numOfPoints = points.length;
+  const sizeOfArea = area(bboxPolygon(studyBbox));
+  const lengthOfSide = Math.sqrt(sizeOfArea / numOfPoints * 2);
+  const grid = squareGrid(studyBbox, lengthOfSide, {
+    units: "meters"
+  });
+  const quadrats = grid.features;
+  const quadratIdDict = {};
+  for (let i = 0; i < quadrats.length; i++) {
+    quadratIdDict[i] = {
+      box: turfBBox(quadrats[i]),
+      cnt: 0
+    };
+  }
+  let sumOfPoint = 0;
+  for (const pt of points) {
+    for (const key of Object.keys(quadratIdDict)) {
+      const box = quadratIdDict[key].box;
+      if (inBBox(getCoord(pt), box)) {
+        quadratIdDict[key].cnt += 1;
+        sumOfPoint += 1;
+        break;
+      }
+    }
+  }
+  let maxCnt = 0;
+  for (const key of Object.keys(quadratIdDict)) {
+    const cnt = quadratIdDict[key].cnt;
+    if (cnt > maxCnt) {
+      maxCnt = cnt;
+    }
+  }
+  const expectedDistribution = [];
+  const numOfQuadrat = Object.keys(quadratIdDict).length;
+  const lambda = sumOfPoint / numOfQuadrat;
+  let cumulativeProbility = 0;
+  for (let x = 0; x < maxCnt + 1; x++) {
+    cumulativeProbility += Math.exp(-lambda) * Math.pow(lambda, x) / factorial(x);
+    expectedDistribution.push(cumulativeProbility);
+  }
+  const observedDistribution = [];
+  let cumulativeObservedQuads = 0;
+  for (let x = 0; x < maxCnt + 1; x++) {
+    for (const key of Object.keys(quadratIdDict)) {
+      if (quadratIdDict[key].cnt === x) {
+        cumulativeObservedQuads += 1;
+      }
+    }
+    const p = cumulativeObservedQuads / numOfQuadrat;
+    observedDistribution.push(p);
+  }
+  let maxDifference = 0;
+  for (let x = 0; x < maxCnt + 1; x++) {
+    const difference = Math.abs(
+      expectedDistribution[x] - observedDistribution[x]
+    );
+    if (difference > maxDifference) {
+      maxDifference = difference;
+    }
+  }
+  const k = K_TABLE[confidenceLevel];
+  const criticalValue = k / Math.sqrt(numOfQuadrat);
+  const result = {
+    criticalValue,
+    isRandom: true,
+    maxAbsoluteDifference: maxDifference,
+    observedDistribution
+  };
+  if (maxDifference > criticalValue) {
+    result.isRandom = false;
+  }
+  return result;
+}
+__name(quadratAnalysis, "quadratAnalysis");
+var K_TABLE = {
+  20: 1.07275,
+  15: 1.13795,
+  10: 1.22385,
+  5: 1.3581,
+  2: 1.51743,
+  1: 1.62762
+};
+function inBBox(pt, bbox) {
+  return bbox[0] <= pt[0] && bbox[1] <= pt[1] && bbox[2] >= pt[0] && bbox[3] >= pt[1];
+}
+__name(inBBox, "inBBox");
+function factorial(num) {
+  const f = [];
+  function inner(n) {
+    if (n === 0 || n === 1) {
+      return 1;
+    }
+    if (f[n] > 0) {
+      return f[n];
+    }
+    return f[n] = inner(n - 1) * n;
+  }
+  __name(inner, "inner");
+  return inner(num);
+}
+__name(factorial, "factorial");
+var turf_quadrat_analysis_default = quadratAnalysis;
+export {
+  turf_quadrat_analysis_default as default,
+  quadratAnalysis
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../index.ts"],"sourcesContent":["import { BBox, FeatureCollection, Point } from \"geojson\";\nimport { area } from \"@turf/area\";\nimport { bbox as turfBBox } from \"@turf/bbox\";\nimport { bboxPolygon } from \"@turf/bbox-polygon\";\nimport { getCoord } from \"@turf/invariant\";\nimport { squareGrid } from \"@turf/square-grid\";\n\ninterface QuadratAnalysisResult {\n  criticalValue: number;\n  maxAbsoluteDifference: number;\n  isRandom: boolean;\n  observedDistribution: number[];\n}\n\n/**\n * Quadrat analysis lays a set of equal-size areas(quadrat) over the study area and counts\n * the number of features in each quadrat and creates a frequency table.\n * The table lists the number of quadrats containing no features,\n * the number containing one feature, two features, and so on,\n * all the way up to the quadrat containing the most features.\n * The method then creates the frequency table for the random distribution, usually based on a Poisson distribution.\n * The method uses the distribution to calculate the probability for 0 feature occuring,\n * 1 feature occuring, 2 features, and so on,\n * and lists these probabilities in the frequency table.\n * By comparing the two frequency tables, you can see whether the features create a pattern.\n * If the table for the observed distribution has more quadrats containing many features than the\n * table for the random distribution dose, then the features create a clustered pattern.\n *\n * It is hard to judge the frequency tables are similar or different just by looking at them.\n * So, we can use serval statistical tests to find out how much the frequency tables differ.\n * We use Kolmogorov-Smirnov test.This method calculates cumulative probabilities for both distributions,\n * and then compares the cumulative probabilities at each class level and selects the largest absolute difference D.\n * Then, the test compares D to the critical value for a confidence level you specify.\n * If D is greater than the critical value, the difference between  the observed distribution and\n * the random distribution is significant. The greater the value the bigger the difference.\n *\n * Traditionally, squares are used for the shape of the quadrats, in a regular grid(square-grid).\n * Some researchers suggest that the quadrat size equal twice the size of mean area per feature,\n * which is simply the area of the study area divided by the number of features.\n *\n *\n * @name quadratAnalysis\n * @param {FeatureCollection<Point>} pointFeatureSet point set to study\n * @param {Object} [options={}] optional parameters\n * @param {bbox} [options.studyBbox] bbox representing the study area\n * @param {number} [options.confidenceLevel=20] a confidence level.\n * The unit is percentage . 5 means 95%, value must be in {@link K_TABLE}\n * @returns {Object} result {@link QuadratAnalysisResult}\n * @example\n *\n * var bbox = [-65, 40, -63, 42];\n * var dataset = turf.randomPoint(100, { bbox: bbox });\n * var result = turf.quadratAnalysis(dataset);\n *\n */\nfunction quadratAnalysis(\n  pointFeatureSet: FeatureCollection<Point>,\n  options: {\n    studyBbox?: [number, number, number, number];\n    confidenceLevel?: 20 | 15 | 10 | 5 | 2 | 1;\n  }\n): QuadratAnalysisResult {\n  options = options || {};\n  const studyBbox = options.studyBbox || turfBBox(pointFeatureSet);\n  const confidenceLevel = options.confidenceLevel || 20;\n  const points = pointFeatureSet.features;\n\n  // create square-grid\n  const numOfPoints = points.length;\n  const sizeOfArea = area(bboxPolygon(studyBbox));\n  const lengthOfSide = Math.sqrt((sizeOfArea / numOfPoints) * 2);\n  const grid = squareGrid(studyBbox, lengthOfSide, {\n    units: \"meters\",\n  });\n  const quadrats = grid.features;\n\n  // count the number of features in each quadrat\n  const quadratIdDict: { [key: string]: { box: BBox; cnt: number } } = {};\n  for (let i = 0; i < quadrats.length; i++) {\n    quadratIdDict[i] = {\n      box: turfBBox(quadrats[i]),\n      cnt: 0,\n    };\n  }\n\n  let sumOfPoint = 0;\n  for (const pt of points) {\n    for (const key of Object.keys(quadratIdDict)) {\n      const box = quadratIdDict[key].box;\n      if (inBBox(getCoord(pt), box)) {\n        quadratIdDict[key].cnt += 1;\n        sumOfPoint += 1;\n        break;\n      }\n    }\n  }\n\n  // the most amount of features in quadrat\n  let maxCnt = 0;\n  for (const key of Object.keys(quadratIdDict)) {\n    const cnt = quadratIdDict[key].cnt;\n    if (cnt > maxCnt) {\n      maxCnt = cnt;\n    }\n  }\n\n  const expectedDistribution = [];\n  const numOfQuadrat = Object.keys(quadratIdDict).length;\n  const lambda = sumOfPoint / numOfQuadrat;\n\n  // get the cumulative probability of the random distribution\n  let cumulativeProbility = 0.0;\n  for (let x = 0; x < maxCnt + 1; x++) {\n    cumulativeProbility +=\n      (Math.exp(-lambda) * Math.pow(lambda, x)) / factorial(x);\n    expectedDistribution.push(cumulativeProbility);\n  }\n\n  // get the cumulative probability of the observed distribution\n  const observedDistribution = [];\n  let cumulativeObservedQuads = 0;\n  for (let x = 0; x < maxCnt + 1; x++) {\n    for (const key of Object.keys(quadratIdDict)) {\n      if (quadratIdDict[key].cnt === x) {\n        cumulativeObservedQuads += 1;\n      }\n    }\n    const p = cumulativeObservedQuads / numOfQuadrat;\n    observedDistribution.push(p);\n  }\n\n  // get the largest absolute difference between two distributions\n  let maxDifference = 0;\n  for (let x = 0; x < maxCnt + 1; x++) {\n    const difference = Math.abs(\n      expectedDistribution[x] - observedDistribution[x]\n    );\n    if (difference > maxDifference) {\n      maxDifference = difference;\n    }\n  }\n\n  const k = K_TABLE[confidenceLevel];\n\n  // statistical test\n  const criticalValue = k / Math.sqrt(numOfQuadrat);\n  const result: QuadratAnalysisResult = {\n    criticalValue,\n    isRandom: true,\n    maxAbsoluteDifference: maxDifference,\n    observedDistribution,\n  };\n\n  if (maxDifference > criticalValue) {\n    result.isRandom = false;\n  }\n\n  return result;\n}\n\n/**\n * the confidence level\n * @type {Object} K_TABLE\n * @property {number} 20\n * @property {number} 15\n * @property {number} 10\n * @property {number} 5\n * @property {number} 2\n * @property {number} 1\n */\nconst K_TABLE = {\n  20: 1.07275,\n  15: 1.13795,\n  10: 1.22385,\n  5: 1.3581,\n  2: 1.51743,\n  1: 1.62762,\n};\n\n/**\n * the return type of the quadratAnalysis\n * @typedef {Object} QuadratAnalysisResult\n * @property {number} criticalValue\n * @property {number} maxAbsoluteDifference\n * @property {boolean} isRandom\n * @property {Array.<number>} observedDistribution the cumulative distribution of observed features,\n * the index represents the number of features in the quadrat.\n */\n\n/**\n * inBBox from @turf/boolean-point-in-polygon\n *\n * @private\n * @param {Array<number>} pt point [x,y]\n * @param {BBox} bbox BBox [west, south, east, north]\n * @returns {boolean} true/false if point is inside BBox\n */\nfunction inBBox(pt: number[], bbox: BBox) {\n  return (\n    bbox[0] <= pt[0] && bbox[1] <= pt[1] && bbox[2] >= pt[0] && bbox[3] >= pt[1]\n  );\n}\n\n/**\n * https://stackoverflow.com/questions/3959211/fast-factorial-function-in-javascript\n * @private\n * @param {number} num Number\n * @returns {number} the factorial of num\n */\nfunction factorial(num: number) {\n  const f: number[] = [];\n  function inner(n: number): number {\n    if (n === 0 || n === 1) {\n      return 1;\n    }\n    if (f[n] > 0) {\n      return f[n];\n    }\n    return (f[n] = inner(n - 1) * n);\n  }\n  return inner(num);\n}\n\nexport { QuadratAnalysisResult, quadratAnalysis };\nexport default quadratAnalysis;\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turf/quadrat-analysis",
-  "version": "7.0.0-alpha.2",
+  "version": "7.0.0",
   "description": "turf quadrat-analysis module",
   "author": "Turf Authors",
   "contributors": [
@@ -23,53 +23,58 @@
     "turf",
     "quadrat-analysis"
   ],
-  "main": "dist/js/index.js",
-  "module": "dist/es/index.js",
+  "type": "module",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./dist/js/index.d.ts",
-      "import": "./dist/es/index.js",
-      "require": "./dist/js/index.js"
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
     }
   },
-  "types": "dist/js/index.d.ts",
   "sideEffects": false,
   "files": [
     "dist"
   ],
   "scripts": {
-    "bench": "tsx bench.js",
-    "build": "npm-run-all build:*",
-    "build:es": "tsc --outDir dist/es --module esnext --declaration false && echo '{\"type\":\"module\"}' > dist/es/package.json",
-    "build:js": "tsc",
-    "docs": "tsx ../../scripts/generate-readmes",
-    "test": "npm-run-all test:*",
-    "test:tape": "tsx test.js"
+    "bench": "tsx bench.ts",
+    "build": "tsup --config ../../tsup.config.ts",
+    "docs": "tsx ../../scripts/generate-readmes.ts",
+    "test": "npm-run-all --npm-path npm test:*",
+    "test:tape": "tsx test.ts"
   },
   "devDependencies": {
-    "@turf/nearest-neighbor-analysis": "^7.0.0-alpha.2",
-    "@types/tape": "*",
-    "benchmark": "*",
-    "load-json-file": "*",
-    "npm-run-all": "*",
-    "tape": "*",
-    "tslint": "*",
-    "tsx": "*",
-    "typescript": "*",
-    "write-json-file": "*"
+    "@turf/nearest-neighbor-analysis": "^7.0.0",
+    "@types/benchmark": "^2.1.5",
+    "@types/tape": "^4.2.32",
+    "benchmark": "^2.1.4",
+    "load-json-file": "^7.0.1",
+    "npm-run-all": "^4.1.5",
+    "tape": "^5.7.2",
+    "tsup": "^8.0.1",
+    "tsx": "^4.6.2",
+    "typescript": "^5.2.2",
+    "write-json-file": "^5.0.0"
   },
   "dependencies": {
-    "@turf/area": "^7.0.0-alpha.2",
-    "@turf/bbox": "^7.0.0-alpha.2",
-    "@turf/bbox-polygon": "^7.0.0-alpha.2",
-    "@turf/centroid": "^7.0.0-alpha.2",
-    "@turf/helpers": "^7.0.0-alpha.2",
-    "@turf/invariant": "^7.0.0-alpha.2",
-    "@turf/point-grid": "^7.0.0-alpha.2",
-    "@turf/random": "^7.0.0-alpha.2",
-    "@turf/square-grid": "^7.0.0-alpha.2",
-    "tslib": "^2.3.0"
+    "@turf/area": "^7.0.0",
+    "@turf/bbox": "^7.0.0",
+    "@turf/bbox-polygon": "^7.0.0",
+    "@turf/centroid": "^7.0.0",
+    "@turf/helpers": "^7.0.0",
+    "@turf/invariant": "^7.0.0",
+    "@turf/point-grid": "^7.0.0",
+    "@turf/random": "^7.0.0",
+    "@turf/square-grid": "^7.0.0",
+    "tslib": "^2.6.2"
   },
-  "gitHead": "dd35b52725945b4fa29a98d9a550733e06cc222e"
+  "gitHead": "3d3a7917025fbabe191dbddbc89754b86f9c7739"
 }

package/dist/es/index.js

@@ -1,187 +0,0 @@
-import area from "@turf/area";
-import turfBBox from "@turf/bbox";
-import bboxPolygon from "@turf/bbox-polygon";
-import { getCoord } from "@turf/invariant";
-import squareGrid from "@turf/square-grid";
-/**
- * Quadrat analysis lays a set of equal-size areas(quadrat) over the study area and counts
- * the number of features in each quadrat and creates a frequency table.
- * The table lists the number of quadrats containing no features,
- * the number containing one feature, two features, and so on,
- * all the way up to the quadrat containing the most features.
- * The method then creates the frequency table for the random distribution, usually based on a Poisson distribution.
- * The method uses the distribution to calculate the probability for 0 feature occuring,
- * 1 feature occuring, 2 features, and so on,
- * and lists these probabilities in the frequency table.
- * By comparing the two frequency tables, you can see whether the features create a pattern.
- * If the table for the observed distribution has more quadrats containing many features than the
- * table for the random distribution dose, then the features create a clustered pattern.
- *
- * It is hard to judge the frequency tables are similar or different just by looking at them.
- * So, we can use serval statistical tests to find out how much the frequency tables differ.
- * We use Kolmogorov-Smirnov test.This method calculates cumulative probabilities for both distributions,
- * and then compares the cumulative probabilities at each class level and selects the largest absolute difference D.
- * Then, the test compares D to the critical value for a confidence level you specify.
- * If D is greater than the critical value, the difference between  the observed distribution and
- * the random distribution is significant. The greater the value the bigger the difference.
- *
- * Traditionally, squares are used for the shape of the quadrats, in a regular grid(square-grid).
- * Some researchers suggest that the quadrat size equal twice the size of mean area per feature,
- * which is simply the area of the study area divided by the number of features.
- *
- *
- * @name quadratAnalysis
- * @param {FeatureCollection<Point>} pointFeatureSet point set to study
- * @param {Object} [options={}] optional parameters
- * @param {bbox} [options.studyBbox] bbox representing the study area
- * @param {number} [options.confidenceLevel=20] a confidence level.
- * The unit is percentage . 5 means 95%, value must be in {@link K_TABLE}
- * @returns {Object} result {@link QuadratAnalysisResult}
- * @example
- *
- * var bbox = [-65, 40, -63, 42];
- * var dataset = turf.randomPoint(100, { bbox: bbox });
- * var result = turf.quadratAnalysis(dataset);
- *
- */
-export default function quadratAnalysis(pointFeatureSet, options) {
-    options = options || {};
-    const studyBbox = options.studyBbox || turfBBox(pointFeatureSet);
-    const confidenceLevel = options.confidenceLevel || 20;
-    const points = pointFeatureSet.features;
-    // create square-grid
-    const numOfPoints = points.length;
-    const sizeOfArea = area(bboxPolygon(studyBbox));
-    const lengthOfSide = Math.sqrt((sizeOfArea / numOfPoints) * 2);
-    const grid = squareGrid(studyBbox, lengthOfSide, {
-        units: "meters",
-    });
-    const quadrats = grid.features;
-    // count the number of features in each quadrat
-    const quadratIdDict = {};
-    for (let i = 0; i < quadrats.length; i++) {
-        quadratIdDict[i] = {
-            box: turfBBox(quadrats[i]),
-            cnt: 0,
-        };
-    }
-    let sumOfPoint = 0;
-    for (const pt of points) {
-        for (const key of Object.keys(quadratIdDict)) {
-            const box = quadratIdDict[key].box;
-            if (inBBox(getCoord(pt), box)) {
-                quadratIdDict[key].cnt += 1;
-                sumOfPoint += 1;
-                break;
-            }
-        }
-    }
-    // the most amount of features in quadrat
-    let maxCnt = 0;
-    for (const key of Object.keys(quadratIdDict)) {
-        const cnt = quadratIdDict[key].cnt;
-        if (cnt > maxCnt) {
-            maxCnt = cnt;
-        }
-    }
-    const expectedDistribution = [];
-    const numOfQuadrat = Object.keys(quadratIdDict).length;
-    const lambda = sumOfPoint / numOfQuadrat;
-    // get the cumulative probability of the random distribution
-    let cumulativeProbility = 0.0;
-    for (let x = 0; x < maxCnt + 1; x++) {
-        cumulativeProbility +=
-            (Math.exp(-lambda) * Math.pow(lambda, x)) / factorial(x);
-        expectedDistribution.push(cumulativeProbility);
-    }
-    // get the cumulative probability of the observed distribution
-    const observedDistribution = [];
-    let cumulativeObservedQuads = 0;
-    for (let x = 0; x < maxCnt + 1; x++) {
-        for (const key of Object.keys(quadratIdDict)) {
-            if (quadratIdDict[key].cnt === x) {
-                cumulativeObservedQuads += 1;
-            }
-        }
-        const p = cumulativeObservedQuads / numOfQuadrat;
-        observedDistribution.push(p);
-    }
-    // get the largest absolute difference between two distributions
-    let maxDifference = 0;
-    for (let x = 0; x < maxCnt + 1; x++) {
-        const difference = Math.abs(expectedDistribution[x] - observedDistribution[x]);
-        if (difference > maxDifference) {
-            maxDifference = difference;
-        }
-    }
-    const k = K_TABLE[confidenceLevel];
-    // statistical test
-    const criticalValue = k / Math.sqrt(numOfQuadrat);
-    const result = {
-        criticalValue,
-        isRandom: true,
-        maxAbsoluteDifference: maxDifference,
-        observedDistribution,
-    };
-    if (maxDifference > criticalValue) {
-        result.isRandom = false;
-    }
-    return result;
-}
-/**
- * the confidence level
- * @type {Object} K_TABLE
- * @property {number} 20
- * @property {number} 15
- * @property {number} 10
- * @property {number} 5
- * @property {number} 2
- * @property {number} 1
- */
-const K_TABLE = {
-    20: 1.07275,
-    15: 1.13795,
-    10: 1.22385,
-    5: 1.3581,
-    2: 1.51743,
-    1: 1.62762,
-};
-/**
- * the return type of the quadratAnalysis
- * @typedef {Object} QuadratAnalysisResult
- * @property {number} criticalValue
- * @property {number} maxAbsoluteDifference
- * @property {boolean} isRandom
- * @property {Array.<number>} observedDistribution the cumulative distribution of observed features,
- * the index represents the number of features in the quadrat.
- */
-/**
- * inBBox from @turf/boolean-point-in-polygon
- *
- * @private
- * @param {Array<number>} pt point [x,y]
- * @param {BBox} bbox BBox [west, south, east, north]
- * @returns {boolean} true/false if point is inside BBox
- */
-function inBBox(pt, bbox) {
-    return (bbox[0] <= pt[0] && bbox[1] <= pt[1] && bbox[2] >= pt[0] && bbox[3] >= pt[1]);
-}
-/**
- * https://stackoverflow.com/questions/3959211/fast-factorial-function-in-javascript
- * @private
- * @param {number} num Number
- * @returns {number} the factorial of num
- */
-function factorial(num) {
-    const f = [];
-    function inner(n) {
-        if (n === 0 || n === 1) {
-            return 1;
-        }
-        if (f[n] > 0) {
-            return f[n];
-        }
-        return (f[n] = inner(n - 1) * n);
-    }
-    return inner(num);
-}

package/dist/es/package.json

@@ -1 +0,0 @@
-{"type":"module"}

package/dist/js/index.js

@@ -1,191 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const area_1 = tslib_1.__importDefault(require("@turf/area"));
-const bbox_1 = tslib_1.__importDefault(require("@turf/bbox"));
-const bbox_polygon_1 = tslib_1.__importDefault(require("@turf/bbox-polygon"));
-const invariant_1 = require("@turf/invariant");
-const square_grid_1 = tslib_1.__importDefault(require("@turf/square-grid"));
-/**
- * Quadrat analysis lays a set of equal-size areas(quadrat) over the study area and counts
- * the number of features in each quadrat and creates a frequency table.
- * The table lists the number of quadrats containing no features,
- * the number containing one feature, two features, and so on,
- * all the way up to the quadrat containing the most features.
- * The method then creates the frequency table for the random distribution, usually based on a Poisson distribution.
- * The method uses the distribution to calculate the probability for 0 feature occuring,
- * 1 feature occuring, 2 features, and so on,
- * and lists these probabilities in the frequency table.
- * By comparing the two frequency tables, you can see whether the features create a pattern.
- * If the table for the observed distribution has more quadrats containing many features than the
- * table for the random distribution dose, then the features create a clustered pattern.
- *
- * It is hard to judge the frequency tables are similar or different just by looking at them.
- * So, we can use serval statistical tests to find out how much the frequency tables differ.
- * We use Kolmogorov-Smirnov test.This method calculates cumulative probabilities for both distributions,
- * and then compares the cumulative probabilities at each class level and selects the largest absolute difference D.
- * Then, the test compares D to the critical value for a confidence level you specify.
- * If D is greater than the critical value, the difference between  the observed distribution and
- * the random distribution is significant. The greater the value the bigger the difference.
- *
- * Traditionally, squares are used for the shape of the quadrats, in a regular grid(square-grid).
- * Some researchers suggest that the quadrat size equal twice the size of mean area per feature,
- * which is simply the area of the study area divided by the number of features.
- *
- *
- * @name quadratAnalysis
- * @param {FeatureCollection<Point>} pointFeatureSet point set to study
- * @param {Object} [options={}] optional parameters
- * @param {bbox} [options.studyBbox] bbox representing the study area
- * @param {number} [options.confidenceLevel=20] a confidence level.
- * The unit is percentage . 5 means 95%, value must be in {@link K_TABLE}
- * @returns {Object} result {@link QuadratAnalysisResult}
- * @example
- *
- * var bbox = [-65, 40, -63, 42];
- * var dataset = turf.randomPoint(100, { bbox: bbox });
- * var result = turf.quadratAnalysis(dataset);
- *
- */
-function quadratAnalysis(pointFeatureSet, options) {
-    options = options || {};
-    const studyBbox = options.studyBbox || bbox_1.default(pointFeatureSet);
-    const confidenceLevel = options.confidenceLevel || 20;
-    const points = pointFeatureSet.features;
-    // create square-grid
-    const numOfPoints = points.length;
-    const sizeOfArea = area_1.default(bbox_polygon_1.default(studyBbox));
-    const lengthOfSide = Math.sqrt((sizeOfArea / numOfPoints) * 2);
-    const grid = square_grid_1.default(studyBbox, lengthOfSide, {
-        units: "meters",
-    });
-    const quadrats = grid.features;
-    // count the number of features in each quadrat
-    const quadratIdDict = {};
-    for (let i = 0; i < quadrats.length; i++) {
-        quadratIdDict[i] = {
-            box: bbox_1.default(quadrats[i]),
-            cnt: 0,
-        };
-    }
-    let sumOfPoint = 0;
-    for (const pt of points) {
-        for (const key of Object.keys(quadratIdDict)) {
-            const box = quadratIdDict[key].box;
-            if (inBBox(invariant_1.getCoord(pt), box)) {
-                quadratIdDict[key].cnt += 1;
-                sumOfPoint += 1;
-                break;
-            }
-        }
-    }
-    // the most amount of features in quadrat
-    let maxCnt = 0;
-    for (const key of Object.keys(quadratIdDict)) {
-        const cnt = quadratIdDict[key].cnt;
-        if (cnt > maxCnt) {
-            maxCnt = cnt;
-        }
-    }
-    const expectedDistribution = [];
-    const numOfQuadrat = Object.keys(quadratIdDict).length;
-    const lambda = sumOfPoint / numOfQuadrat;
-    // get the cumulative probability of the random distribution
-    let cumulativeProbility = 0.0;
-    for (let x = 0; x < maxCnt + 1; x++) {
-        cumulativeProbility +=
-            (Math.exp(-lambda) * Math.pow(lambda, x)) / factorial(x);
-        expectedDistribution.push(cumulativeProbility);
-    }
-    // get the cumulative probability of the observed distribution
-    const observedDistribution = [];
-    let cumulativeObservedQuads = 0;
-    for (let x = 0; x < maxCnt + 1; x++) {
-        for (const key of Object.keys(quadratIdDict)) {
-            if (quadratIdDict[key].cnt === x) {
-                cumulativeObservedQuads += 1;
-            }
-        }
-        const p = cumulativeObservedQuads / numOfQuadrat;
-        observedDistribution.push(p);
-    }
-    // get the largest absolute difference between two distributions
-    let maxDifference = 0;
-    for (let x = 0; x < maxCnt + 1; x++) {
-        const difference = Math.abs(expectedDistribution[x] - observedDistribution[x]);
-        if (difference > maxDifference) {
-            maxDifference = difference;
-        }
-    }
-    const k = K_TABLE[confidenceLevel];
-    // statistical test
-    const criticalValue = k / Math.sqrt(numOfQuadrat);
-    const result = {
-        criticalValue,
-        isRandom: true,
-        maxAbsoluteDifference: maxDifference,
-        observedDistribution,
-    };
-    if (maxDifference > criticalValue) {
-        result.isRandom = false;
-    }
-    return result;
-}
-exports.default = quadratAnalysis;
-/**
- * the confidence level
- * @type {Object} K_TABLE
- * @property {number} 20
- * @property {number} 15
- * @property {number} 10
- * @property {number} 5
- * @property {number} 2
- * @property {number} 1
- */
-const K_TABLE = {
-    20: 1.07275,
-    15: 1.13795,
-    10: 1.22385,
-    5: 1.3581,
-    2: 1.51743,
-    1: 1.62762,
-};
-/**
- * the return type of the quadratAnalysis
- * @typedef {Object} QuadratAnalysisResult
- * @property {number} criticalValue
- * @property {number} maxAbsoluteDifference
- * @property {boolean} isRandom
- * @property {Array.<number>} observedDistribution the cumulative distribution of observed features,
- * the index represents the number of features in the quadrat.
- */
-/**
- * inBBox from @turf/boolean-point-in-polygon
- *
- * @private
- * @param {Array<number>} pt point [x,y]
- * @param {BBox} bbox BBox [west, south, east, north]
- * @returns {boolean} true/false if point is inside BBox
- */
-function inBBox(pt, bbox) {
-    return (bbox[0] <= pt[0] && bbox[1] <= pt[1] && bbox[2] >= pt[0] && bbox[3] >= pt[1]);
-}
-/**
- * https://stackoverflow.com/questions/3959211/fast-factorial-function-in-javascript
- * @private
- * @param {number} num Number
- * @returns {number} the factorial of num
- */
-function factorial(num) {
-    const f = [];
-    function inner(n) {
-        if (n === 0 || n === 1) {
-            return 1;
-        }
-        if (f[n] > 0) {
-            return f[n];
-        }
-        return (f[n] = inner(n - 1) * n);
-    }
-    return inner(num);
-}