Thread overview | ||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
January 07, 2019 signed nibble | ||||
---|---|---|---|---|
| ||||
Is there any direct way to convert a signed nibble in to a signed byte with the same absolute value? Obviously I can do some bit comparisons but just curious if there is a very quick way. |
January 07, 2019 Re: signed nibble | ||||
---|---|---|---|---|
| ||||
Posted in reply to Michelle Long | On Monday, 7 January 2019 at 17:23:19 UTC, Michelle Long wrote:
> Is there any direct way to convert a signed nibble in to a signed byte with the same absolute value? Obviously I can do some bit comparisons but just curious if there is a very quick way.
byte b = nibble | ((nibble & 0x40)?0xF0:0);
|
January 07, 2019 Re: signed nibble | ||||
---|---|---|---|---|
| ||||
Posted in reply to Patrick Schluter | On Monday, 7 January 2019 at 18:42:13 UTC, Patrick Schluter wrote:
> byte b = nibble | ((nibble & 0x40)?0xF0:0);
don't you mean & 0x80 ?
|
January 07, 2019 Re: signed nibble | ||||
---|---|---|---|---|
| ||||
Posted in reply to Adam D. Ruppe | On Monday, 7 January 2019 at 18:47:04 UTC, Adam D. Ruppe wrote:
> On Monday, 7 January 2019 at 18:42:13 UTC, Patrick Schluter wrote:
>> byte b = nibble | ((nibble & 0x40)?0xF0:0);
>
> don't you mean & 0x80 ?
He asked for signed nybble. So mine is wrong and yours also :-)
It's obviously 0x08 for the highest bit of the low nybble.
byte b = nibble | ((nibble & 0x08)?0xF0:0);
|
January 07, 2019 Re: signed nibble | ||||
---|---|---|---|---|
| ||||
Posted in reply to Michelle Long | On Mon, Jan 07, 2019 at 05:23:19PM +0000, Michelle Long via Digitalmars-d-learn wrote: > Is there any direct way to convert a signed nibble in to a signed byte with the same absolute value? Obviously I can do some bit comparisons but just curious if there is a very quick way. Assuming you have the nibble stored in the lower bits of a ubyte: import std.stdio; byte nibSgnExt(ubyte nib) { return cast(byte)(nib << 4) >> 4; } void main() { writefln("%02X", nibSgnExt(0x0F)); writefln("%02X", nibSgnExt(0x07)); } T -- If it breaks, you get to keep both pieces. -- Software disclaimer notice |
January 07, 2019 Re: signed nibble | ||||
---|---|---|---|---|
| ||||
Posted in reply to Patrick Schluter | On Mon, Jan 07, 2019 at 06:42:13PM +0000, Patrick Schluter via Digitalmars-d-learn wrote: > On Monday, 7 January 2019 at 17:23:19 UTC, Michelle Long wrote: > > Is there any direct way to convert a signed nibble in to a signed byte with the same absolute value? Obviously I can do some bit comparisons but just curious if there is a very quick way. > > byte b = nibble | ((nibble & 0x40)?0xF0:0); This is equivalent to doing a bit comparison (implied by the ? operator). You can do it without a branch: cast(byte)(nibble << 4) >> 4 will use the natural sign extension of a (signed) byte to "stretch" the upper bit. It just takes 2-3 CPU instructions. T -- Written on the window of a clothing store: No shirt, no shoes, no service. |
January 07, 2019 Re: signed nibble | ||||
---|---|---|---|---|
| ||||
Posted in reply to H. S. Teoh | On Monday, 7 January 2019 at 18:56:17 UTC, H. S. Teoh wrote:
> On Mon, Jan 07, 2019 at 06:42:13PM +0000, Patrick Schluter via Digitalmars-d-learn wrote:
>> On Monday, 7 January 2019 at 17:23:19 UTC, Michelle Long wrote:
>> > Is there any direct way to convert a signed nibble in to a signed byte with the same absolute value? Obviously I can do some bit comparisons but just curious if there is a very quick way.
>>
>> byte b = nibble | ((nibble & 0x40)?0xF0:0);
>
> This is equivalent to doing a bit comparison (implied by the ? operator). You can do it without a branch:
>
> cast(byte)(nibble << 4) >> 4
>
> will use the natural sign extension of a (signed) byte to "stretch" the upper bit. It just takes 2-3 CPU instructions.
>
Yeah, my bit-fiddle-fu goes back to pre-barrel-shifter days. Up to 32 bit processors, shifting was more expensive than branching.
|
January 07, 2019 Re: signed nibble | ||||
---|---|---|---|---|
| ||||
Posted in reply to Patrick Schluter | On Mon, Jan 07, 2019 at 08:06:17PM +0000, Patrick Schluter via Digitalmars-d-learn wrote: > On Monday, 7 January 2019 at 18:56:17 UTC, H. S. Teoh wrote: > > On Mon, Jan 07, 2019 at 06:42:13PM +0000, Patrick Schluter via Digitalmars-d-learn wrote: [...] > > > byte b = nibble | ((nibble & 0x40)?0xF0:0); > > > > This is equivalent to doing a bit comparison (implied by the ? operator). You can do it without a branch: > > > > cast(byte)(nibble << 4) >> 4 > > > > will use the natural sign extension of a (signed) byte to "stretch" the upper bit. It just takes 2-3 CPU instructions. > > > > Yeah, my bit-fiddle-fu goes back to pre-barrel-shifter days. Up to 32 bit processors, shifting was more expensive than branching. Really? Haha, never knew that, even though I date all the way back to writing assembly on 8-bit processors. :-D T -- One reason that few people are aware there are programs running the internet is that they never crash in any significant way: the free software underlying the internet is reliable to the point of invisibility. -- Glyn Moody, from the article "Giving it all away" |
January 07, 2019 Re: signed nibble | ||||
---|---|---|---|---|
| ||||
Posted in reply to H. S. Teoh | On Monday, 7 January 2019 at 20:28:21 UTC, H. S. Teoh wrote:
> On Mon, Jan 07, 2019 at 08:06:17PM +0000, Patrick Schluter via Digitalmars-d-learn wrote:
>> On Monday, 7 January 2019 at 18:56:17 UTC, H. S. Teoh wrote:
>> > On Mon, Jan 07, 2019 at 06:42:13PM +0000, Patrick Schluter via Digitalmars-d-learn wrote:
> [...]
>> > > byte b = nibble | ((nibble & 0x40)?0xF0:0);
>> >
>> > This is equivalent to doing a bit comparison (implied by the ? operator). You can do it without a branch:
>> >
>> > cast(byte)(nibble << 4) >> 4
>> >
>> > will use the natural sign extension of a (signed) byte to "stretch" the upper bit. It just takes 2-3 CPU instructions.
>> >
>>
>> Yeah, my bit-fiddle-fu goes back to pre-barrel-shifter days. Up to 32 bit processors, shifting was more expensive than branching.
>
> Really? Haha, never knew that, even though I date all the way back to writing assembly on 8-bit processors. :-D
>
Most of my career was programming for 80186. Shifting by one was 2 cycles in register and 15 in memory. Shifting by 4, 9 cycles for regs/21 for mem. And 80186 was a fast shifter compared to 8088/86 or 68000 (8+2n cycles).
|
January 07, 2019 Re: signed nibble | ||||
---|---|---|---|---|
| ||||
Posted in reply to Patrick Schluter | On Mon, Jan 07, 2019 at 08:41:32PM +0000, Patrick Schluter via Digitalmars-d-learn wrote: > On Monday, 7 January 2019 at 20:28:21 UTC, H. S. Teoh wrote: > > On Mon, Jan 07, 2019 at 08:06:17PM +0000, Patrick Schluter via Digitalmars-d-learn wrote: [...] > > > Up to 32 bit processors, shifting was more expensive than branching. > > > > Really? Haha, never knew that, even though I date all the way back to writing assembly on 8-bit processors. :-D > > > Most of my career was programming for 80186. Shifting by one was 2 cycles in register and 15 in memory. Shifting by 4, 9 cycles for regs/21 for mem. And 80186 was a fast shifter compared to 8088/86 or 68000 (8+2n cycles). I used to hack 6502 assembly code. During the PC revolution I wrote an entire application in 8088 assembly. Used to know many of the opcodes and cycle counts by heart like you do, but it's all but a faint memory now. T -- Right now I'm having amnesia and deja vu at the same time. I think I've forgotten this before. |
Copyright © 1999-2021 by the D Language Foundation