Handling Decimal Calculations in PHP with the New BCMath Object API

Originally published at Takeshi Yu's Blog.

---

Accurate numerical computation is paramount in enterprise applications, especially those dealing with finance, accounting, or inventory. Even minor rounding errors can cause significant problems. PHP 8.4's enhanced BCMath Object API offers a refined solution for precise and efficient decimal calculations.

---

Experienced PHP developers are familiar with floating-point imprecision:

$a = 0.1;
$b = 0.2;
var_dump($a + $b);  // Outputs: 0.30000000000000004

This inaccuracy is unacceptable in financial contexts. These small errors accumulate, leading to real-world discrepancies.

Database Design for Precision

Precise decimal calculations begin with the database. The DECIMAL type is essential:

// In Laravel Migration
Schema::create('items', function (Blueprint $table) {
    $table->id();
    $table->decimal('quantity', 10, 3);  // Precision: 10 digits, 3 decimal places
    $table->decimal('price', 10, 3);     // Precision: 10 digits, 3 decimal places
    $table->decimal('discount', 10, 3);  // Precision: 10 digits, 3 decimal places
    $table->decimal('tax', 10, 3);       // Precision: 10 digits, 3 decimal places
    // ... other columns
});

DECIMAL ensures:

• Exact decimal precision.
• Customizable scale and precision.
• Suitability for financial applications.

While potentially slightly slower than FLOAT, the precision advantage outweighs the performance difference in mission-critical systems.

Leveraging Laravel's Casting

Laravel simplifies decimal handling with its casting system:

class Item extends Model
{
    protected $casts = [
        'quantity' => 'decimal:3',
        'price' => 'decimal:3',
        'discount' => 'decimal:3',
        'tax' => 'decimal:3',
    ];
}

However, remember that Laravel casting primarily manages:

• Data formatting.
• Consistent value representation.

Avoiding Type Conversion Pitfalls

Even with correct database types and Laravel casting, calculation errors can occur:

// Database values
$item1 = Item::find(1);  // price: "99.99"
$item2 = Item::find(2);  // price: "149.99"

// Calculation without BCMath
$subtotal = $item1->price + $item2->price;
$tax = $subtotal * 0.05;  // 5% tax

var_dump($tax);  // Outputs: float(12.499000000000002) instead of 12.499

This happens because PHP implicitly converts strings to numbers during arithmetic:

// String values from database
$price1 = "99.99";
$price2 = "149.99";
echo gettype($price1);  // string

// Implicit conversion to float
$total = $price1 + $price2;
echo gettype($total);   // double (float)

BCMath Before PHP 8.4: Precise but Tedious

The traditional BCMath extension provides precision:

// Database values
$item1 = Item::find(1);  // price: "99.99"
$item2 = Item::find(2);  // price: "149.99"

// Using BCMath functions
$subtotal = bcadd($item1->price, $item2->price, 3);
$tax = bcmul($subtotal, $item2->tax, 3);

var_dump($tax);  // Precisely outputs: string(5) "12.499"

However, complex calculations become verbose and less maintainable:

// Complex order calculation (using BCMath functions)
// ... (code omitted for brevity)

PHP 8.4's BCMath Object API: Elegance and Precision

PHP 8.4's object-oriented BCMath API simplifies precise calculations:

use BCMath\Number;

$item1 = Item::find(1);
$price = new Number($item1->price);
$quantity = new Number($item1->quantity);
$discountRate = new Number($item1->discount);
$taxRate = new Number($item1->tax);

// Natural and readable calculations
$subtotal = $price * $quantity;
$discount = $subtotal * $discountRate;
$afterDiscount = $subtotal - $discount;
$tax = $afterDiscount * $taxRate;
$total = $afterDiscount + $tax;

var_dump($total);  // Automatically converts to string

Advantages of the new API:

• Intuitive object-oriented design.
• Standard mathematical operator support.
• Immutable objects for data integrity.
• Stringable interface implementation.

Seamless Laravel Integration

Further elegance is achieved with Laravel's accessors:

use BCMath\Number;

class Item extends Model
{
    // ... (accessor methods for quantity, price, discount, tax using Number) ...
}

Or with a custom cast:

// ... (DecimalCast class implementation) ...

Then:

$item1 = Item::find(1);

$subtotal = $item1->price * $item1->quantity;
// ... (rest of the calculation) ...

Conclusion

In healthcare inventory management, precise decimal calculations are vital. PHP 8.4's BCMath Object API, integrated with Laravel, significantly improves the handling of these calculations, offering precision, readability, maintainability, and type safety. While the older BCMath functions served their purpose, this new approach streamlines development considerably.

The above is the detailed content of Handling Decimal Calculations in PHP with the New BCMath Object API. For more information, please follow other related articles on the PHP Chinese website!