Search
```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.

```
```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);
```
```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 ?
```
```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);
```
```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
```
```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.
```
```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.

```
```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"
```
```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).

```
```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.
```
« First   ‹ Prev
1 2