PHP => BC Math (Binary Calculator)

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

PHP
BC Math (Binary Calculator)

Ricerca…