ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫಂಕ್ಷನ್ ರಿಟರ್ನ್‌ನಿಂದ ದಶಮಾಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು: ಒಂದು ಸರಳ ಮಾರ್ಗದರ್ಶಿ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯಗಳಲ್ಲಿ ದಶಮಾಂಶ ಸಮಸ್ಯೆಗಳನ್ನು ನಿಭಾಯಿಸುವುದು

JavaScript ಕಾರ್ಯಗಳನ್ನು ಬರೆಯುವಾಗ, ದಶಮಾಂಶ ಸಂಖ್ಯೆಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ, ವಿಶೇಷವಾಗಿ ವಿಭಾಗ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುವಾಗ. ಔಟ್‌ಪುಟ್‌ನಂತೆ ಶುದ್ಧ ಮತ್ತು ಪೂರ್ಣ ಸಂಖ್ಯೆಯ ಅಗತ್ಯವಿರುವ ಡೆವಲಪರ್‌ಗಳಿಗೆ, ಈ ದಶಮಾಂಶ ಫಲಿತಾಂಶಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುವುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ.

ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ, ಆರಂಭಿಕ ಲೆಕ್ಕಾಚಾರವು ದಶಮಾಂಶಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆಯೇ ಎಂಬುದನ್ನು ಲೆಕ್ಕಿಸದೆ, ಹಿಂತಿರುಗಿಸುವ ಮೌಲ್ಯವು ಪೂರ್ಣಾಂಕವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು JavaScript ಕಾರ್ಯವನ್ನು ಹೇಗೆ ಮಾರ್ಪಡಿಸುವುದು ಎಂಬುದನ್ನು ನಾವು ಅನ್ವೇಷಿಸುತ್ತೇವೆ. ಅನುಪಾತಗಳು ಅಥವಾ ಸರಾಸರಿಗಳನ್ನು ನಿರ್ಧರಿಸುವಂತಹ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಕಾರ್ಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಇದು ಅನೇಕ ಆರಂಭಿಕರು ಎದುರಿಸುವ ಸವಾಲಾಗಿದೆ.

ಸಮಸ್ಯೆಯು ಸಾಮಾನ್ಯವಾಗಿ ಪೂರ್ಣ ಸಂಖ್ಯೆಯ ಫಲಿತಾಂಶವನ್ನು ಉತ್ಪಾದಿಸದ ಸಂಖ್ಯೆಗಳನ್ನು ವಿಭಜಿಸುವುದರಿಂದ ಉಂಟಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಪ್ರತಿ ಶಿಕ್ಷಕರಿಗೆ ಸರಾಸರಿ ವಿದ್ಯಾರ್ಥಿಗಳ ಲೆಕ್ಕಾಚಾರವು ದಶಮಾಂಶವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಇದು ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ ಅಪೇಕ್ಷಿಸದಿರಬಹುದು. ಔಟ್‌ಪುಟ್‌ನ ಓದುವಿಕೆ ಮತ್ತು ಉಪಯುಕ್ತತೆಯನ್ನು ಸುಧಾರಿಸಲು ಈ ದಶಮಾಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು ಅಥವಾ ಪೂರ್ತಿಗೊಳಿಸುವುದು ಸಾಮಾನ್ಯ ಕಾರ್ಯವಾಗಿದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಅಂತರ್ನಿರ್ಮಿತ ಗಣಿತ ಕಾರ್ಯಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬ ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ ನಾವು ನಡೆಯುತ್ತೇವೆ Math.round(), Math.floor(), ಮತ್ತು Math.ceil(), ದಶಮಾಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಮತ್ತು ಪೂರ್ಣ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸಲು. ಇದರ ಅಂತ್ಯದ ವೇಳೆಗೆ, ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳನ್ನು ಪೂರೈಸಲು ನಿಮ್ಮ ಫಂಕ್ಷನ್ ರಿಟರ್ನ್ ಅನ್ನು ಹೇಗೆ ಫಾರ್ಮಾಟ್ ಮಾಡುವುದು ಎಂಬುದನ್ನು ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿರಿ.

ದಶಮಾಂಶಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ವಿಧಾನಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫಂಕ್ಷನ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ದಶಮಾಂಶಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ ವಿದ್ಯಾರ್ಥಿಗಳು ಪರ್ಆಡ್ಮಿನ್ ಕಾರ್ಯ, ಪೂರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಪಡೆಯಲು ಫಲಿತಾಂಶಗಳನ್ನು ಹೇಗೆ ಮಾರ್ಪಡಿಸುವುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅತ್ಯಗತ್ಯ. ಈ ಕಾರ್ಯದಲ್ಲಿ, ಪ್ರತಿ ಶಿಕ್ಷಕರಿಗೆ ಸರಾಸರಿ ವಿದ್ಯಾರ್ಥಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಶಿಕ್ಷಕರು ಮತ್ತು ಸಹಾಯಕರ ಮೊತ್ತದಿಂದ ವಿದ್ಯಾರ್ಥಿಗಳ ಸಂಖ್ಯೆಯನ್ನು ಭಾಗಿಸುವ ಮೂಲಕ ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ. ಆದಾಗ್ಯೂ, ವಿಭಜನೆಯು ಸಾಮಾನ್ಯವಾಗಿ ದಶಮಾಂಶ ಮೌಲ್ಯಗಳಿಗೆ ಕಾರಣವಾಗುವುದರಿಂದ, ಈ ಫಲಿತಾಂಶಗಳನ್ನು ನಿರ್ವಹಿಸಲು ವಿವಿಧ ಗಣಿತದ ವಿಧಾನಗಳು ಬೇಕಾಗುತ್ತವೆ. ಪ್ರತಿ ಶಿಕ್ಷಕರಿಗೆ ಎಷ್ಟು ವಿದ್ಯಾರ್ಥಿಗಳನ್ನು ನಿಯೋಜಿಸಲಾಗಿದೆ ಎಂದು ವರದಿ ಮಾಡುವಂತಹ ಸಂಪೂರ್ಣ ಸಂಖ್ಯೆ ಮಾತ್ರ ಉಪಯುಕ್ತವಾಗಿರುವ ಸಂದರ್ಭಕ್ಕೆ ಸರಿಹೊಂದುವಂತೆ ದಶಮಾಂಶ ಭಾಗವನ್ನು ಸುತ್ತಿಕೊಳ್ಳುವುದು ಅಥವಾ ಮೊಟಕುಗೊಳಿಸುವುದು ಸವಾಲಾಗಿದೆ.

ಉದಾಹರಣೆಯಲ್ಲಿ ಬಳಸಿದ ಮೊದಲ ವಿಧಾನ Math.round(). ಈ ವಿಧಾನವು ದಶಮಾಂಶ ಸಂಖ್ಯೆಯನ್ನು ಹತ್ತಿರದ ಪೂರ್ಣ ಸಂಖ್ಯೆಗೆ ಸುತ್ತುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಸರಾಸರಿ 13.666 ಆಗಿದ್ದರೆ, ಗಣಿತ. ಸುತ್ತು ದಶಮಾಂಶವು 0.5 ಕ್ಕಿಂತ ಹೆಚ್ಚಿರುವುದರಿಂದ 14 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಸಂಖ್ಯೆಯನ್ನು ಸರಳಗೊಳಿಸುವಾಗ ನೀವು ನಿಖರತೆಯನ್ನು ಕಾಪಾಡಿಕೊಳ್ಳಲು ಬಯಸುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಈ ವಿಧಾನವು ಉಪಯುಕ್ತವಾಗಿದೆ. ಇನ್ನೊಂದು ವಿಧಾನವೆಂದರೆ Math.floor(), ಇದು ಯಾವಾಗಲೂ ಸಂಖ್ಯೆಯನ್ನು ಪೂರ್ತಿಗೊಳಿಸುತ್ತದೆ. ದಶಮಾಂಶ ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕಿಸದೆ ಅದೇ ಉದಾಹರಣೆಯಲ್ಲಿ 13 ಅನ್ನು ಹಿಂತಿರುಗಿಸುವಂತಹ ದಶಮಾಂಶ ಭಾಗವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತ್ಯಜಿಸಲು ನೀವು ಬಯಸಿದಾಗ ಇದನ್ನು ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ.

ಮತ್ತೊಂದೆಡೆ, Math.ceil() ವಿರುದ್ಧ ಉದ್ದೇಶಕ್ಕಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ Math.floor(), ಯಾವಾಗಲೂ ಸಂಖ್ಯೆಯನ್ನು ಹತ್ತಿರದ ಪೂರ್ಣ ಸಂಖ್ಯೆಗೆ ಪೂರ್ಣಾಂಕಗೊಳಿಸುತ್ತದೆ. ಪೂರ್ಣಾಂಕ ಭಾಗಕ್ಕಿಂತ ಮೌಲ್ಯವು ಎಂದಿಗೂ ಕಡಿಮೆಯಾಗುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನೀವು ಬಯಸಿದಾಗ ಈ ವಿಧಾನವು ಸೂಕ್ತವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಸರಾಸರಿ 13.1 ಆಗಿದ್ದರೆ, Math.ceil() ದಶಮಾಂಶ ಭಾಗವು ಸಾಕಷ್ಟು ಚಿಕ್ಕದಾಗಿದ್ದರೂ ಸಹ 14 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ. ಈ ವಿಧಾನಗಳು ನಿಮ್ಮ ಲೆಕ್ಕಾಚಾರದ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳನ್ನು ಅವಲಂಬಿಸಿ ನಮ್ಯತೆಯನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಗುರಿಯು ಸಮೀಪಕ್ಕೆ ಸುತ್ತುವುದು, ರೌಂಡ್ ಡೌನ್ ಅಥವಾ ರೌಂಡ್ ಅಪ್ ಆಗಿರಲಿ, ಪ್ರತಿ ಕಾರ್ಯವು ಒಂದು ವಿಶಿಷ್ಟ ಉದ್ದೇಶವನ್ನು ಪೂರೈಸುತ್ತದೆ.

ಹೆಚ್ಚುವರಿಯಾಗಿ, ಬಳಕೆ assert.strictEqual() ಘಟಕ ಪರೀಕ್ಷೆಗಳಲ್ಲಿ ಕಾರ್ಯಗಳು ನಿರೀಕ್ಷೆಯಂತೆ ವರ್ತಿಸುತ್ತವೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ವಿವಿಧ ಪರೀಕ್ಷಾ ಸಂದರ್ಭಗಳಲ್ಲಿ ನಿಮ್ಮ ಕಾರ್ಯದ ಔಟ್‌ಪುಟ್ ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಈ ಆಜ್ಞೆಯು ಮುಖ್ಯವಾಗಿದೆ. ಇದು ರಕ್ಷಣೆಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಡೆವಲಪರ್‌ಗಳು ತಮ್ಮ ಬದಲಾವಣೆಗಳು ಕಾರ್ಯವನ್ನು ಮುರಿಯುತ್ತವೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ತ್ವರಿತವಾಗಿ ಪರಿಶೀಲಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಜೊತೆಗೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ ಅಗತ್ಯವಿದೆ() ಅಗತ್ಯ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಲು, ಈ ಪರೀಕ್ಷೆಗಳು ಮೌಲ್ಯೀಕರಣದ ಹೆಚ್ಚುವರಿ ಪದರವನ್ನು ಸೇರಿಸುತ್ತವೆ, ಉತ್ಪಾದನಾ ಪರಿಸರದಲ್ಲಿ ಕೋಡ್‌ನ ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ತಂತ್ರಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ, ಕೋಡ್ ನಿಖರವಾಗಿ ಮಾತ್ರವಲ್ಲದೆ ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಲ್ಪಟ್ಟಿದೆ ಮತ್ತು ವಿಭಿನ್ನ ಬಳಕೆಯ ಸನ್ನಿವೇಶಗಳಿಗೆ ಸಿದ್ಧವಾಗಿದೆ.

// Solution 1: Using Math.round() to round to the nearest integer
function studentsPerAdmin(students, teachers, helpers) {
  const average = students / (teachers + helpers);
  const roundedAverage = Math.round(average);
  if (roundedAverage > 10) {
    console.log(`There are on average ${roundedAverage} students for each educator.`);
  } else {
    console.log('Unfortunately this class will be cancelled due to not having enough students enrolled.');
  }
  return roundedAverage;
}
studentsPerAdmin(41, 1, 2); // Result: 14 students for each educator

// Solution 2: Using Math.floor() to always round down
function studentsPerAdmin(students, teachers, helpers) {
  const average = students / (teachers + helpers);
  const flooredAverage = Math.floor(average);
  if (flooredAverage > 10) {
    console.log(`There are on average ${flooredAverage} students for each educator.`);
  } else {
    console.log('Unfortunately this class will be cancelled due to not having enough students enrolled.');
  }
  return flooredAverage;
}
studentsPerAdmin(41, 1, 2); // Result: 13 students for each educator

// Solution 3: Using Math.ceil() to always round up
function studentsPerAdmin(students, teachers, helpers) {
  const average = students / (teachers + helpers);
  const ceiledAverage = Math.ceil(average);
  if (ceiledAverage > 10) {
    console.log(`There are on average ${ceiledAverage} students for each educator.`);
  } else {
    console.log('Unfortunately this class will be cancelled due to not having enough students enrolled.');
  }
  return ceiledAverage;
}
studentsPerAdmin(41, 1, 2); // Result: 14 students for each educator

// Unit Test for verifying all solutions
const assert = require('assert');
assert.strictEqual(studentsPerAdmin(41, 1, 2), 14);  // Using Math.round()
assert.strictEqual(studentsPerAdmin(30, 1, 2), 10);  // Using Math.floor()
assert.strictEqual(studentsPerAdmin(35, 1, 2), 12);  // Using Math.ceil()
console.log('All tests passed!');

ಸಂಕೀರ್ಣ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ದಶಮಾಂಶಗಳನ್ನು ನಿರ್ವಹಿಸುವುದು

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಪೂರ್ಣಾಂಕದ ದಶಮಾಂಶಗಳು ಸಾಮಾನ್ಯ ಅಗತ್ಯವಾಗಿದ್ದರೂ, ದಶಮಾಂಶ ಸ್ಥಳಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಣದ ಅಗತ್ಯವಿರುವ ಇತರ ಸನ್ನಿವೇಶಗಳಿವೆ. ಅತ್ಯಂತ ಮುಖ್ಯವಾದ ತಂತ್ರವೆಂದರೆ ಕೆಲಸ ಮಾಡುವುದು ಸ್ಥಿರ (). ಈ ವಿಧಾನವು ನಿಮಗೆ ಎಷ್ಟು ದಶಮಾಂಶ ಸ್ಥಾನಗಳನ್ನು ಬೇಕು ಎಂಬುದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಅನುಮತಿಸುತ್ತದೆ, ಸ್ಥಿರವಾದ ಪ್ರದರ್ಶನ ಸ್ವರೂಪವನ್ನು ಖಾತ್ರಿಪಡಿಸುವಾಗ ಸಂಖ್ಯೆಯನ್ನು ಹತ್ತಿರದ ಮೌಲ್ಯಕ್ಕೆ ಪೂರ್ಣಾಂಕಗೊಳಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, number.toFixed(2) ಯಾವಾಗಲೂ ಎರಡು ದಶಮಾಂಶ ಸ್ಥಾನಗಳೊಂದಿಗೆ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಕರೆನ್ಸಿ ಲೆಕ್ಕಾಚಾರಗಳು ಅಥವಾ ವೈಜ್ಞಾನಿಕ ಅಳತೆಗಳಂತಹ ನಿಖರತೆಯು ಮುಖ್ಯವಾದ ಸಂದರ್ಭಗಳಿಗೆ ಇದು ಸೂಕ್ತವಾಗಿದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಅಂಕಗಣಿತವನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದು ಮತ್ತೊಂದು ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ. ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಖ್ಯೆಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ವಿಧಾನದಿಂದಾಗಿ, ದಶಮಾಂಶಗಳ ಮೇಲಿನ ಕಾರ್ಯಾಚರಣೆಗಳು ಕೆಲವೊಮ್ಮೆ ಅನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ಎರಡು ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆಗಳನ್ನು ಹೋಲಿಸಿದಾಗ. ಉದಾಹರಣೆಗೆ, 0.1 + 0.2 ನಿಖರವಾಗಿ ಸಮನಾಗಿರುವುದಿಲ್ಲ 0.3 JavaScript ನಲ್ಲಿ, ಇದು ಕೆಲವು ಲೆಕ್ಕಾಚಾರಗಳಲ್ಲಿ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು. ಈ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ದೋಷಗಳನ್ನು ತಪ್ಪಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ, ವಿಶೇಷವಾಗಿ ಹಣಕಾಸು ಅಥವಾ ಸಂಖ್ಯಾಶಾಸ್ತ್ರೀಯ ಲೆಕ್ಕಾಚಾರಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ.

ಇದಲ್ಲದೆ, ನೀವು ಪೂರ್ಣಾಂಕವಿಲ್ಲದೆಯೇ ದಶಮಾಂಶಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತೆಗೆದುಹಾಕಬೇಕಾದರೆ, ನೀವು ಬಿಟ್‌ವೈಸ್ ಆಪರೇಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು ~~ (ಡಬಲ್ ಟಿಲ್ಡ್), ಇದು ಸಂಖ್ಯೆಯ ದಶಮಾಂಶ ಭಾಗವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮೊಟಕುಗೊಳಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಬಿಟ್‌ವೈಸ್ ಆಪರೇಟರ್‌ಗಳು ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಸಂಖ್ಯೆಯನ್ನು ಪೂರ್ಣಾಂಕಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತಾರೆ. ಉದಾಹರಣೆಗೆ, ~~13.666 ಫಲಿತಾಂಶಗಳು ~~13.99. ಈ ವಿಧಾನವು ಕಡಿಮೆ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸಲ್ಪಡುತ್ತದೆ ಆದರೆ ಕಾರ್ಯಕ್ಷಮತೆಯು ನಿರ್ಣಾಯಕವಾದಾಗ ದಶಮಾಂಶಗಳನ್ನು ಮೊಟಕುಗೊಳಿಸುವ ಗುರಿಯನ್ನು ಸಾಧಿಸಲು ವೇಗದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.