Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:122832
Content-Type: text/plain;
	charset=utf-8
Precedence: bulk
Mime-Version: 1.0 (Mac OS X Mail 16.0 \(3731.700.6\))
Subject: Re: [PHP-DEV] [RFC] [Discussion] Support object type in BCMath
In-Reply-To: <CAMrTa2EK6ymBQuxeFj7tMV0M2crqCCCR=mLN-FSfuCgrQHEZ6A@mail.gmail.com>
Date: Sun, 31 Mar 2024 09:09:18 +0900
Cc: Aleksander Machniak <alec@alec.pl>,
 php internals <internals@lists.php.net>
Content-Transfer-Encoding: quoted-printable
Message-ID: <AB663F3F-A888-45F7-B19A-00530A4EDB0C@sakiot.com>
References: <4F094EDA-5058-407D-AF39-06FD934FDE1F@sakiot.com>
 <bbcff629-4dd6-bc50-ac9f-641849dc218a@php.net>
 <68CF373E-6ABF-4471-8992-813B4BA1B508@sakiot.com>
 <904197f4-afb5-401e-9e17-7a655c5449d0@alec.pl>
 <CAMrTa2EK6ymBQuxeFj7tMV0M2crqCCCR=mLN-FSfuCgrQHEZ6A@mail.gmail.com>
To: Jordan LeDoux <jordan.ledoux@gmail.com>
From: saki@sakiot.com (Saki Takamachi)

Hi Jordan,

> For addition, it absolutely should expand scale like this, unless the =
constructor also defines a default rounding type that is used in that =
situation. All numbers, while arbitrary, will be finite, so addition =
will always be exact and known based on inputs prior to calculation.=20
>=20
> Treating scale like this isn't more strict, it's confusing. For =
instance:
>=20
> ```
> $numA =3D new Number('1.23', 2);
> $numB =3D new Number('1.23456', 5);
>=20
> $expandedScale1 =3D $numA + $numB; // 2.46456
> $expandedScale2 =3D $numB + $numA; // 2.46456
>=20
> $strictScale1 =3D $numA + $numB; // 2.46 assuming truncation
> $strictScale2 =3D $numB + $numA; // 2.46456
> ```
>=20
> I ran into this same issue with operand ordering when I was writing my =
operator overload RFC.
>=20
> There are ways you could do the overload implementation that would get =
around this for object + object operations, but it's also mathematically =
unsound and probably unexpected for anyone who is going to the trouble =
of using an arbitrary precision library.
>=20
> Addition and subtraction should automatically use the largest scale =
from all operands. Division and multiplication should require a =
specified scale.
>=20
> Because of this, I'm not entirely sure that specifying a scale in the =
constructor is actually a good thing. It is incredibly easy to create =
situations, unless the implementation in C is VERY careful, where the =
operand positions matter beyond the simple calculation. Multiplication =
is commutative, but division is not. This would almost certainly lead to =
some very difficult to track down bugs.
>=20
> Putting scale in the constructor is similar to some of the examples of =
"possible misuse cases of operator overloading" that I had to go over =
when I was making my RFC. We definitely want to avoid that if possible =
for the first number/math object that has operator overloads.

Your opinion may be reasonable given the original BCMath calculation =
order. That is, do you intend code like this?

Signature:
```
// public function __construct(string|int $number)
// public function getNumber(?int $scale =3D null): string
```

Add:
```
// public function add(Number|string|int $number): string

$num =3D new Number('1.23456');
$num2 =3D new Number('1.23');

$add =3D $num + $num2;
$add->getNumber(); // '2.46456'
$add->getNumber(1); // =E2=80=982.4'

$add =3D $num->add($num2);
$add->getNumber(); // '2.46456'
$add->getNumber(1); // '2.4'
```

Div:
```
// public function div(Number|string|int $number, int =
$scaleExpansionLimit =3D 10): string


// case 1
$num =3D new Number('0.0001');
$num2 =3D new Number('3');

$div =3D $num / $num2; // scale expansion limit is always 10
$div->getNumber(); // '0.0000333333333'

$div =3D $num->div($num2, 20);
$div->getNumber(); // '0.00003333333333333333333'
$div->getNumber(7); // =E2=80=980.0000333'


// case 2
$num =3D new Number('1.111111');
$num2 =3D new Number('3');

$div =3D $num->div($num2, 3);
$div->getNumber(); // '0.370'
$div->getNumber(7); // =E2=80=980.3700000'
```

Since the scale can be inferred for everything other than div, a special =
argument is given only for div.

Regards.

Saki=