>
>
> #include <stdio.h>
> #include <stdlib.h>
> #include <math.h>
>
> int main()
> {
> � float P = 100000; // Loan Amount
> � float r = 7.5; // Advertised Interest Rate
> � int n = 12; // Loan Period
> � float payBack = (P * r / 1200 * pow(1 + r / 1200, n)) / (pow((1 +
> r / 1200), n) - 1);
> � float Opening = P; // Opening Balance
> � float closing = 0;� // Closing Balance
> � float interest = 0;
> � float Total = 0;
> � float repaid = 0;
>
> � printf("\nMonthly payment is: %.2f\n", payBack);
>
> ��� printf("%10s %14s %13s %10s %14s %12s\n", "Month", "Beginning",
> "Interest", "Total", "Repayment", "Balance");
>
> ��� for (int i = 1; i <= n; i++)
> ��� {
> ������� for (int j = 0; j <= n; j++)
> ������� {
> ����������� interest = Opening * r / 1200;
> ����������� Total = Opening + interest;
> ����������� repaid = payBack;
> ����������� closing = Total - payBack;
> ������� }
> ������� printf("%10d %14.0f %13.0f %10.0f %14.0f %12.0f\n", i,
> Opening, interest, Total, repaid, closing);
> ������� Opening = closing;
> ��� }
> ��� return 0;
> }
>
> /*
> * Output should be:
> Monthly payment is: 8675.71
> ���� Month����� Beginning����� Interest����� Total Repayment Balance
> �������� 1�������� 100000���������� 625���� 100625 8676 91949
> �������� 2��������� 91949���������� 575����� 92524 8676 83848
> �������� 3��������� 83848���������� 524����� 84372 8676 75697
> �������� 4��������� 75697���������� 473����� 76170 8676 67494
> �������� 5��������� 67494���������� 422����� 67916 8676 59240
> �������� 6��������� 59240���������� 370����� 59610 8676 50935
> �������� 7��������� 50935���������� 318����� 51253 8676 42577
> �������� 8��������� 42577���������� 266����� 42843 8676 34168
> �������� 9��������� 34168���������� 214����� 34381 8676 25706
> ������� 10��������� 25706���������� 161����� 25866 8676 17190
> ������� 11��������� 17190���������� 107����� 17298 8676 8622
> ������� 12���������� 8622����������� 54������ 8676 8676 0
>
> */
>
>
>
>
>

On 12/24/2021 5:00 PM, Manu Raju wrote:
>>
>> #include <stdio.h>
>> #include <stdlib.h>
>> #include <math.h>
>>
>> int main()
>> {
>>   float P = 100000; // Loan Amount
>>   float r = 7.5; // Advertised Interest Rate
>>   int n = 12; // Loan Period
>>   float payBack = (P * r / 1200 * pow(1 + r / 1200, n)) / (pow((1 +
>> r / 1200), n) - 1);
>>   float Opening = P; // Opening Balance
>>   float closing = 0;  // Closing Balance
>>   float interest = 0;
>>   float Total = 0;
>>   float repaid = 0;
>>
>>   printf("\nMonthly payment is: %.2f\n", payBack);
>>
>>     printf("%10s %14s %13s %10s %14s %12s\n", "Month", "Beginning",
>> "Interest", "Total", "Repayment", "Balance");
>>
>>     for (int i = 1; i <= n; i++)
>>     {
>>         for (int j = 0; j <= n; j++)
>>         {
>>             interest = Opening * r / 1200;
>>             Total = Opening + interest;
>>             repaid = payBack;
>>             closing = Total - payBack;
>>         }
>>         printf("%10d %14.0f %13.0f %10.0f %14.0f %12.0f\n", i,
>> Opening, interest, Total, repaid, closing);
>>         Opening = closing;
>>     }
>>     return 0;
>> }

Certainly.

1. int main(void)

2. Stop using `float` for local variables. "Default" floating-point type
in C is `double`. Everything else is used only if you have a good reason
to do that. In this case you don't.

3. Stop using "regular" floating point types for representing monetary
quantities. They are not good for that purpose.

4. It appears that you are actually trying to use `float` to represent
_integer_ quantities (judging by your `printf`). Why?

5. Stop using `pow` for calculating integer powers. You don't really
need `<math.h>` here.

6. Stop piling up all variable declarations at the beginning of the
function. Declare variables as locally as possible.

7. Stop using dummy initializers for your variables. It is better to
leave them uninitialized than initialize them to dummy zeros. This point
is actually connected to the previous one: once you start declaring
variables as locally as possible, you'll normally have a meaningful
initializers for them at the point of declaration.

8. What's going on with capitalization in your variables names?
`Opening`, `closing`, `interest`, `Total`? Is this a convention of some
sort?

9. "Magical constants"? What on Earth is `1200`?

10. Repetitive subexpressions, like `1 + r / 1200` (some explicit, some
slightly obfuscated) are probably a matter of style.... But anyway: DRY
- do not repeat yourself.

--
Best regards,
Andrey Tarasevich

On 25/12/2021 06:44, Andrey Tarasevich wrote:

>
> Certainly.
>
> 1. int main(void)
>
> 2. Stop using `float` for local variables. "Default" floating-point type
> in C is `double`. Everything else is used only if you have a good reason
> to do that. In this case you don't.
>
> 3. Stop using "regular" floating point types for representing monetary
> quantities. They are not good for that purpose.
>
> 4. It appears that you are actually trying to use `float` to represent
> _integer_ quantities (judging by your `printf`). Why?
>
> 5. Stop using `pow` for calculating integer powers. You don't really
> need `<math.h>` here.
>
> 6. Stop piling up all variable declarations at the beginning of the
> function. Declare variables as locally as possible.
>
> 7. Stop using dummy initializers for your variables. It is better to
> leave them uninitialized than initialize them to dummy zeros. This point
> is actually connected to the previous one: once you start declaring
> variables as locally as possible, you'll normally have a meaningful
> initializers for them at the point of declaration.
>
> 8. What's going on with capitalization in your variables names?
> `Opening`, `closing`, `interest`, `Total`? Is this a convention of some
> sort?
>
> 9. "Magical constants"? What on Earth is `1200`?
>
> 10. Repetitive subexpressions, like `1 + r / 1200` (some explicit, some
> slightly obfuscated) are probably a matter of style.... But anyway: DRY
> - do not repeat yourself.
>

That's a good list. Let me add:

11. Be very suspicious of short variable names with a comment attached.
It /might/ be the best choice, because of the way the variable is used
or how it matches some external information (like a mathematical
formula). But often it is better to give the variable a more complete
name. (As a rule of thumb, the smaller the scope, the shorter the
variable name you can get away with.)

12. Be clear in your units - perhaps also including them in names or
even type information (though that is not common in C). Make it clear
which variables are money, percentages, monthly rates, annual rates, etc.

13. Any variables that are fixed at initialisation and not changed
should be declared with "const". It makes code clearer and lets the
compiler catch some kinds of mistakes.

14. It looks like you are mixing up 12 years loan period and 12 months
per year, using the same rather anonymous variable "n" for the purpose.

(Don't take this long list as a sign that your code is terrible. It's
not bad, and I'm sure we've all seen far worse. But these are all tips
for ways to improve it and get in good coding habits early.)

On 25/12/2021 01:00, Manu Raju wrote:
>>
>>
>> #include <stdio.h>
>> #include <stdlib.h>
>> #include <math.h>
>>
>> int main()
>> {
>>   float P = 100000; // Loan Amount
>>   float r = 7.5; // Advertised Interest Rate
>>   int n = 12; // Loan Period
>>   float payBack = (P * r / 1200 * pow(1 + r / 1200, n)) / (pow((1 +
>> r / 1200), n) - 1);
>>   float Opening = P; // Opening Balance
>>   float closing = 0;  // Closing Balance
>>   float interest = 0;
>>   float Total = 0;
>>   float repaid = 0;
>>
>>   printf("\nMonthly payment is: %.2f\n", payBack);
>>
>>     printf("%10s %14s %13s %10s %14s %12s\n", "Month", "Beginning",
>> "Interest", "Total", "Repayment", "Balance");
>>
>>     for (int i = 1; i <= n; i++)
>>     {
>>         for (int j = 0; j <= n; j++)
>>         {
>>             interest = Opening * r / 1200;
>>             Total = Opening + interest;
>>             repaid = payBack;
>>             closing = Total - payBack;
>>         }
>>         printf("%10d %14.0f %13.0f %10.0f %14.0f %12.0f\n", i,
>> Opening, interest, Total, repaid, closing);
>>         Opening = closing;
>>     }
>>     return 0;
>> }

Unlike the other replies, I think this program is largely OK. However
I'd make the following tweaks, for these reasons (I've assumed US$ amounts):

* Use double rather than float; this is more precise. With float, the
final balance will be out by some cents (hidden if shown to nearest
dollar, but sometimes you will see "-0" because of negative cents)

* I've made capitalisation more consistent

* I've lined up the comments, and added extra notes

* 'r' has been changed to 0.075 from 7.5%, to avoid that mysterious 1200
in the code. Now with '12' is easier to guess it is 12 months and you
are calculating a monthly rate.

* The display layout has been adjusted (see below), but that was just my
own preference.

On the last point, in your post, the last two columns were not properly
aligned, but when I tried, they were properly right-justified.

(Interestingly, the complicated expression initialising 'payback'
revealed a bug in one compiler, making it generate an erroneous value.
But that is not your problem. Just be aware if using Tiny C.)

Example:
------------------------------------------------------------

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

int main(void)
{ double P = 100000; // Loan Amount (all amounts dollars(etc))
double r = 7.5/100; // Advertised Interest Rate (percent/100,
annual)
int n = 12; // Loan Period (months)
double payback = // Monthly repayment
(P * r/12 * pow(1+r/12, n)) / (pow((1+r/12),n) - 1);
double opening = P; // Opening Balance
double closing = 0; // Closing Balance
double interest = 0;
double total = 0;
double repaid = 0;

printf("\nMonthly payment is: %.2f\n", payback);

printf("%10s %14s %10s %10s %10s %12s\n", "Month", "Beginning",
"Interest", "Total", "Repayment", "Balance");
puts("
------------------------------------------------------------------");

for (int i = 1; i <= n; i++)
{
for (int j = 0; j <= n; j++)
{
interest = opening * r / 12;
total = opening + interest;
repaid = payback;
closing = total - payback;
}
printf("%10d %14.0f %10.0f %10.0f %10.0f %12.0f\n", i,
opening, interest, total, repaid, closing);
opening = closing;
}
}

You've received very good advice from others. I'll add my voice
to the chorus, now. But, for only one point ...

On Sat, 25 Dec 2021 01:00:00 +0000, Manu Raju wrote:

>> #include <stdio.h>
>> #include <stdlib.h>
>> #include <math.h>
>>
>> int main()
>> {
>>   float P = 100000; // Loan Amount
>>   float r = 7.5; // Advertised Interest Rate
>>   int n = 12; // Loan Period
>>   float payBack = (P * r / 1200 * pow(1 + r / 1200, n)) / (pow((1 +
>> r / 1200), n) - 1);
>>   float Opening = P; // Opening Balance
>>   float closing = 0;  // Closing Balance
>>   float interest = 0;
>>   float Total = 0;
>>   float repaid = 0;
>>
>>   printf("\nMonthly payment is: %.2f\n", payBack);
>>
>>     printf("%10s %14s %13s %10s %14s %12s\n", "Month", "Beginning",
>> "Interest", "Total", "Repayment", "Balance");
>>
>>     for (int i = 1; i <= n; i++)
>>     {
>>         for (int j = 0; j <= n; j++)
>>         {
>>             interest = Opening * r / 1200;
>>             Total = Opening + interest;
>>             repaid = payBack;
>>             closing = Total - payBack;
>>         }

When writing a loop such as above, you should consider placing
loop-invariant calculations outside of the loop. Most
compilers would optimize the loop-invariant statements such that
they only execute once, so this isn't really a performance issue.

However, it /is/ a readability issue. So, your given logic would
be easier to read as...

for (int i = 1; i <= n; i++)
  {
   interest = Opening * r / 1200; /* neither Opening nor r change within the j loop */
    repaid = payBack; /* payBack does not change within the j loop */
for (int j = 0; j <= n; j++)
    {
     Total = Opening + interest;
      closing = Total - payBack;
    }
printf("%10d %14.0f %13.0f %10.0f %14.0f %12.0f\n",
i, Opening, interest, Total, repaid, closing);
Opening = closing;
}

>>         printf("%10d %14.0f %13.0f %10.0f %14.0f %12.0f\n", i,
>> Opening, interest, Total, repaid, closing);
>>         Opening = closing;
>>     }
>>     return 0;
>> }

--
Lew Pitcher
"In Skills, We Trust"

On Saturday, 25 December 2021 at 19:38:17 UTC+2, Lew Pitcher wrote:
> interest = Opening * r / 1200; /* neither Opening nor r change within the j loop */
> repaid = payBack; /* payBack does not change within the j loop */

And since you removed "interest" out of j loop also "Total" should go out
and since "Total" went out also "closing" so go out and since j loop is
now empty it should be erased. ;-)

Lew Pitcher <lew.pitcher@digitalfreehold.ca> writes:
>You've received very good advice from others. I'll add my voice
>to the chorus, now. But, for only one point ...

I have a totally different POV on this than yall!

1st The "greater-than" signs at the start of every
line are a violation of Usenet customs and/or
syntax errors in the C program.

2nd Questions raised in the Subject header field
should be repeated in the body of the post.

3rd I also was not able to decode some characters.
Maybe the OP misses the declaration of the correct
encoding? (Could also be a problem with my newsreader.
I'm not sure here.)

4th When the required output is given as
a certain text and this is the whole specification,
the most robust way to implement this is to write
a single puts or fputs call with this string given
as a string literal or a sequence of string literals,
or maybe a sequence of puts or fputs calls.

Andrey Tarasevich <andreytarasevich@hotmail.com> writes:

> On 12/24/2021 5:00 PM, Manu Raju wrote:
>
>> [revised to repair white space]
>>
>> #include <stdio.h>
>> #include <stdlib.h>
>> #include <math.h>
>>
>> int main()
>> {
>> float P = 100000; // Loan Amount
>> float r = 7.5; // Advertised Interest Rate
>> int n = 12; // Loan Period
>> float payBack = (P * r / 1200 * pow(1 + r / 1200, n))
>> / (pow((1 + r / 1200), n) - 1);
>> float Opening = P; // Opening Balance
>> float closing = 0; // Closing Balance
>> float interest = 0;
>> float Total = 0;
>> float repaid = 0;
>>
>> printf("\nMonthly payment is: %.2f\n", payBack);
>>
>> printf("%10s %14s %13s %10s %14s %12s\n", "Month", "Beginning",
>> "Interest", "Total", "Repayment", "Balance");
>>
>> for (int i = 1; i <= n; i++)
>> {
>> for (int j = 0; j <= n; j++)
>> {
>> interest = Opening * r / 1200;
>> Total = Opening + interest;
>> repaid = payBack;
>> closing = Total - payBack;
>> }
>> printf("%10d %14.0f %13.0f %10.0f %14.0f %12.0f\n", i,
>> Opening, interest, Total, repaid, closing);
>> Opening = closing;
>> }
>> return 0;
>> }
>
> Certainly.
>
> 1. int main(void)

Check.

> 2. Stop using `float` for local variables. "Default" floating-point
> type in C is `double`. Everything else is used only if you have a
> good reason to do that. In this case you don't.

Check.

> 3. Stop using "regular" floating point types for representing
> monetary quantities. They are not good for that purpose.

For this level of programming I think floating point is okay. A
problem that is important is the program makes no effort to round
(to the nearest cent, for example), so the calculation gives
funny results typical of calculations done with floating point.
But that problem can be addressed without throwing out floating
point altogether.

> 4. It appears that you are actually trying to use `float` to
> represent _integer_ quantities (judging by your `printf`). Why?

To me that just looks like what the print formats are, not what
the kinds of quantities are.

> 5. Stop using `pow` for calculating integer powers. You don't
> really need `<math.h>` here.

I have to vote against this comment. Using pow() makes it
obvious what is being done, the exponent being integral
notwithstanding.

> 6. Stop piling up all variable declarations at the beginning of
> the function. Declare variables as locally as possible.

Good advice here I would say, but this rule is a point of style
with differing viewpoints.

> 7. Stop using dummy initializers for your variables. It is better
> to leave them uninitialized than initialize them to dummy zeros.
> This point is actually connected to the previous one: once you
> start declaring variables as locally as possible, you'll normally
> have a meaningful initializers for them at the point of declaration.

Check.

> 8. What's going on with capitalization in your variables names?
> Opening`, `closing`, `interest`, `Total`? Is this a convention of
> some sort?

Check.

> 9. "Magical constants"? What on Earth is `1200`?

Check. However I think it should be added that the "magicness"
of the constant(s) can be addressed by rephrasing the expressions
where they are used, without necessarily taking the constants
out of those expressions.

> 10. Repetitive subexpressions, like `1 + r / 1200` (some explicit,
> some slightly obfuscated) are probably a matter of style.... But
> anyway: DRY - do not repeat yourself.

More significant here, I think, is that defining a variable with
the value of this expression offers an opportunity to give some
sort of descriptive name to the quantity.

Two additional points:

The #include <stdlib.h> can be removed.

The inner loop (with 'j' as the index variable) does the same
calculation over and over again. There is no reason to make
that a loop - just write the body.

On Sat, 25 Dec 2021 10:58:20 -0800, Öö Tiib wrote:

> On Saturday, 25 December 2021 at 19:38:17 UTC+2, Lew Pitcher wrote:
>> interest = Opening * r / 1200; /* neither Opening nor r change within the j loop */
>> repaid = payBack; /* payBack does not change within the j loop */
>
> And since you removed "interest" out of j loop also "Total" should go out
> and since "Total" went out also "closing" so go out and since j loop is
> now empty it should be erased. ;-)

Why, yes. Now that you mention it.

But we must leave /some/ details as exercises for the student, agreed?

--
Lew Pitcher
"In Skills, We Trust"

Manu Raju <MR@invalid.invalid> writes:

[revised to repair spacing issues]

> #include <stdio.h>
> #include <stdlib.h>
> #include <math.h>
>
> int main()
> {
> float P = 100000; // Loan Amount
> float r = 7.5; // Advertised Interest Rate
> int n = 12; // Loan Period
> float payBack = (P * r / 1200 * pow(1 + r / 1200, n))
> / (pow((1 + r / 1200), n) - 1);
> float Opening = P; // Opening Balance
> float closing = 0; // Closing Balance
> float interest = 0;
> float Total = 0;
> float repaid = 0;
>
> printf("\nMonthly payment is: %.2f\n", payBack);
>
> printf("%10s %14s %13s %10s %14s %12s\n", "Month", "Beginning",
> "Interest", "Total", "Repayment", "Balance");
>
> for (int i = 1; i <= n; i++)
> {
> for (int j = 0; j <= n; j++)
> {
> interest = Opening * r / 1200;
> Total = Opening + interest;
> repaid = payBack;
> closing = Total - payBack;
> }
> printf("%10d %14.0f %13.0f %10.0f %14.0f %12.0f\n", i,
> Opening, interest, Total, repaid, closing);
> Opening = closing;
> }
> return 0;
> }

I gave some other comments in another response. Here is
a re-writing to make my suggestions more concrete.

(Note to all: Merry Christmas!)

#include <stdio.h>
#include <math.h>

static void show_payment_table( double, double, int );

int
main(void){
show_payment_table( 100000, 7.5, 12 );
return 0;
}

void
show_payment_table( double amount, double yearly_percentage_rate, int months ){
double const monthly_rate = yearly_percentage_rate / 100 / 12;
double const compounded = pow( 1 + monthly_rate, months );
double const adjustment = compounded / (compounded - 1);
double const payment = amount * monthly_rate * adjustment;

double balance = amount;

printf( "\nMonthly payment is: %.2f\n", payment );

printf( "%10s %14s %13s %10s %14s %12s\n",
"Month", "Beginning", "Interest", "Total", "Repayment", "Balance"
);

for( int i = 1; i <= months; i++ ){
double const interest = balance * monthly_rate;
double const owing = balance + interest;
double const remaining = owing - payment;

printf( "%10d %14.0f %13.0f %10.0f %14.0f %12.0f\n",
i, balance, interest, owing, payment, remaining
);
balance = remaining;
}
}

On Saturday, 25 December 2021 at 21:16:59 UTC+2, Lew Pitcher wrote:
> On Sat, 25 Dec 2021 10:58:20 -0800, Öö Tiib wrote:
>
> > On Saturday, 25 December 2021 at 19:38:17 UTC+2, Lew Pitcher wrote:
> >> interest = Opening * r / 1200; /* neither Opening nor r change within the j loop */
> >> repaid = payBack; /* payBack does not change within the j loop */
> >
> > And since you removed "interest" out of j loop also "Total" should go out
> > and since "Total" went out also "closing" so go out and since j loop is
> > now empty it should be erased. ;-)
>
> Why, yes. Now that you mention it.
>
> But we must leave /some/ details as exercises for the student, agreed?

Oops. I added too much spoilers?
My bad. But usually at that point the teacher hints that
finding the rest of cases is exercise.

ram@zedat.fu-berlin.de (Stefan Ram) writes:
>Lew Pitcher <lew.pitcher@digitalfreehold.ca> writes:
>>You've received very good advice from others. I'll add my voice
>>to the chorus, now. But, for only one point ...
>
> I have a totally different POV on this than yall!
>
> 1st The "greater-than" signs at the start of every
> line are a violation of Usenet customs and/or
> syntax errors in the C program.

Or, perhaps, they are standard Usenet quoting characters, in use
for four decades.

On 12/25/2021 9:38 AM, Lew Pitcher wrote:
>
>    interest = Opening * r / 1200; /* neither Opening nor r change within the j loop */
>     repaid = payBack; /* payBack does not change within the j loop */
>

Yes, I missed this part. The whole loop

for (int j = 0; j <= n; j++)
{
interest = Opening * r / 1200;
Total = Opening + interest;
repaid = payBack;
closing = Total - payBack;
}

does not have any observable behavior, its body does not depend on `j`
and actions performed inside do not have any cumulative effect. Each
iteration begins in the same input state.

This means that the loop is completely pointless. It is equivalent to a
one-time execution of its body

interest = Opening * r / 1200;
Total = Opening + interest;
repaid = payBack;
closing = Total - payBack;

--
Best regards,
Andrey Tarasevich

On Saturday, 25 December 2021 at 03:38:05 UTC, Manu Raju wrote:
> >
> >
> > #include <stdio.h>
> > #include <stdlib.h>
> > #include <math.h>
> >
> > int main()
> > {
> > float P = 100000; // Loan Amount
> > float r = 7.5; // Advertised Interest Rate
> > int n = 12; // Loan Period
> > float payBack = (P * r / 1200 * pow(1 + r / 1200, n)) / (pow((1 +
> > r / 1200), n) - 1);
> > float Opening = P; // Opening Balance
> > float closing = 0; // Closing Balance
> > float interest = 0;
> > float Total = 0;
> > float repaid = 0;
> >
> > printf("\nMonthly payment is: %.2f\n", payBack);
> >
> > printf("%10s %14s %13s %10s %14s %12s\n", "Month", "Beginning",
> > "Interest", "Total", "Repayment", "Balance");
> >
> > for (int i = 1; i <= n; i++)
> > {
> > for (int j = 0; j <= n; j++)
> > {
> > interest = Opening * r / 1200;
> > Total = Opening + interest;
> > repaid = payBack;
> > closing = Total - payBack;
> > }
> > printf("%10d %14.0f %13.0f %10.0f %14.0f %12.0f\n", i,
> > Opening, interest, Total, repaid, closing);
> > Opening = closing;
> > }
> > return 0;
> > }
> >
> > /*
> > * Output should be:
> > Monthly payment is: 8675.71
> > Month Beginning Interest Total Repayment Balance
> > 1 100000 625 100625 8676 91949
> > 2 91949 575 92524 8676 83848
> > 3 83848 524 84372 8676 75697
> > 4 75697 473 76170 8676 67494
> > 5 67494 422 67916 8676 59240
> > 6 59240 370 59610 8676 50935
> > 7 50935 318 51253 8676 42577
> > 8 42577 266 42843 8676 34168
> > 9 34168 214 34381 8676 25706
> > 10 25706 161 25866 8676 17190
> > 11 17190 107 17298 8676 8622
> > 12 8622 54 8676 8676 0
> >
> > */
> >
> >
> >
> >
> >

for (int j = 0; j <= n; j++)

This line looks supicious. You are applying the interest 13 times. That might be
right (13 4 week months in a year), but it needs a comment.
YOu shouldn't re-use "n", as other have suggested.

On 12/25/2021 6:44 AM, Andrey Tarasevich wrote:
> 6. Stop piling up all variable declarations at the beginning of the
> function. Declare variables as locally as possible.

Put this way, this is questionable advice, IMO.
Experienced programmers may have your same opinion, but some others,
equally experienced, may label that same programming style as sloppy -
I've seen some myself.

In order to turn this opinion into good advice, I think there is more to
add to it:

1) Functions should perform simple, well defined tasks, which implies
that complex tasks should be split into multiple functions. After you do
this, then it becomes natural that you don't have "piles" of local
variables, and you may well have the variables you need at the beginning
of the function and still be "local".

2) Make good use of language constructs to keep counters, indexes etc.
local: for example, instead of declaring a generic counter "n" at the
beginning of the function and reuse it multiple times, prefer the following:

for (int n = 0; n < COUNT; ++n)
{ /* ... */
}

and thus have multiple "for" (and friends) constructs each with its own
counter.

3) If in the function body you have a code section that performs some
specific operation that needs its local variables, you may use a local
scope for it, and declare its variables inside it (check point 1 above
as well):

int myfunction(void)
{ /* ... */

{
int myvar = 42;
/* ... */
}

/* ... */
}

Obviously, the body of language constructs like "if", "for", "while",
"do" make natural local scopes that are good candidates for this purpose.

4) For algorithmic parameters that may affect the entire task, (e.g.
number of months in a year), you may well have a "const" variable at the
beginning of the function. "static const" at the beginning of the source
file is also an option, as well as many others.

>
> 7. Stop using dummy initializers for your variables. It is better to
> leave them uninitialized than initialize them to dummy zeros. This point
> is actually connected to the previous one: once you start declaring
> variables as locally as possible, you'll normally have a meaningful
> initializers for them at the point of declaration.

This is tricky. One of the worst bugs I have ever encountered was
"strlen" being called on an uninitialized string buffer.

I believe the best option is to initialize variables with meaningful
values, which leads to locality, as you say, but with my notes above.
However, as a last resort, it is probably better to leave them
uninitialized, rather than dummy zeros, *if* you have a decent compiler
that will spot its use before assignment.

On 12/25/2021 10:58 AM, Öö Tiib wrote:
> On Saturday, 25 December 2021 at 19:38:17 UTC+2, Lew Pitcher wrote:
>> interest = Opening * r / 1200; /* neither Opening nor r change within the j loop */
>> repaid = payBack; /* payBack does not change within the j loop */
>
> And since you removed "interest" out of j loop also "Total" should go out
> and since "Total" went out also "closing" so go out and since j loop is
> now empty it should be erased. ;-)

Tell that to the bank... ;^)

On Sat, 25 Dec 2021 15:01:46 -0800, Chris M. Thomasson wrote:

> On 12/25/2021 10:58 AM, Öö Tiib wrote:
>> On Saturday, 25 December 2021 at 19:38:17 UTC+2, Lew Pitcher wrote:
>>> interest = Opening * r / 1200; /* neither Opening nor r change within the j loop */
>>> repaid = payBack; /* payBack does not change within the j loop */
>>
>> And since you removed "interest" out of j loop also "Total" should go out
>> and since "Total" went out also "closing" so go out and since j loop is
>> now empty it should be erased. ;-)
>
> Tell that to the bank... ;^)

Öö Tiib wasn't wrong. I didn't take my advice far enough :-)

As for "the bank", the OP's program produces identical results with
the removal of the j loop, so if the original program was good enough,
then the OP can take the loop-invariant version "to the bank" as well ;-)

Keep well, my friends.
--
Lew Pitcher
"In Skills, We Trust"

scott@slp53.sl.home (Scott Lurndal) writes:
> ram@zedat.fu-berlin.de (Stefan Ram) writes:
>>Lew Pitcher <lew.pitcher@digitalfreehold.ca> writes:
>>>You've received very good advice from others. I'll add my voice
>>>to the chorus, now. But, for only one point ...
>>
>> I have a totally different POV on this than yall!
>>
>> 1st The "greater-than" signs at the start of every
>> line are a violation of Usenet customs and/or
>> syntax errors in the C program.
>
> Or, perhaps, they are standard Usenet quoting characters, in use
> for four decades.

They are, but they're generally used to quote text from previous
articles. The code in the question is original text. I'm not
necessarily criticizing the original poster, but IMHO it would have been
better for the code not to be prefixed with anything, particularly so
that readers can copy-and-paste or save the article and easily extract
the code from it.

My newsreader (Gnus) showed me a lot of strange characters. Here's what
the original article looked like to me:

> #include <stdio.h>
> #include <stdlib.h>
> #include <math.h>
>
> int main()
> {
> \240 float P = 100000; // Loan Amount
> \240 float r = 7.5; // Advertised Interest Rate
> \240 int n = 12; // Loan Period
> \240 float payBack = (P * r / 1200 * pow(1 + r / 1200, n)) / (pow((1 +
> r / 1200), n) - 1);

the \240 is a NO-BREAK SPACE character. And when I tried to save the
article, emacs gave me an error message; it was unable to encode the
\240 characters to UTF-8. It appears that the original article was
encoded in ISO-8859-1 or something similar, but not marked as such in
the headers.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
Working, but not speaking, for Philips
void Void(void) { Void(); } /* The recursive call of the void */

On 12/25/2021 1:27 PM, Malcolm McLean wrote:
>
> for (int j = 0; j <= n; j++)
>
> This line looks supicious. You are applying the interest 13 times. That might be
> right (13 4 week months in a year), but it needs a comment.
> YOu shouldn't re-use "n", as other have suggested.

True, but as it has already been stated above, the body of the loop does
not have any cumulative effect. It is not really "applying" anything to
anything.

You can run this loop 10000 times, or you can run it only once - makes
no difference whatsoever.

--
Best regards,
Andrey Tarasevich

On 12/25/2021 3:09 PM, Lew Pitcher wrote:
> On Sat, 25 Dec 2021 15:01:46 -0800, Chris M. Thomasson wrote:
>
>> On 12/25/2021 10:58 AM, Öö Tiib wrote:
>>> On Saturday, 25 December 2021 at 19:38:17 UTC+2, Lew Pitcher wrote:
>>>> interest = Opening * r / 1200; /* neither Opening nor r change within the j loop */
>>>> repaid = payBack; /* payBack does not change within the j loop */
>>>
>>> And since you removed "interest" out of j loop also "Total" should go out
>>> and since "Total" went out also "closing" so go out and since j loop is
>>> now empty it should be erased. ;-)
>>
>> Tell that to the bank... ;^)
>
> Öö Tiib wasn't wrong. I didn't take my advice far enough :-)
>
> As for "the bank", the OP's program produces identical results with
> the removal of the j loop, so if the original program was good enough,
> then the OP can take the loop-invariant version "to the bank" as well ;-)
>
> Keep well, my friends.

Ahhhh! Touche. Merry Christmas!

On 25/12/2021 05:44, Andrey Tarasevich wrote:
> On 12/24/2021 5:00 PM, Manu Raju wrote:
>>>
>>> #include <stdio.h>
>>> #include <stdlib.h>
>>> #include <math.h>
>>>
>>> int main()
>>> {
>>>    float P = 100000; // Loan Amount
>>>    float r = 7.5; // Advertised Interest Rate
>>>    int n = 12; // Loan Period
>>>    float payBack = (P * r / 1200 * pow(1 + r / 1200, n)) / (pow((1 +
>>> r / 1200), n) - 1);
>>>    float Opening = P; // Opening Balance
>>>    float closing = 0;  // Closing Balance
>>>    float interest = 0;
>>>    float Total = 0;
>>>    float repaid = 0;
>>>
>>>    printf("\nMonthly payment is: %.2f\n", payBack);
>>>
>>>      printf("%10s %14s %13s %10s %14s %12s\n", "Month", "Beginning",
>>> "Interest", "Total", "Repayment", "Balance");
>>>
>>>      for (int i = 1; i <= n; i++)
>>>      {
>>>          for (int j = 0; j <= n; j++)
>>>          {
>>>              interest = Opening * r / 1200;
>>>              Total = Opening + interest;
>>>              repaid = payBack;
>>>              closing = Total - payBack;
>>>          }
>>>          printf("%10d %14.0f %13.0f %10.0f %14.0f %12.0f\n", i,
>>> Opening, interest, Total, repaid, closing);
>>>          Opening = closing;
>>>      }
>>>      return 0;
>>> }
>
>
> 9. "Magical constants"? What on Earth is `1200`?

It is just a figure 12 * 100. You first need to convert percentage into
decimals by dividing by 100; Then you need to divide the number again by
12 to give monthly rate. Interest rate is normally annual rate. Hope
this explains the magic number.

X-Mozilla-Status: 0811
X-Mozilla-Status2: 00000000
X-Mozilla-Keys:

On 25/12/2021 12:47, Bart wrote:
> On 25/12/2021 01:00, Manu Raju wrote:
>>>
>>>
>
> Unlike the other replies, I think this program is largely OK. However
> I'd make the following tweaks, for these reasons (I've assumed US$
> amounts):
>
> * Use double rather than float; this is more precise. With float, the
> final balance will be out by some cents (hidden if shown to nearest
> dollar, but sometimes you will see "-0" because of negative cents)
>
> * I've made capitalisation more consistent
>
> * I've lined up the comments, and added extra notes
>
> * 'r' has been changed to 0.075 from 7.5%, to avoid that mysterious 1200
>   in the code. Now with '12' is easier to guess it is 12 months and you
>   are calculating a monthly rate.
>
> * The display layout has been adjusted (see below), but that was just my
>   own preference.
>
> On the last point, in your post, the last two columns were not properly
> aligned, but when I tried, they were properly right-justified.
>
> (Interestingly, the complicated expression initialising 'payback'
> revealed a bug in one compiler, making it generate an erroneous value.
> But that is not your problem. Just be aware if using Tiny C.)
>
>
> Example:
> ------------------------------------------------------------
>
> #include <stdio.h>
> #include <stdlib.h>
> #include <math.h>
>
> int main(void)
> {
>   double P = 100000;        // Loan Amount (all amounts dollars(etc))
>   double r = 7.5/100;       // Advertised Interest Rate (percent/100,
> annual)
>   int n = 12;               // Loan Period (months)
>   double payback  =         // Monthly repayment
>          (P * r/12 * pow(1+r/12, n)) / (pow((1+r/12),n) - 1);
>   double opening  = P;      // Opening Balance
>   double closing  = 0;      // Closing Balance
>   double interest = 0;
>   double total    = 0;
>   double repaid   = 0;
>
>   printf("\nMonthly payment is: %.2f\n", payback);
>
>     printf("%10s %14s %10s %10s %10s %12s\n", "Month", "Beginning",
> "Interest", "Total", "Repayment", "Balance");
>     puts("
> ------------------------------------------------------------------");
>
>     for (int i = 1; i <= n; i++)
>     {
>         for (int j = 0; j <= n; j++)
>         {
>             interest = opening * r / 12;
>             total = opening + interest;
>             repaid = payback;
>             closing = total - payback;
>         }
>         printf("%10d %14.0f %10.0f %10.0f %10.0f %12.0f\n", i,
>             opening, interest, total, repaid, closing);
>         opening = closing;
>     }
> }
>

Thank you for your feedback.

Kind regards Merry Christmas.

On 25/12/2021 17:38, Lew Pitcher wrote:
> You've received very good advice from others. I'll add my voice
> to the chorus, now. But, for only one point ...
>
>
>
> When writing a loop such as above, you should consider placing
> loop-invariant calculations outside of the loop. Most
> compilers would optimize the loop-invariant statements such that
> they only execute once, so this isn't really a performance issue.
>
> However, it /is/ a readability issue. So, your given logic would
> be easier to read as...
>
>

Thank you.

On 25/12/2021 19:22, Tim Rentsch wrote:
> Manu Raju <MR@invalid.invalid> writes:
>
> [revised to repair spacing issues]
>

Thank you. Very helpful and using a function was exactly what I wanted
to do.

On 25/12/2021 23:50, Keith Thompson wrote:
>
>
> My newsreader (Gnus) showed me a lot of strange characters. Here's what
> the original article looked like to me:

The code was copy/pasted from VS Code so that might be the reason.

>
>
> the \240 is a NO-BREAK SPACE character. And when I tried to save the
> article, emacs gave me an error message; it was unable to encode the
> \240 characters to UTF-8. It appears that the original article was
> encoded in ISO-8859-1 or something similar, but not marked as such in
> the headers.

The code was copied from VS Code and pasted in Mozilla Thunderbird. Not
sure why it changed.

>