def result_pressed(self): """Sets the result text for pressing result button.""" if "^" in self.line_result.text(): try: string = str(self.line_result.text()) string = string.split("^") try: base = int(string[0]) except ValueError: base = float(string[0]) exponent = int(string[1]) result = round(MathLib.power(base, exponent)) self.line_result.setText(str(result)) except ValueError: self.line_result.setText("Math Error") elif "√" in self.line_result.text(): try: string = str(self.line_result.text()) string = string.split("√") n = int(string[0]) base = int(string[1]) result = round(MathLib.root(base, n)) self.line_result.setText(str(result)) except ValueError: self.line_result.setText("Math Error") if not self.is_result_set(): self.line_subresult.setText(self.line_subresult.text() + " " + self.line_result.text()) self.calculate_result()
def calculate_result(self): """Calculates the result placed in subresult.""" try: result = self.line_subresult.text() string = str(result) result = string.split() try: res = int(result[0]) except ValueError: res = float(result[0]) for x in range(1, len(result), 2): number = result[x + 1] try: number = int(number) except ValueError: number = float(number) if "+" in result[x]: res = round(MathLib.add(res, number), 9) if "-" in result[x]: res = round(MathLib.subtract(res, number), 9) if "*" in result[x]: res = round(MathLib.multiply(res, number), 9) if "/" in result[x]: res = round(MathLib.divide(res, number), 9) self.line_result.setText(str(res)) self.line_subresult.setText(self.line_subresult.text() + " " + "=") except ValueError: self.line_result.setText("Math Error") except OverflowError: self.line_result.setText("Overflow Error")
def sqr_pressed(self): """Set the result text for square root.""" try: number = float(self.line_result.text()) result = round(MathLib.power(number, 2), 9) self.line_result.setText(str(result)) except ValueError: self.line_result.setText("Math Error")
def factorial_pressed(self): """Set the result text for factorial.""" try: number = int(self.line_result.text()) result = MathLib.factorial(number) self.line_result.setText(str(result)) except ValueError: self.line_result.setText("Math Error")
def __init__(self, handle): ShareableActivity.__init__(self, handle) self.old_eqs = [] self.ml = MathLib() self.parser = AstParser(self.ml) # These will result in 'Ans <operator character>' being inserted self._chars_ans_diadic = [ op[0] for op in self.parser.get_diadic_operators() ] if '-' in self._chars_ans_diadic: self._chars_ans_diadic.remove('-') self.KEYMAP['multiply'] = self.ml.mul_sym self.KEYMAP['divide'] = self.ml.div_sym self.KEYMAP['equal'] = self.ml.equ_sym self.clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD) self.select_reason = self.SELECT_SELECT self.buffer = "" self.showing_version = 0 self.showing_error = False self.ans_inserted = False self.show_vars = False self.connect("key_press_event", self.keypress_cb) self.connect("destroy", self.cleanup_cb) self.color = sugar3.profile.get_color() self.layout = CalcLayout(self) self.label_entry = self.layout.label_entry self.text_entry = self.layout.text_entry self.last_eq_sig = None self.last_eqn_textview = None self.reset() self.layout.show_it() self.connect('joined', self._joined_cb) self.parser.log_debug_info()
def eq_button_pressed(self): self.flag_op = 0 self.flag_clear = 1 equation = str(self.label.text()) try: result = str(ml.solve_eq(equation)) except: result = "Incorrect Syntax" self.label.setText(result)
def divide_by_x_pressed(self): """Set the result text for division by x.""" try: number = float(self.line_result.text()) result = round(MathLib.divide(1, number), 9) self.line_result.setText(str(result)) except ValueError: self.line_result.setText("Math Error") except OverflowError: self.line_result.setText("Overflow Error")
def advanced_ops_pressed(self): """Set the result text for advanced operation.""" try: button = (self.sender()) number = float(self.line_result.text()) if "ln" in str(button.text()): result = round(MathLib.natural_log(number), 9) self.line_result.setText(str(result)) elif "log" in str(button.text()): result = round(MathLib.log(number), 9) self.line_result.setText(str(result)) elif "sin" in str(button.text()): result = round(MathLib.sin(number), 9) self.line_result.setText(str(result)) elif "cos" in str(button.text()): result = round(MathLib.cos(number), 9) self.line_result.setText(str(result)) elif "tan" in str(button.text()): result = round(MathLib.tan(number), 9) self.line_result.setText(str(result)) elif "cot" in str(button.text()): result = round(MathLib.cot(number), 9) self.line_result.setText(str(result)) except ValueError: self.line_result.setText("Math Error") except OverflowError: self.line_result.setText("Overflow Error")
def exp_pressed(self): """Set the result text for exp.""" try: try: number = int(self.line_result.text()) except ValueError: number = float(self.line_result.text()) result = round(MathLib.exp(number), 9) self.line_result.setText(str(result)) except ValueError: self.line_result.setText("Math Error") except OverflowError: self.line_result.setText("Overflow Error")
def calculate_standard_deviation(values): """Calculates standard deviation. Args: values (list): Data set to use in the calculation. Returns: float: Standard deviation of the data set. """ n = len(values) s = MathLib.root( MathLib.divide( MathLib.subtract( reduce(MathLib.add, map(lambda a: MathLib.power(a, 2), values)), MathLib.multiply( n, MathLib.power( MathLib.divide(reduce(MathLib.add, values), n), 2))), MathLib.subtract(n, 1)), 2) return s
def __init__(self, ml=None, pl=None): self._namespace = {} self._immutable_vars = [] self._used_var_ofs = {} if ml is None: self.ml = MathLib() else: self.ml = ml if pl is None: self.pl = Plot(self) else: self.pl = pl for key, val in self.BUILTIN_VARS.iteritems(): self.set_var(key, val, immutable=True) # Help manager self._helper = Helper(self) self.set_var('help', self._helper.get_help, immutable=True) self._special_func_args = { (self._helper.get_help, 0): self._ARG_STRING, (self.pl.plot, 0): self._ARG_NODE, } # Plug-in plot function self.set_var('plot', self.pl.plot, immutable=True) self._helper.add_help('plot', PLOTHELP) self._load_plugins() # Redirect operations to registered functions for key, val in self.UNARYOP_MAP.iteritems(): if type(val) is types.StringType: self.UNARYOP_MAP[key] = self.get_var(val) for key, val in self.BINOP_MAP.iteritems(): if type(val) is types.StringType: self.BINOP_MAP[key] = self.get_var(val)
from mathlib import MathLib as m s = list(map(int, input().split())) n = len(s) std_deviation = m.root_n( m.div(m.a_sum(m.pow_x_y((m.sub(x, m.div(m.a_sum(s), n))), 2) for x in s), (m.sub(n, 1))), 2) print(std_deviation)
class Calculate(ShareableActivity): TYPE_FUNCTION = 1 TYPE_OP_PRE = 2 TYPE_OP_POST = 3 TYPE_TEXT = 4 SELECT_NONE = 0 SELECT_SELECT = 1 SELECT_TAB = 2 KEYMAP = { 'Return': lambda o: o.process(), 'period': '.', 'equal': '=', 'plus': '+', 'minus': '-', 'asterisk': '*', 'multiply': '×', 'divide': '÷', 'slash': '/', 'BackSpace': lambda o: o.remove_character(-1), 'Delete': lambda o: o.remove_character(1), 'parenleft': '(', 'parenright': ')', 'exclam': '!', 'ampersand': '&', 'bar': '|', 'asciicircum': '^', 'less': '<', 'greater': '>', 'percent': '%', 'comma': ',', 'underscore': '_', 'Left': lambda o: o.move_left(), 'Right': lambda o: o.move_right(), 'Up': lambda o: o.get_older(), 'Down': lambda o: o.get_newer(), 'colon': lambda o: o.label_entered(), 'Home': lambda o: o.text_entry.set_position(0), 'End': lambda o: o.text_entry.set_position( len(o.text_entry.get_text())), 'Tab': lambda o: o.tab_complete(), } CTRL_KEYMAP = { 'c': lambda o: o.text_copy(), 'v': lambda o: o.text_paste(), 'x': lambda o: o.text_cut(), 'q': lambda o: o.close(), 'a': lambda o: o.text_select_all(), } SHIFT_KEYMAP = { 'Left': lambda o: o.expand_selection(-1), 'Right': lambda o: o.expand_selection(1), 'Home': lambda o: o.expand_selection(-1000), 'End': lambda o: o.expand_selection(1000), } IDENTIFIER_CHARS = \ "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_ " def __init__(self, handle): ShareableActivity.__init__(self, handle) self.old_eqs = [] self.ml = MathLib() self.parser = AstParser(self.ml) # These will result in 'Ans <operator character>' being inserted self._chars_ans_diadic = [op[0] for op in self.parser.get_diadic_operators()] if '-' in self._chars_ans_diadic: self._chars_ans_diadic.remove('-') self.KEYMAP['multiply'] = self.ml.mul_sym self.KEYMAP['divide'] = self.ml.div_sym self.KEYMAP['equal'] = self.ml.equ_sym self.clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD) self.select_reason = self.SELECT_SELECT self.buffer = "" self.showing_version = 0 self.showing_error = False self.ans_inserted = False self.show_vars = False self.connect("key_press_event", self.keypress_cb) self.connect("destroy", self.cleanup_cb) self.color = sugar3.profile.get_color() self.layout = CalcLayout(self) self.label_entry = self.layout.label_entry self.text_entry = self.layout.text_entry self.last_eq_sig = None self.last_eqn_textview = None self.reset() self.layout.show_it() self.connect('joined', self._joined_cb) self.parser.log_debug_info() def ignore_key_cb(self, widget, event): return True def cleanup_cb(self, arg): _logger.debug('Cleaning up...') def equation_pressed_cb(self, eqn): """Callback for when an equation box is clicked.""" if isinstance(eqn.result, SVGImage): return True if len(eqn.label) > 0: text = eqn.label else: # don't insert plain text if type(eqn.result) in (bytes, str): text = '' else: text = self.parser.ml.format_number(eqn.result) text = text.rstrip('0').rstrip('.') if '.' in text else text self.button_pressed(self.TYPE_TEXT, text) return True def set_last_equation(self, eqn): """Set the 'last equation' TextView.""" if self.last_eq_sig is not None: self.layout.last_eq.disconnect(self.last_eq_sig) self.last_eq_sig = None if not isinstance(eqn.result, ParserError): self.last_eq_sig = self.layout.last_eq.connect( 'button-press-event', lambda a1, a2, e: self.equation_pressed_cb(e), eqn) self.layout.last_eq.set_buffer(eqn.create_lasteq_textbuf()) def set_error_equation(self, eqn): """Set equation with error markers. Since set_last_equation implements this we can just forward the call.""" self.set_last_equation(eqn) def clear_equations(self): """Clear the list of old equations.""" self.old_eqs = [] self.showing_version = 0 def add_equation(self, eq, prepend=False, drawlasteq=False, tree=None): """ Insert equation in the history list and set variable if assignment. Input: eq: the equation object prepend: if True, prepend to list, else append drawlasteq: if True, draw in 'last equation' textbox and queue the buffer to be added to the history next time an equation is added. tree: the parsed tree, this will be used to set the label variable so that the equation can be used symbolicaly. """ if eq.equation is not None and len(eq.equation) > 0: if prepend: self.old_eqs.insert(0, eq) else: self.old_eqs.append(eq) self.showing_version = len(self.old_eqs) if self.last_eqn_textview is not None and drawlasteq: # Prepending here should be the opposite: prepend -> eqn on top. # We always own this equation self.layout.add_equation(self.last_eqn_textview, True, prepend=not prepend) self.last_eqn_textview = None if eq.label is not None and len(eq.label) > 0: w = self.create_var_textview(eq.label, eq.result) if w is not None: self.layout.add_variable(eq.label, w) if tree is None: tree = self.parser.parse(eq.equation) try: self.parser.set_var(eq.label, tree) except Exception as e: eq.result = ParseError(e.message, 0, "") self.set_error_equation(eq) return own = (eq.owner == self.get_owner_id()) w = eq.create_history_object() w.connect('button-press-event', lambda w, e: self.equation_pressed_cb(eq)) if drawlasteq: self.set_last_equation(eq) # SVG images can't be plotted in last equation window if isinstance(eq.result, SVGImage): self.layout.add_equation(w, own, prepend=not prepend) else: self.last_eqn_textview = w else: self.layout.add_equation(w, own, prepend=not prepend) # FIXME: to be implemented def process_async(self, eqn): """Parse and process an equation asynchronously.""" def process(self): """Parse the equation entered and show the result.""" s = _s(self.text_entry.get_text()) label = self.label_entry.get_text() _logger.debug('process(): parsing %r, label: %r', s, label) try: tree = self.parser.parse(s) res = self.parser.evaluate(tree) except ParserError as e: res = e self.showing_error = True if isinstance(res, str) and res.find('</svg>') > -1: res = SVGImage(data=res) _logger.debug('Result: %r', res) # Check whether assigning this label would cause recursion if not isinstance(res, ParserError) and len(label) > 0: lastpos = self.parser.get_var_used_ofs(label) if lastpos is not None: res = RuntimeError( _('Can not assign label: will cause recursion'), lastpos) # If parsing went ok, see if we have to replace the previous answer # to get a (more) exact result if self.ans_inserted and not isinstance(res, ParserError) \ and not isinstance(res, SVGImage): ansvar = self.format_insert_ans() pos = s.find(ansvar) if len(ansvar) > 6 and pos != -1: s2 = s.replace(ansvar, 'LastEqn') _logger.debug( 'process(): replacing previous answer %r: %r', ansvar, s2) tree = self.parser.parse(s2) res = self.parser.evaluate(tree) if isinstance(res, ParserError): eqn = Equation(label, _n(s), res, self.color, self.get_owner_id(), ml=self.ml) self.set_error_equation(eqn) else: eqn = Equation(label, _n(s), _n(str(res)), self.color, self.get_owner_id(), ml=self.ml) self.add_equation(eqn, drawlasteq=True, tree=tree) self.send_message("add_eq", value=str(eqn)) self.parser.set_var('Ans', eqn.result) # Setting LastEqn to the parse tree would certainly be faster, # however, it introduces recursion problems self.parser.set_var('LastEqn', eqn.result) self.showing_error = False self.ans_inserted = False self.text_entry.set_text('') self.label_entry.set_text('') return res is not None def create_var_textview(self, name, value): """Create a Gtk.TextView for a variable.""" reserved = ["Ans", "LastEqn", "help"] if name in reserved: return None w = Gtk.TextView() w.modify_base( Gtk.StateType.NORMAL, Gdk.color_parse(self.color.get_fill_color())) w.modify_bg( Gtk.StateType.NORMAL, Gdk.color_parse(self.color.get_stroke_color())) w.set_wrap_mode(Gtk.WrapMode.WORD_CHAR) w.set_border_window_size(Gtk.TextWindowType.LEFT, 4) w.set_border_window_size(Gtk.TextWindowType.RIGHT, 4) w.set_border_window_size(Gtk.TextWindowType.TOP, 4) w.set_border_window_size(Gtk.TextWindowType.BOTTOM, 4) w.connect('realize', _textview_realize_cb) buf = w.get_buffer() # TODO Fix for old Sugar 0.82 builds, red_float not available bright = ( Gdk.color_parse(self.color.get_fill_color()).red_float + Gdk.color_parse(self.color.get_fill_color()).green_float + Gdk.color_parse(self.color.get_fill_color()).blue_float) / 3.0 if bright < 0.5: col = Gdk.color_parse('white') else: col = Gdk.color_parse('black') tag = buf.create_tag(font=CalcLayout.FONT_SMALL_NARROW, foreground=col) text = '%s:' % (name) buf.insert_with_tags(buf.get_end_iter(), text, tag) tag = buf.create_tag(font=CalcLayout.FONT_SMALL, foreground=col) text = '%s' % (str(value)) buf.insert_with_tags(buf.get_end_iter(), text, tag) return w def clear(self): self.text_entry.set_text('') self.text_entry.grab_focus() return True def reset(self): self.clear() return True # # Journal functions # def write_file(self, file_path): """Write journal entries, Calculate Journal Version (cjv) 1.0""" _logger.info(_('Writing to journal (%s)'), file_path) f = open(file_path, 'w') f.write("cjv 1.0\n") sel = self.text_entry.get_selection_bounds() pos = self.text_entry.get_position() if len(sel) == 0: sel = (pos, pos) f.write("%s;%d;%d;%d\n" % (self.text_entry.get_text(), pos, sel[0], sel[1])) # In reverse order for eq in self.old_eqs: f.write(str(eq)) f.close() def read_file(self, file_path): """Read journal entries, version 1.0""" _logger.info('Reading from journal (%s)', file_path) f = open(file_path, 'r') str = f.readline().rstrip("\r\n") # chomp k = str.split() if len(k) != 2: _logger.error('Unable to determine version') return False version = k[1] if len(version) > 1 and version[0:2] == "1.": _logger.info('Reading journal entry (version %s)', version) str = f.readline().rstrip("\r\n") k = str.split(';') if len(k) != 4: _logger.error('State line invalid (%s)', str) return False self.text_entry.set_text(k[0]) self.text_entry.set_position(int(k[1])) if k[2] != k[3]: self.text_entry.select_region(int(k[2]), int(k[3])) self.clear_equations() for str in f: eq = Equation(eqnstr=str, ml=self.ml) self.add_equation(eq, prepend=False) return True else: _logger.error( 'Unable to read journal entry, unknown version (%s)', version) return False # # User interaction functions # def remove_character(self, dir): pos = self.text_entry.get_position() sel = self.text_entry.get_selection_bounds() if len(sel) == 0: if pos + dir <= len(self.text_entry.get_text()) and pos + dir >= 0: if dir < 0: self.text_entry.delete_text(pos + dir, pos) pos -= 1 else: self.text_entry.delete_text(pos, pos + dir) pos += 1 else: self.text_entry.delete_text(sel[0], sel[1]) self.text_entry.grab_focus() self.text_entry.set_position(pos) def move_left(self): pos = self.text_entry.get_position() if pos > 0: pos -= 1 self.text_entry.set_position(pos) self.text_entry.grab_focus() self.text_entry.set_position(pos) def move_right(self): pos = self.text_entry.get_position() if pos < len(self.text_entry.get_text()): pos += 1 self.text_entry.set_position(pos) self.text_entry.grab_focus() self.text_entry.set_position(pos) def label_entered(self): if len(self.label_entry.get_text()) > 0: return pos = self.text_entry.get_position() str = self.text_entry.get_text() self.label_entry.set_text(str[:pos]) self.text_entry.set_text(str[pos:]) def tab_complete(self): # Get start of variable name str = self.text_entry.get_text() if len(str) == 0: return sel = self.text_entry.get_selection_bounds() if len(sel) == 0: end_ofs = self.text_entry.get_position() else: end_ofs = sel[0] start_ofs = end_ofs - 1 while start_ofs > 0 and str[start_ofs - 1] in self.IDENTIFIER_CHARS: start_ofs -= 1 if end_ofs - start_ofs <= 0: return False partial_name = str[start_ofs:end_ofs] _logger.debug('tab-completing %s...', partial_name) # Lookup matching variables vars = self.parser.get_names(start=partial_name) if len(vars) == 0: return False # Nothing selected, select first match if len(sel) == 0: name = vars[0] self.text_entry.set_text(str[:start_ofs] + name + str[end_ofs:]) # Select next matching variable else: full_name = str[start_ofs:sel[1]] if full_name not in vars: name = vars[0] else: name = vars[(vars.index(full_name) + 1) % len(vars)] self.text_entry.set_text(str[:start_ofs] + name + str[sel[1]:]) self.text_entry.set_position(start_ofs + len(name)) self.text_entry.select_region(end_ofs, start_ofs + len(name)) self.select_reason = self.SELECT_TAB return True # Selection related functions def expand_selection(self, dir): # logger.info('Expanding selection in dir %d', dir) sel = self.text_entry.get_selection_bounds() slen = len(self.text_entry.get_text()) pos = self.text_entry.get_position() if len(sel) == 0: sel = (pos, pos) if dir < 0: # apparently no such thing as a cursor position during select newpos = max(0, sel[0] + dir) self.text_entry.set_position(newpos) self.text_entry.select_region(newpos, sel[1]) elif dir > 0: newpos = min(sel[1] + dir, slen) self.text_entry.set_position(newpos) self.text_entry.select_region(sel[0], newpos) self.select_reason = self.SELECT_SELECT def text_copy(self): if self.layout.graph_selected is not None: self.clipboard.set_image( self.layout.graph_selected.get_child().get_pixbuf()) self.layout.toggle_select_graph(self.layout.graph_selected) else: str = self.text_entry.get_text() sel = self.text_entry.get_selection_bounds() # _logger.info('text_copy, sel: %r, str: %s', sel, str) if len(sel) == 2: (start, end) = sel self.clipboard.set_text(str[start:end], -1) def text_select_all(self): end = self.text_entry.get_text_length() self.text_entry.select_region(0, end) def get_clipboard_text(self): text = self.clipboard.wait_for_text() if text is None: return "" else: return text def text_paste(self): self.button_pressed(self.TYPE_TEXT, self.get_clipboard_text()) def text_cut(self): self.text_copy() self.remove_character(1) def keypress_cb(self, widget, event): if not self.text_entry.is_focus(): return key = Gdk.keyval_name(event.keyval) if event.hardware_keycode == 219: if (event.get_state() & Gdk.ModifierType.SHIFT_MASK): key = 'divide' else: key = 'multiply' _logger.debug('Key: %s (%r, %r)', key, event.keyval, event.hardware_keycode) if event.get_state() & Gdk.ModifierType.CONTROL_MASK: if key in self.CTRL_KEYMAP: f = self.CTRL_KEYMAP[key] return f(self) elif (event.get_state() & Gdk.ModifierType.SHIFT_MASK) and \ key in self.SHIFT_KEYMAP: f = self.SHIFT_KEYMAP[key] return f(self) elif str(key) in self.IDENTIFIER_CHARS: self.button_pressed(self.TYPE_TEXT, key) elif key in self.KEYMAP: f = self.KEYMAP[key] if isinstance(f, str) or \ isinstance(f, str): self.button_pressed(self.TYPE_TEXT, f) else: return f(self) return True def get_older(self): self.showing_version = max(0, self.showing_version - 1) if self.showing_version == len(self.old_eqs) - 1: self.buffer = self.text_entry.get_text() if len(self.old_eqs) > 0: self.text_entry.set_text( self.old_eqs[self.showing_version].equation) def get_newer(self): self.showing_version = min(len(self.old_eqs), self.showing_version + 1) if self.showing_version == len(self.old_eqs): self.text_entry.set_text(self.buffer) else: self.text_entry.set_text( self.old_eqs[self.showing_version].equation) def add_text(self, input_str): self.button_pressed(self.TYPE_TEXT, input_str) # This function should be split up properly def button_pressed(self, str_type, input_str): sel = self.text_entry.get_selection_bounds() pos = self.text_entry.get_position() # If selection by tab completion just manipulate end if len(sel) == 2 and self.select_reason != self.SELECT_SELECT: pos = sel[1] sel = () self.text_entry.grab_focus() if len(sel) == 2: (start, end) = sel text = self.text_entry.get_text() elif len(sel) != 0: _logger.error('button_pressed(): len(sel) != 0 or 2') return False if str_type == self.TYPE_FUNCTION: if len(sel) == 0: self.text_entry.insert_text(input_str + '()', pos) self.text_entry.set_position(pos + len(input_str) + 1) else: self.text_entry.set_text( text[:start] + input_str + '(' + text[start:end] + ')' + text[end:]) self.text_entry.set_position(end + len(input_str) + 2) elif str_type == self.TYPE_OP_PRE: if len(sel) == 2: pos = start self.text_entry.insert_text(input_str, pos) self.text_entry.set_position(pos + len(input_str)) elif str_type == self.TYPE_OP_POST: if len(sel) == 2: pos = end elif pos == 0: ans = self.format_insert_ans() input_str = ans + input_str self.ans_inserted = True self.text_entry.insert_text(input_str, pos) self.text_entry.set_position(pos + len(input_str)) elif str_type == self.TYPE_TEXT: tlen = len(self.text_entry.get_text()) if len(sel) == 2: tlen -= (end - start) if tlen == 0 and (input_str in self._chars_ans_diadic) and \ self.parser.get_var('Ans') is not None and \ type(self.parser.get_var('Ans')) is not str: ans = self.format_insert_ans() self.text_entry.set_text(ans + input_str) self.text_entry.set_position(len(ans) + len(input_str)) self.ans_inserted = True elif len(sel) == 2: self.text_entry.set_text(text[:start] + input_str + text[end:]) self.text_entry.set_position( pos + start - end + len(input_str)) else: self.text_entry.insert_text(input_str, pos) self.text_entry.set_position(pos + len(input_str)) else: _logger.error(_('button_pressed(): invalid type')) def message_received(self, msg, **kwargs): _logger.debug('Message received: %s(%r)', msg, kwargs) value = kwargs.get('value', None) if msg == "add_eq": eq = Equation(eqnstr=str(value), ml=self.ml) self.add_equation(eq) elif msg == "req_sync": data = [] for eq in self.old_eqs: data.append(str(eq)) self.send_message("sync", value=data) elif msg == "sync": self.clear_equations() for eq_str in value: _logger.debug('receive_message: %s', str(eq_str)) self.add_equation(Equation(eqnstr=str(eq_str)), ml=self.ml) def _joined_cb(self, gobj): _logger.debug('Requesting synchronization') self.send_message('req_sync') def format_insert_ans(self): ans = self.parser.get_var('Ans') if isinstance(ans, Rational): return str(ans) elif ans is not None: return self.ml.format_number(ans) else: return ''
def setUp(self): self.matlib = MathLib()
class matlibTest(unittest.TestCase): def setUp(self): self.matlib = MathLib() def test_add(self): self.assertEqual(self.matlib.add(1, 2), 3) self.assertEqual(self.matlib.add(-2, 2), 0) self.assertEqual(self.matlib.add(0.002, -0), 0.002) self.assertEqual(self.matlib.add(-2.5, -1.5), -4) self.assertEqual(self.matlib.add(0, 0), 0) self.assertRaises(TypeError, self.matlib.add) self.assertRaises(TypeError, self.matlib.add, 2) def test_sub(self): self.assertEqual(self.matlib.sub(4, 2), 2) self.assertEqual(self.matlib.sub(0, 2), -2) self.assertEqual(self.matlib.sub(-0.00005, 4), -4.00005) self.assertEqual(self.matlib.sub(4, -2), 6) self.assertEqual(self.matlib.sub(0, 0), 0) self.assertRaises(TypeError, self.matlib.sub) self.assertRaises(TypeError, self.matlib.sub, 2) def test_mul(self): self.assertEqual(self.matlib.mul(2, 5), 10) self.assertEqual(self.matlib.mul(0.0005, 0.1), 0.00005) self.assertEqual(self.matlib.mul(-2, 5), -10) self.assertEqual(self.matlib.mul(-2, -5), 10) self.assertEqual(self.matlib.mul(2, 0), 0) self.assertEqual(self.matlib.mul(0, 0), 0) self.assertRaises(TypeError, self.matlib.mul) self.assertRaises(TypeError, self.matlib.mul, 2) def test_div(self): self.assertEqual(self.matlib.div(8, 4), 2) self.assertEqual(self.matlib.div(8, -2), -4) self.assertEqual(self.matlib.div(8, 0.4), 20) self.assertEqual(self.matlib.div(0.8, 4), 0.2) self.assertEqual(self.matlib.div(0, 4), 0) self.assertEqual(self.matlib.div(-0, 4), 0) self.assertRaises(ZeroDivisionError, self.matlib.div, 5, 0) self.assertRaises(TypeError, self.matlib.div) self.assertRaises(TypeError, self.matlib.div, 2) def test_fac(self): self.assertEqual(self.matlib.fac(5), 120) self.assertEqual(self.matlib.fac(1), 1) self.assertEqual(self.matlib.fac(0), 1) self.assertEqual(self.matlib.fac(2), 2) self.assertRaises(TypeError, self.matlib.fac) self.assertRaises(Exception, self.matlib.fac, -2) self.assertRaises(Exception, self.matlib.fac, 1.55) def test_root_n(self): self.assertEqual(self.matlib.root_n(4, 2), 2) self.assertEqual(self.matlib.root_n(0, 5), 0) self.assertEqual(self.matlib.root_n(1, 6), 1) self.assertEqual(self.matlib.root_n(10.89, 2), 3.3) self.assertEqual(self.matlib.root_n(10.903204, 2), 3.302) self.assertRaises(TypeError, self.matlib.root_n) self.assertRaises(Exception, self.matlib.root_n, -2) def test_pow_x_y(self): self.assertEqual(self.matlib.pow_x_y(4, 2), 16) self.assertEqual(self.matlib.pow_x_y(0.5, 3), 0.125) self.assertEqual(self.matlib.pow_x_y(1, 200), 1) self.assertEqual(self.matlib.pow_x_y(0, 200), 0) self.assertEqual(self.matlib.pow_x_y(0, 0), 1) self.assertEqual(self.matlib.pow_x_y(251, 0), 1) self.assertEqual(self.matlib.pow_x_y(251, 0), 1) self.assertEqual(self.matlib.pow_x_y(2, -2), 0.25) self.assertEqual(self.matlib.pow_x_y(2, 2.2), 4.59479341998814) self.assertRaises(TypeError, self.matlib.pow_x_y) def test_log_n(self): self.assertEqual(self.matlib.log_n(2), 0.6931471805599454) self.assertEqual(self.matlib.log_n(1.1), 0.09531017980432499) self.assertEqual(self.matlib.log_n(1), 0) self.assertEqual(self.matlib.log_n(2.8), 1.0296194171811583) self.assertEqual(self.matlib.log_n(284), 5.648974238161206) self.assertRaises(Exception, self.matlib.log_n, 0) self.assertRaises(Exception, self.matlib.log_n, 0) self.assertRaises(Exception, self.matlib.log_n, -1) self.assertRaises(TypeError, self.matlib.log_n)
def setUp(self): self.math = MathLib()
class MathLibTests(TestCase): def setUp(self): self.math = MathLib() # Tests for add function def test_add_positive(self): self.assertEqual(self.math.add(1, 3), 4) self.assertEqual(self.math.add(13, 19), 32) self.assertEqual(self.math.add(0, 1), 1) self.assertEqual(self.math.add(1, 0), 1) self.assertEqual(self.math.add(0, 0), 0) def test_add_negative(self): self.assertEqual(self.math.add(-1, -3), -4) self.assertEqual(self.math.add(-25, -56), -81) self.assertEqual(self.math.add(-1, 0), -1) self.assertEqual(self.math.add(0, -1), -1) def test_add_both(self): self.assertEqual(self.math.add(-1, 2), 1) self.assertEqual(self.math.add(1, -2), -1) self.assertEqual(self.math.add(-23, 56), 33) self.assertEqual(self.math.add(20, -20), 0) self.assertEqual(self.math.add(-1, 1), 0) def test_add_float(self): self.assertAlmostEqual(self.math.add(-1.5, -3.5), -5, 1) self.assertAlmostEqual(self.math.add(5.3, 10.4), 15.7, 1) self.assertAlmostEqual(self.math.add(5.4, -5.3), 0.1, 1) self.assertAlmostEqual(self.math.add(-1.3, 3.3), 2, 1) # Tests for sub function def test_sub_positive(self): self.assertEqual(self.math.subtract(7, 3), 4) self.assertEqual(self.math.subtract(3, 7), -4) self.assertEqual(self.math.subtract(0, 3), -3) self.assertEqual(self.math.subtract(3, 0), 3) self.assertEqual(self.math.subtract(0, 0), 0) self.assertEqual(self.math.subtract(10, 10), 0) self.assertEqual(self.math.subtract(54, 22), 32) def test_sub_negative(self): self.assertEqual(self.math.subtract(-4, -3), -1) self.assertEqual(self.math.subtract(-3, -4), 1) self.assertEqual(self.math.subtract(0, -3), 3) self.assertEqual(self.math.subtract(-3, 0), -3) self.assertEqual(self.math.subtract(-56, -45), -11) def test_sub_both(self): self.assertEqual(self.math.subtract(7, -3), 10) self.assertEqual(self.math.subtract(-7, 3), -10) self.assertEqual(self.math.subtract(54, -10), 64) self.assertEqual(self.math.subtract(-54, 10), -64) def test_sub_float(self): self.assertEqual(self.math.subtract(5.5, 3.3), 2.2) self.assertEqual(self.math.subtract(-7.4, -2.4), -5) self.assertEqual(self.math.subtract(10.5, -2.4), 12.9) self.assertEqual(self.math.subtract(-5.2, 10), -15.2) # Tests for multiply function def test_multiply_positive(self): self.assertEqual(self.math.multiply(3, 2), 6) self.assertEqual(self.math.multiply(2, 3), 6) self.assertEqual(self.math.multiply(0, 2), 0) self.assertEqual(self.math.multiply(4, 0), 0) self.assertEqual(self.math.multiply(0, 0), 0) self.assertEqual(self.math.multiply(45, 23), 1035) def test_multiply_negative(self): self.assertEqual(self.math.multiply(-3, -2), 6) self.assertEqual(self.math.multiply(0, -2), 0) self.assertEqual(self.math.multiply(-2, 0), 0) self.assertEqual(self.math.multiply(-12, -34), 408) def test_multiply_both(self): self.assertEqual(self.math.multiply(3, -2), -6) self.assertEqual(self.math.multiply(-3, 2), -6) self.assertEqual(self.math.multiply(-12, 2), -24) self.assertEqual(self.math.multiply(2, -12), -24) def test_multiply_float(self): self.assertAlmostEqual(self.math.multiply(3.3, 2.2), 7.26, 2) self.assertAlmostEqual(self.math.multiply(-6.2, -2.1), 13.02, 2) self.assertAlmostEqual(self.math.multiply(-3.3, 2.2), -7.26, 2) self.assertAlmostEqual(self.math.multiply(6.2, -2.1), -13.02, 2) # Tests for divide function def test_divide_positive(self): self.assertEqual(self.math.divide(5, 1), 5) self.assertEqual(self.math.divide(1, 2), 0.5) self.assertEqual(self.math.divide(0, 1), 0) self.assertEqual(self.math.divide(55, 2), 27.5) def test_divide_negative(self): self.assertEqual(self.math.divide(-10, -2), 5) self.assertEqual(self.math.divide(-1, -2), 0.5) self.assertEqual(self.math.divide(0, -2), 0) self.assertEqual(self.math.divide(-55, -11), 5) def test_divide_both(self): self.assertAlmostEqual(self.math.divide(-10, 2), -5, 1) self.assertAlmostEqual(self.math.divide(10, -2), -5, 1) self.assertAlmostEqual(self.math.divide(-55, 2), -27.5, 1) self.assertAlmostEqual(self.math.divide(55, -11), -5, 1) def test_divide_float(self): self.assertAlmostEqual(self.math.divide(5.5, 1.1), 5, 1) self.assertAlmostEqual(self.math.divide(-3.2, -0.5), 6.4, 1) self.assertAlmostEqual(self.math.divide(10.3, -2), -5.15, 2) self.assertAlmostEqual(self.math.divide(-10, 2.5), -4, 1) def test_divide_zero(self): with self.assertRaises(ValueError): self.math.divide(2, 0) # Tests for power function def test_power_even(self): self.assertEqual(self.math.power(1, 4), 1) self.assertEqual(self.math.power(2, 2), 4) self.assertEqual(self.math.power(-5, 2), 25) self.assertEqual(self.math.power(2.5, 2), 6.25) self.assertEqual(self.math.power(0, 0), 1) def test_power_odd(self): self.assertEqual(self.math.power(1, 3), 1) self.assertEqual(self.math.power(2, 3), 8) self.assertEqual(self.math.power(-2, 3), -8) self.assertEqual(self.math.power(2.5, 3), 15.625) def test_power_base(self): # Base need to be natural number with self.assertRaises(ValueError): self.math.power(2, 0) self.math.power(3, -5) self.math.power(-4, 1.5) self.math.power(5.5, -1) # Tests for root function def test_root_even(self): self.assertEqual(self.math.root(1, 2), 1) self.assertEqual(self.math.root(4, 2), 2) self.assertAlmostEqual(self.math.root(2, 2), 1.41, 2) def test_root_odd(self): self.assertEqual(self.math.root(1, 3), 1) self.assertEqual(self.math.root(27, 3), 3) self.assertEqual(self.math.root(8, 3), 2) def test_root_number(self): with self.assertRaises(ValueError): self.math.root(-5, 2) self.math.root(-1.5, 2) # Tests for sin function def test_sin(self): self.assertAlmostEqual(self.math.sin(1), 0.8415, 4) self.assertAlmostEqual(self.math.sin(5), -0.9589, 4) self.assertAlmostEqual(self.math.sin(-1), -0.8415, 4) self.assertAlmostEqual(self.math.sin(1.6), 0.9996, 4) # Tests for cos function def test_cos(self): self.assertAlmostEqual(self.math.cos(1), 0.5403, 4) self.assertAlmostEqual(self.math.cos(2), -0.4161, 4) self.assertAlmostEqual(self.math.cos(-4), -0.6536, 4) self.assertAlmostEqual(self.math.cos(1.5), 0.0707, 4) # Tests for tan function def test_tan(self): self.assertAlmostEqual(self.math.tan(1), 1.5574, 4) self.assertAlmostEqual(self.math.tan(0.8), 1.0296, 4) self.assertAlmostEqual(self.math.tan(4), 1.1578, 4) self.assertAlmostEqual(self.math.tan(3.5), 0.3746, 4) # Tests for exp function def test_exp(self): self.assertAlmostEqual(self.math.exp(1), 2.7183, 4) self.assertAlmostEqual(self.math.exp(2), 7.3891, 4) self.assertAlmostEqual(self.math.exp(-2), 0.1353, 4) self.assertAlmostEqual(self.math.exp(1.5), 4.4817, 4) # Tests for natural_log function def test_natural_log(self): self.assertEqual(self.math.natural_log(1), 0) self.assertAlmostEqual(self.math.natural_log(2), 0.6931, 4) self.assertAlmostEqual(self.math.natural_log(3.5), 1.2528, 4) def test_negative_natural_log(self): with self.assertRaises(ValueError): self.math.natural_log(0) self.math.natural_log(-5) self.math.natural_log(-2.5) # Tests for log function def test_log(self): self.assertAlmostEqual(self.math.log(1), 0, 1) self.assertAlmostEqual(self.math.log(100), 2, 1) self.assertAlmostEqual(self.math.log(2), 0.3010, 4) def test_negative_log(self): with self.assertRaises(ValueError): self.math.log(0) self.math.log(-1) self.math.log(-2.5) def test_factorial(self): self.assertEqual(self.math.factorial(12), 479001600) self.assertEqual(self.math.factorial(5), 120) self.assertEqual(self.math.factorial(1), 1) self.assertEqual(self.math.factorial(0), 1) with self.assertRaises(ValueError): self.math.factorial(-1) self.math.factorial(-100) self.math.factorial(-1.01) self.math.factorial(0.99) self.math.factorial(10.5)