This should work on many platforms for the example data you gave:

my $float= unpack "f", pack "L", 0x428C0000;
[download]

(assuming the value you wanted was the nice-looking "70").

but I'm not sure how to reconcile the terms "in ASCII" vs. "e.g. 0x428C0000". Perhaps you have a string like "0x428C0000":

my $string= "0x428C0000";
my $float= unpack "f", pack "L", hex $string;
[download]

my $string= "\x42\x8C\x00\x00";
[download]

$float= unpack "f", $string;
$float= unpack "f", scalar reverse $string;
[download]

my $string= "\x42\x8C\x00\x00";
my $float= unpack "f", pack "L", unpack "N", $string;
[download]

$float= unpack "f", pack "L", 0x428C0000;
print $float; # 70
$float= unpack "L", pack "f", 70 ;
print $float; # print 1116471296

Please tye, could you just point me why?

Because

print hex '428C0000';
1116471296
[download]

The original input was in hex, you are printing decimal.

---

Examine what is said, not who speaks.

"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail
Timing (and a little luck) are everything!

It's even more complex than that, you have to take into account the architecture of the CPU as well. When I did this I found it most usefull to start from floats and get to the hex. I also did it via binary:

$f2_5 = unpack("b64",pack("d",2.5));
print $f2_5 . "\n";
# Will return something like 00000000000000000000000000000000000000000
+00000000010000000000010
[download]

What I have done is to convert hex to binary then (possibly) shuffle the binary to a form suitable for this CPU and use pack/ unpack to assemble the float.

{
  my($endian,$binary2double_fun);

sub deduce_endian
  {
    my($v);

    # Deduce the machine's native FP format by encoding the 
    # number 2.5 as a bit string.  Once we know how to get
    # from doubles to bit strings we can deduce the function
    # for doing the reverse
    $v = unpack("b64",pack("d",2.5));
    if($v eq "00000000000000000000000000000000000000000000000000100000
+00000010")
      {
        # Intel or something like it
        $endian = "ieee-little";
        $binary2double_fun = sub 
          {
            # We have to reverse the bitstring
            my $bits = reverse(shift);

            # Then map to floats
            return(unpack("d",pack("b64",$bits)));
          };
      }
    elsif($v eq "01000000000001000000000000000000000000000000000000000
+00000000000")
      {
        # *NIX hardware
        $endian = "ieee-big";
        $binary2double_fun = sub 
          {
            # a combination of pack and unpack will do it
            my $bits = shift;
            return(unpack("d",pack("b64",$bits)));
          };
      }
    else
      {
        print STDERR "Not configured for this machine yet\n";
        exit(20);
      }
  }

sub hex2double
  {
    my($in,$out,$val) = @_;

    deduce_endian() if(!$endian);

    # The string we were given was a hex representation of 
    # the bits of an IEEE 64' double in network order.  
    # Convert to a string of 64 "0" and "1"s.  We cannot 
    # use pack here because then the order depends on the 
    # hardware
    $out = hex2binary($in);

    # Then map this to our double representation
    return &{$binary2double_fun}($out) if($binary2double_fun);

    # No mapping function defined!
    return 0.0;
  }
}
[download]

I have my own hex2binary function for various reasons that are not worth dwelling on. It sounds like you want one that takes into account the byte order of the input.

    #!/usr/bin/perl -wl


    my $hex =  '0x428C0000';
       $hex =~ s/0x//i; # Strip the hex 0x if present


    print unpack "f", reverse pack "H*", $hex ;
    print unpack "f",         pack "H*", $hex ;



    __END__
    Prints on an a little endian platform:

    70
    5.03150226600469e-041
[download]

In this case the first of these looks like the right value.

It is rare that you will encounter a platform where one of these doesn't work. If you do then I have some Perl code for packing and unpacking IEEE 754 floats and doubles independently of the architecture.

--
John.

This trick will also work for the other allowed number formats, such as 0777 (leading 0 implies octal).

For example,

 print " $_ is " . eval($_) . "\n" for qw( 0x428C000 0777 );
[download]

- barrachois