## D - Casting int to bit[]

• C. Sauls (26/26) Dec 19 2003 Is it possible, or could be made possible, to cast an integral type to
• J Anderson (4/30) Dec 20 2003 It would guess that bit's would be stored as 8-bit or 32-bit on most
• Sean L. Palmer (7/33) Dec 20 2003 I asked for this a while back. I'd post a link but by god the web inter...
• C. Sauls (22/36) Dec 20 2003 Out of fairness I thought I should show how I currently have this
• Alix Pexton (12/48) Dec 21 2003 I think that the attached code should do something like a cast to and
• Chris Sauls (10/30) Dec 24 2003 It does indeed work... and it leads me to ressurect another subject we
• Alix Pexton (8/38) Dec 26 2003 I'm very pleased it worked, that it has been helpful, and that it has
"C. Sauls" <ibisbasenji yahoo.com> writes:
Is it possible, or could be made possible, to cast an integral type to
an array of bits, and vice versa?  Ie:

int i = 123;
bit[] bs = cast(bit[]) i;
// bs == 0000 0000 0000 0000 0000 0000 0111 1011

int i2 = cast(int) bs;
// i2 == 123

An example of how I think this could be useful:

const char[] hexdigits = "0123456789ABCDEF";
char[] toHexLiteral(int i)
{
bit[]  buf = cast(bit[]) i;
int    nibel;
char[] ret;

for (int idx = 0; idx < buf.length; idx += 4)
{
nibel = cast(int) buf[idx..idx+4];
ret ~= hexdigits[nibel];
}
return ret;
}

Would it not be possible to implement this by duplicating the int's
memory into the storage for the bit[]?  Might be something I don't know
about that prevents it.  Just a random thought.

-- C. Sauls
-- Invironz
Dec 19 2003
C. Sauls wrote:

Is it possible, or could be made possible, to cast an integral type to
an array of bits, and vice versa?  Ie:
That would be quite useful for set RLE (run length encoding) as well.
int i = 123;
bit[] bs = cast(bit[]) i;
// bs == 0000 0000 0000 0000 0000 0000 0111 1011

int i2 = cast(int) bs;
// i2 == 123

An example of how I think this could be useful:

const char[] hexdigits = "0123456789ABCDEF";
char[] toHexLiteral(int i)
{
bit[]  buf = cast(bit[]) i;
int    nibel;
char[] ret;

for (int idx = 0; idx < buf.length; idx += 4)
{
nibel = cast(int) buf[idx..idx+4];
ret ~= hexdigits[nibel];
}
return ret;
}

Would it not be possible to implement this by duplicating the int's
memory into the storage for the bit[]?  Might be something I don't
know about that prevents it.  Just a random thought.
It would guess that bit's would be stored as 8-bit or 32-bit on most machines, there probably wouldn't be a need for copying.
-- C. Sauls
-- Invironz
Dec 20 2003
"Sean L. Palmer" <palmer.sean verizon.net> writes:
I asked for this a while back.  I'd post a link but by god the web interface
for the D ng sucks hard.

(instead of a bitfield you'd have a constant slice of some bit array)

Sean

"C. Sauls" <ibisbasenji yahoo.com> wrote in message
news:bs0qdh\$112i\$1 digitaldaemon.com...
Is it possible, or could be made possible, to cast an integral type to
an array of bits, and vice versa?  Ie:

int i = 123;
bit[] bs = cast(bit[]) i;
// bs == 0000 0000 0000 0000 0000 0000 0111 1011

int i2 = cast(int) bs;
// i2 == 123

An example of how I think this could be useful:

const char[] hexdigits = "0123456789ABCDEF";
char[] toHexLiteral(int i)
{
bit[]  buf = cast(bit[]) i;
int    nibel;
char[] ret;

for (int idx = 0; idx < buf.length; idx += 4)
{
nibel = cast(int) buf[idx..idx+4];
ret ~= hexdigits[nibel];
}
return ret;
}

Would it not be possible to implement this by duplicating the int's
memory into the storage for the bit[]?  Might be something I don't know
about that prevents it.  Just a random thought.

-- C. Sauls
-- Invironz
Dec 20 2003
"C. Sauls" <ibisbasenji yahoo.com> writes:
C. Sauls wrote:
const char[] hexdigits = "0123456789ABCDEF";
char[] toHexLiteral(int i)
{
bit[]  buf = cast(bit[]) i;
int    nibel;
char[] ret;

for (int idx = 0; idx < buf.length; idx += 4)
{
nibel = cast(int) buf[idx..idx+4];
ret ~= hexdigits[nibel];
}
return ret;
}
Out of fairness I thought I should show how I currently have this implemented, since its not too complex as is. I just think that int->bit[],bit[]->int has some potential. Current toHexLiteral(): // begin snippet const char[] hexdigits = "0123456789abcdef"; char[] toHexLiteral(uint foo) { char[] ret; for (int i = 28; i >= 0; i -= 4) { ret ~= hexdigits[cast(ubyte)(foo >> i) & 0x0f]; } return ret; } // end snippet It more-or-less does the same thing, but includes all the fun and joy of bit-shifting. I think the bit[] indexing would be instructionally simpler. Could be wrong. Wouldn't be the first time. :D -- C. Sauls -- Invironz
Dec 20 2003
Alix Pexton <Alix thedjournal.com> writes:
I think that the attached code should do something like a cast to and
from a bit array, using templates, so it will work for more types than
just uint, but what you get will not be that usefull for signed types,
floats, pointers, arrays, references. But the process could be built
upon to do more interesting things. I haven't tested it, so don't cry
foul if it doesn't work, though I don't see why it souldn't work...

Alix...

C. Sauls wrote:

C. Sauls wrote:

const char[] hexdigits = "0123456789ABCDEF";
char[] toHexLiteral(int i)
{
bit[]  buf = cast(bit[]) i;
int    nibel;
char[] ret;

for (int idx = 0; idx < buf.length; idx += 4)
{
nibel = cast(int) buf[idx..idx+4];
ret ~= hexdigits[nibel];
}
return ret;
}
Out of fairness I thought I should show how I currently have this implemented, since its not too complex as is. I just think that int->bit[],bit[]->int has some potential. Current toHexLiteral(): // begin snippet const char[] hexdigits = "0123456789abcdef"; char[] toHexLiteral(uint foo) { char[] ret; for (int i = 28; i >= 0; i -= 4) { ret ~= hexdigits[cast(ubyte)(foo >> i) & 0x0f]; } return ret; } // end snippet It more-or-less does the same thing, but includes all the fun and joy of bit-shifting. I think the bit[] indexing would be instructionally simpler. Could be wrong. Wouldn't be the first time. :D -- C. Sauls -- Invironz
-- Alix Pexton Webmaster - http://www.theDjournal.com Alix theDjournal.com
Dec 21 2003
Chris Sauls <ibisbasenji yahoo.com> writes:
Alix Pexton wrote:

public alias bit[T.size * 8] bitMask;

T type;
}

m.type = t;
return m.bits;
}

m.bits = bm;
return m.type;
}
}
It does indeed work... and it leads me to ressurect another subject we brought up once some while back: persistance. I've done a little experimenting with this template of yours and found that it could very well be used to build a nice persisting module! I'll post my own experiment here sometime soon, once I clear up a couple of bugs and add a lovely packaging feature I'm wanting. :) -- C. Sauls -- Invironz
Dec 24 2003
Alix Pexton <Alix thedjournal.com> writes:
I'm very pleased it worked, that it has been helpful, and that it has
inspired you.

Alix...

Chris Sauls wrote:

Alix Pexton wrote:

public alias bit[T.size * 8] bitMask;

T type;
}