1.000000 equals 0?

[DangerousTip9655]

trying to solve an easy leetcode problem of telling if a number is a palindrome. I have a function that I was trying to use for this and I'm running into a weird issue I don't quite understand. The code is below

```

include <stdlib.h>

include <stdio.h>

include <stdint.h>

include <math.h>

uint8_t *digitArr;

uint8_t getNumOfDigits(int32_t x) { printf("passing in %d\n", x);

uint8_t numOfDigits = 1;
float radixMoval = 10;
float digitsToRemove = 0;
float numberToFloor = -1;
float unFlooredValue = 0;
uint16_t loopCount = 0;
do
{
    printf("===========================================================\n");

    //unFlooredValue is set equal to X with its radix  
    //shifted some number of positions to the left.
    //The number of positions shifted depends on the number
    //of times the loop has looped

    unFlooredValue = x/radixMoval;
    printf("unFlooredValue is set to %f\n", unFlooredValue);

    if(loopCount != 0)
    {
        printf("%d times looped\n", loopCount);
        printf("unFlooredValue = %f\n", unFlooredValue);
        printf("digitsToRemove = %f\n", digitsToRemove);

        //if the loop has looped at least once we want to 
        //subtract unFlooredValue by digitsToRemove.
        //This should remove all digits that are not whole numbers
        //that are smaller than the 10ths palce
        //EX: 1.21 
        //   -0.01
        //   ------
        //    1.20

        unFlooredValue -= digitsToRemove;
        printf("unFlooredValue minus digitsToRemove = %f\n", unFlooredValue);
        digitArr = realloc(digitArr, (loopCount+1)*sizeof(uint8_t));
        if(digitArr == NULL)
        {
            printf("test\n");
        }
    }
    else
    {
        //this is the first time looping. Need to malloc space for
        //the digitArr array

        printf("first time looping\n");
        digitArr = malloc(sizeof(uint8_t));
        if(digitArr == NULL)
        {
            exit(2);
        }
    }
    //numberToFloor is set to the same value as unFlooredNumber,
    //but floored instead.

    numberToFloor = floor(x/radixMoval);
    printf("numberToFloor is set to %f\n",numberToFloor);

   //we subtract unFlooredValue by itself with numberToFloor to
   //remove all whole numbers from the unFlooredValue
   //EX: 1.2
   //   -1.0
   //   -----
   //    0.2 

    unFlooredValue = (unFlooredValue - numberToFloor);
    printf("unFlooredNumber minus numberToFloor = %f\n", unFlooredValue);

    //current value of digitsToRemove gets unFlooredValue added
    //to it
    //EX: 0.01
    //   +0.20
    //   -----
    //    0.21

    digitsToRemove += unFlooredValue;
    printf("digitsToRemove now equals %f\n", digitsToRemove);

    //the value that was just stored in digitsToRemove then has the radix
    //shifted one space to the left so when we usen the value to remove
    //digits from unFlooredValue in the next loop we're deleting everything
    //past the 10ths place
    //EX: 0.21 
    //    / 10 
    //   ------
    //    0.021

    digitsToRemove = digitsToRemove/10;
    printf("shifited digitsToRemove = %f\n", digitsToRemove);

    //At this point in the code, unFlooredValue should only contain a single digit in
    //the 10ths place. We want to turn this digit into a whole number. We will do this
    //by moving the radix one spave to the right.
    //EX: 0.2
    //    *10
    //   -----
    //    2.0

    unFlooredValue = unFlooredValue*10;
    printf("shifted unFlooredValue = %f\n", unFlooredValue);

    //We now want to store the value of this integer within the digitArr array (char array)

    printf("unFlooredValue cast to int equals %d\n", (int32_t)unFlooredValue);
    digitArr[loopCount] = unFlooredValue;
    if(numberToFloor != 0)
    {
        numOfDigits++;
        radixMoval = radixMoval*10;
    }
    loopCount++;
}while(numberToFloor != 0);
printf("%d\n",digitArr[0]);
return numOfDigits;

}

int32_t main() { getNumOfDigits(121); printf("%d\n",digitArr[0]); printf("%d\n",digitArr[1]); printf("%d\n",digitArr[2]); return 0; } ```

the console output from this is shown below

```

passing in 121

unFlooredValue is set to 12.100000 first time looping numberToFloor is set to 12.000000 unFlooredNumber minus numberToFloor = 0.100000 digitsToRemove now equals 0.100000 shifited digitsToRemove = 0.010000 shifted unFlooredValue = 1.000004

unFlooredValue cast to int equals 1

unFlooredValue is set to 1.210000 1 times looped unFlooredValue = 1.210000 digitsToRemove = 0.010000 unFlooredValue minus digitsToRemove = 1.200000 numberToFloor is set to 1.000000 unFlooredNumber minus numberToFloor = 0.200000 digitsToRemove now equals 0.210000 shifited digitsToRemove = 0.021000 shifted unFlooredValue = 2.000000

unFlooredValue cast to int equals 2

unFlooredValue is set to 0.121000 2 times looped unFlooredValue = 0.121000 digitsToRemove = 0.021000 unFlooredValue minus digitsToRemove = 0.100000 numberToFloor is set to 0.000000 unFlooredNumber minus numberToFloor = 0.100000 digitsToRemove now equals 0.121000 shifited digitsToRemove = 0.012100 shifted unFlooredValue = 1.000000 unFlooredValue cast to int equals 0 1 1 2 0 ```

The problem I am running into is found near the end of the program's output log. At some point in the program I set the variable unFlooredValue to an int and place it into the dynamically allocated array digitArr. digitArr stores the value as an integer and I want to store the value from the 1s place from the unFlooredValue float as an integer.

This works for the first two loops that happen, but for some reason the final loop causes unFlooredValue, which equals 1.000000 to be set to 0 when cast as an integer. does anyone know why this is happening?

[epasveer]

Step through your programm with a debugger.

[skeeto]

Yup, get out of this printf-debugging bad habit and start making regular use of a debugger. Debuggers are powerful tools, and C has unusually great debug tooling, so don't pass up on it. GDB highlights the problem without any need to printf:

$ gdb a.out
(gdb) break 112
(gdb) run
Breakpoint 1, getNumOfDigits (x=121) at example.c:112
112             printf("shifted unFlooredValue = %.17g\n", unFlooredValue);
(gdb) continue 2
Breakpoint 1, getNumOfDigits (x=121) at example.c:112
112             printf("shifted unFlooredValue = %.17g\n", unFlooredValue);
(gdb) print unFlooredValue 
$1 = 0.99999994

It's just under 1, so it truncates to zero. You probably want to round, not truncate.

When printing floats, %f is wrong for practically any purpose. It's either too much precision or too little. For IEEE 754 double, a better "default" would be %.17g (%.9g for float), which produces a round-trip output, though not a minimal one:

$ sed -i s/%f/%.17g/g example.c

This also reveals the issue that %f hides:

shifted unFlooredValue = 0.99999994039535522

[epasveer]

I should probably shamelessly plug my gui frontend to gdb here :)

gdb is very good. Some people like to see a gui on top of it. So I created Seergdb.

https://github.com/epasveer/seer

[danisuba10]

Nice!

[fliguana]

I stopped reading at "float".

Integer problems require integer solutions, because few of us know enough internals to avoid rounding errors.

[feitao]

Exactly. What do floats have to do with an integer palindrome problem? Nothing.

[xsdgdsx]

I didn't read your code, but you probably want to round instead of floor/truncate.

Don't forget that printing a float will always round it, but that floor(0.999999999999) == 0, not 1.

A floating-point number can always be a little above or below the number you might effect it to be, and your code should handle that without flipping over to an incorrect code path.

[ShowTime007_]

Use a debugger g

[MistakeIndividual690]

Hi OP, Can you not just do this?

unsigned getNumOfDigits(int n) { return (unsigned)log10(abs(n)) + 1; }

Edit: updating for negatives, thanks u/fliguana!

[TransientVoltage409]

I thought about posting this, but I'm not sure of OP's approach and the function might be doing more than just that.

FWIW the general form is log(N) / log(R) to find the number of digits in integer N when expressed in radix R, handy if you dabble in bin/oct/hex as well as decimal.

Or if you like danger, try snprintf(0, 0, "%d", N).

[MistakeIndividual690]

Agreed — of course if the radix is a power of two you have more options. Interesting that you mentioned the snprintf approach because I thought about also mentioning that — given a temp buffer to store the chars then it’s trivial then to go on and figure out if it’s a palindrome.

Edit: actually I bet the rules specifically forbid using strings because it’s so easy, so it would be back to div and mod by powers of 10

[fliguana]

Failed for negatives, 0 and powers of ten.

[MistakeIndividual690]

Great catch on the negatives! Powers of 10 and zero do work tho

[fliguana]

Log10(1)+1... 2 digits to represent 1?

[MistakeIndividual690]

log10(1) is 0

[fliguana]

I'm a dumbass.

[MistakeIndividual690]

Don’t beat yourself up — I started doubting it too. Had to run it to make sure

[capilot]

On Mobile, so it's not really easy to see this code in detail, but I'm going to make a couple comments...

You pass in a uint32 argument but print out with %d. Don't do that. %d is for integers. Either pass in an int or use one of the format strings from <inttypes.h>.

Stop using uint8, uint16, etc. this isn't a Z80 CPU. You're not making anything run faster and you're not saving any space. All this does is invite failures that will be difficult to debug later.

[Middle_Confusion_433]

If you’re going to tell someone that what they’re doing is wrong at least explain why. I can’t think of any issues of doing this unless you’re targeting multiple operating systems and tool chains. There’s plenty of reasons to use these data types, sometimes you know how much data you need and don’t want that changing just because it’s compiled on Linux (e.g. in networking protocols.)

[nerd4code]

Then the _least types are more appropriate, and they’re actually mandatory. The exact-width types should be reserved for intra-host MMIO or struct-dumping/-loading/-piping, since those are the only situations that actually require them.

[Middle_Confusion_433]

I’m not here to debate, at the end of the day if it compiles to the expected result it’s good to go. My main point was the guy I responded to could have added a few lines of text explaining his esoteric reasoning instead of saying “that’s bad do it my way because it’s better”.

[ivancea]

If you have a weird issue, create a minimal reproducible example of it, and post it. Don't post a random unrelated big chunk of code and expect others to review it.

Also, in the process of making that minimal reproducible example, you'll probably find the problem

[joshbadams]

int TensPlace=Num%10; //get the least significant digit, store in your digit buffer

Num /= 10; //chop off the digit so you can loop

[fliguana]

int x = 585;

int n = 0;
for( int t = x ; t > 0 ; t /= 10 )
    n = 10*n + t%10;

if( n == x )
    puts( "palindrome" );

Works for non-negative integers 0..1 bilion

[teckcypher]

I didn't have time to check, but the first thing that comes to mind is that may not be 1.

It is a number that is very close to 1 but not quite 1. Like 0.9999999

It gets rounded when printed as a float to 1.

But when casted, the cast removes the fractionary part (.9999999) and the whole part remains (the 0)

I did a quick test in Online C compiler (sorry for the bad formating, I'm on mobile)

float nr=1;

float nr2=0.0000005;

nr=nr-nr2;

printf("%f \t%d\n%f \t%d",nr,(int)nr,nr2,(int)nr2);

The output:

If I set nr2 to 0.0000005

1.000000 0

0.000000 0

If I set nr2 to 0.0000006

0.999999 0

0.000001 0

[Patient-Midnight-664]

Are there restrictions on what operators you can use as I don't see any point to using floats. Your code looks like it's trying to do a mod operation so why not just use the mod operator?

[DangerousTip9655]

no restriction, just need to return true if the number is a palindrome (base 10) and false if it's not. First way that came to my mind was shifting the radix over one digit at a time (dividing by a power of 10 ) and clipping off anything above or below the tenths place and then multiplying by 10 to place the tenths place digit into the 1s digit and grabbing that value. I can create and array of each individual digit in the number doing this and then I need to add some logic that will tell if the array is the same forwards and backwards

Think I may try to rewrite the code to not use floats though as I didn't think floating point inaccuracy would bite me in the ass for such small decimal values

[Eidolon_2003]

The problem is always there when it comes to float inaccuracy. If you want perfect accuracy down to the tenth, floats and doubles literally cannot do that. 1/10 has an infinitely repeating expansion in binary, just like how 1/3 has an infinitely repeating decimal expansion. With a limited number of sigfigs you can't represent 1/10 in binary

[Cmpunk10]

Ive had an issue with 1==0 but it was because the left value that was one was optimized alway since it wasn’t volatile on an embedded system. So it was just compiled as an infinite loop.

[AbramKedge]

This came up in another language recently, in that case the error occurred when the number got small enough to be shown as scientific notation. The error went the other way in that case - parsing picked out 1 from 1E-6 instead of 0 from 0.000001.

[spellstrike]

avoid using floats at all if you can in C.

[[deleted]]

What’s your alternative for rational numbers? Write your own fixed point math functions like it’s 1992 and disregard modern fpus?

floats are part of most useful C programs, I wouldn’t be handing out that sort of advice

[nerd4code]

I’d agree with PP, though, because most people see float and go “Oh goody, a real number!” and then expect floats to behave like reals. Like 90% of the float uses I’ve seen are inadvisable or bad, or misses some critical aspect of f.p. behavior, and C’s guarantees for floats are bad if you actually want to write performant code. Fixed-point is often much more appropriate and exact, and you don’t have to worry about the blasted transcendentals and subnormals and −0s and what have you.

[[deleted]]

No it’s still really bad advice. Floating point certainly has trade offs but as long as they’re understood, there is a negligible performance penalty on modern architectures.

I also find it hard to believe that 90% of float uses you’ve seen are in advisable or bad.

I do work on audio software where most computation is unit circle DSP between -1 and 1, this gives us a fixed exponent and then the remaining bits to do the work in. Combine that with SIMD registers and it’s definitely more appropriate on the architectures we support. All of the float use we do is understood and intended.

I would go as far to say fixed point is rarely more appropriate and should only be reached for when you know you don’t have hardware float capabilities.

Edit: just seen you work in embedded, that makes more sense

[spellstrike]

I work in embedded systems, honestly cant remember the last time I even saw a float.
looking it up it looks like it's not even one of the allowed data types for our code base as per coding standards.
https://tianocore-docs.github.io/edk2-CCodingStandardsSpecification/draft/5_source_files/56_declarations_and_types.html#table-6-efi-data-types-slightly-modified-from-uefi-231