I want to create an unsigned arithmetic type that can hold a maximum size of 360. Without having to create a method.
It should be in such a manner that:
returns 359, instead of 255, or 65535 or whatever max value the type I base my type on can hold.Code:typedef uint8_t radius; radius rotation = 0; radius foo (radius rotation) { return --rotation; }
Any ideas on how to tackle this?
Thanks.
Last edited by skyliner; 06-26-2014 at 02:35 AM.
What do you mean by "without having to create a method"?
One way of doing this is to create a class. The class interface will restrict what values can be stored into an object of the class. You can overload the various arithmetic operators such that they behave as if your objects are of an unsigned integer type with a range [0, 360].
Look up a C++ Reference and learn How To Ask Questions The Smart WayOriginally Posted by Bjarne Stroustrup (2000-10-14)
Thank you, the operator overload is a great idea. I just wanted to simplify things for my class users by avoiding calling a method on the object.It looks neater that way.
Why not simply change your idea of how many "degrees" are in a circle?
Instead of degrees, you could use 1/256ths of a circle as your fundamental angular unit. Or if that's not fine-grained enough, go up to 16 bits and use 1/65536th as your fundamental unit. Now you can take advantage of the way the hardware wraps things and don't have to invent some weird type.
Data can be translated to/from the traditional 1/360 degrees on its way in and out of the system.
Code://try //{ if (a) do { f( b); } while(1); else do { f(!b); } while(1); //}
FWIW, I've always preferred mapping angles to some value between zero and one (floating point, of course). That approach can be used to simplify the manipulation of many other things as well, such as colors (RGB, HSV, etc), amplitude values for PCM (audio) data, etc, etc.
Code:#include <cmath> #include <complex> bool euler_flip(bool value) { return std::pow ( std::complex<float>(std::exp(1.0)), std::complex<float>(0, 1) * std::complex<float>(std::atan(1.0) *(1 << (value + 2))) ).real() < 0; }
Yeah, floats can do this efficiently as well if you map things that way. They don't wrap automatically, but you just have to take the fractional part which isn't too expensive (and you can manually wrap them yourself at an opportune moment).
EDIT: "fractional part" in this case means x - floor(x), not x - trunc(x) which is important if the value is negative
Last edited by brewbuck; 06-26-2014 at 06:52 PM.
Code://try //{ if (a) do { f( b); } while(1); else do { f(!b); } while(1); //}
0.o. That's simple and brilliant, or: "simply brilliant" haha, Thanks. I went ahead with it.
