खोज…


परिचय

बाइनरी कैलकुलेटर का उपयोग किसी भी आकार की संख्या और 2147483647-1 दशमलव तक की सटीकता के साथ गणना करने के लिए किया जा सकता है। बाइनरी कैलकुलेटर PHP की फ्लोट गणना की तुलना में अधिक सटीक है।

वाक्य - विन्यास

  • string bcadd (स्ट्रिंग $ left_operand, string $ right_operand [, int $ scale = 0])
  • int bccomp (स्ट्रिंग $ left_operand, string $ right_operand [, int $ scale = 0])
  • string bcdiv (string $ left_operand, string $ right_operand [, int $ scale = 0])
  • स्ट्रिंग bcmod (स्ट्रिंग $ left_operand, स्ट्रिंग $ मापांक)
  • string bcmul (string $ left_operand, string $ right_operand [, int $ scale = 0])
  • string bcpowmod (string $ left_operand, string $ right_operand, string $ modulus [, int $ scale = 0])
  • बूल बीस्केल (इंट $ स्केल)
  • string bcsqrt (स्ट्रिंग $ ऑपरेंड [, इंट $ स्केल = 0])
  • स्ट्रिंग बीक्यूब (स्ट्रिंग $ left_operand, string $ right_operand [, int $ scale = 0])

पैरामीटर

bcadd दो मनमाना सटीक संख्याएँ जोड़ें।
left_operand एक स्ट्रिंग के रूप में बाएं ऑपरेंड।
right_operand एक स्ट्रिंग के रूप में सही ऑपरेंड।
scale परिणाम में दशमलव स्थान के बाद अंकों की संख्या निर्धारित करने के लिए एक वैकल्पिक पैरामीटर।
bccomp दो मनमाना सटीक संख्याओं की तुलना करें।
left_operand एक स्ट्रिंग के रूप में बाएं ऑपरेंड।
right_operand एक स्ट्रिंग के रूप में सही ऑपरेंड।
scale दशमलव स्थान के बाद अंकों की संख्या निर्धारित करने के लिए एक वैकल्पिक पैरामीटर जिसका उपयोग तुलना में किया जाएगा।
bcdiv दो मनमाना सटीक संख्याओं को विभाजित करें।
left_operand एक स्ट्रिंग के रूप में बाएं ऑपरेंड।
right_operand एक स्ट्रिंग के रूप में सही ऑपरेंड।
scale परिणाम में दशमलव स्थान के बाद अंकों की संख्या निर्धारित करने के लिए एक वैकल्पिक पैरामीटर।
bcmod एक मनमाना सटीक संख्या का मापांक प्राप्त करें।
left_operand एक स्ट्रिंग के रूप में बाएं ऑपरेंड।
modulus मापांक, एक स्ट्रिंग के रूप में।
bcmul दो मनमाने ढंग से सटीक संख्याओं को गुणा करें।
left_operand एक स्ट्रिंग के रूप में बाएं ऑपरेंड।
right_operand एक स्ट्रिंग के रूप में सही ऑपरेंड।
scale परिणाम में दशमलव स्थान के बाद अंकों की संख्या निर्धारित करने के लिए एक वैकल्पिक पैरामीटर।
bcpow एक अन्य के लिए एक मनमाना सटीक संख्या उठाएँ।
left_operand एक स्ट्रिंग के रूप में बाएं ऑपरेंड।
right_operand एक स्ट्रिंग के रूप में सही ऑपरेंड।
scale परिणाम में दशमलव स्थान के बाद अंकों की संख्या निर्धारित करने के लिए एक वैकल्पिक पैरामीटर।
bcpowmod एक निर्दिष्ट मापांक द्वारा कम किए गए, एक अन्य के लिए एक मनमाना सटीक संख्या उठाएँ।
left_operand एक स्ट्रिंग के रूप में बाएं ऑपरेंड।
right_operand एक स्ट्रिंग के रूप में सही ऑपरेंड।
modulus मापांक, एक स्ट्रिंग के रूप में।
scale परिणाम में दशमलव स्थान के बाद अंकों की संख्या निर्धारित करने के लिए एक वैकल्पिक पैरामीटर।
bcscale सभी बीसी गणित कार्यों के लिए डिफ़ॉल्ट स्केल पैरामीटर सेट करें।
scale पैमाना कारक।
bcsqrt एक मनमाना सटीक संख्या का वर्गमूल प्राप्त करें।
operand एक स्ट्रिंग के रूप में ऑपरेंड।
scale परिणाम में दशमलव स्थान के बाद अंकों की संख्या निर्धारित करने के लिए एक वैकल्पिक पैरामीटर।
bcsub एक मनमानी सटीक संख्या को दूसरे से घटाएं।
left_operand एक स्ट्रिंग के रूप में बाएं ऑपरेंड।
right_operand एक स्ट्रिंग के रूप में सही ऑपरेंड।
scale परिणाम में दशमलव स्थान के बाद अंकों की संख्या निर्धारित करने के लिए एक वैकल्पिक पैरामीटर।

टिप्पणियों

सभी बीसी कार्यों के लिए, यदि scale पैरामीटर सेट नहीं है, तो यह 0 से डिफॉल्ट करता है, जो सभी ऑपरेशनों को पूर्णांक ऑपरेशन बना देगा।

बीसीएमथ और फ्लोट अंकगणितीय संचालन के बीच तुलना

bcadd बनाम फ्लोट + फ्लोट

var_dump('10' + '-9.99');           // float(0.0099999999999998)
var_dump(10 + -9.99);               // float(0.0099999999999998)
var_dump(10.00 + -9.99);            // float(0.0099999999999998)
var_dump(bcadd('10', '-9.99', 20)); // string(22) "0.01000000000000000000"

बीक्यूएसबी बनाम फ्लोट-फ्लोट

var_dump('10' - '9.99');           // float(0.0099999999999998)
var_dump(10 - 9.99);               // float(0.0099999999999998)
var_dump(10.00 - 9.99);            // float(0.0099999999999998)
var_dump(bcsub('10', '9.99', 20)); // string(22) "0.01000000000000000000"

bcmul बनाम int * int

var_dump('5.00' * '2.00');            // float(10)
var_dump(5.00 * 2.00);                // float(10)
var_dump(bcmul('5.0', '2', 20));      // string(4) "10.0"
var_dump(bcmul('5.000', '2.00', 20)); // string(8) "10.00000"
var_dump(bcmul('5', '2', 20));        // string(2) "10"

bcmul बनाम फ्लोट * फ्लोट

var_dump('1.6767676767' * '1.6767676767');           // float(2.8115498416259)
var_dump(1.6767676767 * 1.6767676767);               // float(2.8115498416259)
var_dump(bcmul('1.6767676767', '1.6767676767', 20)); // string(22) "2.81154984162591572289"

बीडीसीवी बनाम फ्लोट / फ्लोट

var_dump('10' / '3.01');           // float(3.3222591362126)
var_dump(10 / 3.01);               // float(3.3222591362126)
var_dump(10.00 / 3.01);            // float(3.3222591362126)
var_dump(bcdiv('10', '3.01', 20)); // string(22) "3.32225913621262458471"

32-बिट सिस्टम पर एक बाइनरी लंबे पढ़ने / लिखने के लिए bcmath का उपयोग करना

32-बिट सिस्टम पर, 0x7FFFFFFF से अधिक के पूर्णांक को आदिम रूप से संग्रहीत नहीं किया जा सकता है, जबकि 0x0000000080000000 और 0x7FFFFFFFFFFFFFFF बीच पूर्णांक को 64-बिट पर संग्रहीत किया जा सकता है, लेकिन 32-बिट सिस्टम ( signed long long ) पर नहीं। हालांकि, चूंकि 64-बिट सिस्टम और कई अन्य भाषाएं signed long long पूर्णांक का समर्थन signed long long हैं, इसलिए कभी-कभी पूर्णांकों की इस श्रेणी को सटीक मान में संग्रहीत करना आवश्यक होता है। ऐसा करने के कई तरीके हैं, जैसे दो संख्याओं के साथ एक सरणी बनाना या पूर्णांक को अपने दशमलव मानव-पठनीय रूप में परिवर्तित करना। इसके कई फायदे हैं, जैसे कि उपयोगकर्ता को प्रस्तुत करने में सुविधा, और सीधे bcmath के साथ हेरफेर करने की क्षमता।

pack / unpack विधियों का उपयोग बाइनरी बाइट्स और संख्याओं के दशमलव रूप (दोनों प्रकार के string , लेकिन एक बाइनरी और एक ASCII है) के बीच परिवर्तित करने के लिए किया जा सकता है, लेकिन वे हमेशा ASCII स्ट्रिंग को 32-बिट में डालने का प्रयास करेंगे 32-बिट सिस्टम पर int। निम्नलिखित स्निपेट एक विकल्प प्रदान करता है:

/** Use pack("J") or pack("p") for 64-bit systems */
function writeLong(string $ascii) : string {
    if(bccomp($ascii, "0") === -1) { // if $ascii < 0
        // 18446744073709551616 is equal to (1 << 64)
        // remember to add the quotes, or the number will be parsed as a float literal
        $ascii = bcadd($ascii, "18446744073709551616");
    }

    // "n" is big-endian 16-bit unsigned short. Use "v" for small-endian.
    return pack("n", bcmod(bcdiv($ascii, "281474976710656"), "65536")) .
        pack("n", bcmod(bcdiv($ascii, "4294967296"), "65536")) .
        pack("n", bcdiv($ascii, "65536"), "65536")) .
        pack("n", bcmod($ascii, "65536"));
}

function readLong(string $binary) : string {
    $result = "0";
    $result = bcadd($result, unpack("n", substr($binary, 0, 2)));
    $result = bcmul($result, "65536");
    $result = bcadd($result, unpack("n", substr($binary, 2, 2)));
    $result = bcmul($result, "65536");
    $result = bcadd($result, unpack("n", substr($binary, 4, 2)));
    $result = bcmul($result, "65536");
    $result = bcadd($result, unpack("n", substr($binary, 6, 2)));

    // if $binary is a signed long long
    // 9223372036854775808 is equal to (1 << 63) (note that this expression actually does not work even on 64-bit systems)
    if(bccomp($result, "9223372036854775808") !== -1) { // if $result >= 9223372036854775807
        $result = bcsub($result, "18446744073709551616"); // $result -= (1 << 64)
    }
    return $result;
}


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow