Skip to content
Snippets Groups Projects
Commit 224b17ff authored by Dao's avatar Dao
Browse files

fix(calculator): support negative exponent.

parent dd41821b
No related branches found
No related tags found
No related merge requests found
class Calculator {
private int result;
private double result;
public Calculator() {
reset();
......@@ -9,62 +9,106 @@ class Calculator {
this.result = 0;
}
public int getResult() {
public double getResult() {
return this.result;
}
public void add(int value) {
public void add(double value) {
this.result += value;
}
public void subtract(int value) {
public void subtract(double value) {
this.result -= value;
}
public void multiply(int value) {
// Multiply with zero.
if (0 == value) {
public void multiply(double value) {
// Multiply with zero, the result is zero.
if (0 == value || 0 == this.result) {
this.result = 0;
return;
}
int currentResult = this.result;
int currentAbsoluteResult = getAbsoluteValue(currentResult);
int absoluteValue = getAbsoluteValue(value);
// Multiply with one, nothing to do.
if (1 == value) {
return;
}
double currentResult = this.result;
double currentAbsoluteResult = getAbsoluteValue(currentResult);
double absoluteValue = getAbsoluteValue(value);
boolean isSameSigns = (value > 0 && currentResult > 0) || (value < 0 && currentResult < 0);
// Multiply of positive numbers, the result will be positive.
this.result = currentAbsoluteResult;
multiplyByPositiveNumber(absoluteValue);
for (int i = 1; i < absoluteValue; i++) {
add(currentAbsoluteResult);
// Different signs, so the result is negative.
if (!isSameSigns) {
this.result = -this.result;
}
}
boolean isPositiveNumberMultiplyWithNegativeNumber = (value > 0 && currentResult < 0)
|| (value < 0 && currentResult > 0);
public void exponent(int value) {
// Zero exponent.
if (0 == value) {
this.result = 1;
if (isPositiveNumberMultiplyWithNegativeNumber) {
this.result = -this.result;
return;
}
// Current result is zero.
if (0 == this.result) {
if (value > 0) {
this.result = 0;
return;
} else {
throw new ArithmeticException("Not finite");
}
}
public void exponent(int value) {
if (value < 0) {
throw new RuntimeException("Does not support.");
// One rule.
if (1 == value || 1 == this.result) {
return;
}
// Zero exponent
if (0 == value) {
// Minus one rule.
if (-1 == this.result) {
if (0 == value % 2) {
this.result = 1;
}
int currentResult = this.result;
return;
}
// Power of positive number first.
double absoluteValue = getAbsoluteValue(value);
raiseToThePowerOfPositiveNumber(absoluteValue);
// Negative exponent.
if (value < 0) {
this.result = 1 / this.result;
}
}
private void multiplyByPositiveNumber(double value) {
double currentResult = this.result;
for (int i = 1; i < value; i++) {
add(currentResult);
}
}
private void raiseToThePowerOfPositiveNumber(double value) {
double currentResult = this.result;
for (int i = 1; i < value; i++) {
multiply(currentResult);
}
}
private int getAbsoluteValue(int value) {
private double getAbsoluteValue(double value) {
if (value < 0) {
value = -value;
}
......
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import static org.junit.jupiter.api.Assertions.*;
class CalculatorTest {
......@@ -41,146 +43,234 @@ class CalculatorTest {
assertEquals(4, calculator.getResult());
}
@Test
void multiplyPositiveNumberWithNegativeNumber() {
Calculator calculator = new Calculator();
calculator.add(10);
calculator.multiply(-2);
assertEquals(-20, calculator.getResult());
void multiply() {
for (ArrayList<Double> args : getMultiplyData()) {
multiply(args.get(0), args.get(1), args.get(2));
}
@Test
void multiplyPositiveNumberWithPositiveNumber() {
Calculator calculator = new Calculator();
calculator.add(10);
calculator.multiply(2);
assertEquals(20, calculator.getResult());
}
@Test
void multiplyNegativeNumberWithNegativeNumber() {
Calculator calculator = new Calculator();
calculator.add(-10);
calculator.multiply(-2);
assertEquals(20, calculator.getResult());
void exponent() {
for (ArrayList<Double> args : getExponentData()) {
exponent(args.get(0), args.get(1).intValue(), args.get(2));
}
@Test
void multiplyNegativeNumberWithZero() {
Calculator calculator = new Calculator();
calculator.add(-10);
calculator.multiply(0);
assertEquals(0, calculator.getResult());
}
@Test
void multiplyPositiveNumberWithZero() {
private void multiply(double factor1, double factor2, double result) {
Calculator calculator = new Calculator();
calculator.add(10);
calculator.multiply(0);
calculator.add(factor1);
calculator.multiply(factor2);
assertEquals(0, calculator.getResult());
assertEquals(result, calculator.getResult());
}
@Test
void multiplyNegativeNumberWithOne() {
private void exponent(double base, int exponent, double result) {
Calculator calculator = new Calculator();
calculator.add(-10);
calculator.multiply(1);
calculator.add(base);
calculator.exponent(exponent);
assertEquals(-10, calculator.getResult());
assertEquals(result, calculator.getResult());
}
@Test
void multiplyPositiveNumberWithOne() {
Calculator calculator = new Calculator();
calculator.add(10);
calculator.multiply(1);
private ArrayList<ArrayList<Double>> getMultiplyData() {
ArrayList<ArrayList<Double>> data = new ArrayList<ArrayList<Double>>();
assertEquals(10, calculator.getResult());
}
ArrayList<Double> positiveNumberByNegativeNumber = new ArrayList<Double>();
positiveNumberByNegativeNumber.add(10.0);
positiveNumberByNegativeNumber.add(-2.0);
positiveNumberByNegativeNumber.add(-20.0);
data.add(positiveNumberByNegativeNumber);
@Test
void multiplyNegativeNumberWithMinusOne() {
Calculator calculator = new Calculator();
calculator.add(-10);
calculator.multiply(-1);
ArrayList<Double> positiveNumberByPositiveNumber = new ArrayList<Double>();
positiveNumberByPositiveNumber.add(10.0);
positiveNumberByPositiveNumber.add(2.0);
positiveNumberByPositiveNumber.add(20.0);
data.add(positiveNumberByPositiveNumber);
assertEquals(10, calculator.getResult());
}
@Test
void multiplyPositiveNumberWithMinusOne() {
Calculator calculator = new Calculator();
calculator.add(10);
calculator.multiply(-1);
assertEquals(-10, calculator.getResult());
}
@Test
void exponentPositiveNumberWithPositiveNumber() {
Calculator calculator = new Calculator();
calculator.add(2);
calculator.exponent(3);
ArrayList<Double> negativeNumberByNegativeNumber = new ArrayList<Double>();
negativeNumberByNegativeNumber.add(-10.0);
negativeNumberByNegativeNumber.add(-2.0);
negativeNumberByNegativeNumber.add(20.0);
data.add(negativeNumberByNegativeNumber);
assertEquals(8, calculator.getResult());
}
@Test
void exponentPositiveNumberWithOne() {
Calculator calculator = new Calculator();
calculator.add(2);
calculator.exponent(1);
ArrayList<Double> negativeNumberByZero = new ArrayList<Double>();
negativeNumberByZero.add(-10.0);
negativeNumberByZero.add(0.0);
negativeNumberByZero.add(0.0);
data.add(negativeNumberByZero);
assertEquals(2, calculator.getResult());
}
@Test
void exponentPositiveNumberWithZero() {
Calculator calculator = new Calculator();
calculator.add(2);
calculator.exponent(0);
ArrayList<Double> positiveNumberByZero = new ArrayList<Double>();
positiveNumberByZero.add(10.0);
positiveNumberByZero.add(0.0);
positiveNumberByZero.add(0.0);
data.add(positiveNumberByZero);
assertEquals(1, calculator.getResult());
}
@Test
void exponentNegativeNumberWithPositiveNumber() {
Calculator calculator = new Calculator();
calculator.add(-2);
calculator.exponent(3);
ArrayList<Double> negativeNumberByOne = new ArrayList<Double>();
negativeNumberByOne.add(-10.0);
negativeNumberByOne.add(1.0);
negativeNumberByOne.add(-10.0);
data.add(negativeNumberByOne);
assertEquals(-8, calculator.getResult());
}
ArrayList<Double> positiveNumberByOne = new ArrayList<Double>();
positiveNumberByOne.add(10.0);
positiveNumberByOne.add(1.0);
positiveNumberByOne.add(10.0);
data.add(positiveNumberByOne);
@Test
void exponentNegativeNumberWithOne() {
Calculator calculator = new Calculator();
calculator.add(-2);
calculator.exponent(1);
assertEquals(-2, calculator.getResult());
}
ArrayList<Double> negativeNumberByMinusOne = new ArrayList<Double>();
negativeNumberByMinusOne.add(-10.0);
negativeNumberByMinusOne.add(-1.0);
negativeNumberByMinusOne.add(10.0);
data.add(negativeNumberByMinusOne);
@Test
void exponentNegativeNumberWithZero() {
Calculator calculator = new Calculator();
calculator.add(-2);
calculator.exponent(0);
ArrayList<Double> positiveNumberByMinusOne = new ArrayList<Double>();
positiveNumberByMinusOne.add(10.0);
positiveNumberByMinusOne.add(-1.0);
positiveNumberByMinusOne.add(-10.0);
data.add(positiveNumberByMinusOne);
assertEquals(1, calculator.getResult());
return data;
}
@Test
void exponentNumberWithNegativeNumber() {
Calculator calculator = new Calculator();
calculator.add(2);
assertThrows(RuntimeException.class, () -> {calculator.exponent(-1);});
private ArrayList<ArrayList<Double>> getExponentData() {
ArrayList<ArrayList<Double>> data = new ArrayList<ArrayList<Double>>();
ArrayList<Double> zeroExponentPositiveBase = new ArrayList<Double>();
zeroExponentPositiveBase.add(10.0);
zeroExponentPositiveBase.add(0.0);
zeroExponentPositiveBase.add(1.0);
data.add(zeroExponentPositiveBase);
ArrayList<Double> zeroExponentNegativeBase = new ArrayList<Double>();
zeroExponentNegativeBase.add(-10.0);
zeroExponentNegativeBase.add(0.0);
zeroExponentNegativeBase.add(1.0);
data.add(zeroExponentNegativeBase);
ArrayList<Double> zeroBasePositiveExponent = new ArrayList<Double>();
zeroBasePositiveExponent.add(0.0);
zeroBasePositiveExponent.add(2.0);
zeroBasePositiveExponent.add(0.0);
data.add(zeroBasePositiveExponent);
ArrayList<Double> oneExponentPositiveBase = new ArrayList<Double>();
oneExponentPositiveBase.add(10.0);
oneExponentPositiveBase.add(1.0);
oneExponentPositiveBase.add(10.0);
data.add(oneExponentPositiveBase);
ArrayList<Double> oneExponentNegativeBase = new ArrayList<Double>();
oneExponentNegativeBase.add(-10.0);
oneExponentNegativeBase.add(1.0);
oneExponentNegativeBase.add(-10.0);
data.add(oneExponentNegativeBase);
ArrayList<Double> oneBasePositiveExponent = new ArrayList<Double>();
oneBasePositiveExponent.add(1.0);
oneBasePositiveExponent.add(2.0);
oneBasePositiveExponent.add(1.0);
data.add(oneBasePositiveExponent);
ArrayList<Double> oneBaseNegativeExponent = new ArrayList<Double>();
oneBaseNegativeExponent.add(1.0);
oneBaseNegativeExponent.add(-2.0);
oneBaseNegativeExponent.add(1.0);
data.add(oneBaseNegativeExponent);
ArrayList<Double> minusOneBasePositiveEvenExponent = new ArrayList<Double>();
minusOneBasePositiveEvenExponent.add(-1.0);
minusOneBasePositiveEvenExponent.add(2.0);
minusOneBasePositiveEvenExponent.add(1.0);
data.add(minusOneBasePositiveEvenExponent);
ArrayList<Double> minusOneBasePositiveOddExponent = new ArrayList<Double>();
minusOneBasePositiveOddExponent.add(-1.0);
minusOneBasePositiveOddExponent.add(3.0);
minusOneBasePositiveOddExponent.add(-1.0);
data.add(minusOneBasePositiveOddExponent);
ArrayList<Double> minusOneBaseNegativeEvenExponent = new ArrayList<Double>();
minusOneBaseNegativeEvenExponent.add(-1.0);
minusOneBaseNegativeEvenExponent.add(-2.0);
minusOneBaseNegativeEvenExponent.add(1.0);
data.add(minusOneBaseNegativeEvenExponent);
ArrayList<Double> minusOneBaseNegativeOddExponent = new ArrayList<Double>();
minusOneBaseNegativeOddExponent.add(-1.0);
minusOneBaseNegativeOddExponent.add(-3.0);
minusOneBaseNegativeOddExponent.add(-1.0);
data.add(minusOneBaseNegativeOddExponent);
ArrayList<Double> minusOneExponentPositiveBase = new ArrayList<Double>();
minusOneExponentPositiveBase.add(2.0);
minusOneExponentPositiveBase.add(-1.0);
minusOneExponentPositiveBase.add(0.5);
data.add(minusOneExponentPositiveBase);
ArrayList<Double> minusOneExponentNegativeBase = new ArrayList<Double>();
minusOneExponentNegativeBase.add(-2.0);
minusOneExponentNegativeBase.add(-1.0);
minusOneExponentNegativeBase.add(-0.5);
data.add(minusOneExponentNegativeBase);
ArrayList<Double> positiveBasePositiveOddExponent = new ArrayList<Double>();
positiveBasePositiveOddExponent.add(2.0);
positiveBasePositiveOddExponent.add(3.0);
positiveBasePositiveOddExponent.add(8.0);
data.add(positiveBasePositiveOddExponent);
ArrayList<Double> positiveBasePositiveEvenExponent = new ArrayList<Double>();
positiveBasePositiveEvenExponent.add(2.0);
positiveBasePositiveEvenExponent.add(2.0);
positiveBasePositiveEvenExponent.add(4.0);
data.add(positiveBasePositiveEvenExponent);
ArrayList<Double> positiveBaseNegativeOddExponent = new ArrayList<Double>();
positiveBaseNegativeOddExponent.add(2.0);
positiveBaseNegativeOddExponent.add(-3.0);
positiveBaseNegativeOddExponent.add(0.125);
data.add(positiveBaseNegativeOddExponent);
ArrayList<Double> positiveBaseNegativeEvenExponent = new ArrayList<Double>();
positiveBaseNegativeEvenExponent.add(2.0);
positiveBaseNegativeEvenExponent.add(-2.0);
positiveBaseNegativeEvenExponent.add(0.25);
data.add(positiveBaseNegativeEvenExponent);
ArrayList<Double> negativeBasePositiveOddExponent = new ArrayList<Double>();
negativeBasePositiveOddExponent.add(-2.0);
negativeBasePositiveOddExponent.add(3.0);
negativeBasePositiveOddExponent.add(-8.0);
data.add(negativeBasePositiveOddExponent);
ArrayList<Double> negativeBasePositiveEvenExponent = new ArrayList<Double>();
negativeBasePositiveEvenExponent.add(-2.0);
negativeBasePositiveEvenExponent.add(2.0);
negativeBasePositiveEvenExponent.add(4.0);
data.add(negativeBasePositiveEvenExponent);
ArrayList<Double> negativeBaseNegativeOddExponent = new ArrayList<Double>();
negativeBaseNegativeOddExponent.add(-2.0);
negativeBaseNegativeOddExponent.add(-3.0);
negativeBaseNegativeOddExponent.add(-0.125);
data.add(negativeBaseNegativeOddExponent);
ArrayList<Double> negativeBaseNegativeEvenExponent = new ArrayList<Double>();
negativeBaseNegativeEvenExponent.add(-2.0);
negativeBaseNegativeEvenExponent.add(-2.0);
negativeBaseNegativeEvenExponent.add(0.25);
data.add(negativeBaseNegativeEvenExponent);
return data;
}
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment