On Friday, 16 May 2025 at 19:19:41 UTC, H. S. Teoh wrote:
> For example, how do you negate a ubyte?

Mathematically this is only defined for 0 over the range of
ubyte.

> Obviously, you can't do this:
>
> ```
> 	ubyte a;
> 	a -=;
> ```
>
> But writing it as `a = -a;` runs into the same error, for the same reason.
>
> Instead, you have to work around it with this baroque periphrasis:
>
> ```
> 	ubyte a;
> 	a = cast(ubyte) -a;
> ```
>
> Does it make sense?

How about:

```
   a *= -1;
```

?

On Wed, May 21, 2025 at 05:47:20PM +0000, WhatMeWorry via Digitalmars-d-learn wrote:
> On Friday, 16 May 2025 at 19:04:24 UTC, WhatMeWorry wrote:
> > /+ SDL3 has a function
> > bool SDL_SetTextureAlphaMod(SDL_Texture *texture, Uint8 alpha);
> > which has a Uint8 for one of its parameters.  So I try to use a
> > ubyte
> > +/
> > 
> > [...]
> 
> So what would be best practice here?

I think Walter's suggestion is to use int for computations, and narrow ints like ubyte only for storage.  So inside your function you'd be loading values into ints and doing computations as ints, and when storing back to whatever structure you'd do a range check and then cast the value.  So something like this:

```
int tmp = myData.shortValue;
tmp = ... // computation here
myData.shortValue = tmp.to!ubyte; // std.conv.to does range checks
				// or you can do it yourself
```


> Declare an int, manually make sure the value stays between 0 and 255, and then cast it to the ubyte?

Pretty much what std.conv.to does. You could just do something like:

```
myData.shortValue = (myData.shortValue * whatever + something).to!ubyte;
```

That's assuming you want regular semantics with narrow int arithmetic.

My nopromote module/hack is intended for doing narrow int arithmetic without checks, i.e., when either you're 100% sure wraparound isn't a problem and you want to skip the range checks, or when you *want* wraparound semantics (like using ubyte/ushort wraparound to implement a ring buffer).


T

-- 
Time flies like an arrow. Fruit flies like a banana.