અલીગેશન કેલ્કુલેટર — મિશ્રણ ગુણોત્તર અને માત્રા

આ કેલ્કુલેટર શું કરે છે (ELI5)

તમારી પાસે બે વસ્તુઓ છે જેની કિંમત અલગ અલગ છે — એક સ્તે અને એક મોંઘી — અને તમે તેમને એક મિશ્રણમાં મેળવવા માંગો છો જે બે વચ્ચે કોઈક લક્ષ્ય કિંમતે હોય. અલીગેશન તમને કહે છે કે દરેકમાંથી કેટલું ઉપયોગ કરવું.

સીસો વિશે વિચાર કરો. લક્ષ્ય મૂલ્ય પીવટ છે. જે ઘટક કિંમત લક્ષ્યથી દૂર છે તે નાની માત્રામાં હોવો જોઈએ, અને જે નજીક છે તે મોટી માત્રામાં હોવો જોઈએ, જેથી બંને બાજુ સંતુલિત રહે. અલીગેશન માત્ર તે સંતુલનનું અંકગણિત છે.

ત્રણ સંખ્યાઓ દાખલ કરો — સ્તો મૂલ્ય, મોંધો મૂલ્ય, અને લક્ષ્ય — અને આ સાધન તમને આપે છે:

• મિશ્રણનો ગુણોત્તર (દા.ત. 1 : 2, એટલે કે સ્તામાંથી 1 ભાગ મોંધામાંથી 2 ભાગ સુધી),
• દરેક ઘટકની ચોક્કસ માત્રા જ્યારે તમે કુલ માત્રા દાખલ કરો,
• એક ક્રોસ ડાયાગ્રામ અને રચના ચાર્ટ જેથી તમે મિશ્રણ જોઈ શકો.

"મૂલ્ય" કોઈ કિંમત, ટકાવાર શક્તિ, અથવા સાંદ્રતા હોઈ શકે છે (%, mg/mL, w/v) — કોઈ પણ વસ્તુ એક સુસંગત ધોરણમાં માપી શકાય.

સૂત્ર

સ્તો મૂલ્ય C સાથે, મોંધો મૂલ્ય D, અને લક્ષ્ય મિશ્રણ મૂલ્ય M જ્યાં C < M < D:

$\text{સ્તા ભાગો} : \text{મોંધા ભાગો} = (D - M) : (M - C)$

દરેક ઘટકના ભાગો વિરુદ્ધ તફાવતમાંથી આવે છે — જીતનો જલ્દી લક્ષ્ય ઘટક પાસેથી દૂર બેસે છે, તેટલા વધુ અન્ય ઘટકની જરૂર છે. જો તમે કુલ માત્રા Q પણ જાણો છો:

$\text{સ્તો પ્રમાણ} = \frac{D - M}{(D - M) + (M - C)}\,Q \qquad \text{મોંધો પ્રમાણ} = \frac{M - C}{(D - M) + (M - C)}\,Q$

અલીગેશન ક્રોસ

આનું લેઆઉટ કરવાનો શાસ્ત્રીય રીત "ક્રોસ" છે: બંને ઘટક મૂલ્યો ડાબી બાજુ મૂકો, લક્ષ્ય મધ્યમાં મૂકો, અને દરેક કર્ણ સાથે બાદ કરો. દરેક તફાવત વિરુદ્ધ ખૂણા પર ઉતરે છે અને તે ઘટકના ભાગો બને છે.

1   મોંધો (D) ───────┐        ┌─────── (M − C) = મોંધા ભાગો
2                      ╲      ╱
3                    લક્ષ્ય (M)
4                      ╱      ╲
5  સ્તો (C) ───────┘        └─────── (D − M) = સ્તા ભાગો
6

કાર્ય ઉદાહરણ

$10 ઘટક અને$30 ઘટક મિશ્રિત કરો તેને $20 માં વેચવા માટે:

$\text{સ્તો} : \text{મોંધો} = (30 - 20) : (20 - 10) = 10 : 10 = 1 : 1$

સમાન ભાગો. 100 એકમોની કુલ માટે, તે સ્તોમાંથી 50 અને મોંધોમાંથી 50 છે — અને મિશ્રણ મૂલ્ય બરાબર $20 છે. લક્ષ્યને$25 માં ખસેડો અને ગુણોત્તર 5 : 15 = 1 : 3 બને છે: જો લક્ષ્ય મોંધ મૂલ્યમાં નજીક બેસે છે, તેટલા વધુ મોંધ ઘટકની જરૂર છે.

અલીગેશન વૈકલ્પિક વર્સ અલીગેશન મીડીયલ

• અલીગેશન વૈકલ્પિક (આ સાધન શું કરે છે) — તમે બંને ઘટક મૂલ્યો અને લક્ષ્ય જાણો છો, અને તમે ગુણોત્તર માટે ઉકેલો.
• અલીગેશન મીડીયલ — તમે ઘટકોની માત્રા અને મૂલ્યો જાણો છો, અને તમે પરિણામી મિશ્રણ મૂલ્યના માટે ઉકેલો. તે માત્ર ભારાંકિત સરેરાશ છે: $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                            ' સ્તા ભાગો  (D − M)
2=M2-C2                            ' મોંધા ભાગો   (M − C)
3=(D2-M2)/((D2-M2)+(M2-C2))*Q2     ' સ્તો પ્રમાણ
4=(M2-C2)/((D2-M2)+(M2-C2))*Q2     ' મોંધો પ્રમાણ
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 બધા કામ કરે છે — માત્ર સમાન એકમમાં ત્રણે ઇનપુટ રાખો.

શું હું તેનો ત્રણ અથવા વધુ ઘટક માટે ઉપયોગ કરી શકું? આ સાધન બે-ઘટક કેસ સંભાળે છે. ત્રણ અથવા વધુ ઘટક સમસ્યાઓ ઘણા માન્ય જવાબો ધરાવે છે અને સામાન્યત: જોડીનું મિશ્રણ અથવા રેખીય સમીકરણ વચ્ચે ઉકેલ્યા જાય છે.

શું અલીગેશન ભારાંકિત સરેરાશ સમાન છે? તે વિપર્યય છે. ભારાંકિત સરેરાશ (અલીગેશન મીડીયલ) માત્રાને મિશ્રણ મૂલ્યમાં ફેરવે છે; અલીગેશન વૈકલ્પિક લક્ષ્ય મૂલ્યને માત્રામાં ફેરવે છે.

સોતો

• અલીગેશન — વિકિપીડિયા — અલીગેશન વૈકલ્પિક અને મીડીયલ અને અંતર્ગત નિયમની વ્યાખ્યાઓ.
• અલીગેશન કેલ્કુલેટર — ઓમ્ની કેલ્કુલેટર — ફાર્મેસીમાં ઉપયોગ કરવામાં આવતું સાંદ્રતા-આધારિત સ્વરૂપ, કાર્ય ઉદાહરણો સાથે.
• ફાર્માસ્યુટિકલ ગણતરીઓ અલીગેશન પદ્ધતિ દ્વારા — EGPAT — સંમિશ્રણ માટે અલીગેશન ક્રોસની મૂલ સિદ્ધાંતો દ્વારા ચાલવું.