Reference Value Algorithm (#6)

* feat: reference function create & result type set

* feat: function parameter change & referenceArray find

* feat: add sample data & fix referenceArray finding method

* feat: find rangeValue [scan referenceArray and notReference Array]

* feat: complete referenceValue algorithm ✅

* feat: add test case1

* feat: add test case2

* feat: add LAST test case ✅

* style: edit comment lines

* refactor: improvement code style and change variable

* style: remove space

* fix: null type issue fixed

* fix: type changed. All issues fixed ✅

* style: variable name changed

Author: burakodabas

src/algorithms/reference-value.ts

@@ -0,0 +1,41 @@
+import { ReferenceResult, FormulaType } from '../types';
+const _ = require('lodash');
+
+export function ReferenceValue(
+  x: number,
+  formulae: FormulaType[]
+): ReferenceResult | null {
+  /* First, try to calculate using reference Formula */
+  const referenceArray = formulae.filter((formula) => formula.is_reference);
+  let formulaInRange = referenceArray.filter((r) => {
+    return r.min <= x && r.max >= x;
+  });
+
+  /* Second, if reference value is not found, try to calculate using non-reference Formula */
+  if (formulaInRange.length === 0) {
+    const notReferenceArray = formulae.filter(
+      (formula) => formula.is_reference === false
+    );
+
+    formulaInRange = notReferenceArray.filter((r) => {
+      return r.min <= x && r.max >= x;
+    });
+  }
+
+  // if there is no range value both reference and not reference value are in the range of x then return null
+  if (formulaInRange.length === 0) {
+    return null;
+  }
+
+  // Lastly, calculate the value using the formula
+  const chainArray = formulaInRange.map((r) => {
+    const formulaResult = eval(r.formula.replace(/X/g, x.toString()));
+    return {
+      method: r.method,
+      value: formulaResult,
+    };
+  });
+
+  return _.maxBy(chainArray, 'value');
+  
+}

src/lib.ts

@@ -6,4 +6,6 @@ export * from './algorithms/q-hampel';
 
 export * from './algorithms/a-algorithm';
 
+export * from './algorithms/reference-value';
+
 export * from './grubbs';

src/types.ts

@@ -6,5 +6,16 @@ export type AResult = {
   robust: number;
   robustDeviation: number;
   highLimit: number;
-  lowLimit: number;  
-};
+  lowLimit: number;
+};
+export type ReferenceResult = {
+  value: number;
+  method: string;
+};
+export type FormulaType = {
+  is_reference: boolean;
+  method: string;
+  formula: string;
+  min: number;
+  max: number;
+};

tests/algorithms.test.ts

@@ -1,6 +1,113 @@
-import { MADe, M_Estimator, Q, Hampel, A_Algorithm } from '../src/lib';
+import {
+  MADe,
+  M_Estimator,
+  Q,
+  Hampel,
+  A_Algorithm,
+  ReferenceValue,
+} from '../src/lib';
 
 describe('Algorithms', () => {
+  it('Reference Value (CASE1: x value is not range)', () => {
+    let x = 0.4;
+    const formulae = [
+      {
+        formula: '0.075*X+4.6',
+        method: 'TS EN 13132',
+        min: 60.1,
+        max: 500.0,
+        is_reference: true,
+      },
+      {
+        formula: '0.016*X+3.70 ',
+        method: 'TS EN ISO 13032',
+        min: 8.0,
+        max: 50.0,
+        is_reference: true,
+      },
+      {
+        formula: '0.6*X',
+        method: 'ASTM D381',
+        min: 1.0,
+        max: 30.0,
+        is_reference: false,
+      },
+    ];
+    const output = ReferenceValue(x, formulae);
+
+    expect(output).toBe(null);
+  });
+
+  it('Reference Value (CASE2: is not reference array)', () => {
+    let x = 0.4;
+    const formulae = [
+      {
+        formula: '0.075*X+4.6',
+        method: 'TS EN 13132',
+        min: 60.1,
+        max: 500.0,
+        is_reference: false,
+      },
+      {
+        formula: '0.016*X+3.70 ',
+        method: 'TS EN ISO 13032',
+        min: 8.0,
+        max: 50.0,
+        is_reference: false,
+      },
+      {
+        formula: '0.6*X',
+        method: 'ASTM D381',
+        min: 1.0,
+        max: 30.0,
+        is_reference: false,
+      },
+    ];
+    let output = ReferenceValue(x, formulae);
+    expect(output).toBe(null);
+
+    x = 10;
+    output = ReferenceValue(x, formulae);
+
+    expect(output?.value).toBeCloseTo(6, 3);
+    expect(output?.method).toBe('ASTM D381');
+  });
+
+  it('Reference Value (CASE3: is reference array)', () => {
+    let x = 0.4;
+    const formulae = [
+      {
+        formula: '0.075*X+4.6',
+        method: 'TS EN 13132',
+        min: 60.1,
+        max: 500.0,
+        is_reference: true,
+      },
+      {
+        formula: '0.016*X+3.70 ',
+        method: 'TS EN ISO 13032',
+        min: 8.0,
+        max: 50.0,
+        is_reference: true,
+      },
+      {
+        formula: '0.6*X',
+        method: 'ASTM D381',
+        min: 1.0,
+        max: 30.0,
+        is_reference: false,
+      },
+    ];
+    let output = ReferenceValue(x, formulae);
+    expect(output).toBe(null);
+
+    x = 10;
+    output = ReferenceValue(x, formulae);
+
+    expect(output?.value).toBeCloseTo(3.86, 3);
+    expect(output?.method).toBe('TS EN ISO 13032');
+  });
+
   it('A algorithm', () => {
     const samples = [
       0.04, 0.055, 0.178, 0.202, 0.206, 0.227, 0.228, 0.23, 0.23, 0.235, 0.236,