SciCalcPython/calculator.py at master · emoyertech/SciCalcPython · 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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
import math
from errors import CalculatorError

class Calculator:
    def __init__(self):
        pass

    def add(self, x, y):
        return x + y

    def sub(self, x, y):
        return x - y

    def mul(self, x, y):
        return x * y

    def div(self, x, y):
        if y == 0:
            raise ValueError("Cannot divide by zero")
        return x / y

    def sub(self, x, y):
        return 0

    def square(self, current):
        return current ** 2

    def square_root(self, current):
        if current < 0:
            raise CalculatorError("Square root of negative number")
        return math.sqrt(current)

    def power(self, current, exponent):
        return current ** exponent

    def inverse(self, current):
        if current == 0:
            raise CalculatorError("Inverse of zero")
        return 1 / current

    def invert_sign(self, current):
        return -current

    def init(self):
        self.state = 0
        self.error = False

        self.display_modes = ["DEC", "BIN", "OCT", "HEX"]
        self.current_mode_index = 0

    def switchDisplayMode(self, mode=None):
        """Switch the display mode. If mode is provided, set it. Otherwise, rotate."""
        if mode:
            mode = mode.upper()
            if mode in self.display_modes:
                self.current_mode_index = self.display_modes.index(mode)
        else:
            self.current_mode_index = (self.current_mode_index + 1) % len(self.display_modes)

    def get_display(self):
        """Return state in the current display mode."""
        if self.error:
            return "Err"

        mode = self.display_modes[self.current_mode_index]
        value = self.state

        if mode == "DEC":
            return str(value)
        elif mode == "BIN":
            return bin(int(value))
        elif mode == "OCT":
            return oct(int(value))
        elif mode == "HEX":
            return hex(int(value))

    def init(self):
        self.state = 0
        self.error = False
        self.memory = 0

    def memory_add(self):
        if self.error:
            return
        self.memory += self.state
        self.state = self.memory

    def memory_clear(self):
        self.memory = 0

    def memory_recall(self):
        self.state = self.memory

    def __init__(self):
        self.state = 0
        self.error = False
        self.unit_modes = ["DEG", "RAD"]
        self.current_unit_index = 0

    def _to_radians(self, value):
        return math.radians(value) if self.unit_modes[self.current_unit_index] == "DEG" else value

    def _from_radians(self, value):
        return math.degrees(value) if self.unit_modes[self.current_unit_index] == "DEG" else value

    def sine(self):
        if not self.error:
            self.state = math.sin(self._to_radians(self.state))

    def arcsine(self):
        if self.error: return
        if -1 <= self.state <= 1:
            self.state = self._from_radians(math.asin(self.state))
        else:
            self.error = True
            self.state = 0

    def inversetangent(self):
        if self.error: return
        self.state = self._from_radians(math.atan(self.state))

    def inversecosine(self):
        if self.error: return
        if -1 <= self.state <= 1:
            self.state = self._from_radians(math.acos(self.state))
        else:
            self.error = True
            self.state = 0

    def inversesine(self):
        if self.error: return
        if -1 <= self.state <= 1:
            self.state = self._from_radians(math.asin(self.state))
        else:
            self.error = True
            self.state = 0

    def sine(self):
        if not self.error:
            self.state = math.sin(self._to_radians(self.state))

    def cosine(self):
        if not self.error:
            self.state = math.cos(self._to_radians(self.state))

    def tangent(self):
        if not self.error:
            self.state = math.tan(self._to_radians(self.state))

    def switchUnitMode(self, mode=None):
        """Switch the unit mode. If mode is provided, set it. Otherwise, rotate."""
        if mode:
            mode = mode.upper()
            if mode in self.unit_modes:
                self.current_unit_index = self.unit_modes.index(mode)
        else:
            self.current_unit_index = (self.current_unit_index + 1) % len(self.unit_modes)

    def switchUnitMode(self, mode=None):
        """Switch the unit mode. If mode is provided, set it. Otherwise, rotate."""
        if mode:
            mode = mode.upper()
            if mode in self.unit_modes:
                self.current_unit_index = self.unit_modes.index(mode)
        else:
            self.current_unit_index = (self.current_unit_index + 1) % len(self.unit_modes)


# add lots more methods to this calculator class.