Ricerca…


introduzione

Il Calcolatore binario può essere utilizzato per calcolare con numeri di qualsiasi dimensione e precisione fino a 2147483647-1 decimali, in formato stringa. Il calcolatore binario è più preciso del calcolo a virgola mobile di PHP.

Sintassi

  • string bcadd (string $ left_operand, string $ right_operand [, int $ scale = 0])
  • int bccomp (stringa $ left_operand, stringa $ right_operand [, int $ scale = 0])
  • stringa bcdiv (stringa $ left_operand, stringa $ right_operand [, int $ scale = 0])
  • stringa bcmod (stringa $ left_operand, stringa $ modulo)
  • stringa bcmul (stringa $ left_operand, stringa $ right_operand [, int $ scale = 0])
  • stringa bcpowmod (stringa $ left_operand, stringa $ right_operand, stringa $ modulo [, int $ scale = 0])
  • bool bcscale (int $ scale)
  • stringa bcsqrt (stringa $ operando [, int $ scale = 0])
  • stringa bcsub (stringa $ left_operand, stringa $ right_operand [, int $ scale = 0])

Parametri

bcadd Aggiungi due numeri di precisione arbitrari.
left_operand L'operando di sinistra, come una stringa.
right_operand L'operando giusto, come una stringa.
scale Un parametro facoltativo per impostare il numero di cifre dopo la virgola nel risultato.
bccomp Confronta due numeri di precisione arbitrari.
left_operand L'operando di sinistra, come una stringa.
right_operand L'operando giusto, come una stringa.
scale Un parametro facoltativo per impostare il numero di cifre dopo la cifra decimale che verrà utilizzata nel confronto.
bcdiv Dividi due numeri di precisione arbitrari.
left_operand L'operando di sinistra, come una stringa.
right_operand L'operando giusto, come una stringa.
scale Un parametro facoltativo per impostare il numero di cifre dopo la virgola nel risultato.
bcmod Ottieni modulo di un numero di precisione arbitrario.
left_operand L'operando di sinistra, come una stringa.
modulus Il modulo, come una stringa.
bcmul Moltiplicare due numeri di precisione arbitrari.
left_operand L'operando di sinistra, come una stringa.
right_operand L'operando giusto, come una stringa.
scale Un parametro facoltativo per impostare il numero di cifre dopo la virgola nel risultato.
bcpow Aumenta un numero arbitrario di precisione su un altro.
left_operand L'operando di sinistra, come una stringa.
right_operand L'operando giusto, come una stringa.
scale Un parametro facoltativo per impostare il numero di cifre dopo la virgola nel risultato.
bcpowmod Aumenta un numero arbitrario di precisione ad un altro, ridotto di un modulo specificato.
left_operand L'operando di sinistra, come una stringa.
right_operand L'operando giusto, come una stringa.
modulus Il modulo, come una stringa.
scale Un parametro facoltativo per impostare il numero di cifre dopo la virgola nel risultato.
bcscale Imposta il parametro di scala predefinito per tutte le funzioni matematiche di bc.
scale Il fattore di scala.
bcsqrt Ottieni la radice quadrata di un numero di precisione arbitrario.
operand L'operando, come una stringa.
scale Un parametro facoltativo per impostare il numero di cifre dopo la virgola nel risultato.
bcsub Sottrai un numero arbitrario di precisione da un altro.
left_operand L'operando di sinistra, come una stringa.
right_operand L'operando giusto, come una stringa.
scale Un parametro facoltativo per impostare il numero di cifre dopo la virgola nel risultato.

Osservazioni

Per tutte le funzioni BC, se il parametro di scale non è impostato, esso assume come valore predefinito 0, che renderà tutte le operazioni con operazioni su interi.

Confronto tra le operazioni matematiche BCMath e float

bcadd vs float + float

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"

bcsub vs float-float

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 vs 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 vs float * float

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"

bcdiv vs float / float

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"

Usando bcmath per leggere / scrivere un binario lungo sul sistema a 32 bit

Sui sistemi a 32 bit, gli interi superiori a 0x7FFFFFFF non possono essere memorizzati in modo primitivo, mentre i numeri interi tra 0x0000000080000000 e 0x7FFFFFFFFFFFFFFF possono essere memorizzati in modo primitivo su sistemi a 64 bit ma non su sistemi a 32 bit ( signed long long ). Tuttavia, poiché i sistemi a 64 bit e molti altri linguaggi supportano la memorizzazione di interi signed long long segno, a volte è necessario memorizzare questo intervallo di numeri interi in un valore esatto. Ci sono diversi modi per farlo, come la creazione di un array con due numeri, o la conversione del numero intero nella sua forma decimale leggibile. Questo ha diversi vantaggi, come la comodità nel presentare all'utente e la possibilità di manipolarlo direttamente con bcmath.

I metodi pack / unpack possono essere usati per convertire tra i byte binari e la forma decimale dei numeri (entrambi di tipo string , ma uno è binario e uno è ASCII), ma cercheranno sempre di trasmettere la stringa ASCII in un 32 bit int su sistemi a 32 bit. Il seguente frammento fornisce un'alternativa:

/** 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
Autorizzato sotto CC BY-SA 3.0
Non affiliato con Stack Overflow