Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:128309
Feedback-ID: id5114917:Fastmail
Content-Type: multipart/alternative;
 boundary="------------eVK9Hhv74yipiBPdelLBMb6x"
Message-ID: <639dcf61-1b15-4381-aaff-54f0bd6bc23a@rwec.co.uk>
Date: Tue, 29 Jul 2025 21:09:20 +0100
Precedence: bulk
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: [PHP-DEV] [RFC] Add "is_representable_as_float()" and
 "is_representable_as_int()" functions
Content-Language: en-GB
To: internals@lists.php.net
References: <CAMU7irKj_SyyM2kVz4kEqjDK+ucc8uRP1amJgASTFRM+V+Ld3w@mail.gmail.com>
In-Reply-To: <CAMU7irKj_SyyM2kVz4kEqjDK+ucc8uRP1amJgASTFRM+V+Ld3w@mail.gmail.com>
From: imsop.php@rwec.co.uk ("Rowan Tommins [IMSoP]")

This is a multi-part message in MIME format.
--------------eVK9Hhv74yipiBPdelLBMb6x
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit

On 29/07/2025 13:52, Alexandre Daubois wrote:
> https://wiki.php.net/rfc/is-representable-as-float-int


In general, I think the proposed semantics make sense. I'm not sure 
about the names, but it's hard to think of a name that accurately 
describes what they do.


> The value is a float that is not NaN or infinity


It feels a bit odd to have a value where is_float($v) would be true, but 
is_representable_as_float($v) would be false. I'd be interested to 
understand the thinking behind this case.


> Because of this, the function return value is also platform-dependent:
>
> is_representable_as_float(PHP_INT_MAX); // true on 64-bit platforms, false on 32-bit platforms


This is, at best, misleading: it's not the function that's behaving 
differently, it's just being given different input. By that reasoning, 
strlen() is platform-dependent, because strlen(PHP_OS_FAMILY) returns 5 
on Linux but 7 on Windows.

As written, it's also the wrong way around: on a 32-bit platform, you 
are passing 2147483647, which is a "safe" value; on a 64-bit platform, 
you are passing 9223372036854775807, which is an odd number outside the 
"safe" range.

is_representable_as_float(2147483647) === true on any platform

is_representable_as_float(9223372036854775807) === false on a 64-bit build

Confusingly, passing that absolute value on a 32-bit system will appear 
to return true, but that's because the loss of precision *has already 
happened* in the compiler: 9223372036854775807 will actually be compiled 
as 9223372036854775808.0, the nearest representable float. So again, 
it's actually running the same function with different input, not 
different behaviour inside the function.


I suggest removing that sentence and example completely. There is 
nothing the function can or should do differently on different platforms.


> Here also, the function return value is platform-dependent:
>
> is_representable_as_int(2**31); // true on 64-bit platforms, false on 32-bit platforms


This one is fair enough, but I'd suggest tweaking the example slightly 
to avoid the same problem with different inputs: on a 64-bit build, 
2**31 already is an integer, so it's trivially true. So either force a 
floating point input:

is_representable_as_int(2.0**31); // true on 64-bit platforms, false on 
32-bit platforms

or, perhaps clearer, use an out-of-range string input:

is_representable_as_int('2147483648'); // true on 64-bit platforms, 
false on 32-bit platforms


Regards,

-- 
Rowan Tommins
[IMSoP]

--------------eVK9Hhv74yipiBPdelLBMb6x
Content-Type: text/html; charset=UTF-8
Content-Transfer-Encoding: 8bit

<!DOCTYPE html>
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  </head>
  <body>
    <div class="moz-cite-prefix">On 29/07/2025 13:52, Alexandre Daubois
      wrote:<span style="white-space: pre-wrap">
</span></div>
    <blockquote type="cite"
cite="mid:CAMU7irKj_SyyM2kVz4kEqjDK+ucc8uRP1amJgASTFRM+V+Ld3w@mail.gmail.com">
      <pre wrap="" class="moz-quote-pre"><a class="moz-txt-link-freetext" href="https://wiki.php.net/rfc/is-representable-as-float-int">https://wiki.php.net/rfc/is-representable-as-float-int</a></pre>
    </blockquote>
    <p><br>
    </p>
    <p>In general, I think the proposed semantics make sense. I'm not
      sure about the names, but it's hard to think of a name that
      accurately describes what they do.</p>
    <p><br>
    </p>
    <p>
      <blockquote type="cite">The value is a float that is not NaN or
        infinity</blockquote>
    </p>
    <p><br>
    </p>
    <p>It feels a bit odd to have a value where is_float($v) would be
      true, but is_representable_as_float($v) would be false. I'd be
      interested to understand the thinking behind this case.</p>
    <p><br>
    </p>
    <p>
      <blockquote type="cite">
        <p>Because of this, the function return value is
          also platform-dependent:
        </p>
        <div class="phpok">
          <pre class="code php">is_representable_as_float<span
          class="br0">(</span>PHP_INT_MAX<span class="br0">)</span><span
          class="sy0">;</span> <span class="co1">// true on 64-bit platforms, false on 32-bit platforms</span></pre>
        </div>
      </blockquote>
    </p>
    <p><br>
    </p>
    <p>This is, at best, misleading: it's not the function that's
      behaving differently, it's just being given different input. By
      that reasoning, strlen() is platform-dependent, because
      strlen(PHP_OS_FAMILY) returns 5 on Linux but 7 on Windows.</p>
    <p>As written, it's also the wrong way around: <span class="simpara">on
        a 32-bit platform, you are passing </span><span class="simpara">2147483647,
        which is a "safe" value; </span>on a 64-bit platform, you are
      passing <span class="simpara">9223372036854775807, which is an odd
        number outside the "safe" range.</span></p>
    <p><span class="simpara">is_representable_as_float(</span><span
        class="simpara"></span><span class="simpara">2147483647) ===
        true on any platform</span></p>
    <p><span class="simpara">is_representable_as_float(</span><span
        class="simpara"></span><span class="simpara"></span><span
        class="simpara">9223372036854775807</span><span class="simpara">)
        === false on a 64-bit build</span></p>
    <p><span class="simpara">Confusingly, passing that absolute value on
        a 32-bit system will appear to return true, but that's because
        the </span>loss of precision *has already happened* in the
      compiler: <span class="simpara"></span><span class="simpara"></span><span
        class="simpara">9223372036854775807</span><span class="simpara"> will
        actually be compiled as </span><span class="simpara"></span><span
        class="simpara"></span><span class="simpara">9223372036854775808.0,
        the nearest representable float. So again, it's actually running
        the same function with different input, not different behaviour
        inside the function.</span></p>
    <p><br>
    </p>
    <p>I suggest removing that sentence and example completely. There is
      nothing the function can or should do differently on different
      platforms.</p>
    <p><br>
    </p>
    <p>
      <blockquote type="cite">
        <p>
          Here also, the function return value is platform-dependent:
        </p>
        <div class="phpok">
          <pre class="code php">is_representable_as_int<span class="br0">(</span><span
          class="nu0">2</span><span class="sy0">**</span><span
          class="nu0">31</span><span class="br0">)</span><span
          class="sy0">;</span> <span class="co1">// true on 64-bit platforms, false on 32-bit platforms</span></pre>
        </div>
      </blockquote>
    </p>
    <p><br>
    </p>
    <p>This one is fair enough, but I'd suggest tweaking the example
      slightly to avoid the same problem with different inputs: on a
      64-bit build, 2**31 already is an integer, so it's trivially true.
      So either force a floating point input:</p>
    <p>is_representable_as_int(2.0**31); // true on 64-bit platforms,
      false on 32-bit platforms</p>
    <p>or, perhaps clearer, use an out-of-range string input:</p>
    <p>is_representable_as_int('<span class="simpara">2147483648'); //
        true on 64-bit platforms, false on 32-bit platforms</span></p>
    <p><br>
    </p>
    <p>Regards,</p>
    <pre class="moz-signature" cols="72">-- 
Rowan Tommins
[IMSoP]</pre>
  </body>
</html>

--------------eVK9Hhv74yipiBPdelLBMb6x--