qesuite 1.0.1 → 1.0.2

package/classes.ts

@@ -0,0 +1,240 @@
+import { Mean } from ".";
+
+// Specification Classes
+export class QESpecification{
+    constructor(spec: any, USL: number = NaN, LSL: number = NaN, tolerance: number = NaN, tol_plus: number = NaN, tol_minus: number = NaN, units: string = ''){
+        if(Number.isNaN(Number(spec))){
+            let parsed = this.ParseSpec(spec);
+            this.nominal = parsed.nominal;
+            this.USL = parsed.USL;
+            this.LSL = parsed.LSL;
+            this.tolerance = parsed.tolerance ?? NaN;
+            this.tol_plus = parsed.tol_plus ?? NaN;
+            this.tol_minus = parsed.tol_minus ?? NaN;
+            this.units = parsed.units ?? '';
+        }else{
+            this.nominal = spec;
+            this.USL = USL;
+            this.LSL = LSL;
+            this.tolerance = tolerance;
+            this.tol_plus = tol_plus;
+            this.tol_minus = tol_minus;
+            this.units = units;
+        }
+        
+    }
+
+    nominal: number;
+    USL: number;
+    LSL: number;
+    units: string;
+    tolerance: number;
+    tol_plus: number;
+    tol_minus: number;
+
+    // methods
+    ParseSpec(spec: string) {
+        // This function parses specs and returns an array of values, in this order:
+        // Nominal, USL, LSL, Units, Tolerance(if UT and LT differ then {UT, LT})
+        let string = spec;
+        let nominal;
+        let USL;
+        let LSL;
+        let tol_plus;
+        let tol_minus;
+        let tol;
+        let units;
+      
+        if (string.indexOf("±") !== -1) {
+          nominal = Number(string.substring(0, string.indexOf("±")).replace("Ø", ""));
+          let after = this.SplitUnits(string.substring(string.indexOf("±") + 1));
+          tol = Number(after[0]);
+          units = after[1];
+          tol_plus = Number(tol);
+          tol_minus = Number(tol);
+        }
+        if (string.indexOf("+") !== -1) {
+          tol_plus = Number(this.SplitUnits(string.substring(string.indexOf("+") + 1))[0]);
+          nominal = Number(this.SplitUnits(string)[0]);
+        }
+        if (string.indexOf("-") !== -1) {
+          tol_minus = Number(this.SplitUnits(string.substring(string.indexOf("-") + 1))[0]);
+          nominal = Number(this.SplitUnits(string)[0]);
+        }
+        if (string.indexOf("+-") !== -1 || string.indexOf("+/-") !== -1) {
+          nominal = Number(string.substring(0, string.indexOf("+")));
+          let after = this.SplitUnits(string.substring(string.indexOf("-") + 1));
+          tol = Number(after[0]);
+          units = after[1];
+          tol_plus = Number(tol);
+          tol_minus = Number(tol);
+        }
+        if (string.indexOf("-+") !== -1 || string.indexOf("-/+") !== -1) {
+          nominal = Number(string.substring(0, string.indexOf("-")));
+          let after = this.SplitUnits(string.substring(string.indexOf("+") + 1));
+          tol = Number(after[0]);
+          units = after[1];
+          tol_plus = Number(tol);
+          tol_minus = Number(tol);
+        }
+      
+        if(nominal && tol_plus && tol_minus){
+          USL = nominal + tol_plus;
+          //   Round USL
+          let digits = String(tol_plus).split(".");
+          
+          USL = Number(USL).toFixed(digits[1].length);
+        
+        
+          LSL = nominal - tol_minus;
+          // Round LSL
+          digits = String(tol_minus).split(".");
+          
+          LSL = Number(LSL).toFixed(digits[1].length);
+        }
+        
+        if (tol) {
+          return {
+            nominal: nominal ?? NaN,
+            USL: USL ?? NaN,
+            LSL: LSL ?? NaN,
+            units: units ?? '',
+            tolerance: tol ?? NaN
+          }
+        } else {
+          return {
+            nominal: nominal ?? NaN,
+            USL: USL ?? NaN,
+            LSL: LSL ?? NaN,
+            units: units,
+            tol_plus: tol_plus ?? NaN,
+            tol_minus: tol_minus ?? NaN
+          }
+        }
+    }
+    SplitUnits(string: string) {
+        let dim = "";
+        let units = "";
+        let isDim = true;
+        for (let i = 0; i < string.length; i++) {
+          if (!Number(string.substring(i, i + 1))) {
+            isDim = true;
+            if (string.substring(i, i + 1) === "." || string.substring(i, i + 1) === "0") {
+              isDim = true;
+            }
+          }
+          if (isDim) {
+            dim += string.substring(i, i + 1);
+          } else {
+            units += string.substring(i, i + 1);
+          }
+        }
+        return [dim, units]
+    }
+}
+
+// GRR Classes
+export class GRR_Data{
+    constructor(operators: GRR_Operator[]){
+        this.operators = operators
+    }
+
+    operators: GRR_Operator[];
+
+    getPartsByIndex(index?: number){
+        let array: any[] = [];
+        this.operators.forEach(r => {
+            array = [...array, ...r.getPartsByIndex(index)]
+        })
+        return array;
+    }
+
+    getPartCount(){
+        let partCount = this.operators.map( r => {return r.getPartCount()});        
+        return partCount.every(v => v === partCount[0]) ? partCount[0] : NaN;
+    }
+    
+    getReplicationCount(){
+        let replicationCount = this.operators.map(o => {return o.replications.length})
+        return replicationCount.every(v => v === replicationCount[0]) ? replicationCount[0] : NaN;
+    }
+
+    getOperatorCount(){
+        return this.operators.length;
+    }
+
+    getOperatorMeans(){
+        return this.operators.map(o => {return o.getMean()})
+    }
+
+    getPartMeans(){
+        let N = this.getPartCount();
+        let partMeans: number[] = [];
+
+        let N_op = this.getOperatorCount();
+        let N_rep = this.getReplicationCount();
+
+        for(let i = 0; i < N; i++){
+            partMeans.push(Mean(this.getPartsByIndex(i)));
+        }
+        return partMeans;
+    }
+
+    getGrandMean(){
+        return Mean(this.getOperatorMeans());
+    }
+}
+
+export class GRR_Operator{
+    constructor(replications: GRR_Replication[], name?: string){
+        this.replications = replications;
+        this.name = name ?? '';
+    }
+    replications: GRR_Replication[];
+    name: string;
+
+    getPartsByIndex(index?: number){
+        let array: any[] = [];
+        this.replications.forEach(r => {
+            array = [...array, ...r.getPartsByIndex(index)]
+        })
+        return array;
+    }
+
+    getPartCount(){
+        let partCount = this.replications.map( r => {return r.getPartCount()});        
+        return partCount.every(v => v === partCount[0]) ? partCount[0] : NaN;
+    }
+
+    getPartAverages(){
+        let partAverages: number[] = [];
+        let partCount = this.getPartCount();
+        for(let i = 0; i < partCount; i++){
+            let parts = this.getPartsByIndex(i);
+            partAverages.push(Mean(parts));
+        }
+        return partAverages;
+    }
+
+    getMean(){
+        return Mean(this.getPartAverages());
+    }
+}
+
+export class GRR_Replication{
+    constructor(parts: number[]){
+        this.parts = parts;
+    }
+    parts: number[];
+
+    getPartsByIndex(index?: number){
+        if(index === undefined){
+            return this.parts
+        }
+        return [this.parts[index]];
+    }
+
+    getPartCount(){
+        return this.parts.length
+    }
+}