mechanical-tolerance-calculator 1.0.6 → 1.0.8

package/index.js

@@ -96,17 +96,34 @@ function returnTolerancesFor(executableMaterialType, spec = "") {
   };
 }
 
-function parseNominalFromMeasurement(measurement, materialType) {
+function parseNominalFromMeasurement(
+  measurement,
+  materialType,
+  THRESHOLD = 0.9
+) {
+  const lowerNominal = Math.floor(measurement);
+
   // For shafts: upper_deviation is 0, so measurement ≤ nominal
   // Therefore, nominal must be ceiling of measurement
   if (materialType === "shafts") {
+    const standardNominal = Math.ceil(measurement); //a standard shaft will always have measurements less than the nominal
+
+    //however, in some cases, we get shafts going beyond the upper deviation
+    //so, we work with a threshold of 0.10 (meaning, a shaft can only go upto 0.10 of it's upper deviation)
+    if (standardNominal - measurement >= THRESHOLD) {
+      return Math.floor(measurement);
+    }
     return Math.ceil(measurement);
   }
 
   // For bores: lower_deviation is 0, so measurement ≥ nominal
   // Therefore, nominal must be floor of measurement
   if (materialType === "housingBores" || materialType === "shellBores") {
-    return Math.floor(measurement);
+    const standardNominal = Math.floor(measurement);
+
+    return measurement - standardNominal >= THRESHOLD
+      ? Math.ceil(measurement)
+      : standardNominal;
   }
 
   // Default: round to nearest
@@ -196,13 +213,21 @@ function processMeasurement(materialType, measurement, tolerances) {
 
   // Check if measurement meets specification
   const meetsSpec = checkMeetsSpecification(measurement, computedBounds);
-  const specMeetingReason = meetsSpec
-    ? `${parseToFixedThreeString(measurement)} falls between ${
-        computedBounds.lowerBound
-      } and ${computedBounds.upperBound}`
-    : `${parseToFixedThreeString(measurement)} doesn't fall between ${
-        computedBounds.lowerBound
-      } and ${computedBounds.upperBound}`;
+
+  const specMeetingReason = generateReasonForSpecs(
+    meetsSpec,
+    measurement,
+    computedBounds.lowerBound,
+    computedBounds.upperBound
+  );
+
+  const outcome =
+    measurement > computedBounds.upperBound
+      ? `${materialType} is over-sized.`
+      : measurement >= computedBounds.lowerBound &&
+        measurement <= computedBounds.upperBound
+      ? `${materialType} is in acceptable size.`
+      : `${materialType} is under-sized.`;
 
   return {
     measurement: parseStringFloat(measurement),
@@ -213,7 +238,11 @@ function processMeasurement(materialType, measurement, tolerances) {
     uncomputed_specification_bounds: uncomputedBounds,
     matched_spec: matchedSpec,
 
-    meets_specification: { meetsSpec, reason: specMeetingReason },
+    meets_specification: {
+      meetsSpec,
+      reason: specMeetingReason,
+      concludedReason: outcome,
+    },
   };
 }
 
@@ -325,15 +354,26 @@ function checkMultipleMeasurementsFor(materialType, measurements) {
     largestMeasurement - smallestMeasurement
   );
 
+  let mostFarMeasurement = largestMeasurement;
   const nominals = {};
   let count = 0;
+  let withInSpecs = [];
   const results = measurements.map((measurement) => {
     const result = processIndividualMeasurement(
       camcoStandardTolerances.type,
       measurement,
       camcoStandardTolerances
     );
+    withInSpecs.push(result.meets_specification.meetsSpec);
     nominals[result.nominal] = count++;
+
+    if (
+      Math.abs(result.nominal - result.measurement) >
+      Math.abs(result.nominal - mostFarMeasurement)
+    ) {
+      mostFarMeasurement = result.measurement;
+    }
+
     return result;
   });
 
@@ -342,7 +382,6 @@ function checkMultipleMeasurementsFor(materialType, measurements) {
   let mostOccuredNominal = Object.keys(nominals).find(
     (nominal) => nominals[nominal] === countOfMostOccuredNominal
   );
-  console.log(mostOccuredNominal);
 
   const baseSpec = results.find(
     (result) => result.nominal === parseInt(mostOccuredNominal)
@@ -350,40 +389,71 @@ function checkMultipleMeasurementsFor(materialType, measurements) {
   const baseITValue = baseSpec.matched_spec[baseSpec.IT_grade];
 
   const meetsIT = ITDifference <= baseITValue;
-  const itMeetingReason = meetsIT
-    ? `The difference between ${parseToFixedThreeString(
-        largestMeasurement
-      )} and ${parseToFixedThreeString(
-        smallestMeasurement
-      )} is less than or equal to ${baseITValue}.`
-    : `The difference between ${parseToFixedThreeString(
-        largestMeasurement
-      )} and ${parseToFixedThreeString(
-        smallestMeasurement
-      )} is greater than to ${baseITValue}.`;
-
-  // Check if measurement meets specification
-  const meetsSpec = checkMeetsSpecification(
+  const itMeetingReason = generateReasonForTolerances(
+    meetsIT,
     largestMeasurement,
-    baseSpec?.computed_specification_bounds
+    smallestMeasurement,
+    baseITValue
+  );
+
+  const meetsSpec = withInSpecs.every((v) => v === true);
+  const specMeetingReason = generateReasonForSpecs(
+    meetsSpec,
+    mostFarMeasurement,
+    baseSpec.computed_specification_bounds.lowerBound,
+    baseSpec.computed_specification_bounds.upperBound
   );
-  console.log(meetsSpec);
-
-  const specMeetingReason = meetsSpec
-    ? `${parseToFixedThreeString(baseSpec.measurement)} falls between ${
-        baseSpec.computed_specification_bounds.lowerBound
-      } and ${baseSpec.computed_specification_bounds.upperBound}`
-    : `${parseToFixedThreeString(largestMeasurement)} doesn't fall between ${
-        baseSpec.computed_specification_bounds.lowerBound
-      } and ${baseSpec.computed_specification_bounds.upperBound}`;
+
+  const isOverSized =
+    mostFarMeasurement > baseSpec.computed_specification_bounds.upperBound;
+  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.`);
   return {
+    ...baseSpec,
+    measurement: measurements,
     meets_specification: { meetsSpec, reason: specMeetingReason },
     meets_IT_Tolerance: { meetsIT, reason: itMeetingReason },
     meets_final_compliance: meetsIT && baseSpec?.meets_specification?.meetsSpec,
-    ...baseSpec,
   };
 }
 
+function generateReasonForSpecs(spec, measurement, base1, base2) {
+  if (spec === true) {
+    return `${parseToFixedThreeString(
+      measurement
+    )} falls between ${base1} and ${base2}`;
+  }
+  return `${parseToFixedThreeString(
+    measurement
+  )} doesn't fall between ${base1} and ${base2}`;
+}
+
+function generateReasonForTolerances(spec, measurement1, measurement2, base) {
+  if (spec === true) {
+    return `The difference between ${parseToFixedThreeString(
+      measurement1
+    )} and ${parseToFixedThreeString(
+      measurement2
+    )} is less than or equal to ${base}.`;
+  }
+  return `The difference between ${parseToFixedThreeString(
+    measurement1
+  )} and ${parseToFixedThreeString(measurement2)} is greater than ${base}.`;
+}
+
 function validateMeasurements(measurements) {
   if (!Array.isArray(measurements)) {
     return {
@@ -402,7 +472,6 @@ function validateMeasurements(measurements) {
 module.exports = {
   getAllTolerancesFor,
   getCamcoStandardTolerancesFor,
-  parseNominalFromMeasurement,
   checkOneMeasurementFor,
   checkMultipleMeasurementsFor,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mechanical-tolerance-calculator",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "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": {