diff --git a/.classpath b/.classpath new file mode 100644 index 0000000..a1e012d --- /dev/null +++ b/.classpath @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/.idea/ant.xml b/.idea/ant.xml new file mode 100644 index 0000000..a2a4769 --- /dev/null +++ b/.idea/ant.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..a818314 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..3ec88eb --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/uiDesigner.xml b/.idea/uiDesigner.xml new file mode 100644 index 0000000..2b63946 --- /dev/null +++ b/.idea/uiDesigner.xml @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..35eb1dd --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.project b/.project new file mode 100644 index 0000000..09c2492 --- /dev/null +++ b/.project @@ -0,0 +1,15 @@ + + + Simple-Java-Calculator(2) + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.jdt.core.javanature + + \ No newline at end of file diff --git a/Simple-Java-Calculator(2).eml b/Simple-Java-Calculator(2).eml new file mode 100644 index 0000000..99cef88 --- /dev/null +++ b/Simple-Java-Calculator(2).eml @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/Simple-Java-Calculator(2).iml b/Simple-Java-Calculator(2).iml new file mode 100644 index 0000000..a1bb186 --- /dev/null +++ b/Simple-Java-Calculator(2).iml @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/simplejavacalculator/Calculator.java b/src/simplejavacalculator/Calculator.java index f76e879..8a13fed 100644 --- a/src/simplejavacalculator/Calculator.java +++ b/src/simplejavacalculator/Calculator.java @@ -12,18 +12,16 @@ package simplejavacalculator; import static java.lang.Double.NaN; -import static java.lang.Math.log; -import static java.lang.Math.log10; -import static java.lang.Math.pow; +import static java.lang.Math.*; public class Calculator { public enum BiOperatorModes { - normal, add, minus, multiply, divide , xpowerofy + normal, add, minus, multiply, divide , xpowerofy , mod } public enum MonoOperatorModes { - square, squareRoot, oneDividedBy, cos, sin, tan, log, rate, abs, ln, + square, squareRoot, oneDividedBy, cos, sin, tan, log, rate, abs, ln, fact, exp } private Double num1, num2; @@ -52,6 +50,13 @@ private Double calculateBiImpl() { if (mode == BiOperatorModes.xpowerofy) { return pow(num1,num2); } + if (mode==BiOperatorModes.mod){ + if(floor(num1) == num1 && floor(num2)==num2) { + return num1%num2; + } else { + return NaN; + } + } // never reach throw new Error(); @@ -75,6 +80,20 @@ public Double calculateEqual(Double num) { return calculateBi(BiOperatorModes.normal, num); } + public Double calculateFact(Double num){ + int i; + double fact=1; + if (num==1){ + return 1.0; + } + else{ + for (i=1; i<=floor(num); i++){ + fact=fact*i; + } + return fact; + } + } + public Double reset() { num2 = 0.0; num1 = 0.0; @@ -83,7 +102,7 @@ public Double reset() { return NaN; } - + public Double calculateMono(MonoOperatorModes newMode, Double num) { if (newMode == MonoOperatorModes.square) { return num * num; @@ -117,12 +136,25 @@ public Double calculateMono(MonoOperatorModes newMode, Double num) { return log(num); } if (newMode == MonoOperatorModes.rate) { - return num / 100; + return num / 100; } if (newMode == MonoOperatorModes.abs){ return Math.abs(num); } + if (newMode == MonoOperatorModes.fact) { + if (num==floor(num) && num>0) { + return calculateFact(num); + } + else { + return NaN; + } + } + + if (newMode == MonoOperatorModes.exp){ + return Math.exp(num); + } + // never reach throw new Error(); } diff --git a/src/simplejavacalculator/UI.java b/src/simplejavacalculator/UI.java index 087bfb1..ca351b8 100644 --- a/src/simplejavacalculator/UI.java +++ b/src/simplejavacalculator/UI.java @@ -31,13 +31,15 @@ import javax.swing.BoxLayout; import java.awt.Image; -import javax.swing.ImageIcon; +import javax.swing.ImageIcon; import java.io.*; +import static java.lang.Double.NaN; + public class UI implements ActionListener { - + private final JFrame frame; - + private final JPanel panel; private final JPanel panelSub1; private final JPanel panelSub2; @@ -47,29 +49,31 @@ public class UI implements ActionListener { private final JPanel panelSub6; private final JPanel panelSub7; private final JPanel panelSub8; - + + private final JPanel panelSub9; + private final JTextArea text; - + private final JButton but[], butAdd, butMinus, butMultiply, butDivide, - butEqual, butCancel, butSquareRoot, butSquare, butOneDividedBy, - butCos, butSin, butTan, butxpowerofy, butlog, butrate, butabs, butBinary, butln; + butEqual, butCancel, butSquareRoot, butSquare, butOneDividedBy, + butCos, butSin, butTan, butxpowerofy, butlog, butrate, butabs, butBinary, butln, butMod, butPi, butFact, butExp, butBack; private final Calculator calc; - + private final String[] buttonValue = {"0", "1", "2", "3", "4", "5", "6", - "7", "8", "9"}; - + "7", "8", "9", "."}; + private final Font font; private final Font textFont; private ImageIcon image; private BufferedImageCustom imageReturn; - + public UI() throws IOException { frame = new JFrame("Calculator PH"); - + imageReturn = new BufferedImageCustom(); - image = new ImageIcon(imageReturn.imageReturn()); - + image = new ImageIcon(imageReturn.imageReturn()); + panel = new JPanel(); panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS)); panelSub1 = new JPanel(new FlowLayout()); @@ -80,53 +84,60 @@ public UI() throws IOException { panelSub6 = new JPanel(new FlowLayout()); panelSub7 = new JPanel(new FlowLayout()); panelSub8 = new JPanel(new FlowLayout()); - + panelSub9 = new JPanel(new FlowLayout()); + font = new Font("Consolas",Font.PLAIN, 18); - + text = new JTextArea(1, 30); - + textFont = new Font("Consolas",Font.BOLD, 24); - - but = new JButton[10]; + + but = new JButton[11]; for (int i = 0; i < 10; i++) { - but[i] = new JButton(String.valueOf(i)); - } - butAdd = new JButton("+"); - butMinus = new JButton("-"); - butMultiply = new JButton("*"); - butDivide = new JButton("/"); - butEqual = new JButton("="); - butSquareRoot = new JButton("sqrt"); - butSquare = new JButton("x*x"); - butOneDividedBy = new JButton("1/x"); - butCos = new JButton("Cos"); - butSin = new JButton("Sin"); - butTan = new JButton("Tan"); - butln = new JButton("ln"); - butxpowerofy = new JButton("x^y"); - butlog = new JButton("log10(x)"); - butrate = new JButton("x%"); - butabs = new JButton("abs(x)"); - butCancel = new JButton("C"); - butBinary = new JButton("Bin"); - + but[i] = new JButton(String.valueOf(i)); + } + but[10] = new JButton("."); + butAdd = new JButton("+"); + butMinus = new JButton("-"); + butMultiply = new JButton("*"); + butDivide = new JButton("/"); + butEqual = new JButton("="); + butSquareRoot = new JButton("sqrt"); + butSquare = new JButton("x*x"); + butOneDividedBy = new JButton("1/x"); + butCos = new JButton("Cos"); + butSin = new JButton("Sin"); + butTan = new JButton("Tan"); + butln = new JButton("ln"); + butxpowerofy = new JButton("x^y"); + butlog = new JButton("log10(x)"); + butrate = new JButton("x%"); + butabs = new JButton("abs(x)"); + butCancel = new JButton("C"); + butBinary = new JButton("Bin"); + butMod = new JButton("mod"); + butPi = new JButton("π"); + butFact=new JButton("!"); + butExp= new JButton("e^x"); + butBack = new JButton("<-"); + calc = new Calculator(); - + } - - public void init() { + + public void init() { frame.setSize(450, 450); - frame.setLocationRelativeTo(null); + frame.setLocationRelativeTo(null); frame.setResizable(false); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setIconImage(image.getImage()); - + text.setFont(textFont); text.setEditable(false); - - for (int i = 0; i < 10; i++) { + + for (int i = 0; i < 11; i++) { but[i].setFont(font); - } + } butAdd.setFont(font); butMinus.setFont(font); butMultiply.setFont(font); @@ -138,18 +149,23 @@ public void init() { butCos.setFont(font); butSin.setFont(font); butTan.setFont(font); - butln.setFont(font); + butln.setFont(font); butxpowerofy.setFont(font); butlog.setFont(font); butrate.setFont(font); butabs.setFont(font); butCancel.setFont(font); - butBinary.setFont(font); - + butBinary.setFont(font); + butMod.setFont(font); + butPi.setFont(font); + butFact.setFont(font); + butExp.setFont(font); + butBack.setFont(font); + panel.add(Box.createHorizontalStrut(100)); panelSub1.add(text); panel.add(panelSub1); - + panelSub2.add(but[1]); panelSub2.add(but[2]); panelSub2.add(but[3]); @@ -157,15 +173,15 @@ public void init() { panelSub2.add(butAdd); panelSub2.add(butMinus); panel.add(panelSub2); - + panelSub3.add(but[4]); panelSub3.add(but[5]); panelSub3.add(but[6]); panelSub3.add(Box.createHorizontalStrut(15)); panelSub3.add(butMultiply); - panelSub3.add(butDivide); + panelSub3.add(butDivide); panel.add(panelSub3); - + panelSub4.add(but[7]); panelSub4.add(but[8]); panelSub4.add(but[9]); @@ -173,33 +189,41 @@ public void init() { panelSub4.add(butEqual); panelSub4.add(butCancel); panel.add(panelSub4); - - panelSub5.add(Box.createHorizontalStrut(92)); + + + panelSub5.add(Box.createHorizontalStrut(30)); + panelSub5.add(but[10]); panelSub5.add(but[0]); - panelSub5.add(butln); - panelSub5.add(Box.createHorizontalStrut(210)); + panelSub5.add(butBack); + panelSub5.add(Box.createHorizontalStrut(2)); + panelSub5.add(butln); + panelSub5.add(butMod); panel.add(panelSub5); - + + panelSub6.add(butSquare); panelSub6.add(butSquareRoot); panelSub6.add(butOneDividedBy); panelSub6.add(butxpowerofy); + panelSub6.add(butFact); panel.add(panelSub6); - + panelSub7.add(butCos); panelSub7.add(butSin); panelSub7.add(butTan); + panelSub7.add(butPi); + panelSub7.add(butExp); panel.add(panelSub7); - + panelSub8.add(butlog); panelSub8.add(butrate); panelSub8.add(butabs); panelSub8.add(butBinary); panel.add(panelSub8); - - for (int i = 0; i < 10; i++) { + + for (int i = 0; i < 11; i++) { but[i].addActionListener(this); - } + } butAdd.addActionListener(this); butMinus.addActionListener(this); butMultiply.addActionListener(this); @@ -210,16 +234,21 @@ public void init() { butCos.addActionListener(this); butSin.addActionListener(this); butTan.addActionListener(this); - butln.addActionListener(this); + butln.addActionListener(this); butxpowerofy.addActionListener(this); butlog.addActionListener(this); butrate.addActionListener(this); butabs.addActionListener(this); butBinary.addActionListener(this); - + butMod.addActionListener(this); + butPi.addActionListener(this); + butFact.addActionListener(this); + butExp.addActionListener(this); + butBack.addActionListener(this); + butEqual.addActionListener(this); butCancel.addActionListener(this); - + frame.add(panel); frame.setVisible(true); } @@ -229,14 +258,20 @@ public void actionPerformed(ActionEvent e) { final Object source = e.getSource(); Double checkNum = null; - for (int i = 0; i < 10; i++) { + for (int i = 0; i < 11; i++) { if (source == but[i]) { text.replaceSelection(buttonValue[i]); return; } } - + + if (source == butPi) { + text.replaceSelection(String.valueOf(Math.PI)); + return; + } + + try { checkNum = Double.parseDouble(text.getText()); } catch(NumberFormatException k) { @@ -259,11 +294,23 @@ public void actionPerformed(ActionEvent e) { text.replaceSelection(butMultiply.getText()); } + if (source == butDivide) { writer(calc.calculateBi(Calculator.BiOperatorModes.divide, reader())); text.replaceSelection(butDivide.getText()); } - + + if (source == butMod) { + if (!calc.calculateBi(Calculator.BiOperatorModes.mod, reader()).isNaN()){ + writer(calc.calculateBi(Calculator.BiOperatorModes.mod, reader())); + text.replaceSelection("%"); + } + else{ + writer("Error"); + } + } + + if (source == butxpowerofy) { writer(calc.calculateBi(Calculator.BiOperatorModes.xpowerofy, reader())); } @@ -272,6 +319,17 @@ public void actionPerformed(ActionEvent e) { writer(calc.calculateMono(Calculator.MonoOperatorModes.square, reader())); } + + if (source == butFact) { + if (!calc.calculateMono(Calculator.MonoOperatorModes.fact, reader()).isNaN()){ + writer(calc.calculateMono(Calculator.MonoOperatorModes.fact, reader())); + text.replaceSelection("!"); + } + else{ + writer("Error"); + } + } + if (source == butSquareRoot) writer(calc.calculateMono(Calculator.MonoOperatorModes.squareRoot, reader())); @@ -284,14 +342,26 @@ public void actionPerformed(ActionEvent e) { if (source == butSin) writer(calc.calculateMono(Calculator.MonoOperatorModes.sin, reader())); - if (source == butTan) - writer(calc.calculateMono(Calculator.MonoOperatorModes.tan, reader())); + + + if (source == butTan) { + if (!calc.calculateMono(Calculator.MonoOperatorModes.tan, reader()).isNaN()){ + writer(calc.calculateMono(Calculator.MonoOperatorModes.tan, reader())); + } + else{ + writer("Error"); + } + } + + if(source == butExp){ + writer(calc.calculateMono(Calculator.MonoOperatorModes.exp, reader())); + } if (source == butlog) writer(calc.calculateMono(Calculator.MonoOperatorModes.log, reader())); if (source == butln) - writer(calc.calculateMono(Calculator.MonoOperatorModes.ln, reader())); + writer(calc.calculateMono(Calculator.MonoOperatorModes.ln, reader())); if (source == butrate) writer(calc.calculateMono(Calculator.MonoOperatorModes.rate, reader())); @@ -305,13 +375,17 @@ public void actionPerformed(ActionEvent e) { if (source == butCancel) writer(calc.reset()); + if (source == butBack) { + text.setText(text.getText().substring(0, text.getText().length() - 1)); + } + if (source == butBinary) parsetoBinary(); } text.selectAll(); } - + private void parsetoBinary() { try { text.setText("" + Long.toBinaryString(Long.parseLong(text.getText()))); @@ -319,16 +393,16 @@ private void parsetoBinary() { System.err.println("Error while parse to binary." + ex.toString()); } } - + public Double reader() { Double num; String str; str = text.getText(); num = Double.valueOf(str); - + return num; } - + public void writer(final Double num) { if (Double.isNaN(num)) { text.setText(""); @@ -336,4 +410,8 @@ public void writer(final Double num) { text.setText(Double.toString(num)); } } + + public void writer(final String str) { + text.setText(str); + } } diff --git a/src/simplejavacalculatorTest/CalculatorTest.java b/tests/simplejavacalculatorTest/CalculatorTest.java old mode 100755 new mode 100644 similarity index 86% rename from src/simplejavacalculatorTest/CalculatorTest.java rename to tests/simplejavacalculatorTest/CalculatorTest.java index 1ea20f7..c4d4978 --- a/src/simplejavacalculatorTest/CalculatorTest.java +++ b/tests/simplejavacalculatorTest/CalculatorTest.java @@ -1,119 +1,128 @@ -package simplejavacalculatorTest; - -import org.junit.jupiter.api.Assertions; -import org.junit.jupiter.api.Test; -import static java.lang.Double.NaN; -import java.lang.Math; - - -import simplejavacalculator.Calculator; - -class CalculatorTest { - - @Test - void calculateBiNormalTest() { - Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0); - Assertions.assertEquals(NaN, calculator.calculateBi(Calculator.BiOperatorModes.normal, 3.0)); - } - - @Test - void calculateBiAddTest() { - Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.add, 3.0); - Assertions.assertEquals(5.5, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.5)); - } - - @Test - void calculateBiMinusTest() { - Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.minus, 3.1415); - Assertions.assertEquals(2.0415, calculator.calculateBi(Calculator.BiOperatorModes.normal, 1.1)); - } - - @Test - void calculateBiMultiplyTest() { - Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.multiply, 3.2); - Assertions.assertEquals(6.4, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0)); - } - - @Test - void calculateBiDivideTest() { - Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.divide, 6.4); - Assertions.assertEquals(3.2, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0)); - } - - @Test - void calculateEqualTest() { - Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.add, 6.4); - calculator.calculateBi(Calculator.BiOperatorModes.add, 2.0); - Assertions.assertEquals(11.4, calculator.calculateEqual(3.0)); - } - - @Test - void resetTest() { - Calculator calculator = new Calculator(); - calculator.calculateBi(Calculator.BiOperatorModes.add, 6.4); - Assertions.assertEquals(8.4, calculator.calculateBi(Calculator.BiOperatorModes.add, 2.0)); - Assertions.assertEquals(NaN, calculator.reset()); - } - - @Test - void CalculateMonoSquareTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(9.0, calculator.calculateMono(Calculator.MonoOperatorModes.square, 3.0)); - } - - @Test - void CalculateMonoSquareRootTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(5.0, calculator.calculateMono(Calculator.MonoOperatorModes.squareRoot, 25.0)); - } - - @Test - void CalculateMonoOneDividedByTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(0.10, calculator.calculateMono(Calculator.MonoOperatorModes.oneDividedBy, 10.0)); - } - - @Test - void CalculateMonoSinTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(0.5, calculator.calculateMono(Calculator.MonoOperatorModes.sin, java.lang.Math.PI / 6), 0.0000000001); - } - - @Test - void CalculateMonoCosTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(0.5, calculator.calculateMono(Calculator.MonoOperatorModes.cos, java.lang.Math.PI / 3), 0.0000000001); - } - - @Test - void CalculateMonoTanTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(1.0, calculator.calculateMono(Calculator.MonoOperatorModes.tan, java.lang.Math.PI / 4), 0.0000000001); - } - - @Test - void CalculateMonoLogTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(2.0, calculator.calculateMono(Calculator.MonoOperatorModes.log, 100.0)); - } - - @Test - void CalculateMonoRateTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(.75, calculator.calculateMono(Calculator.MonoOperatorModes.rate, 75.0)); - } - - @Test - void CalculateMonoAbsTest() { - Calculator calculator = new Calculator(); - Assertions.assertEquals(3.0, calculator.calculateMono(Calculator.MonoOperatorModes.abs, -3.0)); - Assertions.assertEquals(3.0, calculator.calculateMono(Calculator.MonoOperatorModes.abs, 3.0)); - } - -} + +package simplejavacalculatorTest; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import static java.lang.Double.NaN; +import java.lang.Math; + + +import simplejavacalculator.Calculator; + +class CalculatorTest { + + @Test + void calculateBiNormalTest() { + Calculator calculator = new Calculator(); + calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0); + Assertions.assertEquals(NaN, calculator.calculateBi(Calculator.BiOperatorModes.normal, 3.0)); + } + + @Test + void calculateBiAddTest() { + Calculator calculator = new Calculator(); + calculator.calculateBi(Calculator.BiOperatorModes.add, 3.0); + Assertions.assertEquals(5.5, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.5)); + } + + @Test + void calculateBiMinusTest() { + Calculator calculator = new Calculator(); + calculator.calculateBi(Calculator.BiOperatorModes.minus, 3.1415); + Assertions.assertEquals(2.0415, calculator.calculateBi(Calculator.BiOperatorModes.normal, 1.1)); + } + + @Test + void calculateBiMultiplyTest() { + Calculator calculator = new Calculator(); + calculator.calculateBi(Calculator.BiOperatorModes.multiply, 3.2); + Assertions.assertEquals(6.4, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0)); + } + + @Test + void calculateBiDivideTest() { + Calculator calculator = new Calculator(); + calculator.calculateBi(Calculator.BiOperatorModes.divide, 6.4); + Assertions.assertEquals(3.2, calculator.calculateBi(Calculator.BiOperatorModes.normal, 2.0)); + } + + @Test + void calculateEqualTest() { + Calculator calculator = new Calculator(); + calculator.calculateBi(Calculator.BiOperatorModes.add, 6.4); + calculator.calculateBi(Calculator.BiOperatorModes.add, 2.0); + Assertions.assertEquals(11.4, calculator.calculateEqual(3.0)); + } + + @Test + void resetTest() { + Calculator calculator = new Calculator(); + calculator.calculateBi(Calculator.BiOperatorModes.add, 6.4); + Assertions.assertEquals(8.4, calculator.calculateBi(Calculator.BiOperatorModes.add, 2.0)); + Assertions.assertEquals(NaN, calculator.reset()); + } + + @Test + void CalculateMonoSquareTest() { + Calculator calculator = new Calculator(); + Assertions.assertEquals(9.0, calculator.calculateMono(Calculator.MonoOperatorModes.square, 3.0)); + } + + @Test + void CalculateMonoSquareRootTest() { + Calculator calculator = new Calculator(); + Assertions.assertEquals(5.0, calculator.calculateMono(Calculator.MonoOperatorModes.squareRoot, 25.0)); + } + + @Test + void CalculateMonoOneDividedByTest() { + Calculator calculator = new Calculator(); + Assertions.assertEquals(0.10, calculator.calculateMono(Calculator.MonoOperatorModes.oneDividedBy, 10.0)); + } + + @Test + void CalculateMonoSinTest() { + Calculator calculator = new Calculator(); + Assertions.assertEquals(0.5, calculator.calculateMono(Calculator.MonoOperatorModes.sin, 30.0), 0.0000000001); + } + + @Test + void CalculateMonoCosTest() { + Calculator calculator = new Calculator(); + Assertions.assertEquals(0.5, calculator.calculateMono(Calculator.MonoOperatorModes.cos, 60.0), 0.0000000001); + } + + @Test + void CalculateMonoTanTest() { + Calculator calculator = new Calculator(); + Assertions.assertEquals(1.0, calculator.calculateMono(Calculator.MonoOperatorModes.tan, 45.0), 0.0000000001); + } + + @Test + void CalculateMonoLogTest() { + Calculator calculator = new Calculator(); + Assertions.assertEquals(2.0, calculator.calculateMono(Calculator.MonoOperatorModes.log, 100.0)); + } + + @Test + void CalculateMonoRateTest() { + Calculator calculator = new Calculator(); + Assertions.assertEquals(.75, calculator.calculateMono(Calculator.MonoOperatorModes.rate, 75.0)); + } + + @Test + void CalculateMonoAbsTest() { + Calculator calculator = new Calculator(); + Assertions.assertEquals(3.0, calculator.calculateMono(Calculator.MonoOperatorModes.abs, -3.0)); + Assertions.assertEquals(3.0, calculator.calculateMono(Calculator.MonoOperatorModes.abs, 3.0)); + } + + @Test + void CalculateMonoFactTest() { + Calculator calculator = new Calculator(); + Assertions.assertEquals(24.0, calculator.calculateMono(Calculator.MonoOperatorModes.fact, 4.0)); + Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.fact, -3.0)); + Assertions.assertEquals(NaN, calculator.calculateMono(Calculator.MonoOperatorModes.fact, 3.5)); + } + +}