mechanical-tolerance-calculator 1.1.9 → 1.2.1

package/index.js

@@ -379,28 +379,27 @@ function checkMultipleMeasurementsFor(materialType, measurements) {
     largestMeasurement - smallestMeasurement,
   );
 
-  let mostFarMeasurement = largestMeasurement;
   const nominals = {};
   let count = 0;
-  let withInSpecs = [];
+  // let withInSpecs = [];
   const results = measurements.map((measurement) => {
     const result = processIndividualMeasurement(
       camcoStandardTolerances.type,
       measurement,
       camcoStandardTolerances,
     );
-    withInSpecs.push(result.meets_specification.meetsSpec);
+    // withInSpecs.push(result.meets_specification.meetsSpec);
     const nominal = result.nominal;
 
     // count occurrences
     nominals[nominal] = (nominals[nominal] || 0) + 1;
 
-    if (
-      Math.abs(result.nominal - result.measurement) >
-      Math.abs(result.nominal - mostFarMeasurement)
-    ) {
-      mostFarMeasurement = result.measurement;
-    }
+    // if (
+    //   Math.abs(result.nominal - result.measurement) >
+    //   Math.abs(result.nominal - mostFarMeasurement)
+    // ) {
+    //   mostFarMeasurement = result.measurement;
+    // }
 
     return result;
   });
@@ -410,6 +409,12 @@ function checkMultipleMeasurementsFor(materialType, measurements) {
   let mostOccuredNominal = Object.keys(nominals).find(
     (nominal) => nominals[nominal] === countOfMostOccuredNominal,
   );
+  let mostFarMeasurement = measurements.reduce((farthest, current) => {
+    return Math.abs(current - mostOccuredNominal) >
+      Math.abs(farthest - mostOccuredNominal)
+      ? current
+      : farthest;
+  });
 
   const baseSpec = results.find(
     (result) => result.nominal === parseInt(mostOccuredNominal),
@@ -422,14 +427,23 @@ function checkMultipleMeasurementsFor(materialType, measurements) {
     largestMeasurement,
     smallestMeasurement,
     baseITValue,
+    baseSpec.IT_grade,
   );
 
-  const meetsSpec = withInSpecs.every((v) => v === true);
+  const meetsSpec = results.every((r) => {
+    const value = r.measurement;
+    return (
+      value >= baseSpec.computed_specification_bounds.lowerBound &&
+      value <= baseSpec.computed_specification_bounds.upperBound
+    );
+  });
+
   const specMeetingReason = generateReasonForSpecs(
     meetsSpec,
     mostFarMeasurement,
     baseSpec.computed_specification_bounds.lowerBound,
     baseSpec.computed_specification_bounds.upperBound,
+    baseSpec.specification,
   );
 
   const isOverSized =
@@ -437,50 +451,72 @@ function checkMultipleMeasurementsFor(materialType, measurements) {
   const isWithinSizeRange =
     mostFarMeasurement <= baseSpec.computed_specification_bounds.upperBound &&
     mostFarMeasurement >= baseSpec.computed_specification_bounds.lowerBound;
-  const outcome =
-    (isWithinSizeRange
-      ? `${materialType} is acceptable in size`
-      : isOverSized
-        ? `${materialType} is over-sized`
-        : `${materialType} is under-sized`) +
-    (isWithinSizeRange && meetsIT
-      ? `, and `
-      : !meetsIT && isWithinSizeRange
-        ? `, but `
-        : `, and `) +
-    (meetsIT ? `meets IT tolerance.` : `doesn't meet IT tolerance.`);
+
+  const outcome1 = isWithinSizeRange
+    ? `${materialType} is acceptable in size.`
+    : isOverSized
+      ? `${materialType} is over-sized.`
+      : `${materialType} is under-sized.`;
+
+  const outcome2 =
+    isWithinSizeRange && meetsIT
+      ? "And, it meets IT tolerance."
+      : !isWithinSizeRange && meetsIT
+        ? "However, it meets IT tolerance."
+        : `${!isWithinSizeRange ? "And, " : "But, "}it fails IT tolerance.`;
+
+  // const outcome2 = meetsIT ? ""
+
+  //   (isWithinSizeRange && meetsIT
+  //     ? `, and `
+  //     : !meetsIT && isWithinSizeRange
+  //       ? `, but `
+  //       : `, and `) +
+  //   (meetsIT ? `meets IT tolerance.` : `doesn't meet IT tolerance.`);
+
+  const final_compliance = meetsIT === true && meetsSpec === true;
+
+  const outcome3 = final_compliance
+    ? "Finally, it meets final compliance and is acceptable to use."
+    : "Finally, it doesn't meet final compliance and is not acceptable to use.";
   return {
     ...baseSpec,
     measurement: measurements,
     meets_specification: { meetsSpec, reason: specMeetingReason },
     meets_IT_Tolerance: { meetsIT, reason: itMeetingReason },
-    meets_final_compliance: meetsIT === true && meetsSpec === true,
-    generalized_outcome: outcome,
+    meets_final_compliance: final_compliance,
+    generalized_outcome: outcome1 + " " + outcome2 + " " + outcome3,
   };
 }
 
-function generateReasonForSpecs(spec, measurement, base1, base2) {
+function generateReasonForSpecs(spec, measurement, base1, base2, specType) {
   if (spec === true) {
     return `${parseToFixedThreeString(
       measurement,
-    )} falls between ${base1} and ${base2}`;
+    )} falls between ${base1} and ${base2}. So, the material meets ${specType} specification.`;
   }
   return `${parseToFixedThreeString(
     measurement,
-  )} doesn't fall between ${base1} and ${base2}`;
+  )} doesn't fall between ${base1} and ${base2}. So, the material doesn't meet ${specType} specification.`;
 }
 
-function generateReasonForTolerances(spec, measurement1, measurement2, base) {
+function generateReasonForTolerances(
+  spec,
+  measurement1,
+  measurement2,
+  base,
+  toleranceType,
+) {
   if (spec === true) {
     return `The difference between ${parseToFixedThreeString(
       measurement1,
     )} and ${parseToFixedThreeString(
       measurement2,
-    )} is less than or equal to ${base}.`;
+    )} is less than or equal to ${base}. So, it meets ${toleranceType} Tolerance.`;
   }
   return `The difference between ${parseToFixedThreeString(
     measurement1,
-  )} and ${parseToFixedThreeString(measurement2)} is greater than ${base}.`;
+  )} and ${parseToFixedThreeString(measurement2)} is greater than ${base}. So, it doesn't meet ${toleranceType} Tolerance.`;
 }
 
 function validateMeasurements(measurements) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mechanical-tolerance-calculator",
-  "version": "1.1.9",
+  "version": "1.2.1",
   "description": "Calculates international standard specification and  tolerances for bores, round bars and metals of mechanical units. For examples; H7, H8, H9, h8, h9 specifications and IT5/IT6 tolerances.",
   "main": "index.js",
   "scripts": {

package/test.js

@@ -1,4 +1,6 @@
 const { checkMultipleMeasurementsFor } = require("./index");
 // console.log(checkMultipleMeasurementsFor("housing", [100.04, 100.05]));
 // console.log(checkMultipleMeasurementsFor("housing", [100.04, 100.05, 95.06]));
-console.log(checkMultipleMeasurementsFor("shaft", [98.99, 98.98]));
+console.log(
+  checkMultipleMeasurementsFor("housing", [100, 32, 32, 1, 100, 100]),
+);