CORE_V5 // util

PATH: opt / alt / tests / alt-php81-pecl-imagick_3.8.1-19.el8 / util /

Editing: functions.php

<?php

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

require_once __DIR__ . "/FloatInfo.php";
require_once __DIR__ . "/Float32Info.php";

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('h*', pack('d', $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('h*', pack('f', $num))[1]);
}

/**
 * Convert a floating point number to a FloatInfo object,
 * which contains string representations of the float'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 = '0';

if ($byte1 >= 8) {
        $sign = '1';
    }

$exponentString = substr($float64, 0, 3);
    $exponentValue = hexdec($exponentString) & 0x7ff;
    $exponent = sprintf("%b", $exponentValue);
    $exponent = str_pad($exponent, 11, '0', STR_PAD_LEFT);

$mantissa = substr($float64, 2);
    $mantissa = hexdec($mantissa) & 0xfffffffffffff;
    $mantissa = sprintf("%b", $mantissa);
    $mantissa = str_pad($mantissa, 52, '0', 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'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 = '0';

if ($byte1 >= 8) {
        $sign = '1';
    }
    $exponent3Bits = ($byte1 & 0x7);
    $exponent4Bits = $byte2;
    $exponent1Bit = ($byte3 & 0x8) >> 3;
    $exponent = ($exponent3Bits << 5) | ($exponent4Bits << 1) | $exponent1Bit;

$exponent = sprintf("%b", $exponent);
    $exponent = str_pad($exponent, 8, '0', STR_PAD_LEFT);

$mantissa = substr($float32, 2, 6);
    $mantissa = hexdec($mantissa) & 0x7fffff;
    $mantissa = sprintf("%b", $mantissa);
    $mantissa = str_pad($mantissa, 23, '0', 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  = "┌──────┬─────────────┬──────────────────────────────────────────────────────┐\n";
    $output .= "│ Sign │ Exponent    │ Mantissa                                             │\n";

$format_string = "│    %s │ %s │ %s │\n";

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

$output .= "└──────┴─────────────┴──────────────────────────────────────────────────────┘\n";

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  = "┌──────┬──────────┬─────────────────────────┐\n";
    $output .= "│ Sign │ Exponent │ Mantissa                │\n";

$format_string = "│    %s │ %s │ %s │\n";

$output .= "└──────┴──────────┴─────────────────────────┘\n";

return $output;
}

/**
 * So. One of the disadvantages of non-HDRI compiled Image Magick
 * is that it can't accurately represent a '50%' 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 'error' of
 * 0.00000762939453125
 *
 * The problem is even worse when ImageMagick is compiled with 8-bit
 * numbers (though this really shouldn'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 = [
        '255' => (1 / (pow(2, 8) - 1)) + 0.0000000000001,
        '65535' => (1 / (pow(2, 16) - 1)) + 0.0000000000001,
        '16777215' => (1 / (pow(2, 24) - 1) ) + 0.0000000000001,
        '4294967295' => (1 / (pow(2, 32) - 1)) + 0.0000000000001,
    ];

// These could definitely be defined better...
    $epsilon_values_for_hdri = [
        '255' => 0.0000000000001,
        '65535' => 0.0000000000001,
        '16777215' => 0.0000000000001,
        '4294967295' => 0.0000000000001
    ];

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

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

return $epsilon_values_for_hdri[$quantum];
}

CANCEL