I'm trying to deal with money (probably the wrong way as far as best practices but I thought it would work.. its simple, multiply everything by 100 and then use ints)
import java.util.Scanner;
public class PFiveFifteen {
public static void main(String[] args)
{
Scanner in =new Scanner(System.in);
int i = 0;
double principalIn;
int duration=0;
double interestRate=0;
int thisYear = 0;
int iInterestRate = 0;
int iPrincipalIn = 0;
System.out.println("Please input initial amount: ");
principalIn = in.nextDouble();
iPrincipalIn= (int) principalIn *100;
//System.out.println(principalIn*100);
System.out.println("Please input interest rate as a decimal: ");
interestRate = in.nextDouble()*100;
iInterestRate = (int) interestRate;
//System.out.println(interestRate*100);
System.out.println("Please input duration of investment in years: ");
duration = in.nextInt();
//System.out.println(duration);
while(duration > i ) {
if ( i == 0) {
//System.out.println("Preloop value" + (iInterestRate));
thisYear = (iPrincipalIn * iInterestRate)+ iPrincipalIn;
//System.out.println("Postloop value" + (iPrincipalIn));
i++;
System.out.println("The initial value is " + thisYear);
System.out.println("Year # one one: " +i);
}
else
thisYear = (thisYear*iInterestRate) + thisYear;
i++;
System.out.println(thisYear/10000);
System.out.println("year # " +i);
}
But I'm somehow getting negative numbers back in console
Please input initial amount:
10000
Please input interest rate as a decimal:
100.00
Please input duration of investment in years:
10
The initial value is 1411065408
Year # one one: 1
141106
year # 2
-119738
year # 3
-72104
year # 4
4904
year # 5
84261
year # 6
21917
year # 7
154073
year # 8
-145664
year # 9
63722
year # 10
What in the world is going on here? I could get if there where whacky decimals or soemthing ( even though I cast it all to ints) but what the dickens is taking all positive inputs to below zero??
Your idea of representing money amounts as integers is an OK one, but you have to be very careful of the scaling, especially when you multiply (or divide). Say you start with a principal of $10, which you represent as 1000. Then you enter an interest rate of 0.06 (I assume that the user is entering an actual rate and not a percentage, so 0.06 means 6%). You then represent that as 6.
So if your principal is P, the int you're using to represent it is P*100. And if your interest rate is I, the int you're using to represent it is I*100.
So now you want to compute P*I. Since you're representing everything as 100 times the actual value, you presumably want to get an int whose value is P*I*100. But when you multiply the two ints you have, P*100 and I*100, the result is P*I*10000 -- a factor of 100 too high. That's because you multiplied the scale factors together along with the values. I can see that you did output thisYear / 10000, but you didn't change thisYear. So as you keep going through the loop, you will get values that are a factor of 10000 too high, and 1000000 too high, and so on, and eventually you will overflow. (I wish things really did work that way, but unfortunately I can't talk my bank into using your algorithm.)
To adjust, you'll need to divide this result by 100. (I'd add 50 to it first, so that when you divide by 100 the result will be rounded.)
looks like using ints was just ill conceived.
I did get it to play right with smaller numbers (the biggest issue was having to again bump up the principal by 100 to keep the correct place holder for when the interest which was (p*100)*(i*100) otherwise it was something *100 being added to the interest which was *10000. Sadly any realistic amount of money (like say 250000 for a house) overflows it before the first loop. Though 200000 makes it all the way to loop 30.
Plus interest rates aren't always hundredths, sometimes they are something like .03875
My code lacks the ability to determine the length and even if it had it bumping that up to an int, and keeping everything else like it (multiplying everything by 100000) would definitely not work.
Props to community for not calling me an idiot though! on Youtube et al, I would have gotten answers that would have put me into a corner crying!
Related
I am trying to create a program that will calculate how many days I will need to save X amount of money if I increment the daily contribution by the previous and initial values every day.
Eg: my starting contribution on day 1 is 2, then on day 2 it will be 4, day 3 it will be 6 etc, so the total money in the pot for 3 days will be 12.
My program at the moment looks like this:
int startingValue = 2;
int dailyAmount = startingValue;
int pot = 0;
int desiredMoney = 43554;
int daysSaved =0;
while (pot != desiredMoney){
pot += dailyAmount;
dailyAmount += startingValue;
daysSaved++;
}
System.out.println("Daily amount needed : " + dailyAmount + " Days saved : " + daysSaved + " Money in the pot : " + pot);
Current output of this program is this :
Daily amount needed : 294923972 Days saved : 147461985 Money in the pot : 43554
which doesn't look quite right, but I am not sure why. When I run it in debug mode, it makes sense for the first couple of runs, but when I put the sout statement inside the while loop after a while I see negative numbers such as these:
Daily amount needed : 1054054 Days saved : 527026 Money in the pot : -1415942538
I would expect to see daysSaved as around 1000 days, but my program is clearly broken. Will appreciate any help!
First: why do you get negative numbers when adding? Integer Overflow. Java's ints are 32 bit signed integers. The max safe value for a signed integer is 2147483647. Add just 1 to that it will roll over into -2147483648.
Read more about integer overflows on Wikipedia.
For the second part of your question. pot != desiredMoney is very unlikely to happen, since you keep adding an ever increasing number to your pot. The semantic you want is probably pot < desiredMoney; keep doing this loop while the pot is less than the desired amount of money.
This is a homework question that has been asked a lot, but I am having trouble with the final formatting of the output. This is the question:
Population
Write a program that will predict the size of a population of organisms. The program should ask the user for the starting number of organisms, their average daily population increase (as a percentage, expressed as a fraction in decimal form: for example 0.052 would mean a 5.2% increase each day), and the number of days they will multiply. A loop should display the size of the population for each day.
Prompts, Output Labels and Messages .The three input data should be prompted for with the following prompts: "Enter the starting number organisms: ", "Enter the daily increase : ", and "Enter the number of days the organisms will multiply: " respectively. After the input has been read in successfully, a table is produced, for example:
Day Organisms
-----------------------------
1 200.0
2 300.0
3 450.0
4 675.0
Under the heading is a line of 29 dashes followed by one line for each day, showing the day number and the population at the beginning of that day.
Input Validation.Do not accept a number less than 2 for the starting size of the population. If the user fails to satisfy this print a line with this message "Invalid. Must be at least 2. Re-enter: " and try to read the value . Similarly, do not accept a negative number for average daily population increase , using the message "Invalid. Enter a non-negative number: " and retrying. Finally, do not accept a number less than 1 for the number of days they will multiply and use the message "Invalid. Enter 1 or more: ".
That is my code below:
import java.util.Scanner;
public class Population
{
public static void main(String[] args){
double organism;
int days;
double increase;
Scanner input = new Scanner(System.in);
System.out.print("Enter the starting number organisms: ");
organism = input.nextDouble();
while(organism < 2){
System.out.print("Invalid. Must be at least 2. Re-enter: ");
organism = input.nextDouble();
}
System.out.print("Enter the daily increase: ");
increase = input.nextDouble();
while(increase < 0){
System.out.print("Invalid. Enter a non-negative number: ");
increase = input.nextDouble();
}
System.out.print("Enter the number of days the organisms will multiply: ");
days = input.nextInt();
while(days < 1){
System.out.print("Invalid. Enter 1 or more: ");
days = input.nextInt();
}
System.out.println("Day Organisms");
System.out.println("-----------------------------");
System.out.println("1"+ " " +organism);
for( int i = 2; i <= days; i++){
organism = organism*(increase + 1);
System.out.print(i+" "+organism);
System.out.println();
}
}
}
The problem I am having is when I submit it online. The output my code produces after 20 days with 0.4 or 40% rate of increase and initial amount of 20 organisms is this:
Days Organisms
20&rarr&rarr11952.607917897816↵
What it wants is this:
20&rarr&rarr11952.607917897836↵
This may be unclear. It is how the errors are being shown using Myprogramminlab(a web application to submit homework).
&rarr means right arrow which is a tab and the number 11952 is the number of organisms, but it is being rounded differently.
Also, at 3 days:
Expected is 39.2 My Ouptut is 39.19999999999996
It is basically a small rounding issue. Please help
This is a really small fraction, and in the cases of populations I think it doesn't really matter. If It was up to me I would accept your solution without hesitation.
You can however reach a little more precision even if you use simple doubles, if you write your code like this:
double multiplication = 1;
for( int i = 1; i <= days; i++){
System.out.print(i+" "+organism*multiplication);
multiplication = multiplication * (increase + 1);
System.out.println();
}
Floating point types have the property that they have a bigger precision for number with a smaller absolute value. The value of multiplication will be significantly smaller then the value of organism, so the aggregated rounding (representation) error will also be smaller.
Thanks everyone. I tried what you suggested and it did make it more precise. However, the assignment was still being marked as incorrect. I tried this instead:
System.out.println("1"+ " " +organism);
for( int i = 2; i <= days; i++){
organism += organism*increase;
System.out.println(i+" "+organism);
}
For some reason that was okay. Thanks again though, I really appreciate the help!
This question already has answers here:
Adding and subtracting doubles are giving strange results [duplicate]
(2 answers)
Closed 9 years ago.
Does anyone have an idea where my output problem is?
I have written a Java program, and run it on VM on Mac lion with Eclipse.
Instead of getting 1.41, I got 1.4100000000000001 on my machine.
Example:
Enter the number of quarter: 4
Enter the number of dimes: 3
Enter the number of nickels: 2
Enter the number of pennies: 1
Total $1.4100000000000001
Example:
Enter the number of quarter: 3
Enter the number of dimes: 2
Enter the number of nickels: 1
Enter the number of pennies: 6
Total $1.06
Example:
Enter the number of quarter: 5
Enter the number of dimes: 7
Enter the number of nickels: 4
Enter the number of pennies: 4
Total $2.1900000000000004
It appears sometimes the outputs are correct while other times have an issue.
Code:
import java.util.*;
public class CountChange
{
public static void main(String[]args)
{
Scanner inputScanner = new Scanner(System.in);
System.out.print("Enter the number of quarters: ");
int quarters = inputScanner.nextInt();
System.out.print("Enter the number of dimes: ");
int dimes = inputScanner.nextInt();
System.out.print("Enter the number of nickles: ");
int nickles = inputScanner.nextInt();
System.out.print("Enter the number of pennies: ");
int pennies = inputScanner.nextInt();
inputScanner.close();
double total =0.00;
total = quarters * 0.25 + dimes * 0.1 + nickles * 0.05 + pennies * 0.01;
System.out.println("Total $" + total);
System.out.print("Thank you");
}
}
Your problem is related to how floating point (put easily, float/double related calculations) take place. Floating point numbers are an approximate reperesentation (if you are interested in the theory behind, the standard is IEEE754). Here you are getting exactly that, an approximate representation.
Since you are handling money, which goes only to cents (you cannot have 0.0001$ in currency), I suggest representing values with int (or long, or any integer type) values as cents. Then, divide by 100 when showing the result.
You have experienced the inexactness of representing floating-point numbers as doubles. The number 0.1 cannot be represented exactly in binary, so when you say 0.1 in Java, you get the closest possible approximation to 0.1. The same thing applies to 0.05 and 0.01.
There are a couple of things you can do:
Postpone floating-point arithmetic for as long as possible.
Example:
total = quarters * 25 + dimes * 10 + nickles * 5 + pennies;
total /= 100.0;
Use a DecimalFormat to cut off the display after two decimals.
Example:
DecimalFormat df = new DecimalFormat("0.00");
System.out.println("Total $" + df.format(total));
Neither of these workarounds gets around the basic issue - the inexact representation of a number by a double. Especially for amounts of money, don't use double. You could even use a BigDecimal instead, whose precision is arbitrary.
I agree with the explanations of why you are encountering this problem. My recommended solution for this sort of situation in Java is to use BigDecimal. It does exactly those calculations you would expect to be exact for short decimal fractions. For inexact calculations, it offers a good choice of rounding methods.
In effect, it does integer arithmetic with a scale factor, but automates storage and management of the scale.
Suppose you have one cent ($0.01) in a sock. Each day you double the amount of money you have in the sock. Thus on day one you have one cent, on day two you have two cents ($0.02), on day three you have four cents ($0.04), and so forth.
The doubleEachDay method takes a double value, jackpot, as its input argument, and calculates the number of days needed to reach or exceed the jackpot amount, starting at 0.01 and doubling each day. The method returns the number of days required for doubling; this value should be stored in the integer variable numDays.
Finish the doubleEachDay method below.
This is my code,
public int doubleEachDay(double jackpot) {
double amount = 0.01;
int numDays = 0;
while(amount <= jackpot){
amount=(amount*2);
numDays++;
}
return numDays;
}
My code keeps producing 1 more day than the actual answer. Thanks
The reason is that floating points are inaccurate. For instance, 0.01*2 may equal 0.0199999999 instead of 0.02.
Instead of using doubles, you should use an integer with the number of cents, so 1, 2, 4 and so on.
The other reason is that you wrote amount <= jackpot instead of amount < jackpot. This means that you'll count the day that amount == jackpot as one extra day.
Alternatively, instead of doing amount < jackpot, you can do something like jackpot - amount > 0.0000001 to counteract the slight amount of inaccuracy.
I assumed that you want to count the number of days that the amount is totally EQUAL to jackpot.
just change the loop condition into this:
while (amount != jackpot)...
Hi I'm having an issue while creating a change calculator for a school assignment. It essentially is to calculate the lowest amount of change needed for a certain amount of money.
Ex. $5.36:
2 toonies (2$)
1 loonie (1$)
1 quarter
1 dime
0 nickels
1 penny
I've stated all of my variable to be doubles so I can calculate the values and the totals together. It seems to work fine on whole numbers (5.00, 6.00, 7.00) but messes up whenever I add a decimal place. Like when I say $5.25 it should say 2 toonies 1 loonie and 1 quarter. I think it could be an error in rounding or something wrong with my calculations. Any Help is appreciated. Here is the calculations of the code:
//Rounding to one number
DecimalFormat oneDigit = new DecimalFormat ("#,0");
//Ask user for input
String moneyinput = JOptionPane.showInputDialog ("Welcome to the Change Caluculator. "
+ "Please Enter your amount of money in Dollars ($): ");
//Take user input and create into string.
totmoney = Double.parseDouble (moneyinput);
//Calculate number of toonies
numtoonies = (totmoney/toonieval);
System.out.println ("There is a total of " + oneDigit.format (numtoonies) + " toonies.");
//Find new amount
totmoney = (totmoney%toonieval);
//Calculate the number of loonies
numloonies = (totmoney/loonieval);
//Find new amount
totmoney = (totmoney-numloonies);
System.out.println ("There is a total of " + oneDigit.format (numloonies) + " loonies.");
//Calculate number of quarters
numquarters = (totmoney/quarterval);
//State the about of Coins
System.out.println ("There is a total of " + oneDigit.format (numquarters) + " quarters.");
}
I don't quite understand why you are using the DecimalFormat at all. You should be able to do solve this with only mod % and division /.
This is how I would approach this problem:
Take the input from the user (as a double in the format 5.33)
Save that as int by moving the decimal place (int value = cost * 100)
Find the number of toonies by using division (numToonies = value / toonieval)
Find the remaining amount of money by (value = value % toonieval)
Repeat steps 3 and 4 for the other denominations
Note: you will have to modify the values of the toonies to reflect the fact that the price you used was multiplied by 100.
I don't think this is working properly for floating point numbers:
totmoney = (totmoney%toonieval);
Try
totmoney = totmoney - toonieval*numtoonies;
instead.
Also, be aware that floating point values are generally not suitable for handling monetary values (because of the possiblity of rounding errors). Use fixed point decimals instead (basically, store the value in cents and calculate everyting on a cents base).
Do not use floating point numbers when you need absolute accuracy. The IEEE floating point specification which java follows even states that there will be a loss of precision because the floating point spec can not properly represent all floating point operations it can only approximate them. The solution for this is that you need to store the value in 2 ints, one for the amount left of the decimal and one for the value to the right of the decimal