Develop Reference

Why is the last line of my code not printing? Also, what's the simplest way for me to round numbers to 2 decimals? [duplicate]

This question already has answers here:
How to round a number to n decimal places in Java
(39 answers)
Closed 6 years ago.
When running my program, the last line displaying yearly gas expense is not showing... what have I done wrong? Also would like some help rounding figures to 2 decimal points...
I tried implementing a few strategies but none of them worked.
Any help is appreciated!
public class GasExpenses {
public static void main(String[] args) {
//Use scanner in order to retrieve user input.
Scanner keyboard= new Scanner(System.in);
//Declare variables.
int milesPerWeek;
double milesPerGallon,costOfGas;
System.out.println("GAS EXPENSES");
//Get user input.
System.out.println("How many miles do you drive a week?");
milesPerWeek = keyboard.nextInt();
//Get user input.
System.out.println("How many miles per gallon does your auto get?");
milesPerGallon=keyboard.nextDouble();
//Get user input.
System.out.println("What is the current cost of gas?");
costOfGas=keyboard.nextDouble();
//Calculate miles per year.
int milesPerYear=(milesPerWeek*52);
//Display calculated yearly mileage.
System.out.println("At " + milesPerWeek + "miles per week, you travel "+
milesPerYear + " miles per year.");
//Calculate and display calculated weekly & yearly gallons of gas used.
double gallonsPerWeek=(milesPerWeek/milesPerGallon);
System.out.println("Gallons per week:" + gallonsPerWeek);
double gallonsPerYear=(gallonsPerWeek*52);
System.out.println("Gallons per year:" + gallonsPerYear);
//Calculate and display calculated weekly & yearly gas expense.
System.out.println("With gas at $" +costOfGas + " per gallon, you will
spend: ");
double weeklyGasExpense=(costOfGas*milesPerWeek);
System.out.println("Gas expense per week: $" +weeklyGasExpense);
double yearlyGasExpense=(costOfGas*milesPerYear);
System.out.println("Gas expense per year: $" +yearlyGasExpense);
//Calculate and display calculated weekly & yearly gas expense based on
increased gas price.
double costIncrease= (costOfGas+1);
System.out.println("If gas goes up by one dollar per gallon to $" +
costIncrease +(" per gallon, you will spend:"));
double weeklyIncreasedGas=(costIncrease*milesPerWeek);
double yearlyIncreasedGas=(costIncrease*milesPerYear);
System.out.println("Gas expense per week : $" +weeklyIncreasedGas);
System.out.print("Gas expense per year : $" +yearlyIncreasedGas);
}}

Run system.out.flush() at the end of your code to make sure everything is printed.
For the rounding you could try this answer round up to 2 decimal places in java?

For first question, this line works for me given your code:
System.out.print("Gas expense per year : $" +yearlyIncreasedGas);
For second do this:
double number = 111.12345;
double result = Math.round(number * 100.0) / 100.0;

Boolean Statement in WHILE loop doesn't make sense?

My while statement just doesn't seem to make sense to me, even though it works.
I want it to calculate the interest only as long as the countYears is less than the timeLimit....so if I set timeLimit to 5, it should only calculate 5 years worth of interest but the way I read the current while statement, it doesn't seem to say that. Maybe I am just reading it wrong?
public class RandomPractice {
public static void main(String[] args)
{
Scanner Keyboard = new Scanner(System.in);
double intRate, begBalance, balance;
int countYears, timeLimit;
System.out.println("Please enter your current investment balance.");
begBalance = Keyboard.nextDouble();
System.out.println("Please enter your YEARLY interest rate (in decimals).");
intRate = Keyboard.nextDouble();
System.out.println("Please enter how long (in years) you would like to let interest accrue.");
timeLimit = Keyboard.nextInt();
balance = begBalance * (1 + intRate);
countYears = 0;
/* The way I read this while statement is as follows
* "While countYears is GREATER than the timeLimit...calculate the balance"
* This makes no logical sense to me but I get the correct output?
* I want this code to calculate the investment interest ONLY as long as
* countYears is LESS than timeLimit **/
while (countYears >= timeLimit)
{
balance = balance + (balance * intRate);
countYears++;
}
System.out.println(balance);
}
}

That code you have, as it stands, does not generate the correct data, my transcript for eight years at one percent per annum follows:
Please enter your current investment balance.
100
Please enter your YEARLY interest rate (in decimals).
.01
Please enter how long (in years) you would like to let interest accrue.
8
101.0
In other words, only one year of interest is added rather than eight years.
So either your compiler is totally screwy, your code is not what you think it is, or whatever test data and/or method you're using to check the interest calculation is lacking somewhat.
First, as you foreshadowed, you need to change the condition to be countYears < timeLimit.
In addition, you also need to remove the initial interest calculation before the loop since this would mean you'd get a full year's interest as soon as you deposit the money. With those two changes:
balance = begBalance;
while (countYears < timeLimit) {
balance = balance + (balance * intRate);
countYears++;
}
and you then get the correct value of:
Please enter your current investment balance.
100
Please enter your YEARLY interest rate (in decimals).
.01
Please enter how long (in years) you would like to let interest accrue.
8
108.28567056280801

Your loop isn't being executed at all if you switch it to <= it will be correct.
Right now your output is what is calculated outside of the loop.

Calculating future investment amount in Java

I'm trying to calculate the future investment amount in Java.
My program runs, but it's not giving me the correct answer.
If the
investmentAmount is 1000.56,
interest rate is 4.25, and
number of years is 1,
the answer should be $1043.92.
The formula we have to use is futureInvestmentValue = investmentAmount * (1 + monthlyInterestRate) ^ numberOfYears * 12
Below is my class
// Import Java Scanner
import java.util.Scanner;
public class Ex_2_21 {
public static void main(String[] args) {
//Create a Scanner object
Scanner input = new Scanner(System.in);
//Prompt the user to enter investment amount, annual interest rate, and number of years
System.out.println("Enter investment amount:");
System.out.println("Enter annual interest rate:");
System.out.println("Enter number of years:");
float investmentamount = input.nextFloat();
float interestrate = input.nextFloat();
float numberofyears = input.nextFloat();
float years = numberofyears * 12;
//Formula to calculate the accumulated value
float futureInvestmentValue = (float) (investmentamount * Math.pow((years), 1 + interestrate));
//Print result
System.out.println("The accumulated value is " + futureInvestmentValue);
}
}

On top of what #Luiggi said, did you consider that if it is 4.25 interest rate, that is 425% interest rate, what you want is 1 + 0.0425

You're using years (equal to years * 12) when you mean months, and you're not using monthly interest rate at all. Divide annual interest rate (as entered) by 12 to get monthly interest rate (and also make sure it's a fraction, not a bare percentage, so if they're entering 4.25 it needs to be divided by 100 to get .0425), and introduce a new variable for total month duration. Then (as Luiggi notes) swap the argument order.
float futureInvestmentValue = (float) (investmentAmount * Math.pow(1 + monthlyInterestRate, months));

Here's the problem:
Math.pow((years), 1 + interestrate)
It should be
Math.pow(1 + interestrate, years)
As noted in Math#pow(double a, double b):
Parameters:
a - the base
b - the exponent
Returns
The value ab

There are two problems in the above given Java program:
Lack of problem understanding (kindly, take this suggestion in a positive interest. If we, understand the problem correctly, we are very much near to its correct programming solution.)
Formula for future investment value (A) is as follows:
a) Compounded annually:
A = P*(1+R)^N
Where, A = Future value, P = Original amount invested, R = Interest rate (given as %, in calculation use as R/100), N = Time period for which compound interest rate is applied (in years)
b) Compounded monthly:
A = P*(1+(R/12))^(N*12)
Where, A = Future value, P = Original amount invested, R = Monthly interest rate (given as %, in calculation use as R/100, it is not annual interest rate), N = Time period for which compound interest rate is applied (in years)
As per values of given sample problem, we find in order to calculate future investment value, we should be using formula (b).
So, w.r.t above given Java program, to incorporate this correction we need to simply add one more statement after the interestrate variable declaration line:
interestrate = interestrate / (100 * 12);
Second problem is lack of understanding of Java programming language constructs / logical error by ignorance. Whatever is the case; it does not matter. Technically, it is a programming error and thus it needs rectification.
As already suggested above by Luiggi Mendoza, in Java programming language if we want to express mathematical expression A^B then we have to use java.lang.Math.pow() method with following syntax:
public static double pow(double A, double B)
So, again w.r.t above given Java program, to incorporate this second correction we have to simply correct the line which declares the futureInvestmentValue variable and using the Math.pow() method; as follows:
float futureInvestmentValue = (float) (investmentamount * Math.pow(1 + interestrate, years));
Incorporating these two corrections, we make our solution correct. Based on the principle of GIGO (Garbage In Garbage Out, Gold In Gold Out) we will definitely get correct and exact answer to our any sample problem given values; as expected.
Happy Programming.

Need help Java amortization table calculations

This is my homework it is due Monday the 16th.
I finally got the months to display right but the amounts are wrong.
Also, not necessary but it would be nice to stop and Print something between each loan.
Like loan 1, loan 2, loan 3...
Any help will be appreciated
/*Write the program in Java (without a graphical user interface)
and have it calculate the payment amount for 3 mortgage loans:
- 7 year at 5.35%
- 15 year at 5.5%
- 30 year at 5.75%
Use an array for the different loans.
Display the mortgage payment amount for each loan
and then list the loan balance and interest paid for
each payment over the term of the loan.
Use loops to prevent lists from scrolling off the screen.*/
I have the months correct but the loan amounts are wrong.
import java.io.IOException; //Code that delays ending the program
class MonthlyRhondav4
{
public static void main ( String[] args) throws IOException{
double loanAmount = 200000.00; // $ amount borrowed
double monthlyPayment = 0; // monthly payment for calculating
double loanBalance;
double interestPaid;
double principalPaid;
int paymentCounter;
int lineCounter = 0;
java.text.DecimalFormat dcm = new java.text.DecimalFormat("$,###.00");
int termArray[] = {84, 180, 360}; // Different loan terms in months
double interestArray[] = {0.0535, 0.055, 0.0575};// Different interest rates for the loan
int k =0;// gonna be paymentIndex
/*Code to start the payment list*/
System.out.print("\n\nPlease Press Enter to Continue to the 3 Different Amortization Lists");
System.out.println ();
System.out.println ();
System.in.read();
System.in.read();
/*Display columns*/
System.out.println("Month \t Loan Amount Left\tInterest\t\tPrincipal \n"); //Prints headers for columns
System.out.println ();
/*Loop to calculate and print monthly payments*/
//for(k=0; k<3; k++){// k is going to be paymentIndex to loop through index
for (k = 0; k < interestArray.length; k++) {
for(paymentCounter =1; paymentCounter <= termArray[k]; paymentCounter++) // months through array
{
/********TROUBLE HERE***************************************************************************************/
monthlyPayment = ((loanAmount * (interestArray[k]) * termArray[k]) + loanAmount) / (termArray[k] * 12);
interestPaid = loanAmount*(interestArray[k]/12); //interest paid through array
principalPaid = monthlyPayment-loanAmount*(interestArray[k]/12); //principal paid
/*need to fig monthly payment+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
System.out.println(paymentCounter + "\t" + dcm.format(loanAmount) + "\t\t" + dcm.format(interestPaid) + "\t\t\t" + dcm.format(principalPaid));
lineCounter++; //Increment the display counter
if (lineCounter > 11 && paymentCounter < termArray[k]*12) //Check to see if 12
{
System.out.println ("Please Press Enter to Continue the List" ); //Code to delay ending the program
System.in.read();
System.in.read();
lineCounter = 0;
}
}
loanAmount = (loanAmount - (monthlyPayment-loanAmount*(interestArray[k]/12))); //Calculate new loan amount
}
}//ends public static void main
}//ends public class

One observation -- you're not doing anything with the loan balance. The reason why nothing is changing is that having computed the interest and principal amounts of a given payment, you're not reducing the loan balance by the principal portion of the payment. You need to change your code to display the current loan balance and to compute the principal/interest split from the current loan balance and not the original loan amount.
Edited
Ok -- I see you were trying to update the balance, but you have it outside the loop for the loan. That needs to be inside the loop so that it is updated for each payment. Also, you have things like loanAmount * (interestArray[k] / 12) over and over again. Consider using variables, such as
double interestPaid = loanAmount * (interestArray[k] / 12)
This will make your code easier to read and more maintainable since if you find a mistake in the calculation, you only have to fix the mistake in one place rather than having to fix it everywhere you had the calculation.
I also don't see where you're calculating the monthly payment. That's a function of the original loan amount, number of payments, and interest rate. Remember, the monthly payment is fixed and the interest/principal split of each payment will change as the loan is paid down. You might find http://en.wikipedia.org/wiki/Mortgage_calculator useful to figure out the formula for the monthly payment.

first : never ever use double to calculate something... That's an advice you have to remember. If you don't want to trust me, please search Google for "java double computation" or something like that, and you'll see. Or read the excellent book "Effective Java"
BigDecimal class is there to have correct numbers in Java

A lot of mistakes. For instance you never set the monthlyPayment to anything but 0. You also do not use loanBalance. loanAmount should be a constant. You can also simplify redundant calculations. Example:
interestPaid = loanBalance*(interestArray[k]/12);
principalPaid = monthlyPayment-interestPaid;
instead of
interestPaid = loanBalance*(interestArray[k]/12);
principalPaid = monthlyPayment-loanBalance*(interestArray[k]/12);
I am also not sure you have the correct interest rate formulas, but am not going to check until you remove some of the more obvious errors.

interest calculation

Here's what I got. A linkedList of objects of Customer class of different account types (Savings,current and fixed). Each Customer object has a LinkedList of transactions(another class) as an attribute. 2 types of transactions can be made i.e Debit(withdrawal) or Credit(deposit). Given: A savings account can go into negative while the other two accounts can not. No debit transactions (no withdrawals) from the Fixed account allowed.
if the account balance is positive then the interest rate is 0.0003 while if the account balance is negative (only possible for Saving account)the rate is -0.002. The interest is calculated as follows:
For positive interest, it is based on the money that has
been in the account for the last 24 hours (i.e. from midnight to midnight). For example, if
you have $100 at hour 0 but you have withdrawn $50 at hour 1 and deposited back $50
at hour 2, you will be seen as having only $50 staying in your account for 24 hours at end
of the day (hour 24). At hour 24, the money in your account will be $100 plus the daily
interests computed according to $50.
For negative interest, it is based on the sum of the largest negative money that you owe
the bank on that day. If you borrow money from the bank, they will charge you interest
even if you return the money 1 minute later. For example, if your saving account has
$100 at hour 0 but you withdraw $200 at hour 22 and then deposit $1000 back at hour
23. You will not be paid any positive interest by today mid-night but will be charged for
negative interest for borrow $100 from the bank for today.
For a savings account with initially $566.00 and transactions on the account are as follows:
debit:50 (date:11-09-2008), debit:500(15-09-2008); credit:200(22-09-2008); debit:500(23-09-2008 ).
the sample calculation is given as:
(((566*1.0003^10-50)*1.0003^4-500)*1.0003^8+200-500)*1.002^8 ~= 286.17.
I get some figure of the order of 1377.68 which obviously doesn't match.
Here's what i have for the savings account but i'm pretty sure it's wrong. My question is how to calculate the interest when looping through the transactions for each customer. my calculation is wrong. so i would appreciate it if someone can help me fix the logic
public void update(double rate){ // Savings account interest calc
Transactions ctr = new Transactions();
Node<Transactions> counter = new Node<Transactions>(ctr);
counter=this.trans.head;
int i=0;
double negRate = -0.002;
double posRate = 0.0003;
double updatedBal = this.get_balance();
while(counter!=null){
if (updatedBal >0){
if(trans.getItem(i).AccType.equals("Crebit")){
double exponent = Double.parseDouble(trans.getItem(i).get_Date().substring(0, 2));
updatedBal= (updatedBal*(Math.pow((1+ posRate),exponent-1))+trans.getItem(i).get_Amount());
}
else if(trans.getItem(i).AccType.equals("Debit")){
double exponent = Double.parseDouble(trans.getItem(i).get_Date().substring(0, 2));
updatedBal= (updatedBal*(Math.pow((1+ posRate),exponent-1))-trans.getItem(i).get_Amount());
}
}
else
{
if(trans.getItem(i).AccType.equals("Crebit")){
double exponent = Double.parseDouble(trans.getItem(i).get_Date().substring(0, 2));
updatedBal= (updatedBal*(Math.pow((1+ negRate),exponent-1))+trans.getItem(i).get_Amount());
}
else if(trans.getItem(i).AccType.equals("Debit")){
double exponent = Double.parseDouble(trans.getItem(i).get_Date().substring(0, 2));
updatedBal= (updatedBal*(Math.pow((1+ negRate),exponent-1))-trans.getItem(i).get_Amount());
}
}
counter=counter.next;
}
this.set_balance(updatedBal);
}

Your code has trans.getItem(i).AccType.equals("Crebit") in two places. Presumably that should be Credit. If the value of the AccType field of the transaction items is using the correct spelling, then your if blocks won't "see" the credit transactions when computing the interest and that could lead to a wrong answer.