Error: cannot implicitly convert expression ... of type int to ubyte - d

Question

I'm trying to run this program (from wikipedia):
/**
Multiply two numbers in the GF(2^8) finite field defined
by the polynomial x^8 + x^4 + x^3 + x + 1.
*/
ubyte gMul(ubyte a, ubyte b) pure nothrow {
ubyte p = 0;
foreach (immutable ubyte counter; 0 .. 8) {
p ^= -(b & 1) & a;
auto mask = -((a >> 7) & 1);
// 0b1_0001_1011 is x^8 + x^4 + x^3 + x + 1.
a = (a << 1) ^ (0b1_0001_1011 & mask);
b >>= 1;
}
return p;
}
void main() {
import std.stdio, std.conv;
enum width = ubyte.max + 1, height = width;
auto f = File("rijndael_finite_field_multiplication.pgm", "wb");
f.writefln("P5\n%d %d\n255", width, height);
foreach (immutable y; 0 .. height)
foreach (immutable x; 0 .. width) {
immutable char c = gMul(x.to!ubyte, y.to!ubyte);
f.write(c);
}
}
When I do so I get this error:
test.d(12): Error: cannot implicitly convert expression (cast(int)a << 1 ^ 283 & mask) of type int to ubyte
Failed: ["dmd", "-v", "-o-", "test.d", "-I."]
It's not clear to me how to fix this. Any ideas?

Answer 1

If you see a "cannot implicitly convert" error, one fix is often to just explicitly convert with the cast operator:
// before
a = (a << 1) ^ (0b1_0001_1011 & mask);
// after
a = cast(ubyte)((a << 1) ^ (0b1_0001_1011 & mask));
Notice the cast(ubyte) and the () surrounding the entire expression.
That should fix your problem, but let me also explain a few more things...
test.d(12): Error: cannot implicitly convert expression (cast(int)a << 1 ^ 283 & mask) of type int to ubyte
In this error message, you notice the compiler inserted a cast(int) right before a. This happens in most arithmetic because D inherited C's integer promotion rules: https://www.bing.com/search?q=c+integer+promotion&pc=MOZI&form=MOZLBR any arithmetic is casted to int before it happens in D, just like in C.
But, D is different than C in an important way: it prohibits narrowing implicit conversions, unless the compiler can prove, in the expression alone, that the value of the expression will definitely fit in the type.
So, something like literal 4 + 10, the compiler knows it is greater than or equal to zero, yet less than 256, and will thus fit in a ubyte and it won't require the explicit cast.
But, if you did ubyte a; ubyte b; ubyte c = a + b;, the compiler can no longer PROVE it in this expression alone - a + b could be anywhere from 0 (smallest values, 0 + 0) to 510 (largest values, 255 + 255). So it might fit... but might not. So the compiler will require you to explicitly cast it.
However, check this out: ubyte a, b; ubyte c = a & 0xf + b & 0xf0; that will compile. Why? Because the compiler can see those bit masks and understand it changes the possible value range. Once you mask the values, it limits them and the sum of those possible values fits... so no cast needed.
The idea here is that if a possible value gets dropped by stuffing it into a ubyte (or other small types), the compiler wants to make sure you are aware of it and making a conscious decision. Thus, the cast is needed if there's even a slim chance a bit will get dropped. (C, on the other hand, never needs the cast since it will just happily drop the bytes.)