Re: 24-bit int

[Biotronic via Digitalmars-d-learn]

On Friday, 1 September 2017 at 19:39:14 UTC, EntangledQuanta 
wrote:
Is there a way to create a 24-bit int? One that for all 
practical purposes acts as such? This is for 24-bit stuff like 
audio. It would respect endianness, allow for arrays int24[] 
that work properly, etc.

I haven't looked at endianness beyond it working on my computer. 
If you have special needs in that regard, consider this a 
starting point:


struct int24 {
    ubyte[3] _payload;

    this(int x) {
        value = x;
    }

    @property
    int value() {
        int val = *cast(int*)&_payload & 0xFFFFFF;

        if (val & 0x800000) {
            val |= 0xFF000000;
        }

        return val;
    }

    @property
    int value(int x) {
        _payload = (cast(ubyte*)&x)[0..3];
        return value;
    }

    auto opUnary(string op)() {
        static if (op == "++") {
            value = value + 1;
        } else static if (op == "--") {
            value = value - 1;
        } else static if (op == "+") {
            return value;
        } else static if (op == "-") {
            return -value;
        } else static if (op == "~") {
            return ~value;
        } else {
            static assert(false, "Unary operator '"~op~"' is not 
supported by int24.");
        }
    }

    auto opOpAssign(string op)(int x) {
        static assert(__traits(compiles, {mixin("value = value 
"~op~" x;");}), "Binary operator '"~op~"' is not supported by 
int24.");

        mixin("value = value "~op~" x;");
        return this;
    }

    alias value this;
}

unittest {
    int24[3] a;
    assert(a.sizeof == 9);

    // Max value
    a[1] = 8388607;
    assert(a[1] == 8388607);
    // Test for buffer overflow:
    assert(a[0] == 0);
    assert(a[2] == 0);

    // Overflow
    a[1] = 8388608;
    assert(a[1] == -8388608);
    // Test for buffer overflow:
    assert(a[0] == 0);
    assert(a[2] == 0);

    // negative value
    a[1] = -1;
    assert(a[1] == -1);
    // Test for buffer overflow:
    assert(a[0] == 0);
    assert(a[2] == 0);

    // Unary operators
    a[1] = 0;
    assert(~a[1] == -1);
    a[1]--;
    assert(a[1] == -1);
    assert(-a[1] == 1);
    assert(+a[1] == -1);
    a[1]++;
    assert(a[1] == 0);

    // Binary operators
    a[1] = 0;
    a[1] = a[1] + 1;
    assert(a[1] == 1);
    a[1] += 1;
    assert(a[1] == 2);
    a[1] = a[1] - 1;
    assert(a[1] == 1);
    a[1] -= 1;
    assert(a[1] == 0);

    a[1] = 3;
    a[1] = a[1] * 2;
    assert(a[1] == 6);
    a[1] = a[1] / 2;
    assert(a[1] == 3);
    a[1] *= 2;
    assert(a[1] == 6);
    a[1] /= 2;
    assert(a[1] == 3);
    a[1] = a[1] << 1;
    assert(a[1] == 6);
    a[1] <<= 1;
    assert(a[1] == 12);
    a[1] = a[1] >> 1;
    assert(a[1] == 6);
    a[1] >>= 1;
    assert(a[1] == 3);

    a[1] |= 4;
    assert(a[1] == 7);
    a[1] &= 5;
    assert(a[1] == 5);
    a[1] = a[1] | 2;
    assert(a[1] == 7);
    a[1] = a[1] & 3;
    assert(a[1] == 3);
}

--
  Biotronic