Otdfbt

I'm a bit lost on what to do with the following calculation. The problem is that decimals are being round up/down, which obviously doesn't give me the result I desire.

int totalValue = 275000;
int percentage = 2;

for (uint i = 0; i < 30; i++) 
 totalValue += totalValue * percentage / 100;

With the above code, the result is:

498108

The expected result is:

498124.436

I know that normally you could simply use the following calculation to work with a predetermined amount of decimals like so:

value * 10**4 (4 decimals)

But I haven't gotten that to work in this case, often resulting in insanely high numbers due to the multiplication and division that "do not make sense" once I revert the above calculation using:

value / 10**4

Thank you very much for your time. Any help would be very much appreciated!

You need to multiply before calculations and divide after that:

int decimals = 4;
int totalValue = 275000;
int percentage = 2;

totalValue = totalValue * 10**decimals;
for (uint i = 0; i < 30; i++) 
 int AddValue = totalValue * percentage;
 AddValue = AddValue / 100;
 totalValue += AddValue;

totalValue = totalValue / 10**decimals;

EDIT: fixed line 5 and the percentage calculation
EDIT2: Actually you don't need to multiply the percentage and will get better results - fixed

Generally speaking, in order to avoid data-loss (i.e., precision-loss) in an arithmetic computation, try to postpone every division as much as possible, without altering the expression.

More specifically with regards to your code, it appears that you are trying to compute the result of applying compound interest: 275000 * 1.02 ** 30.

You can do this very precisely in Solidity, by calculating (off-line) the exact value of 1.02 ** 30, and storing it scaled up to the level of precision that you desire.

Moreover, you won't even need those 30 iterations in order to achieve all that, so you can optimize your code here for both accuracy and performance.

For example:

uint256 INTEREST_N = 181136158410335375505681049921897;
uint256 INTEREST_D = 10000000000000000000000000000000;
uint256 totalValue = 275000 * INTEREST_N / INTEREST_D;

Of course, I'm aware of the fact that you most likely want the 275000 part as an input from the outside rather than a hard-coded value (in which case, you could just as well compute everything outside of the contract).

But assuming that the number of iterations and the compound interest percentage are both constant (30 and 2% in your case), you can do it using the numerator and denominator described above.

If either the number of iterations or the compound interest percentage is a variable, then instead of a single pair of numerator and denominator you can use an array of numerators and an array of denominators.

If both the number of iterations and the compound interest percentage are variables, then instead of a pair of arrays you can use a pair of tables.

The reason you are getting the value 498108 is because Solidity truncates divided values.

This means that if you divide 3/2, the result will be 1, not 1.5. Similarly, if you divide 11/3, the result will be 3, not 3.666.

With this in mind, the reason you are getting that final result is because a few of the loop results are being truncated.