Simple-Java-Calculator/src/simplejavacalculator/Calculator.java at a49014b6f0d44b3cde5cc0453070cb8b2ae6b721 · pH-7/Simple-Java-Calculator · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
/**
 * @name        Simple Java Calculator
 * @package     ph.calculator
 * @file        Main.java
 * @author      SORIA Pierre-Henry
 * @email       pierrehs@hotmail.com
 * @link        http://github.com/pH-7
 * @copyright   Copyright Pierre-Henry SORIA, All Rights Reserved.
 * @license     Apache (http://www.apache.org/licenses/LICENSE-2.0)
 */

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;

public class Calculator {

    public enum BiOperatorModes {
        normal {
            public Double apply(Double n1, Double n2) { return n2; }
        },
        add {
            public Double apply(Double n1, Double n2) { return n1 + n2; }
        },
        minus {
            public Double apply(Double n1, Double n2) { return n1 - n2; }
        },
        multiply {
            public Double apply(Double n1, Double n2) { return n1 * n2; }
        },
        divide {
            public Double apply(Double n1, Double n2) { return n1 / n2; }
        },
        xpowerofy {
            public Double apply(Double n1, Double n2) { return pow(n1, n2); }
        };

        public abstract Double apply(Double num1, Double num2);
    }

    public enum MonoOperatorModes {
        square {
            public Double apply(Double n) { return n * n; }
        },
        squareRoot {
            public Double apply(Double n) { return Math.sqrt(n); }
        },
        oneDividedBy {
            public Double apply(Double n) { return 1 / n; }
        },
        cos {
            public Double apply(Double n) { return Math.cos(Math.toRadians(n)); }
        },
        sin {
            public Double apply(Double n) { return Math.sin(Math.toRadians(n)); }
        },
        tan {
            public Double apply(Double n) {
                if (n == 0 || n % 180 == 0) return 0.0;
                if (n % 90 == 0) return NaN;
                return Math.tan(Math.toRadians(n));
            }
        },
        log {
            public Double apply(Double n) { return log10(n); }
        },
        ln {
            public Double apply(Double n) { return log(n); }
        },
        rate {
            public Double apply(Double n) { return n / 100; }
        },
        abs {
            public Double apply(Double n) { return Math.abs(n); }
        };

        public abstract Double apply(Double num);
    }

    private Double num1, num2;
    private BiOperatorModes mode = BiOperatorModes.normal;

    private Double calculateBiImpl() {
        return mode.apply(num1, num2);
    }

    public Double calculateBi(BiOperatorModes newMode, Double num) {
        if (mode.equals(BiOperatorModes.normal)) {
            num2 = 0.0;
            num1 = num;
            mode = newMode;
            return NaN;
        } else {
            num2 = num;
            num1 = calculateBiImpl();
            mode = newMode;
            return num1;
        }
    }

    public Double calculateEqual(Double num) {
        return calculateBi(BiOperatorModes.normal, num);
    }

    public Double reset() {
        num2 = 0.0;
        num1 = 0.0;
        mode = BiOperatorModes.normal;
        return NaN;
    }

    public Double calculateMono(MonoOperatorModes newMode, Double num) {
        return newMode.apply(num);
    }
}