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)