క్యూబిక్ యార్డులలో పరిమాణాన్ని టన్నులలో బరువుగా మార్పిడి చేయండి, మట్టిని, గ్రావెల్, ఇసుక, కాంక్రీట్ మరియు మరిన్నింటిని కలిగి. నిర్మాణం, ల్యాండ్స్కేపింగ్ మరియు పదార్థ అంచనాకు అవసరమైనది.
టన్స్ = క్యూబిక్ యార్డ్స్ × పదార్థం ఘనత్వం: టన్స్ = క్యూబిక్ యార్డ్స్ × పదార్థం ఘనత్వం
ఈ పదార్థానికి: 0 = 1 × 1.4
మార్పిడి సూత్రం: టన్స్ = క్యూబిక్ యార్డ్స్ × పదార్థం ఘనత్వం
ఈ పదార్థానికి మట్టి: టన్స్ = క్యూబిక్ యార్డ్స్ × 1.4
క్యూబిక్ యార్డ్స్ మరియు టన్స్ మధ్య మార్పిడి చేయడానికి పదార్థం ఘనత్వాన్ని తెలుసుకోవడం అవసరం. వేర్వేరు పదార్థాలు వాల్యూమ్ ప్రకారం వేరువేరుగా బరువు ఉంటాయి. ఈ కేల్క్యులేటర్ ఖచ్చితమైన మార్పిడుల కోసం సాధారణ పదార్థాల కోసం ప్రమాణ ఘనత్వ విలువలను ఉపయోగిస్తుంది.
ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳನ್ನು ಟನ್ಗಳಿಗೆ ಪರಿವರ್ತಿಸುವುದು ನಿರ್ಮಾಣ ಯೋಜನೆಗಳು, ನೆಲದ ವಿನ್ಯಾಸ, ಕಸ ನಿರ್ವಹಣೆ ಮತ್ತು ವಸ್ತು ವಿತರಣೆಯಿಗಾಗಿ ಅಗತ್ಯವಿರುವ ಲೆಕ್ಕಾಚಾರವಾಗಿದೆ. ನಮ್ಮ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳನ್ನು ಟನ್ಗಳಿಗೆ ಪರಿವರ್ತಕ ವಿವಿಧ ವಸ್ತುಗಳಿಗೆ (ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳು) ಪ್ರಮಾಣದ ಅಳೆಯುವಿಕೆಯನ್ನು ತೂಕದ ಅಳೆಯುವಿಕೆಗೆ (ಟನ್ಗಳು) ಸರಳ, ನಿಖರವಾದ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಈ ಪರಿವರ್ತನೆ ಮುಖ್ಯವಾಗಿದೆ ಏಕೆಂದರೆ ಮಣ್ಣು, ಕಲ್ಲು, ಮರಳು ಮತ್ತು ಕಾಂಕ್ರೀಟ್ ಇಂತಹ ವಸ್ತುಗಳು ವಿಭಿನ್ನ ಘನತೆಗಳನ್ನು ಹೊಂದಿದ್ದು, ಒಂದೇ ಪ್ರಮಾಣವು ವಸ್ತು ಪ್ರಕಾರವನ್ನು ಆಧರಿಸಿ ವಿಭಿನ್ನ ತೂಕವನ್ನು ಹೊಂದುತ್ತದೆ. ನೀವು ನಿರ್ಮಾಣ ಯೋಜನೆಗಳಿಗೆ ವಸ್ತುಗಳನ್ನು ಆರ್ಡರ್ ಮಾಡುತ್ತಿದ್ದೀರಾ, ತ್ಯಾಜ್ಯ ವೆಚ್ಚಗಳನ್ನು ಅಂದಾಜಿಸುತ್ತಿದ್ದೀರಾ ಅಥವಾ ಸಾಗಣೆ ತೂಕಗಳನ್ನು ಲೆಕ್ಕಹಾಕುತ್ತಿದ್ದೀರಾ, ಈ ಪರಿವರ್ತಕವು ನಿಮಗೆ ಕನಿಷ್ಠ ಪ್ರಯತ್ನದಲ್ಲಿ ನಿಖರವಾದ ಪರಿವರ್ತನೆಗಳನ್ನು ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳಿಂದ ಟನ್ಗಳಿಗೆ ಪರಿವರ್ತಿಸಲು, ನೀವು ಪ್ರಶ್ನೆಯಲ್ಲಿರುವ ವಸ್ತುವಿನ ಘನತೆಯನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕು. ಮೂಲ ಸೂತ್ರವೆಂದರೆ:
ಹಾಗೆಯೇ, ಟನ್ಗಳಿಂದ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳಿಗೆ ಪರಿವರ್ತಿಸಲು:
ವಿಭಿನ್ನ ವಸ್ತುಗಳಿಗೆ ವಿಭಿನ್ನ ಘನತೆಗಳು ಇರುತ್ತವೆ, ಇದು ಪರಿವರ್ತನೆಯನ್ನು ಪರಿಣಾಮಿತಗೊಳಿಸುತ್ತದೆ. ಇಲ್ಲಿ ಸಾಮಾನ್ಯ ವಸ್ತುಗಳ ಘನತೆಗಳ ಸಮಗ್ರ ಚಾರ್ಟ್ ಇಲ್ಲಿದೆ:
ವಸ್ತು | ಘನತೆ (ಟನ್ ಪ್ರತಿ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್) |
---|---|
ಮಣ್ಣು (ಸಾಮಾನ್ಯ) | 1.4 |
ಕಲ್ಲು | 1.5 |
ಮರಳು | 1.3 |
ಕಾಂಕ್ರೀಟ್ | 2.0 |
ಅಸ್ಫಾಲ್ಟ್ | 1.9 |
ಲೈಮ್ಸ್ಟೋನ್ | 1.6 |
ಗ್ರಾನೈಟ್ | 1.7 |
ಕಲೆ | 1.1 |
ಮಲ್ಚ್ | 0.5 |
ಮರದ ಚಿಪ್ಸ್ | 0.7 |
ಕೆಲವು ಅಂಶಗಳು ವಸ್ತುಗಳ ನಿಖರ ಘನತೆಯನ್ನು ಪರಿಣಾಮಿತಗೊಳಿಸಬಹುದು:
ನಿಖರವಾದ ಫಲಿತಾಂಶಗಳಿಗಾಗಿ, ನಿಮ್ಮ ಪರಿವರ್ತನೆಗಳನ್ನು ನಡೆಸುವಾಗ ಈ ಅಂಶಗಳನ್ನು ಪರಿಗಣಿಸಿ.
ನಮ್ಮ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳನ್ನು ಟನ್ಗಳಿಗೆ ಪರಿವರ್ತಕವನ್ನು ಬಳಸುವುದು ಸುಲಭ ಮತ್ತು ಸುಲಭವಾಗಿದೆ. ಈ ಸರಳ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿ:
ಪರವರ್ತಕವು ಪ್ರತಿ ವಸ್ತು ಪ್ರಕಾರದ ಘನತೆ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಒಳಗೊಳ್ಳುವ ಎಲ್ಲಾ ಗಣಿತ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ 1: ಮಣ್ಣಿನ ಪರಿವರ್ತನೆ
ಉದಾಹರಣೆ 2: ಕಾಂಕ್ರೀಟಿನ ಪರಿವರ್ತನೆ
ಉದಾಹರಣೆ 3: ವಿರೋಧ ಪರಿವರ್ತನೆ (ಕಲ್ಲು)
ನಿರ್ಮಾಣದಲ್ಲಿ, ನಿಖರವಾದ ವಸ್ತು ಅಂದಾಜು ಬಜೆಟ್ ಮತ್ತು ಲಾಜಿಸ್ಟಿಕ್ಗಳಿಗೆ ಪ್ರಮುಖವಾಗಿದೆ. ಒಪ್ಪಂದದವರು ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳನ್ನು ಟನ್ಗಳಿಗೆ ಪರಿವರ್ತನೆಗಳನ್ನು ಬಳಸುತ್ತಾರೆ:
ನೆಲದ ವಿನ್ಯಾಸಕಾರರು ಮತ್ತು ತೋಟಗಾರರು ಈ ಪರಿವರ್ತನೆಗಳನ್ನು ಬಳಸುತ್ತಾರೆ:
ಕಸ ನಿರ್ವಹಣಾ ಉದ್ಯಮವು ಪ್ರಮಾಣ-ತೂಕ ಪರಿವರ್ತನೆಗಳನ್ನು ಬಳಸುತ್ತದೆ:
ಈ ಉದ್ಯಮಗಳು ಪರಿವರ್ತನೆಗಳನ್ನು ಬಳಸುತ್ತವೆ:
ಸಾಗಣೆ ಕಂಪನಿಗಳು ನಿಖರವಾದ ತೂಕ ಲೆಕ್ಕಾಚಾರಗಳಿಗೆ ಅಗತ್ಯವಿದೆ:
ಮನೆಮಾಲಿಕರು ಈ ಪರಿವರ್ತನೆಗಳಿಂದ ಲಾಭ ಪಡೆಯುತ್ತಾರೆ:
ಕೃಷಿಕರು ಪ್ರಮಾಣ-ತೂಕ ಪರಿವರ್ತನೆಗಳನ್ನು ಬಳಸುತ್ತಾರೆ:
ಯುನೈಟೆಡ್ ಸ್ಟೇಟ್ಸ್ನಲ್ಲಿ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳು ಮತ್ತು ಟನ್ಗಳು ಸಾಮಾನ್ಯ ಅಳೆಯುವಿಕೆಯಾಗಿದ್ದರೂ, ಇತರ ಅಳೆಯುವಿಕೆಗಳು ಜಾಗತಿಕವಾಗಿ ಅಥವಾ ನಿರ್ದಿಷ್ಟ ಅನ್ವಯಿಕೆಗಳಿಗೆ ಬಳಸಲಾಗುತ್ತವೆ:
ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳು ಪ್ರಾಚೀನ ಅಳೆಯುವಿಕೆ ವ್ಯವಸ್ಥೆಗಳ ಮೂಲವನ್ನು ಹೊಂದಿವೆ. ಯಾರ್ಡ್ ಅನ್ನು ಅಳೆಯುವ ಉದ್ದದ ಘಟಕವು 10ನೇ ಶತಮಾನದಲ್ಲಿ ಪ್ರಾರಂಭವಾದ ಪ್ರಾರಂಭಿಕ ಇಂಗ್ಲಿಷ್ ಅಳೆಯುವಿಕೆಯ ಮಾನದಂಡಗಳಿಗೆ ಹಿಂದಿರುಗುತ್ತದೆ ಎಂದು ಕೆಲವು ಸಾಕ್ಷ್ಯಗಳು ಸೂಚಿಸುತ್ತವೆ. ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್, ಪ್ರಮಾಣದ ಅಳೆಯುವಿಕೆಯಾಗಿ, ಯಾರ್ಡ್ನ ಮೂರು ಆಯಾಮದ ವಿಸ್ತಾರವನ್ನು ವಿಸ್ತಾರಗೊಳಿಸುವಂತೆ ಸ್ವಾಭಾವಿಕವಾಗಿ ಅಭಿವೃದ್ಧಿಯಾಗಿದೆ.
ಯುನೈಟೆಡ್ ಸ್ಟೇಟ್ಸ್ನಲ್ಲಿ, ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ 19ನೇ ಮತ್ತು 20ನೇ ಶತಮಾನಗಳ ನಿರ್ಮಾಣ ಬೂಮ್ ಮತ್ತು ಕೈಗಾರಿಕಾ ಕ್ರಾಂತಿಯ ಸಮಯದಲ್ಲಿ ವಿಶೇಷವಾಗಿ ಮುಖ್ಯವಾಗಿದೆ. ಇದು ನಿರ್ಮಾಣ ಮತ್ತು ನೆಲದ ವಿನ್ಯಾಸದಲ್ಲಿ ಕಚ್ಚಾ ವಸ್ತುಗಳ ಪ್ರಮಾಣದ ಪ್ರಮಾಣದ ಪ್ರಮಾಣದ ಪ್ರಮಾಣವಾಗಿದೆ.
ಟನ್ಗೊಂದು ದೃಷ್ಟಿಯು "ಟನ್" ಎಂಬ ಪದದಿಂದ ಬಂದಿದೆ, ಇದು ಮಧ್ಯಕಾಲೀನ ಇಂಗ್ಲಿಷ್ನಲ್ಲಿ ಶರಾಬು ಸಾಗಿಸಲು ಬಳಸುವ ದೊಡ್ಡ ಬಾರೆಲ್ "ಟನ್" ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಶರಾಬು ಟನ್ಗಳ ತೂಕವು ಸುಮಾರು 2,000 ಪೌಂಡುಗಳಷ್ಟು ಇದೆ, ಇದು ನಂತರ ಯುನೈಟೆಡ್ ಸ್ಟೇಟ್ಸ್ನಲ್ಲಿ "ಶಾರ್ಟ್ ಟನ್" ಎಂದು ಪ್ರಮಾಣಿತಗೊಳ್ಳುತ್ತದೆ.
ಮೆಟ್ರಿಕ್ ಟನ್ (1,000 ಕಿ.ಗ್ರಾಂ) ಮೆಟ್ರಿಕ್ ವ್ಯವಸ್ಥೆಯ ಭಾಗವಾಗಿ ಫ್ರೆಂಚ್ ಕ್ರಾಂತಿಯ ಸಮಯದಲ್ಲಿ ಪರಿಚಯಿಸಲಾಯಿತು, ಇದು ದಶಮಲವೀಯ ಲೆಕ್ಕಾಚಾರಗಳ ಆಧಾರದ ಮೇಲೆ ತೂಕದ ಘಟಕವನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಇತಿಹಾಸದಲ್ಲಿ, ಅಳೆಯುವಿಕೆಗಳನ್ನು ಪ್ರಮಾಣೀಕರಿಸಲು ಅನೇಕ ಪ್ರಯತ್ನಗಳು ನಡೆದಿವೆ:
ಇಲ್ಲಿ ವಿವಿಧ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳನ್ನು ಟನ್ಗಳಿಗೆ ಪರಿವರ್ತಿಸಲು ಹೇಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಎಂಬುದರ ಉದಾಹರಣೆಗಳಿವೆ:
1' ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳನ್ನು ಟನ್ಗಳಿಗೆ ಪರಿವರ್ತನೆಗಾಗಿ ಎಕ್ಸೆಲ್ ಸೂತ್ರ
2Function CubicYardsToTons(cubicYards As Double, materialDensity As Double) As Double
3 CubicYardsToTons = cubicYards * materialDensity
4End Function
5
6' ಕೋಶದಲ್ಲಿ ಉದಾಹರಣೆ ಬಳಕೆ:
7' =CubicYardsToTons(10, 1.4) ' 10 ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳ ಮಣ್ಣಿನ ಪರಿವರ್ತನೆ (ಘನತೆ 1.4)
8
1def cubic_yards_to_tons(cubic_yards, material_type):
2 # ವಸ್ತುಗಳ ಘನತೆಗಳು ಟನ್ ಪ್ರತಿ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ನಲ್ಲಿ
3 densities = {
4 'soil': 1.4,
5 'gravel': 1.5,
6 'sand': 1.3,
7 'concrete': 2.0,
8 'asphalt': 1.9,
9 'limestone': 1.6,
10 'granite': 1.7,
11 'clay': 1.1,
12 'mulch': 0.5,
13 'wood': 0.7
14 }
15
16 if material_type not in densities:
17 raise ValueError(f"ಅಜ್ಞಾತ ವಸ್ತು ಪ್ರಕಾರ: {material_type}")
18
19 return round(cubic_yards * densities[material_type], 2)
20
21# ಉದಾಹರಣೆ ಬಳಕೆ
22material = 'gravel'
23volume = 15
24weight = cubic_yards_to_tons(volume, material)
25print(f"{volume} ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳ {material} ತೂಕವು ಸುಮಾರು {weight} ಟನ್ಗಳು")
26
1function cubicYardsToTons(cubicYards, materialType) {
2 const densities = {
3 soil: 1.4,
4 gravel: 1.5,
5 sand: 1.3,
6 concrete: 2.0,
7 asphalt: 1.9,
8 limestone: 1.6,
9 granite: 1.7,
10 clay: 1.1,
11 mulch: 0.5,
12 wood: 0.7
13 };
14
15 if (!densities[materialType]) {
16 throw new Error(`ಅಜ್ಞಾತ ವಸ್ತು ಪ್ರಕಾರ: ${materialType}`);
17 }
18
19 return parseFloat((cubicYards * densities[materialType]).toFixed(2));
20}
21
22// ಉದಾಹರಣೆ ಬಳಕೆ
23const volume = 10;
24const material = 'concrete';
25const weight = cubicYardsToTons(volume, material);
26console.log(`${volume} ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳ ${material} ತೂಕವು ${weight} ಟನ್ಗಳು`);
27
1import java.util.HashMap;
2import java.util.Map;
3
4public class VolumeConverter {
5 private static final Map<String, Double> MATERIAL_DENSITIES = new HashMap<>();
6
7 static {
8 MATERIAL_DENSITIES.put("soil", 1.4);
9 MATERIAL_DENSITIES.put("gravel", 1.5);
10 MATERIAL_DENSITIES.put("sand", 1.3);
11 MATERIAL_DENSITIES.put("concrete", 2.0);
12 MATERIAL_DENSITIES.put("asphalt", 1.9);
13 MATERIAL_DENSITIES.put("limestone", 1.6);
14 MATERIAL_DENSITIES.put("granite", 1.7);
15 MATERIAL_DENSITIES.put("clay", 1.1);
16 MATERIAL_DENSITIES.put("mulch", 0.5);
17 MATERIAL_DENSITIES.put("wood", 0.7);
18 }
19
20 public static double cubicYardsToTons(double cubicYards, String materialType) {
21 if (!MATERIAL_DENSITIES.containsKey(materialType)) {
22 throw new IllegalArgumentException("ಅಜ್ಞಾತ ವಸ್ತು ಪ್ರಕಾರ: " + materialType);
23 }
24
25 double density = MATERIAL_DENSITIES.get(materialType);
26 return Math.round(cubicYards * density * 100.0) / 100.0;
27 }
28
29 public static double tonsToCubicYards(double tons, String materialType) {
30 if (!MATERIAL_DENSITIES.containsKey(materialType)) {
31 throw new IllegalArgumentException("ಅಜ್ಞಾತ ವಸ್ತು ಪ್ರಕಾರ: " + materialType);
32 }
33
34 double density = MATERIAL_DENSITIES.get(materialType);
35 return Math.round(tons / density * 100.0) / 100.0;
36 }
37
38 public static void main(String[] args) {
39 double cubicYards = 5.0;
40 String material = "gravel";
41 double tons = cubicYardsToTons(cubicYards, material);
42
43 System.out.printf("%.2f ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳ %s ತೂಕವು %.2f ಟನ್ಗಳು%n",
44 cubicYards, material, tons);
45 }
46}
47
1<?php
2function cubicYardsToTons($cubicYards, $materialType) {
3 $densities = [
4 'soil' => 1.4,
5 'gravel' => 1.5,
6 'sand' => 1.3,
7 'concrete' => 2.0,
8 'asphalt' => 1.9,
9 'limestone' => 1.6,
10 'granite' => 1.7,
11 'clay' => 1.1,
12 'mulch' => 0.5,
13 'wood' => 0.7
14 ];
15
16 if (!isset($densities[$materialType])) {
17 throw new Exception("ಅಜ್ಞಾತ ವಸ್ತು ಪ್ರಕಾರ: $materialType");
18 }
19
20 return round($cubicYards * $densities[$materialType], 2);
21}
22
23// ಉದಾಹರಣೆ ಬಳಕೆ
24$volume = 12;
25$material = 'sand';
26$weight = cubicYardsToTons($volume, $material);
27echo "$volume ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳ $material ತೂಕವು $weight ಟನ್ಗಳು";
28?>
29
1using System;
2using System.Collections.Generic;
3
4public class VolumeConverter
5{
6 private static readonly Dictionary<string, double> MaterialDensities = new Dictionary<string, double>
7 {
8 { "soil", 1.4 },
9 { "gravel", 1.5 },
10 { "sand", 1.3 },
11 { "concrete", 2.0 },
12 { "asphalt", 1.9 },
13 { "limestone", 1.6 },
14 { "granite", 1.7 },
15 { "clay", 1.1 },
16 { "mulch", 0.5 },
17 { "wood", 0.7 }
18 };
19
20 public static double CubicYardsToTons(double cubicYards, string materialType)
21 {
22 if (!MaterialDensities.ContainsKey(materialType))
23 {
24 throw new ArgumentException($"ಅಜ್ಞಾತ ವಸ್ತು ಪ್ರಕಾರ: {materialType}");
25 }
26
27 double density = MaterialDensities[materialType];
28 return Math.Round(cubicYards * density, 2);
29 }
30
31 public static void Main()
32 {
33 double cubicYards = 8.0;
34 string material = "limestone";
35 double tons = CubicYardsToTons(cubicYards, material);
36
37 Console.WriteLine($"{cubicYards} ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳ {material} ತೂಕವು {tons} ಟನ್ಗಳು");
38 }
39}
40
ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳನ್ನು ಟನ್ಗಳಿಗೆ ಪರಿವರ್ತಿಸಲು, ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳಲ್ಲಿ ಪ್ರಮಾಣವನ್ನು ವಸ್ತುವಿನ ಘನತೆ (ಟನ್ ಪ್ರತಿ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ನಲ್ಲಿ) ಮೂಲಕ ಗುಣಿಸಿ. ಉದಾಹರಣೆಗೆ, 10 ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳ ಮಣ್ಣಿನ ಘನತೆ 1.4 ಟನ್/ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳಲ್ಲಿ ಪರಿವರ್ತಿಸಲು: 10 × 1.4 = 14 ಟನ್ಗಳು.
ಟನ್ಗಳನ್ನು ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳಿಗೆ ಪರಿವರ್ತಿಸಲು, ಟನ್ಗಳಲ್ಲಿ ತೂಕವನ್ನು ವಸ್ತುವಿನ ಘನತೆ (ಟನ್ ಪ್ರತಿ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ನಲ್ಲಿ) ಮೂಲಕ ಭಾಗಿಸಿ. ಉದಾಹರಣೆಗೆ, 15 ಟನ್ಗಳ ಕಲ್ಲು 1.5 ಟನ್/ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳಲ್ಲಿ ಪರಿವರ್ತಿಸಲು: 15 ÷ 1.5 = 10 ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳು.
ವಿಭಿನ್ನ ವಸ್ತುಗಳಿಗೆ ವಿಭಿನ್ನ ಘನತೆಗಳು (ಪ್ರತಿ ಘಟಕದ ಪ್ರಮಾಣಕ್ಕೆ ತೂಕ). ಕಾಂಕ್ರೀಟ್ (2.0 ಟನ್/ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್) ಹೋಲಿಸಿದರೆ, ಮಲ್ಚ್ (0.5 ಟನ್/ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್) ಹೋಲಿಸಿದರೆ ಹೆಚ್ಚು ತೂಕವನ್ನು ಹೊಂದಿದೆ.
ನಿಖರತೆ ಬಳಸುವ ಘನತೆಯ ಮೌಲ್ಯದ ನಿಖರತೆಯ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ. ನಮ್ಮ ಪರಿವರ್ತಕವು ಪ್ರಮಾಣಿತ ಕೈಗಾರಿಕಾ ಘನತೆ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸುತ್ತದೆ, ಆದರೆ ನಿಖರ ಘನತೆಗಳು ನೀರು ವಿಷಯ, ಸಂಕೋಚನ ಮತ್ತು ವಸ್ತು ಸಂಯೋಜನೆಯಿಂದ ವ್ಯತ್ಯಾಸವಾಗಬಹುದು. ಮಹತ್ವದ ಅನ್ವಯಿಕೆಗಳಿಗೆ, ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ವಸ್ತುವಿನ ಮಾದರಿಯನ್ನು ಪರೀಕ್ಷಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
ಟನ್ (ಯುಎಸ್ನಲ್ಲಿ ಶಾರ್ಟ್ ಟನ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ) 2,000 ಪೌಂಡುಗಳನ್ನು ಹೊಂದಿದೆ, ಏಕೆಂದರೆ ಮೆಟ್ರಿಕ್ ಟನ್ (ಅಥವಾ "ಮೆಟ್ರಿಕ್ ಟನ್") 1,000 ಕಿಲೋಗ್ರಾಂಗಳನ್ನು ಹೊಂದಿದೆ (ಸುಮಾರು 2,204.6 ಪೌಂಡುಗಳು). ವ್ಯತ್ಯಾಸವು ಸುಮಾರು 10% ಇದೆ, ಮೆಟ್ರಿಕ್ ಟನ್ ಹೆಚ್ಚು ತೂಕ ಹೊಂದಿದೆ.
ಮಟ್ಟದ ಡಂಪ್ ಟ್ರಕ್ಗಳು ಸಾಮಾನ್ಯವಾಗಿ 10 ರಿಂದ 14 ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳ ವಸ್ತುಗಳನ್ನು ಹಿಡಿದಿರುತ್ತವೆ. ದೊಡ್ಡ ವರ್ಗಾವಣೆ ಡಂಪ್ ಟ್ರಕ್ಗಳು 20+ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳನ್ನು ಹಿಡಿದಿರುತ್ತವೆ, ಆದರೆ ಸಣ್ಣ ಟ್ರಕ್ಗಳು ಕೇವಲ 5-8 ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳನ್ನು ಹಿಡಿದಿರಬಹುದು. ನಿಖರ ಸಾಮರ್ಥ್ಯ ಟ್ರಕ್ಗಳ ಗಾತ್ರ ಮತ್ತು ವಿನ್ಯಾಸವನ್ನು ಆಧರಿಸುತ್ತದೆ.
ಹೌದು, ಬಹಳಷ್ಟು. ಒದ್ದೆಯಾದ ವಸ್ತುಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಒಣ ವಸ್ತುಗಳಿಗಿಂತ ಹೆಚ್ಚು ತೂಕವನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಉದಾಹರಣೆಗೆ, ಒದ್ದೆಯಾದ ಮಣ್ಣು ಒಣ ಮಣ್ಣಿನ ಹೋಲಿಸಿದರೆ 20-30% ಹೆಚ್ಚು ತೂಕವನ್ನು ಹೊಂದಿರಬಹುದು. ನಮ್ಮ ಪರಿವರ್ತಕವು ಸರಾಸರಿ ನೀರು ವಿಷಯದ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ಧಾರಣೆಯಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳನ್ನು ಲೆಕ್ಕಹಾಕಲು, ಉದ್ದವನ್ನು (ಯಾರ್ಡ್ಗಳಲ್ಲಿ) ಅಗಲವನ್ನು (ಯಾರ್ಡ್ಗಳಲ್ಲಿ) ಆಳವನ್ನು (ಯಾರ್ಡ್ಗಳಲ್ಲಿ) ಗುಣಿಸಿ. ಉದಾಹರಣೆಗೆ, 10 ಅಡಿ ಉದ್ದ, 10 ಅಡಿ ಅಗಲ ಮತ್ತು 1 ಅಡಿ ಆಳವಿರುವ ಪ್ರದೇಶವು: (10 ÷ 3) × (10 ÷ 3) × (1 ÷ 3) = 0.37 ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳು.
ಬ್ಯಾಂಕ್ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳು (ಬಿಸಿ ವೈ) ವಸ್ತುವನ್ನು ಅದರ ನೈಸರ್ಗಿಕ, ಅಡಗಿಸದ ಸ್ಥಿತಿಯಲ್ಲಿ ಅಳೆಯುತ್ತವೆ. ಲೂಸ್ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳು (ಎಲ್ಸಿ ವೈ) ಒದ್ದೆಯಾದ ಮತ್ತು ಲೋಡ್ ಮಾಡಿದ ನಂತರ ಅಳೆಯುತ್ತವೆ. ಕಂಪ್ಯಾಕ್ಟಡ್ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳು (ಸಿ ಸಿ ವೈ) ವಸ್ತು ತನ್ನ ಅಂತಿಮ ಸ್ಥಳದಲ್ಲಿ ಸ್ಥಾಪಿತ ಮತ್ತು ಸಂಕೋಚಿತವಾದ ನಂತರ ಅಳೆಯುತ್ತವೆ. ಒಂದೇ ವಸ್ತು ಪ್ರತಿ ಸ್ಥಿತಿಯಲ್ಲಿ ವಿಭಿನ್ನ ಪ್ರಮಾಣವನ್ನು ಹೊಂದಬಹುದು.
ಹೌದು, ನಮ್ಮ ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳನ್ನು ಟನ್ಗಳಿಗೆ ಪರಿವರ್ತಕವು ವೈಯಕ್ತಿಕ ಮತ್ತು ವ್ಯಾಪಾರ ಬಳಸಲು ಸೂಕ್ತವಾಗಿದೆ. ಆದರೆ ದೊಡ್ಡ ವ್ಯಾಪಾರ ಯೋಜನೆಗಳು ಅಥವಾ ನಿಖರವಾದ ಅಳೆಯುವಿಕೆಗಳು ಅತ್ಯಗತ್ಯವಾದಾಗ, ವಸ್ತು-ನಿಖರವಾದ ಪರೀಕ್ಷೆ ಅಥವಾ ಕೈಗಾರಿಕಾ ತಜ್ಞರೊಂದಿಗೆ ಪರಾಮರ್ಶಿಸುವುದನ್ನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ.
ನಿಮ್ಮ ವಸ್ತುಗಳನ್ನು ಕ್ಯೂಬಿಕ್ ಯಾರ್ಡ್ಗಳಿಂದ ಟನ್ಗಳಿಗೆ ಪರಿವರ್ತಿಸಲು ತಯಾರಾಗಿದ್ದೀರಾ? ಈಗ ನಮ್ಮ ಕ್ಯಾಲ್ಕುಲೇಟರ್ ಅನ್ನು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ತಕ್ಷಣ ನಿಖರವಾದ ಪರಿವರ್ತನೆಗಳನ್ನು ಪಡೆಯಿರಿ!
మీ వర్క్ఫ్లో కోసం ఉపయోగపడవచ్చే ఇతర సాధనాలను కనుగొనండి