Yuku free message boards

The C language does not natively support things like symbolic expressions, and there are separate integer and floating-point data types, so the data type of your expression matters.

When you want to compute the square root of an integer, what kind of result do you want?
* an integer? There are some efficient routines around for that, e.g. the one used in the FAT Engine. You can also go through floating-point arithmetic: (int)(sqrt(x)), but that's slower.
* a floating-point number? If so, sqrt(x) is what you want.
* a symbolic expression? Then see the last paragraph of this post.

Integers never have decimals to remove in the first place. (Again, C has different integer and floating-point data types.) Removing the decimals from a floating-point number while keeping it a float can be done with the floor function. Converting it to an integer data type can be done by a simple typecast, e.g. (int)x.

Division on integer data types will give an integer result. If you want a floating-point result, you have to cast at least one of the operands to (float). If you want a fraction, see the last paragraph again.

TIGCC does give you full access to the mathematical functionality of the calculator, including symbolic manipulation (which also includes fractions). However, as there's no native "symbolic expression" data type in C, you have to work with the internal representation. The main concept is the "expression stack", see http://tigcc.ticalc.org/doc/estack.html#top_estack. Expressions are represented as estack indices (variables of type ESI) which are essentially pointers (the ESI type is just a pointer to ESQ, which stands for estack quantum, but an expression can be more than a quantum, the ESI just points to the last one). You'll want to read the documentation of estack.h carefully if you want to do Mathematics in TIGCC, and probably also learn some more about C than you seem to currently know. C is not TI-BASIC, especially Mathematics are a lot harder to do in C than in TI-BASIC (but also more powerful and faster).

As I have no idea about much of what you just wrote

You'll have to understand it if you want to write your program. These are just the basics.

The square root of a number should be like this : 2^(1/2)=1,41421356237, or 36^(1/2)=6
A number without it's decimals should be like this : int(2,5)=2, or floor(Pi)=3
And a division should naturally be like this : 2/3=0,666666666, or 99/11=9

So you want to work with floating-point numbers most of the time. Square roots are just the sqrt function, as I said, use floor or cast to an integer type such as int, or more likely long or long long, to get the integer part of a floating-point number. Again: in C there are different data types. C is a strongly-typed language, not like TI-BASIC. You have to know whether a variable needs to be an integer or a float (= floating-point number).

And one huge warning: using floating-point numbers when working with prime numbers is an extremely bad idea, prime numbers are about integers and need exact computations, the rounding errors incurred with floating-point operations are likely to give wrong results. And by the way, floats are very slow on the calculator.

Hint: if you want to check whether an integer is divisible by another, the correct way is to test !(x%y) (or (x%y)==0 if you like redundant notations), not (float)x/y==floor((float)x/y) or something like that.

And as a reminder I don't know much about TIGCC programming and I don't need to know much

You do need to know more than what you currently know to write your program. If you aren't willing to learn, you're just wasting my time.

You also didn't specify how large your prime numbers are supposed to be. If you want to go beyond ULONG_MAX, i.e. 4294967295, you'll have to use the expression stack to convert your numbers to strings. If you want to go beyond ULONGLONG_MAX, i.e. 18446744073709551615, you'll have to use the expression stack for computations too. If you'll stay within ULONG_MAX, you can just do your computations with unsigned long, that'll be the easiest. Floats are no solution because they cannot represent numbers above 10000000000000000 exactly, and for prime numbers, it makes a huge difference whether we're talking about 10000000000000000 or 10000000000000001 (which for a float will both be 1.000000000000000*10^16, the last digit gets truncated).

Oh, and estack is simply an abbreviation for "expression stack".

// Here, I want to see if y doesn't have any decimals. If there is decimals, x is not a divider of t.

And the way you're doing it is completely the wrong way, as I already wrote. I already gave you the correct code for that, why did you ignore it?

And as Lionel says, the "easy solution" here is to just throw away the whole crappy program and use the builtin isPrime function in a TI-BASIC loop.

Your code is full of syntax errors (wrong order for assignments, missing parentheses around if conditions, bogus semicolon after for which will make it an empty loop followed by a separate block (i.e. not what you want), invalid parameters for printf), you're using the int data type which only goes up to 32767 and the interfacing with AMS/TI-BASIC (input and output) is missing entirely.

That said, there are more efficient ways to get a list of prime numbers if you're using a fast language like C (in TI-BASIC, it'll probably be slower because isPrime is a fast builtin function whereas TI-BASIC code is slow), e.g. the sieve of Eratosthenes or the sieve of Atkin. But if you can't even get the crappy naive version anywhere near working you have zero hope to get that working ever in your lifetime. Sorry.