#data types

Checking for decimals is useful for displaying formatted numbers and other checks. Although doing so is not obvious in JS. The key is the % operator:

const hasDecimals = function(number) { return number % 1 !== 0; } console.log(hasDecimals(5.22)); // true console.log(hasDecimals(41.00001)); // true console.log(hasDecimals(0)); // false console.log(hasDecimals(42)); // false

The % returns the remainder of Euclidean division (although there is a slight difference in JS). Basically, the first operand is continually subtracted by the second as long as the number keeps the same negative/positive value. If there is anything left, that is the remainder

For example, 5 % 2 = 1, since 5 - 2 = 3, then 3 - 2 = 1. So 5.22 % 2 = 1.22 = 5.22 - 2 = 3.22 - 2 = 1.22. Finally, by using 1 as the second operator instead, it means that only integers will have 0 left after subtractions.

By including an isNaN check, the above can be used to filter out other types (Something that a string conversion decimal check could not easily do):

const hasDecimals2 = function(number) { const result = number % 1; return !isNaN(result) && result !== 0; } console.log(hasDecimals2(null)); // false console.log(hasDecimals2(undefined)); // false console.log(hasDecimals2({})); // false console.log(hasDecimals2('test')); // false console.log(hasDecimals2(2.22)); // true console.log(hasDecimals2(new Number(2.22))); // true

Note that typeof is not used since it gives 'object' when new Number() is used.

The Mysterious “M” in Your DDS: Naming Conventions vs Keyboard Shifts This morning I opened a DSPF and spotted what looked like a data type of “M” against a field that smelled numeric. My first thought? “Since when did IBM i add an M type?” Turns out the original developer had a very correct reason for using ‘M’ and I had simply not seen it for so long (shhh… its been decades) and I had…

The minimum size for this would be 64 bits: a 32-bit chunk with a significand, ending with a terminate bit, then a 32-bit chunk with an exponent, followed by a second terminate bit.

The exponent part seems kind of unnecessarily large, even if it doesn’t explode (which I think, in practice, it virtually never would). I don’t know whether there might be useful special cases when the significand has a binary value equivalent to 1,000,000,000-1,073,741,824. It’s also sort of regrettable that the sign bit is wasted, I think, in every chunk except the first in the case of an exploding number.

Maybe something where the significand chunk is 48 by default, with 40 bits of significand? That leaves a bit for sign and 7 bits for "miscellaneous" -- 128 possible combinations. That's room for "terminate with no exponent -- this is basically an int," "explode and create more significand," "shift to exponent (maybe 16 bits)" but it seems profligate to have seven bits when barely two are needed.

My initial thought was to have the chunks be 12-bit instead of 32-bit, with the "sign, 10 bits, explode/terminate" thing, but that seemed unlikely to be a good idea.

Hey there, curious coders! I hope you just knows about int, long and boolean datatypes. So, I can’t explain it anymore. Now, what happens when we need decimals? Whether it’s calculating your grades, measuring your height, or figuring out your average speed, decimal numbers are everywhere. This is where the float data type comes to the rescue! Think of it as the next step up from int – just like…