Real Int24
Simen Kjærås
simen.kjaras at gmail.com
Mon May 21 15:41:21 UTC 2018
On Saturday, 19 May 2018 at 18:44:42 UTC, IntegratedDimensions
wrote:
> On Saturday, 19 May 2018 at 18:19:35 UTC, IntegratedDimensions
> wrote:
>> Is there any way to create an int24 type that behaves just
>> like any other built in type without having to reimplement
>> everything?
>
> In fact, what I'd like to do is create an arbitrary type:
>
> struct atype(T)
> {
>
> }
>
> where atype(T) is just a "view" in to N_T bits interpreted as
> T, an enum.
>
> If T is bit, then the N = 1 and the interpretation is 1 bit.
> If T is byte, then the N = 8 and the interpretation is 7 bits
> followed by 1 signed bit.
> If T is int24, then the N = 24 and the interpretation is 23
> bits followed by 1 signed bit.
>
> The idea is the storage of atype is exactly N bits. If this is
> not possible due to boundary issues then N can always be a
> multiple of 8(which is for my use cause is the smallest).
D does not support types that take up less than one byte of
space. It's possible to make types that represent less than one
byte - bool may be considered such an example - but they still
take up at least 1 byte.
If you create a custom range type, you could pack more than one
element in each byte, see std.bitmanip.BitArray[0] for an example.
> The main thing is that I would like to be able to use atype as
> if it were a built in type.
>
> If N = 24, 3 bytes, I want to be able to create arrays of
> atype!int24[] which work just as if they were arrays of bytes
> without any exception or special cases.
>
> atype!byte would be equivalent to byte and reduce to the
> compiler internals. I'm not looking to create a "view" of an
> array. I want a standalone type that can behave as all the
> desired types needed, which is most of the numerical types of D
> and some of the ones it neglected like 24-bit ints, 48-bit
> ints, etc. Ideally, any type could be used and the "most
> optimal" code is generated while being able to use the types
> using the standard model.
We already have std.numeric.CustomFloat[1]. As the name implies,
it only works for floats.
I hacked together something somewhat equivalent for ints:
https://gist.github.com/Biotronic/f6668d8ac95b70302015fee93ae9c8c1
Usage:
// Two's-complement, native-endian, 24-bit int type:
CustomInt!24 a;
// Unsigned, native-endian, 15-bit:
CustomInt!(15, Representation.Unsigned) b;
// Offset (-2..5) 3-bit int:
CustomInt!(3, Representation.OffsetBinary, 2) c;
// You get the idea:
CustomInt!(64, Representation.SignedMagnitude, 0,
Endianness.BigEndian) d;
Not sure this is what you're looking for, but it's at the very
least inspired by your post. :)
If what you want is a type that can represent something a packed
array of 13-bit ints, the above is not what you're looking for -
you're going to need a custom range type.
--
Simen
[0]: https://dlang.org/phobos/std_bitmanip#BitArray
[1]: https://dlang.org/phobos/std_numeric.html#.CustomFloat
More information about the Digitalmars-d-learn
mailing list