moderated, 2's complement usage in Perl

by **stylechief** » Fri, 08 Apr 2005 05:46:20 GMT

I need to recognize a 2's complement hex number and render it as a
signed integer. ex: ffbe8e should render as -16754, not 16760462.

I have not found any Perl function that correctly identifies a 2's
complement hex number.

Suggestions/solutions, please.

Thank you,
Liam

by **John Bokma** » Fri, 08 Apr 2005 13:08:12 GMT

correct it if the value is above a certain threshold.

--
John MexIT: http://johnbokma.com/mexit/
personal page: http://johnbokma.com/
Experienced programmer available: http://castleamber.com/
Happy Customers: http://castleamber.com/testimonials.html

by **Thomas, Mark - BLS CTR** » Fri, 08 Apr 2005 21:05:10 GMT

Bit::Vector should be able to do it.

- Mark.

by **Keith Thompson** » Sat, 09 Apr 2005 04:01:15 GMT

"stylechief" < XXXX@XXXXX.COM > writes:

It's not clear (to me) what problem you're trying to solve.

What does it mean for a string of hex digits, such as ffbe8e, to be a
"2's complement hex number"? Before trying to implement in Perl, can
you describe it in English?

I don't see anything about ffbe8e that marks as being 2's complement.
If you assume it's the representation of a 24-bit integer with a 2's
complement representation, its value is -16754; if it's more than 24
bits (say, 32), the value is 16760462.

What determines the number of bits? If it's the number of hex digits,
then anything with a leading digit of 8 or more is a negative value;
ffbe8e becomes -16754, and 0ffbe8e becomes 16760462. Apply the "hex"
function to the string; if you want it to be negative, subtract
2**(4 * length $s).

--
Keith Thompson (The_Other_Keith) XXXX@XXXXX.COM < http://www.ghoti.net/ ~kst>
San Diego Supercomputer Center <*> < http://users.sdsc.edu/ ~kst>
We must do something. This is something. Therefore, we must do this.

by **Liam** » Mon, 11 Apr 2005 23:25:30 GMT

The 2's complement is a method for representing integers in binary that
seems to be common in many operating systems and programming languages.
It is considered to be an easy way to represent negative integers.
Here's one description:
http://www.evergreen.edu/biophysics/technotes/program/2s_comp.htm
It appears that Perl does not 'natively' assume 2's complement like
some other languages. If the binary representation starts with a zero,
then the number is positive, if it starts with a 1, then it is
negative. If one needs to deal with 32 bit or larger numbers, simply
pad with 1's or 0's.

digits,
< http://www.ghoti.net/ ~kst>
< http://users.sdsc.edu/ ~kst>
this.

by **Liam** » Tue, 12 Apr 2005 07:03:36 GMT

Quote from the Bit::Vector module:
"As a consequence, whenever you pass a negative number as an argument
to some method of this module, it will be treated as a (usually very
large) positive number due to its internal two's complement binary
representation, usually resulting in an "index out of range" error
message and program abortion."

Still searching . . . .

by **Alan J. Flavell** » Tue, 12 Apr 2005 08:14:21 GMT

On Mon, Apr 11, Liam blurted out atop a fullquote:

I'd say it's more in the nature of a hardware implementation issue, if
you want to take the broader view.

I think Perl, on the whole, takes a higher-level view of data; but if
you know what you're doing, it's possible, in Perl, to assemble a bit
pattern (i.e with bitwise operators) and then interpret it as a signed
integer. But I've been doing that since long before I ever met Perl.

On the other hand, sometimes one needs 32-bit data interpreted as a
positive number. I'm sure you appreciate that it can't be both at the
same time, so there's a need for definitions.

It's the current fashion, indeed, in hardware. Theorists have many
another possibility to hand if it should ever go out of fashion.

Could you be specific as to the problem that you're experiencing?

That seems to be a rather limited way of saying "when increasing the
size of a signed integer, extend the sign bit". Nothing new there,
really.

Could you be more specific about what you're trying to achieve?
Quoting the entire history of the universe and hanging it onto the end
of your posting is all very well, but even that seems to lack the
necessary context.

by **Keith Thompson** » Tue, 12 Apr 2005 09:08:33 GMT

"Liam" < XXXX@XXXXX.COM > writes:

Yes, I know what 2's complement is, but I still don't understand what
problem you're trying to solve.

You've said that

"ffbe8e should render as -16754, not 16760462"

but one example doesn't make a problem description.

Is the input a string? Why do you consider ffbe8e to represent a
negative value? Is fbe8e (5 hex digits) also negative? What about
00ffbe8e? How would you represent the value 16760462 as a hex number?

The hexadecimal value ffbe8e, stored in a 32-bit 2's-complement
(signed) integer, is a positive value, representable in decimal as
16760462 (the hexadecimal value can also be represented as 00ffbe8e to
show the leading zeros explicitly). The same value stored in a 24-bit
2's-complement integer is a negative value, -16754. If you
sign-extend ffbe8e to 32 bits, it becomes ffffbe8e; is that what you
want? What, if anything, determines whether you want a 24-bit or
32-bit result?

If you want to do sign-extension, you need to define the size of the
input and the size of the output. In other words, you're extending
the sign from where to where?

My guess is that you're looking for a function that takes a string
argument (consisting of hex digits) and returns a numeric value. Show
some examples of what you want the function to return for various
arguments. Include at least the following:

"fbe8e"
"ffbe8e"
"0ffbe8e"
"ffffbe8e"
"1be8e"
"1fbe8e"
"1fffbe8e"

If you're not looking for something that converts a string to a
number, please be more specific about what you do want.

Are you concerned about the way Perl handles hexadecimal literals in
Perl source code? If so, note that ffe8e is not a numeric literal;
0xffe8e is.

Once you've defined the problem, the solution should be quite simple.

--
Keith Thompson (The_Other_Keith) XXXX@XXXXX.COM < http://www.ghoti.net/ ~kst>
San Diego Supercomputer Center <*> < http://users.sdsc.edu/ ~kst>
We must do something. This is something. Therefore, we must do this.

by **Liam** » Tue, 12 Apr 2005 21:23:22 GMT

Thanks to all for your time and consideration. Here is an example of
the solution that I was seeking:

open (BINFILE, "<000332") || die "Cant open: $!\n";
while(read(BINFILE, $data, 3)){
$data=hex(unpack 'H*',$data);
if ($data & 0x800000) {$data |= 0xff000000};
printf "%d \n", $data;
}
close (BINFILE) || die "Cant close: $!\n";

by **Yitzchak Scott-Thoennes** » Wed, 13 Apr 2005 03:33:36 GMT

Ok, now by showing real code you have demonstrated that you aren't
talking about a string like "ffbe8e", but a 3-byte chunk of data like
"\xff\xbe\x8e".

But your solution is flawed. printf("%d") is what is forcing 2's
complement interpretation here, by casting to a signed integer at
the C level. Adding a simple

print "negative" if $data < 0;

will show that you aren't getting what you want in $data itself. This
will help some:

if ($data & 0x800000) { use integer; $data |= 0xff000000 }

use integer forces math and numeric bitwise operations to convert the
operands and the result to signed (2's complement) integers.

Even that won't work if perl is using 64-bit integers. Easiest way
to deal with that is probably:

if ($data & 0x800000) { $data -= 2**24 }

by **Ilmari Karonen** » Fri, 22 Apr 2005 07:04:21 GMT

Liam < XXXX@XXXXX.COM > kirjoitti 12.04.2005:

Ahh... so this isn't really about hexadecimal numbers at all.

Besides the issues pointed out by Yitzchak Scott-Thoennes, all the
messing about with hex() and unpack('H*') is really not needed at all.
Here's how I might rewrite that loop:

open BINFILE, '<', $filename or die "Can't open $filename: $!\n";

while (read BINFILE, my $data, 3) { # read 24-bit big-endian value
my $int = unpack "N", "\0$data"; # parse as unsigned 32-bit
$int -= 1<<24 if $int & 1<<23; # make negative if sign bit set
print "$int\n"; # print in decimal
}

Another, slightly more compact way to write it would be:

while (read BINFILE, my $data, 3, 1) { # read 24-bit big-endian value
my $int = unpack "N", $data; # parse as unsigned 32-bit
$int -= ($int & 1<<23) << 1; # make negative if sign bit set
print "$int\n"; # print in decimal
}

This uses the offset argument of read() to prepend the null byte, and
also a different way of doing the sign extension. Either way works.

--
Ilmari Karonen
To reply by e-mail, please replace ".invalid" with ".net" in address.

moderated, 2's complement usage in Perl

moderated >> 2's complement usage in Perl

moderated >> 2's complement usage in Perl

moderated >> RE: 2's complement usage in Perl

moderated >> 2's complement usage in Perl

moderated >> 2's complement usage in Perl

moderated >> 2's complement usage in Perl

moderated >> 2's complement usage in Perl

moderated >> 2's complement usage in Perl

moderated >> 2's complement usage in Perl

moderated >> 2's complement usage in Perl

moderated >> 2's complement usage in Perl