im calling a function to help work out a second calculation but it complies but dosnt return correct answer
tired a few different things but breaks codes so more then likely completely wrong
9. This question involves writing two functions.
a. The interest on a loan is currently 2.4% (0.024). If you take a £9000
loan to day you will pay 9000 * 0.024 ( £216) for a year. Start by writing a
function called calculateInterest which takes the loanAmount
(which can be any number not just 9000) as a float and a second argument
interestRate (also float can be any faction) which is the interest rate
for the loan. It should return a float which is the Interest (£216 in the
example above).
b. When calculateInterest works write a function called HW2I. (I=capital i)
This takes 2 float arguments. The original loan amount (float) and years
(an int) which is the number of years the loan will operate over (say 35).
Each year the interest is calculated (via a call to the calculateInterest
function). Interest is then added to the loan amount. This value (loan+
interest) is the new loan amount. Write the function HW2I. Don’t forget to
test it yourself to make sure it works correctly. Here is the pseudo code.
To HW2I ( loan, intreastRate , years )
Repeat with year = 1 to years
adjustedLoan = loan + calculateInterest( loan , intreastRate )
loan = adjustedLoan
end repeat
return loan
public float calculateInterest(float loanAmount, float interestRate) {
float intrest;
intrest = loanAmount * interestRate;
return intrest;
}
public float HW2I(float loan, int years) {
for (int i = 0; i <= years; i = i++) {
loan = loan + calculateInterest(9000, 0.24);
}
return (loan);
}
I guess we go to the same university because I have the exact same question so here's the answer:
public float calculateInterest(float loanAmount, float interestRate) {
float interest = (loanAmount * interestRate);
{
return interest;
}
}
public float HW2I(float loanAmount, float interestRate, int years) {
for (int i = 0; i < years; i++) {
float newLoanAmount = loanAmount + calculateInterest(loanAmount, interestRate);
loanAmount = newLoanAmount;
}
return loanAmount;
}
Good luck!
For the explanation:
The first method only asks us to calculate the interest, which is done by multiplying the loanAmount and the interestRate together. After, we return the interest.
For the second function, the pseudo code shows us that we need 3 arguments, which are float loanAmount, float interestRate and int years. It also says "Repeat with year= 1 to years" meaning we need to use iteration, so we do the for(int i= 0; i< years; i++ part. If we look back at the question we need a newLoanAmount which is the first loanAmount + a call to the first method, which is calculateInterest(loanAmount, interestRate). Now the loanAmount becomes the newLoanAmount, kind of replacing the value of the loanAmount before. Because the value has changed, we need to return loanAmount.
I hope this helps further and apologises if it isn't a great explanation; I started learning Java 2 months ago.
I made a code to calculate the monthly mortgage payment. Here is part of my code->
public static void printAmortizationSchedule(double principal, double annualInterestRate,
int numYears) {
double interestPaid, principalPaid, newBalance;
double monthlyInterestRate, monthlyPayment;
int month;
int numMonths = numYears * 12;
monthlyInterestRate = annualInterestRate / 12;
monthlyPayment = monthlyPayment(principal, monthlyInterestRate, numYears);
System.out.format("Your monthly Payment is: %8.2f%n", monthlyPayment);
for (month = 1; month <= numMonths; month++) {
// Compute amount paid and new balance for each payment period
interestPaid = principal * (monthlyInterestRate / 100);
principalPaid = monthlyPayment - interestPaid;
newBalance = principal - principalPaid;
// Update the balance
principal = newBalance;
}
}
static double monthlyPayment(double loanAmount, double monthlyInterestRate, int numberOfYears) {
monthlyInterestRate /= 100;
return loanAmount * monthlyInterestRate /
( 1 - 1 / Math.pow(1 + monthlyInterestRate, numberOfYears * 12) );
}
now, I need to add code that
1.The principal amount must be a non-negative number.
The mortgage payment will be determined by one of these amounts:
• 1 year 3.5%
• 2 year 3.9%
• 3 year 4.4%
• 5 year 5.0%
• 10 year 6.0%
I think I need to use do while statement, or if else code. However, I'm struggling to find where to put. Please help me!
In both cases you're dealing with a condition:
if the principal amount is negative, then don't perform the calculation, otherwise, proceed with the calculation.
if the mortgage is for n years then use r rate.
Hence, you'd use the if-then-else construct.
For the principle amount, check it early; It doesn't make sense to perform computations only to throw it all away because they are invalid. You can throw an exception to indicate the invalid input, a negative principal.
For the rate you just need to make sure you select the right one (with if-then-else) before you use it.
I'm taking a course in Java and we haven't officially learned if statements yet. I was studying and saw this question:
Write a method called pay that accepts two parameters: a real number for a TA's salary, and an integer for the number hours the TA worked this week. The method should return how much money to pay the TA. For example, the call pay(5.50, 6) should return 33.0. The TA should receive "overtime" pay of 1.5 times the normal salary for any hours above 8. For example, the call pay(4.00, 11) should return (4.00 * 8) + (6.00 * 3) or 50.0.
How do you solve this without using if statements? So far I've got this but I'm stuck on regular pay:
public static double pay (double salary, int hours) {
double pay = 0;
for (int i = hours; i > 8; i --) {
pay += (salary * 1.5);
}
}
To avoid direct use of flow control statements like if or while you can use Math.min and Math.max. For this particular problem using a loop would not be efficient either.
They may technically use an if statements or the equivalent, but so do a lot of your other standard library calls you already make:
public static double pay (double salary, int hours) {
int hoursWorkedRegularTime = Math.min(8, hours);
int hoursWorkedOverTime = Math.max(0, hours - 8);
return (hoursWorkedRegularTime * salary) +
(hoursWorkedOverTime * (salary * 1.5));
}
Since you've used a for loop, here's a solution just using two for loops.
public static double pay (double salary, int hours) {
double pay = 0;
for (int i = 0; i < hours && i < 8; i++) {
pay += salary;
}
for (int i = 8; i < hours; i++) {
pay += (salary * 1.5);
}
return pay;
}
This sums the salary for the regular hours up to 8, and then sums the salary for the overtime hours, where the overtime hours are paid at 1.5 * salary.
If there are no overtime hours, the second for loop will not be entered and will have no effect.
There's a few ways you can go about this, but it's hard to know what's allowed (if you can't even use if).
I would recommend using a while loop:
double pay = 0;
while (hoursWorked > 8) {
pay += (salary * 1.5);
hoursWorked--;
}
pay += (hoursWorked * salary);
The reason why this works is it decrements your hoursWorked to a value that is guaranteed to be less than or equal to 8 (assuming hoursWorked and salary are both greater than 0). If hoursWorked <= 8, then it will never enter the while loop.
If you really want to get hacky, you could use bitwise operators:
int otherHours = hours - 8;
int multiplier = (~otherHours & 0x80000000) >>> 31;
otherHours *= multiplier;
return otherHours * 0.5 * salary + hours * salary;
So basically, if otherHours is negative, there should be no overpay. We do this by selecting the sign bit of otherHours and shifting it to the least significant bit (with 0 padding) to mean either 1 or 0. After first negating it (if sign bit is 1, multiplier should be 0).
When you multiply this with otherHours it will be 0 in the case there are less than 8 hours, so as not to accidentally subtract any pay, when doing the final calculation.
Just for the record, here is a solution quite close to where you were stopped :
public static double pay (double salary, int hours) {
double pay = salary * hours;
for (int i = hours; i > 8; i --) {
pay += salary * 0.5;
}
}
You can simply use a ternary operator ?::
pay = hours*salary + ((hours > 8) ? (hours-8)*salary*0.5 : 0);
— pay a standard salary for the whole time worked, plus 50% for time above 8 hours (if any).
A cast to int can be abused for this purpose.
Note that the function
f(x) = 10/9 - 1/(x+1) = 1 + 1/9 - 1/(x+1)
is between 0 and 1 (exclusive) for 0 <= x < 8 and between 1 and 1.2 for x >= 8. Casting this value to int results 0 for x < 8 and in 1 for x >= 8.
This can be used in the calculation of the result:
public static double pay(double salary, int hours) {
int overtime = (int)(10d/9d - 1d/(hours+1));
return salary * (hours + 0.5 * overtime * (hours - 8));
}
Here's a way to do it using truncation from integer division, something that you probably have learnt at the start of java courses. Essentially the solution is a one liner that does not need if, loops, comparisons, libraries.
public static double pay(double salary, int hours) {
//Pay all hours as overtime, and then subtract the extra from the first 8 hours
double p1 = (hours * 1.5 * salary) - (4 * salary);
//In the case where the TA works for less than 8 hours,
//subtract all the extra so that ultimately, pay = salary * hours
double p2 = (hours * 0.5 * salary) - (4 * salary);
//When theres no overtime worked, m equals to 1.
//When there are overtime hours, m is equals to 0.
int m = (8 + 7) / (hours + 7);
//When there are overtime hours, pay is simply equal to p1.
//When there are no overtime hours, p2 is subtracted from p1.
return p1 - m*p2;
}
A solution which does not use any conditional(implicit or explicit)
Practically, you need to calculate hours * rate but if you have overtime then you need to add a bonus of the form overtime_hours * overtime_rate
in pseudo-code:
//you need to return:
hours * rate + is_overtime * overtime_time * overtime_rate
where
is_overtime = ceiling ( x / (x+1)) # this will be zero when x == 0, in rest 1
x = integer_division(hours, 8) # x == 0 if no overtime, in rest a positive integer
overtime_time = hours - 8
overtime_rate = (1.5 - 1) * rate = 0.5 * rate
(((hours/8)-1)*8 + hours%8)*salary*0.5 + (hours*salary)
overtime*salary*0.5 + (hours*salary)
((( 11/8 -1)*8 + 11%8)* 4*0.5 + ( 11* 4) = 50
(( 1 -1)*8 + 3)* 2 + 44 = 50
(( 0)*8 + 3)* 2 + 44 = 50
(( 0 + 3)* 2 + 44 = 50
6 + 44 = 50
So suppose we have (17 hours, 4 salary)
(((17/8)-1)*8 + 17%8)*4*0.5 + 17*4 = 86
( (2 -1)*8 + 1)*4*0.5 + 68 = 86
(8 + 1)*2 + 68 = 86
9*2 + 68 = 86
18 + 68 = 86
17-8=9 is overtime
9*4*1.5 + 8*4 = 9*6 + 32 = 54 + 32 = 86
You could creatively use a while statement as an if statement
while(hours > 8){
return ((hours - 8) * salary * 1.5) + (8 * salary);
}
return hours * salary;
Plenty of good and more efficient answers already, but here's another simple option using a while loop and the ternary operator:
double pay = 0.0;
while(hours > 0){
pay += hours > 8 ? wage * 1.5 : wage;
hours--;
}
return pay;
Using tanh to decide whether the hours are below 8 or not:
public static double pay (double salary, int hours) {
int decider = (int)(tanh(hours - 8) / 2 + 1);
double overtimeCompensation = 1.5;
double result = salary * (hours * (1 - decider) + (8 + (hours - 8) * overtimeCompensation) * decider);
return result;
}
The decider variable is 0 when hours is less than 8, otherwise 1. The equation basically contains two parts: the first hours * (1 - decider) would be for hours < 8, and (8 + (hours - 8) * overtimeCompensation) * decider for when hours >= 8. If hours < 8, then 1 - decider is 1 and decider is 0, so using the equations first part. And if hours >= 8, 1 - decider is 0 and decider is 1, so the opposite happens, the first part of the equation is 0 and the second is multiplied by 1.
public static double pay (double salary, int hours) {
int extra_hours = hours - 8;
extra_hours = extra_hours > 0 ? extra_hours : 0;
double extra_salary = (salary * 1.5) * extra_hours;
double normal_salary = extra_hours > 0 ? salary * 8 : salary * hours;
return normal_salary + extra_salary;
}
You can use ternary operator.
public static double pay(double salary, int hours){
//get the salary and hours
return hours>8?(1.5*hours-4)*salary:hours*salary;
}
Some programming languages have explicit pattern-matching features. So for example, in XSLT, a given template will fire if the node being processed matches a given XPATH query better than other templates in your programme.
This kind of "declarative" programming is a level of abstraction higher than what you have in Java, but you still have the switch statement, which gives you the ability to control your flow with a "matching" approach rather than using explicit if-else constructs.
public static double pay (double salary, int hours) {
double pay = 0;
for (int i = hours; i > 0;i--){
switch (i){
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
pay += (salary);
break;
default:
pay += (salary * 1.5);
break;
}
}
return pay;
}
Having said that, for your specific example, what you really do need is an if statement. The switch approach will work, but it's a bit contrived.
In Tsql
DECLARE #amount float = 4.00
, #hrs int = 11
DECLARE #overtime int
, #overeight bit
SET #overeight = ((#hrs/8) ^ 1)
SET #overtime = CEILING((#hrs%8) / ((#hrs%8) + 1.0)) * ~#overeight
--SELECT #hrs * #amount
SELECT ((#hrs-(#hrs%8 * ~#overeight)) * #amount) + ( #overtime * (#hrs%8 * (#amount * 1.5)))
(from Valentin above)
I am currently trying to develop a compound interest calculator that includes monthly contributions. I have successfully been able to get the compound interest calculation working without the monthly contributions using the following line of code, but cannot figure out what the formula should be when adding monthly contributions.
double calculatedValue = (principalValue * Math.pow(1 + (interestRateValue/numberOfCompoundsValue), (termValue * numberOfCompoundsValue)));
When trying to get the calculated value with contributions I changed the way this is done. See the following code how I approached this.
//The starting principal
double principalValue = 5000;
//Interest rate (%)
double interestRateValue = 0.05;
//How many times a year to add interest
int numberOfCompoundsValue = 4;
//The number of years used for the calculation
double termValue = 30;
//The monthly contribution amount
double monthlyContributionsValue = 400;
//How often interest is added. E.g. Every 3 months if adding interest 4 times in a year
int interestAddedEveryXMonths = 12/numberOfCompoundsValue;
//The total number of months for the calculation
int totalNumberOfMonths = (int)(12 * termValue);
for(int i = 1; i <= totalNumberOfMonths; i++)
{
principalValue += monthlyContributionsValue;
if(i % interestAddedEveryXMonths == 0)
{
principalValue += (principalValue * interestRateValue);
}
}
I figured this should do what I am after. Every month increase the principal by the contribution amount and if that month equals a month where interest should be added then calculate the interest * the interest rate and add that to the principal.
When using the values above I expect the answer $355,242.18 but get $10511941.97, which looks better in my bank account but not in my calculation.
If anyone can offer me some help or point out where I have gone wrong that would be much appreciated.
Thanks in advance
Your problem is here:
principalValue += (principalValue * interestRateValue);
You're adding a full year's interest every quarter, when you should be adding just a quarter's interest. You need to scale that interest rate down to get the right rate.
Here's an example:
class CashFlow {
private final double initialDeposit;
private final double rate;
private final int years;
private final double monthlyContribution;
private final int interestFrequency;
CashFlow(double initialDeposit, double rate, int years,
double monthlyContribution, int interestFrequency) {
if ( years < 1 ) {
throw new IllegalArgumentException("years must be at least 1");
}
if ( rate <= 0 ) {
throw new IllegalArgumentException("rate must be positive");
}
if ( 12 % interestFrequency != 0 ) {
throw new IllegalArgumentException("frequency must divide 12");
}
this.initialDeposit = initialDeposit;
this.rate = rate;
this.years = years;
this.monthlyContribution = monthlyContribution;
this.interestFrequency = interestFrequency;
}
public double terminalValue() {
final int interestPeriod = 12 / interestFrequency;
final double pRate = Math.pow(1 + rate, 1.0 / interestPeriod) - 1;
double value = initialDeposit;
for ( int i = 0; i < years * 12; ++i ) {
value += monthlyContribution;
if ( i % interestFrequency == interestFrequency - 1 ) {
value *= 1 + pRate;
}
}
return value;
}
}
class CompoundCalc {
public static void main(String[] args) {
CashFlow cf = new CashFlow(5000, 0.05, 30, 400, 3);
System.out.println("Terminal value: " + cf.terminalValue());
}
}
with output:
run:
Terminal value: 350421.2302849443
BUILD SUCCESSFUL (total time: 0 seconds)
which is close to the $355k value you found.
There are a number of different conventions you could use to get the quarterly rate. Dividing the annual rate by 4 is a simple and practical one, but the pow(1 + rate, 1 / 4) - 1 method above is more theoretically sound, since it's mathematically equivalent to the corresponding annual rate.
After some brief testing I've come to the conclusion that either you have:
miscalculated the value you want ($355,242.18)
OR
incorrectly asked your question
The calculation you've described that you want ($5000 start + $400 monthly contributions for 30 years + interest every 3 months) is found by the code you've provided. The value that it gives ($10,511,941.97) is indeed correct from what I can see. The only other suggestions I can offer are to only use double if you need to (for example termValue can be an int) AND when ever you know the value is not going to change (for example interestRateValue) use final. It will help avoid any unforeseen error in larger programs. I hope this helps you figure out your interest calculator or answers any questions you have.
static void Main(string[] args)
{
double monthlyDeposit;
double rateOfInterest;
double numberOfCompounds;
double years;
double futureValue = 0;
double totalAmount = 0;
Console.WriteLine("Compound Interest Calculation based on monthly deposits");
Console.WriteLine("Monthly Deposit");
monthlyDeposit = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Rate Of Interest");
rateOfInterest = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Number of Compounds in a year");
numberOfCompounds = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Number of year");
years = Convert.ToDouble(Console.ReadLine());
futureValue = monthlyDeposit;
for (int i = 1; i <= years * 12; i++)
{
totalAmount = futureValue * (1 + (rateOfInterest / 100) / 12);
if (i == years * 12)
futureValue = totalAmount;
else
futureValue = totalAmount + monthlyDeposit;
}
Console.WriteLine("Future Value is=" + futureValue);
Console.ReadLine();
}
//Output
Compound Interest Calculation based on monthly Deposits
Monthly Deposit
1500
Rate Of Interest
7.5
Number of Compounds in a year
12
Number of year
1
Future Value is=18748.2726237313
Hi basically I need to write a method to calculate the price of Shirts The first 10 Shirts ordered are charged at $20 per Shirt and then any shirt after are charged at $15 per Shirt. Would any one be able to help me work this out this is what I have so far thanks.
public static double calculateCost(int ShirtsOrdered) {
double cost = 0.0;
if (ShirtsOrdered <= 10) {
cost = cost + 20.00 * ((ShirtsOrdered) / 1);
} else if ((ShirtsOrdered > 10) {
cost = cost + 15.00 * ((ShirtsOrdered) / 1);
return cost;
}
The shortest solution would be:
public static double calculateCost(int ShirtsOrdered) {
if (ShirtsOrdered > 10){
return 200.0 + (ShirtsOrdered - 10) * 15.0;
}
return ShirtsOrdered * 20.0;
}
You must count how many shirts after 10
public static double calculateCost(int ShirtsOrdered) {
double cost = 0.0;
if (ShirtsOrdered <= 10) {
cost = cost + 20.00 * ((ShirtsOrdered) / 1);
} else if ((ShirtsOrdered > 10) {
cost = cost + 20.00 * (10 / 1);//<-- here the cost for 10 first shirt
cost = cost + 15.00 * ((ShirtsOrdered-10) / 1); //<-- here make the count
return cost;
}