Alligation कैलकुलेटर — मिश्रण अनुपात और मात्राएं

यह कैलकुलेटर क्या करता है (ELI5)

आपके पास अलग-अलग मूल्य की दो चीजें हैं — एक सस्ती और एक महंगी — और आप उन्हें एक मिश्रण में मिलाना चाहते हैं जो बीच में कहीं लक्ष्य मूल्य पर है। Alligation आपको बताता है प्रत्येक में से कितना उपयोग करना है।

एक सीसा की कल्पना करें। लक्ष्य मूल्य धुरी है। घटक जिसका मूल्य लक्ष्य से दूर है, उसकी मात्रा कम होनी चाहिए, और जो पास है, उसकी मात्रा अधिक होनी चाहिए, ताकि दोनों तरफ संतुलित हो जाए। Alligation बस उस संतुलन का अंकगणित है।

तीन नंबर दर्ज करें — सस्ता मूल्य, महंगा मूल्य, और लक्ष्य — और उपकरण आपको देता है:

• मिश्रण अनुपात (जैसे 1 : 2, का अर्थ है सस्ता का 1 भाग महंगा का 2 भाग),
• प्रत्येक घटक की सटीक मात्रा एक बार जब आप कुल मात्रा दर्ज करते हैं,
• एक क्रॉस आरेख और एक संरचना चार्ट ताकि आप मिश्रण को देख सकें।

"मूल्य" एक कीमत, एक प्रतिशत शक्ति, या एक सांद्रता (%, mg/mL, w/v) हो सकता है — कुछ भी जो एक सुसंगत पैमाने पर मापा जाता है।

सूत्र

सस्ते मूल्य C, महंगे मूल्य D, और लक्ष्य मिश्रण मूल्य M के साथ जहां C < M < D:

$\text{cheaper parts} : \text{dearer parts} = (D - M) : (M - C)$

प्रत्येक घटक के भाग विपरीत अंतर से आते हैं — जितना दूर लक्ष्य एक घटक से बैठता है, उतना अधिक आपको दूसरे घटक की आवश्यकता होती है। यदि आप कुल मात्रा Q भी जानते हैं:

$\text{cheaper amount} = \frac{D - M}{(D - M) + (M - C)}\,Q \qquad \text{dearer amount} = \frac{M - C}{(D - M) + (M - C)}\,Q$

Alligation क्रॉस

इसे रखने का क्लासिक तरीका "क्रॉस" है: दो घटक मूल्यों को बाईं ओर रखें, बीच में लक्ष्य रखें, और प्रत्येक विकर्ण के साथ घटाएं। प्रत्येक अंतर विपरीत कोने पर उतरता है और उस घटक के भाग बन जाता है।

1   Dearer (D) ───────┐        ┌─────── (M − C) = dearer parts
2                      ╲      ╱
3                    Target (M)
4                      ╱      ╲
5  Cheaper (C) ───────┘        └─────── (D − M) = cheaper parts
6

कार्य किए गए उदाहरण

$10 घटक और$30 घटक को $20 पर बेचने के लिए मिलाएं:

$\text{cheaper} : \text{dearer} = (30 - 20) : (20 - 10) = 10 : 10 = 1 : 1$

बराबर भाग। 100 इकाइयों कुल के लिए, यह है सस्ता का 50 और महंगा का 50 — और मिश्रित मूल्य बिल्कुल $20 है। लक्ष्य को$25 पर ले जाएं और अनुपात 5 : 15 = 1 : 3 बन जाता है: जितना करीब लक्ष्य महंगे मूल्य के पास बैठता है, उतना अधिक महंगा घटक आपको चाहिए।

Alligation विकल्प बनाम alligation माध्य

• Alligation विकल्प (यह उपकरण क्या करता है) — आप दो घटक मूल्य और लक्ष्य जानते हैं, और आप अनुपात को हल करते हैं।
• Alligation माध्य — आप घटकों की मात्रा और मूल्य जानते हैं, और आप परिणामी मिश्रण मूल्य को हल करते हैं। यह बस भारित औसत है: $M = \dfrac{\sum q_i v_i}{\sum q_i}$।

दोनों एक दूसरे के विपरीत हैं, जो अपने काम की जांच करने का एक सुविधाजनक तरीका है: इस उपकरण द्वारा दी गई मात्राओं को एक भारित औसत में वापस डालें और आपको अपने लक्ष्य पर उतरना चाहिए।

इसका उपयोग कहां किया जाता है

• फार्मेसी मिश्रण — एक उच्च और निम्न शक्ति की तैयारी को मिलाएं (जैसे 70% और 20% समाधान) एक निर्धारित सांद्रता पर। मूल्य प्रतिशत या mg/mL हैं डॉलर के बजाय; अंकगणित समान है।
• व्यापार और मूल्य निर्धारण — एक सस्ती और प्रीमियम स्टॉक को मिलाएं एक लक्ष्य इकाई लागत या बिक्री मूल्य को हिट करने के लिए।
• रसायन विज्ञान और खाद्य/पेय — एक लक्ष्य सांद्रता, प्रमाण, या ब्रिक्स को पतला करें या मजबूत करें।

क्योंकि नियम को केवल एक सुसंगत पैमाने पर एक मूल्य की आवश्यकता है, समान तीन इनपुट इन सभी को कवर करते हैं।

इसका उपयोग कैसे करें

1. सस्ता मूल्य, महंगा मूल्य, और लक्ष्य मिश्रण मूल्य दर्ज करें (कोई भी सुसंगत इकाई)।
2. वैकल्पिक रूप से कुल मात्रा दर्ज करें प्रत्येक घटक की सटीक मात्रा प्राप्त करने के लिए।
3. अनुपात, सरलीकृत अनुपात, और मात्राएं पढ़ें; क्रॉस आरेख और डोनट विभाजन दिखाते हैं।

इनपुट पृष्ठ URL पर सिंक करते हैं, इसलिए आप एक सटीक सेटअप बुकमार्क या साझा कर सकते हैं। लक्ष्य दोनों घटक मूल्यों के बीच कठोरता से होना चाहिए — अन्यथा कोई मिश्रण उन्हें नहीं पहुंच सकता, और उपकरण ऐसा कहता है।

कोड में इसकी गणना करें

प्रत्येक स्निपेट सस्ता मूल्य c, महंगा मूल्य d, लक्ष्य m, और कुल मात्रा q लेता है, और दोनों भागों और दोनों मात्राओं को लौटाता है।

Excel

मानते हुए कि C2 = सस्ता, D2 = महंगा, M2 = लक्ष्य, Q2 = कुल मात्रा:

1=D2-M2                            ' cheaper parts  (D − M)
2=M2-C2                            ' dearer parts   (M − C)
3=(D2-M2)/((D2-M2)+(M2-C2))*Q2     ' cheaper amount
4=(M2-C2)/((D2-M2)+(M2-C2))*Q2     ' dearer amount
5

1def alligation(c, d, m, q=None):
2    if not (c < m < d):
3        raise ValueError("need cheaper < target < dearer")
4    cheaper_parts, dearer_parts = d - m, m - c
5    total = cheaper_parts + dearer_parts
6    if q is None:
7        return cheaper_parts, dearer_parts
8    return cheaper_parts / total * q, dearer_parts / total * q
9

1function alligation(c, d, m, q) {
2  if (!(c < m && m < d)) throw new Error("need cheaper < target < dearer");
3  const cheaper = d - m, dearer = m - c, total = cheaper + dearer;
4  return q == null
5    ? { cheaper, dearer }
6    : { cheaperAmount: (cheaper / total) * q, dearerAmount: (dearer / total) * q };
7}
8

1double[] alligation(double c, double d, double m, double q) {
2    if (!(c < m && m < d)) throw new IllegalArgumentException("need c < m < d");
3    double cheaper = d - m, dearer = m - c, total = cheaper + dearer;
4    return new double[] { cheaper / total * q, dearer / total * q };
5}
6

1(double cheaper, double dearer) Alligation(double c, double d, double m, double q)
2{
3    if (!(c < m && m < d)) throw new ArgumentException("need c < m < d");
4    double cp = d - m, dp = m - c, total = cp + dp;
5    return (cp / total * q, dp / total * q);
6}
7

1#include <stdexcept>
2#include <utility>
3std::pair<double, double> alligation(double c, double d, double m, double q) {
4    if (!(c < m && m < d)) throw std::invalid_argument("need c < m < d");
5    double cheaper = d - m, dearer = m - c, total = cheaper + dearer;
6    return { cheaper / total * q, dearer / total * q };
7}
8

1func Alligation(c, d, m, q float64) (float64, float64, error) {
2    if !(c < m && m < d) {
3        return 0, 0, errors.New("need c < m < d")
4    }
5    cheaper, dearer := d-m, m-c
6    total := cheaper + dearer
7    return cheaper / total * q, dearer / total * q, nil
8}
9

1fn alligation(c: f64, d: f64, m: f64, q: f64) -> Option<(f64, f64)> {
2    if !(c < m && m < d) { return None; }
3    let (cheaper, dearer) = (d - m, m - c);
4    let total = cheaper + dearer;
5    Some((cheaper / total * q, dearer / total * q))
6}
7

1function alligation($c, $d, $m, $q) {
2    if (!($c < $m && $m < $d)) throw new InvalidArgumentException('need c < m < d');
3    $cheaper = $d - $m; $dearer = $m - $c; $total = $cheaper + $dearer;
4    return [$cheaper / $total * $q, $dearer / $total * $q];
5}
6

1def alligation(c, d, m, q)
2  raise ArgumentError, "need c < m < d" unless c < m && m < d
3  cheaper, dearer = d - m, m - c
4  total = cheaper + dearer
5  [cheaper / total * q, dearer / total * q]
6end
7

1alligation <- function(c, d, m, q) {
2  stopifnot(c < m, m < d)
3  cheaper <- d - m; dearer <- m - c; total <- cheaper + dearer
4  c(cheaper = cheaper / total * q, dearer = dearer / total * q)
5}
6

अक्सर पूछे जाने वाले प्रश्न

क्या होगा अगर लक्ष्य दोनों मूल्यों के बीच नहीं है? तब दोनों का कोई मिश्रण उस तक नहीं पहुंच सकता — $10 और$30 आइटम का एक मिश्रण हमेशा $10 और$30 के बीच उतरता है। उपकरण इसके बजाय एक नकली अनुपात लौटाने के बजाय इसे फ्लैग करता है।

क्या इकाई महत्वपूर्ण है? नहीं। अनुपात केवल एक सुसंगत पैमाने पर अंतर पर निर्भर करता है, इसलिए कीमतें, प्रतिशत, और mg/mL सभी काम करते हैं — बस सभी तीन इनपुट को एक ही इकाई में रखें।

क्या मैं इसे तीन या अधिक घटकों के लिए उपयोग कर सकता हूं? यह उपकरण दो-घटक मामले को संभालता है। तीन या अधिक घटकों वाली समस्याओं के कई वैध उत्तर हैं और आमतौर पर जोड़ी घटकों या रैखिक समीकरणों के साथ हल किए जाते हैं।

क्या alligation एक भारित औसत के समान है? वे विपरीत हैं। एक भारित औसत (alligation माध्य) मात्राओं को एक मिश्रण मूल्य में बदल देता है; alligation विकल्प एक लक्ष्य मूल्य को मात्राओं में बदल देता है।

स्रोत

• Alligation — Wikipedia — alligation विकल्प और माध्य की परिभाषाएं और अंतर्निहित नियम।
• Alligation Calculator — Omni Calculator — फार्मेसी में उपयोग किए जाने वाले सांद्रता-आधारित रूप, कार्य किए गए उदाहरणों के साथ।
• Pharmaceutical calculations by alligation method — EGPAT — मिश्रण के लिए alligation क्रॉस की पहली सिद्धांत वॉकथ्रू।