[SOLVED] Tried to solve a problem. Probably a better way. Asking for tips to simplify.

jmgibson1981 · 01-21-2023, 04:16 PM

My first attempt at creating something. I have no doubt there is a better way to do this. be gentle please. this is to verify that floats or integers are the only acceptable input for my calculator i've been working on.

Code:

int valid_numbers(char numtest[24])
{
    // declare and set variables
    int total_chars = strlen(numtest);
    int total_char_test;
    int difftest;
    for (int i = 0; i < total_chars; i++)
    {
        if (isdigit(numtest[i]))
        {
            // if number is digit then increment test variable
            total_char_test++;
        }
    }

    // set variable difference total & test
    difftest = total_chars - total_char_test;
    if (difftest == 1 && strchr(numtest, '.') != NULL)
    {
        return 0;
    }
    if (difftest > 1)
    {
        return 1;
    }
    return 0;
}

*edit* found it didn't work.updated code above to working config.

ntubski · 01-22-2023, 11:03 AM

You didn't initialize total_char_test to 0, it might work by accident right now, but depending on some unrelated things might fail to work later. I think the compiler should be warning you about this if you set the right options.

For readability, I would suggest naming that variable total_digits, or something like that instead. Also, the 24 in char numtest[24] is not doing anything so I suggest to remove it (maybe you want to add a test against total_chars that it's 24 or less?)

Do you consider "123." or ".123" as valid integers or floats? (That's not rhetorical, any choice you make here is fine, as long as you've thought about it)

pan64 · 01-22-2023, 11:06 AM

you can try to count non-digit chars, and stop (return 1) if more than one found or is not dot. That would be probably a bit better.
You can also check the minus sign (if you wish). And probably you want to handle longer numbers too. And check the end-of-string.
Otherwise it looks ok.

pan64 · 01-22-2023, 12:47 PM

regarding validity, a "regular" decimal number must not start with 0 (zero) if it is >1 and must not end with 0 if there is a decimal point somewhere. But these are not that important, you can simply cut them (leading and trailing zeros) if you wish.

Keith Hedger · 01-22-2023, 02:15 PM

Quote:

Originally Posted by pan64

regarding validity, a "regular" decimal number must not start with 0 (zero) if it is >1 and must not end with 0 if there is a decimal point somewhere. But these are not that important, you can simply cut them (leading and trailing zeros) if you wish.

?
100 and 100.0 both valid decimal numbers both end in 0 or am I missing somthing?

rtmistler · 01-22-2023, 03:29 PM

You could approach it with ever increasing checks.

Plus or minus should only be the first character.
There only should ever be one decimal point.
The rest can be digits, but there are some rules to consider which you can decide as to what is allowable.

sundialsvcs · 01-22-2023, 10:13 PM

Actually, if you are seriously interested in knowing more about "how cheap calculators actually do it," you may wish to someday explore the concept of a FSM = Finite-State Machine.

Such as this web-site which actually discusses the specific implementation of "a calculator." https://mitadmissions.org/blogs/entr...th-fsm-logic1/

"Finite-State Machines" are actually a very-important but maybe counter-intuitive class of algorithms which are actually very relevant to problems of this sort. In summary, the "machine" processes its input "one input at a time," while maintaining an internal "state" to dictate exactly how it should process "any possible input" at "this particular time (in this particular 'state' ...)

ntubski · 01-22-2023, 11:12 PM

Quote:

Originally Posted by sundialsvcs

you may wish to someday explore the concept of a FSM = Finite-State Machine.

Such as this web-site which actually discusses the specific implementation of "a calculator." https://mitadmissions.org/blogs/entr...th-fsm-logic1/

It looks like they are using a finite state machine to handle operator precedence. It's certainly possible to do this when there are only two* levels of precedence (plus/minus vs multiply/divide), but in my opinion it's not a good approach because it leads to an overly complex set of states, and you should not follow this example.

* or any finite number of levels n if you're willing to handle 2ⁿ states, but you can't handle arbitrarily nested parentheses with a finite state machine.

pan64 · 01-23-2023, 02:03 AM

Quote:

Originally Posted by Keith Hedger

?
100 and 100.0 both valid decimal numbers both end in 0 or am I missing somthing?

Yes, 001000.34 is not really acceptable, 213.343000 again. That's what I wanted to explain. Next time I will try to explain better, that was not that perfect.

GazL · 01-24-2023, 03:13 PM

Another approach would be to use strtol() and then call strtod() when there's a fractional component (i.e. when *endptr == '.' ).

Something like this perhaps:

Code:

#include <stdio.h>
#include <stdlib.h>

void *validate_number_str( char *nstr, long *return_long, double *return_double)
{
	char *endptr;

	if ( nstr == NULL || return_long == NULL )
		return NULL;

	*return_long =  strtol(nstr, &endptr, 10);
	if ( endptr == nstr )
		return NULL;

	if ( return_double  &&  *endptr == '.' )
	{
		*return_double = strtod(nstr, &endptr);
		if ( *endptr == '\0' )
			return return_double;
	} else if ( *endptr == '\0' )
		return return_long;

	return NULL;
}

int main(int argc, char *argv[])
{

	double my_double;
	long my_long;

	if (argc < 2 )
		return 1;

	void *ptr = validate_number_str(argv[1], &my_long, &my_double );

	if (ptr == &my_long )
		printf("valid long %ld\n", my_long);
	else if ( ptr == &my_double )
		printf("valid double %f\n", my_double);
	else
		printf("Invalid\n");

	return 0;
}

I'll leave stripping trailing whitespace and any further robustness checks as an exercise for the reader.