mechanical-tolerance-calculator 1.0.3 → 1.0.5

package/README.md

@@ -29,7 +29,7 @@ console.log(housingTolerances["housingBoresTolerances"]);
 
 ---
 
-## API
+## API EXACPLES
 
 ### `getAllTolerancesFor(materialType: String)`
 

package/index.js

@@ -96,40 +96,299 @@ function returnTolerancesFor(executableMaterialType, spec = "") {
   };
 }
 
-function parseNominalFromMeasurement(measurement) {
-  const nominalString = measurement.toString();
-  let nominal = "";
-  for (let index = 0; index < nominalString.length; index++) {
-    if (nominalString[index] === ".") {
-      break;
-    }
-    nominal += nominalString[index];
+function parseNominalFromMeasurement(measurement, materialType) {
+  // For shafts: upper_deviation is 0, so measurement ≤ nominal
+  // Therefore, nominal must be ceiling of measurement
+  if (materialType === "shafts") {
+    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);
   }
-  return parseInt(nominal);
+
+  // Default: round to nearest
+  return Math.round(measurement);
+}
+
+const MATERIAL_TYPE_CONFIG = {
+  shafts: {
+    specification: "h9",
+    itGrade: "IT5",
+
+    rangeMatch: (nominal, spec) =>
+      nominal > spec.minimum_diameter && nominal <= spec.maximum_diameter,
+  },
+  housingBores: {
+    specification: "H8",
+    itGrade: "IT6",
+
+    rangeMatch: (nominal, spec) =>
+      nominal >= spec.minimum_diameter && nominal < spec.maximum_diameter,
+  },
+  shellBores: {
+    specification: "H9",
+    itGrade: "IT6",
+    rangeMatch: (nominal, spec) =>
+      nominal >= spec.minimum_diameter && nominal < spec.maximum_diameter,
+  },
+};
+
+function findMatchingSpec(nominal, specs, rangeMatchFn) {
+  return specs.find((spec) => rangeMatchFn(nominal, spec)) || null;
+}
+
+function calculateComputedBounds(nominal, spec) {
+  return {
+    upperBound: parseComputedBound(nominal, spec.upper_deviation, 3),
+    lowerBound: parseComputedBound(nominal, spec.lower_deviation, 3),
+  };
+}
+
+function calculateUncomputedBounds(nominal, spec) {
+  return {
+    upperBound: parseUncomputedBound(nominal, spec.upper_deviation, "+"),
+    lowerBound: parseUncomputedBound(nominal, spec.lower_deviation, "-"),
+  };
+}
+
+function checkMeetsSpecification(measurement, bounds) {
+  const measure = parseStringFloat(measurement);
+  const upper = parseStringFloat(bounds.upperBound);
+  const lower = parseStringFloat(bounds.lowerBound);
+
+  return measure >= lower && measure <= upper;
+}
+
+function processMeasurement(materialType, measurement, tolerances) {
+  const config = MATERIAL_TYPE_CONFIG[materialType];
+
+  if (!config) {
+    return {
+      error: true,
+      message: `Unknown material type: ${materialType}`,
+    };
+  }
+
+  // Calculate nominal diameter
+  const nominal = parseNominalFromMeasurement(measurement, materialType);
+
+  // Find matching specification
+  const matchedSpec = findMatchingSpec(
+    nominal,
+    tolerances.specification,
+    config.rangeMatch
+  );
+
+  if (!matchedSpec) {
+    return {
+      error: true,
+      message: `No specification found for nominal diameter: ${nominal}`,
+      nominal,
+    };
+  }
+
+  // Calculate bounds
+  const computedBounds = calculateComputedBounds(nominal, matchedSpec);
+  const uncomputedBounds = calculateUncomputedBounds(nominal, matchedSpec);
+
+  // 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}`;
+
+  return {
+    measurement: parseStringFloat(measurement),
+    nominal,
+    specification: config.specification,
+    IT_grade: config.itGrade,
+    computed_specification_bounds: computedBounds,
+    uncomputed_specification_bounds: uncomputedBounds,
+    matched_spec: matchedSpec,
+
+    meets_specification: { meetsSpec, reason: specMeetingReason },
+  };
+}
+
+function processOneMeasurement(materialType, measurement, tolerances) {
+  const processedMeasurement = processMeasurement(
+    materialType,
+    measurement,
+    tolerances
+  );
+  return {
+    ...processedMeasurement,
+    meets_IT_tolerance: processedMeasurement.meet_specification,
+  };
 }
 
 function checkOneMeasurementFor(materialType, measurement) {
   const camcoStandardTolerances = getCamcoStandardTolerancesFor(materialType);
-  let nominal = parseNominalFromMeasurement(measurement);
-  let matchedSpec = {};
-  if (camcoStandardTolerances.type === "shafts") {
-    const shaftNominal = nominal + 1;
-    const specs = camcoStandardTolerances["specification"];
-    Array.from(specs).forEach((spec) => {
-      if (
-        shaftNominal > spec.minimum_diameter &&
-        shaftNominal <= spec.maximum_diameter
-      ) {
-        matchedSpec = spec;
-      }
-    });
 
-    const check = Number(matchedSpec.upper_deviation).toFixed(3);
-    console.log(check);
+  if (camcoStandardTolerances.error) {
+    return camcoStandardTolerances;
+  }
+
+  if (typeof measurement !== "number" || isNaN(measurement)) {
+    return {
+      error: true,
+      message: "Invalid measurement value",
+    };
+  }
+
+  return processOneMeasurement(
+    camcoStandardTolerances.type,
+    measurement,
+    camcoStandardTolerances
+  );
+}
+
+function parseComputedBound(base, value, decimalCount) {
+  return Number(base + parseStringFloat(value)).toFixed(decimalCount);
+}
+
+function parseUncomputedBound(value1, value2, sign) {
+  if (value2.startsWith("-")) {
+    return (
+      parseToFixedThreeString(value1) +
+      " " +
+      sign +
+      " " +
+      parseToFixedThreeString(value2.slice(1, value2.length))
+    );
+  }
+
+  return (
+    parseToFixedThreeString(value1) +
+    " " +
+    sign +
+    " " +
+    parseToFixedThreeString(value2)
+  );
+}
+
+function parseToFixedThreeString(value) {
+  if (typeof value === "number") {
+    return value.toFixed(3);
+  }
+  return value;
+}
+
+/**
+ * Converts string float values to actual float numbers
+ * @param {string} value - The string representation of a float number
+ * @returns {number} - The parsed float number
+ */
+function parseStringFloat(value) {
+  // Handle edge cases
+  if (value === null || value === undefined) {
+    return 0;
+  }
+
+  // If it's already a number, return it
+  if (typeof value === "number") {
+    return value;
+  }
+
+  // Convert string to float
+  const parsed = parseFloat(value);
+
+  // Return 0 if parsing fails (NaN)
+  return isNaN(parsed) ? 0 : parsed;
+}
+function processIndividualMeasurement(
+  materialType,
+  measurement,
+  tolerances,
+  meetsIT,
+  ITMeetingReason
+) {
+  const processedMeasurement = processMeasurement(
+    materialType,
+    measurement,
+    tolerances
+  );
+  return {
+    ...processedMeasurement,
+  };
+}
+
+function checkMultipleMeasurementsFor(materialType, measurements) {
+  const validation = validateMeasurements(measurements);
+  if (validation?.error) {
+    return validation;
+  }
+  const camcoStandardTolerances = getCamcoStandardTolerancesFor(materialType);
+
+  let largestMeasurement = Math.max(...measurements);
+  let smallestMeasurement = Math.min(...measurements);
+  let ITDifference = parseToFixedThreeString(
+    largestMeasurement - smallestMeasurement
+  );
+
+  const ITs = {
+    IT5: 0,
+    IT6: 0,
+    IT7: 0,
+    IT8: 0,
+    IT9: 0,
+  };
+
+  const results = measurements.map((measurement) => {
+    const result = processIndividualMeasurement(
+      camcoStandardTolerances.type,
+      measurement,
+      camcoStandardTolerances
+    );
+
+    ITs[result.IT_grade]++;
+
+    return result;
+  });
+
+  const baseSpec = results[0];
+  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}.`;
+
+  return {
+    baseSpec,
+    meets_IT_Tolerance: { meetsIT, reason: itMeetingReason },
+  };
+}
+
+function validateMeasurements(measurements) {
+  if (!Array.isArray(measurements)) {
+    return {
+      error: "Measurements must be an array of numbers",
+    };
+  }
+
+  if (measurements.length === 0) {
+    return {
+      error: "Measurements array cannot be empty",
+    };
   }
-  console.log(nominal);
 
-  console.log(matchedSpec);
+  return null;
 }
 
 module.exports = {
@@ -137,4 +396,5 @@ module.exports = {
   getCamcoStandardTolerancesFor,
   parseNominalFromMeasurement,
   checkOneMeasurementFor,
+  checkMultipleMeasurementsFor,
 };

package/package.json

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