Esempio n. 1
0
def check(x, ks):
    if not ks:
        return "empty sequence"
    if len(ks) > 100000:
        return "sequence too long."
    ka = ks.split(',')

    try:
        c = Calculator()
        for k in ka:
            c.click(k)

        if c.equal(x):
            return "passed"
        else:
            return "your result " + str(
                c.v) + " is not equal to " + str(x) + " (max_error = 1e-5)."

    except CalculatorUnknownKey:
        return "there're unknown key(s)."
    except ValueError:
        return "value error"
    except ZeroDivisionError:
        return "float division by zero"
    except Exception as e:
        print(e)
        return "system error"
Esempio n. 2
0
 def test_add(self):
     """
     Test add function from class Calculator
     """
     calcu = Calculator()
     result = calcu.add(3, 4)
     self.assertEqual(result, 7)
Esempio n. 3
0
class CalculatorTest(unittest.TestCase):
    Calculator = Calculator()

    def test_add(self):
        self.assertEqual(4, self.Calculator.add(2, 2))
        self.assertEqual(-2, self.Calculator.add(3, -5))
        self.assertEqual(5.2, self.Calculator.add(3, 2.2))

    def test_multiple(self):
        self.assertEqual(30, self.Calculator.multiple(5, 6))
        self.assertEqual(-30, self.Calculator.multiple(-5, 6))
        self.assertEqual(66.6, self.Calculator.multiple(3, 22.2))

    def test_subtract(self):
        self.assertEqual(2, self.Calculator.subtract(4, 2))
        self.assertEqual(-2, self.Calculator.subtract(2, 4))
        self.assertEqual(6.7, self.Calculator.subtract(10, 3.3))

    def test_divide(self):
        self.assertEqual(3, self.Calculator.divide(9, 3))
        self.assertEqual(-3, self.Calculator.divide(-9, 3))
        self.assertEqual(3.5, self.Calculator.divide(10.5, 3))
        with self.assertRaises(ZeroDivisionError):
            self.Calculator.divide(2, 0)

    def test_x_and_y_are_not_numbers(self):
        self.assertRaises(ValueError, self.Calculator.add, 'two', 'three')
        self.assertRaises(ValueError, self.Calculator.add, 'two', 3)
        self.assertRaises(ValueError, self.Calculator.add, 2, 'three')
Esempio n. 4
0
    def process_request(self, message: str) -> str:
        """Processes HTTP request and returns response."""
        parser = HTTPParser()
        response = HTTPResponse()
        calc = Calculator()

        request = parser.parse_request(message)

        # Invalid request (no expression sent)
        if (not request["params"] or "expression" not in request["params"]):

            print("Request is invalid. Missing parameters.")
            return response.build_response(status=406, data="-1")

        expression = request["params"]["expression"][0]
        print("{}Expression received:{} {}".format(bcolors.OKBLUE,
                                                   bcolors.ENDC, expression))

        # Evaluate the expression
        try:
            result = calc.evaluate(expression)
            print("{}Expression valid{}, result = {}".format(
                bcolors.OKGREEN, bcolors.ENDC, result))

            return response.build_response(status=200, data=result)

        # Send error message if not valid
        except Exception as exc:
            print("{}An exception occurred:{} {} ({})".format(
                bcolors.FAIL, bcolors.ENDC, str(exc),
                type(exc).__name__))

            return response.build_response(status=406, data="-1")

        return ""
def test_calc_stats():
    values = [6, 9, 15, -2, 92, 11]
    calc = Calculator(values)

    assert calc.min == -2
    assert calc.max == 92
    assert calc.len == 6
    assert calc.avg == 21.833333333333332
def repl():
    calc = Calculator()
    while True:
        line = input('> ')
        try:
            print(calc.parse(line))
        except SyntaxError as e:
            print(f'Syntax Error: {e.msg}')
Esempio n. 7
0
    def test_add(self, input_a, input_b, expected_result):
        print("test_add()")
        print("input_a", input_a)
        print("input_b", input_b)
        print("expected_result", expected_result)

        calc = Calculator()
        self.assertEqual(calc.add(input_a, input_b), expected_result)
Esempio n. 8
0
def main():
    """
    main function
    realization of calculation of simples operations
    """
    #pass
    print(__name__)
    calc = Calculator()
    print(calc.add())
Esempio n. 9
0
def test_div():

    calc = Calculator()

    assert calc.divide(5, 5) == 1
    assert calc.divide(5, -5) == -1
    assert calc.divide(5, 3) == 1
    assert calc.divide(5, -3) == -2
    assert calc.divide(5, '$') == 'invalid input'
    assert calc.divide(5, 0) == "Could not calcuate with given input"
def caclulate():
    calc = Calculator()
    data = request.json
    try:
        equation = data['to_calculate']
        result = calc.calculate(equation)
    except KeyError:
        return make_response({"error": "Missing required parameter 'to_caclulate'"}, 400)
    except:
        return make_response({"error": "Could not process equation"}, 400)

    return make_response({'result': result}, 200)
Esempio n. 11
0
    def calc(self, i):
        self.setWindowTitle("Calculator")

        if i == "=":
            formel = self.textLine.text().replace("=", "")

            clc = Calculator()
            try:
                r = clc.worker(formel)
            except ZeroDivisionError as ident:
                r = ""
                self.setWindowTitle("Zero Divison Error")

            self.textLine.setText(str(r))
Esempio n. 12
0
    def __init__(self, log, id, mode, memOC, coreUC, fanSpeed, steps,
                 powerLimit, nbrOfShares, nbrOfDatapoints, marginInMH,
                 powerCost, dollarPerMHash):
        # basics
        self.id = id
        self.log = log
        self.existing = False
        self.calc = Calculator(marginInMH, powerCost, dollarPerMHash)
        self.nvTool = NVTool(self.log, self.id)

        # overall Tuning Variables
        self.maxMemClockFound = False
        self.minCoreClockFound = False
        self.minPowerLimitFound = False

        # HW settings
        self.fanSpeed = fanSpeed
        self.memOC = memOC
        self.coreUC = coreUC
        self.powerLimit = powerLimit

        # tuning variables
        self.mode = mode
        self.steps = steps
        self.nbrOfShares = nbrOfShares
        self.margin = marginInMH
        self.nbrOfDatapoints = nbrOfDatapoints

        ## DATA TO CALCULATE ON ##
        # speed data via mining software
        self.currentMinerData = []
        self.lastMinerData = []
        self.overheatingThreshold = 5
        self.thermalLimitReached = 0

        # hw data of GPU via nvidia-smi
        self.currentHWData = []
        self.lastHWData = []

        ## HELPER VARIABLES ##
        self.dataSummary = []
        self.maxSpeed = 0.0
        self.defaultPowerLimit = 0.0
        self.tuningTries = 0

        ## TUNING PROCESS VARIABLES
        self.requiresRestart = False
        self.tuningDone = False

        self.found = self.Initialize()
Esempio n. 13
0
class CalculatorTest(unittest.TestCase):
    # init class
    calculator = Calculator()

    # test adder
    def test_add(self):
        self.assertEqual(4, self.calculator.add(2, 2))
        self.assertEqual(3.2, self.calculator.add(1, 2.2))

    # test subtracter
    def test_minus(self):
        self.assertEqual(2, self.calculator.minus(3, 1))
        self.assertEqual(-2, self.calculator.minus(1, 3))

    # test mult
    def test_multiple(self):
        self.assertEqual(12, self.calculator.multiple(3, 4))
        self.assertEqual(13.5, self.calculator.multiple(3, 4.5))

    # test div
    def test_divide(self):
        self.assertEqual(3, self.calculator.divide(9, 3))
Esempio n. 14
0
 def test_substract(self):
     #result = Calculator().add(10,5)
     self.assertEqual(Calculator().minus(10, 5), 5)
     self.assertEqual(Calculator().minus(100, -5), 105)
Esempio n. 15
0
#!/usr/bin/env python

import codewars_test as test
from calc import Calculator

test.it("Tests")
for key, val in {
        "127": 127,
        "2 + 3": 5,
        "2 - 3 - 4": -5,
        "10 * 5 / 2": 25,
        "2 / 2 + 3 * 4 - 6": 7,
        "2 + 3 * 4 / 3 - 6 / 3 * 3 + 8": 8,
        "1.1 + 2.2 + 3.3": 6.6,
        "1.1 * 2.2 * 3.3": 7.986
}.items():
    actual = Calculator().evaluate(key)
    test.expect(isinstance(actual, (float, int)),
                "Your result should be a number, not: " + str(type(actual)))
    test.expect(
        abs(actual - val) < 1e-12,
        "Expected %s == %s, but got %s" % (key, val, actual))
Esempio n. 16
0
 def test_add(self):
     print('Test add(self, num1, num2) ')
     calc = Calculator()
     result = calc.add(10, 20)
     self.assertEqual(result, 30, 'Match expected value')
Esempio n. 17
0
 def test_div(self):
     print('Test div(self, num1, num2) ')
     calc = Calculator()
     result = calc.div(20, 5)
     self.assertEqual(result, 4, 'Match expected value')
Esempio n. 18
0
 def test_mul(self):
     print('Test mul(self, num1, num2) ')
     calc = Calculator()
     result = calc.mul(3, 6)
     self.assertEqual(result, 18, 'Match expected value')
Esempio n. 19
0
char = ["+", "-", "/", "*"]
newdata = []
cond = True

while cond:
    for ch in char:
        #print(ch)
        newdata = data.split(ch)
        #print(len(newdata))
        if len(newdata) == 2:
            cond = False
            break
#print(newdata)
for d in newdata:
    try:
        newdata[0] = float(newdata[0])
        newdata[1] = float(newdata[1])
    except ValueError:
        print('errror!')
        sys.exit()
        break
    else:
        c = Calculator(newdata[0], newdata[1])
        actionlst = [c.Add(), c.Sub(), c.Mul(), c.Div()]
        cond = True
for i, character in enumerate(char):
    #print("----")
    if ch == character:
        print(actionlst[i])
        break
Esempio n. 20
0
import unittest
from calc import Calculator
c = Calculator()


class TestCalc1(unittest.TestCase):
    def testIncre(self):
        a = 19
        b = 10
        s = 9
        sum = c.Incre(a, b)
        self.assertEquals(s, sum)

    def testIncre1(self):
        a = -19
        b = 10
        s = -29
        sum = c.Incre(a, b)
        self.assertEquals(s, sum)

    def testIncre2(self):
        a = 19
        b = -10
        s = 29
        sum = c.Incre(a, b)
        self.assertEquals(s, sum)

    def testIncre3(self):
        a = -19
        b = -10
        s = -9
Esempio n. 21
0
    def test_adds_single_number(self):
        calculator = Calculator()

        calculator.add(1)

        self.assertEqual(calculator.total, 1)
Esempio n. 22
0
    def process_data(self):
        calc = Calculator()
        plotter = Plotter()
        rpm_data = []
        rpm_str = []
        for filename in self.file_list:
            print(filename)
            _filename = filename.replace(".txt", "").split("/")[-1]
            day, time, id, iteration = _filename.split('_')
            df_list, ps_shapes, ps_annos, amp_shapes, amp_annos = calc.get_formatted_data(
                filename, 10000)
            filename = filename.replace(".txt", "")
            time_data = []
            shapes = []
            annos = []
            df = pd.concat(df_list)
            if myConfig.get("t_c_dc"):
                time_data.append(
                    plotter.make_graph(df, "time", "current_dc",
                                       " {}|{}".format(id, iteration)))
                time_data.append(
                    plotter.make_graph(df, "time", "eff_curr_dc",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_v_dc"):
                time_data.append(
                    plotter.make_graph(df, "time", "voltage_dc",
                                       " {}|{}".format(id, iteration)))
                time_data.append(
                    plotter.make_graph(df, "time", "eff_volt_dc",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_c_ac_1"):
                time_data.append(
                    plotter.make_graph(df, "time", "current_1",
                                       " {}|{}".format(id, iteration)))
                time_data.append(
                    plotter.make_graph(df, "time", "eff_curr_1",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_c_ac_2"):
                time_data.append(
                    plotter.make_graph(df, "time", "current_2",
                                       " {}|{}".format(id, iteration)))
                time_data.append(
                    plotter.make_graph(df, "time", "eff_curr_2",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_c_ac_3"):
                time_data.append(
                    plotter.make_graph(df, "time", "current_3",
                                       " {}|{}".format(id, iteration)))
                time_data.append(
                    plotter.make_graph(df, "time", "eff_curr_3",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_v_ac_1"):
                time_data.append(
                    plotter.make_graph(df, "time", "voltage_1",
                                       " {}|{}".format(id, iteration)))
                time_data.append(
                    plotter.make_graph(df, "time", "eff_volt_1",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_v_ac_2"):
                time_data.append(
                    plotter.make_graph(df, "time", "voltage_2",
                                       " {}|{}".format(id, iteration)))
                time_data.append(
                    plotter.make_graph(df, "time", "eff_volt_2",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_v_ac_3"):
                time_data.append(
                    plotter.make_graph(df, "time", "voltage_3",
                                       " {}|{}".format(id, iteration)))
                time_data.append(
                    plotter.make_graph(df, "time", "eff_volt_3",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_rpm"):
                time_data.append(
                    plotter.make_graph(df, "time", "rpm",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_torque"):
                time_data.append(
                    plotter.make_graph(df, "time", "torque",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_input"):
                time_data.append(
                    plotter.make_graph(df, "time", "input",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_output"):
                time_data.append(
                    plotter.make_graph(df, "time", "output",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_output_dc"):
                time_data.append(
                    plotter.make_graph(df, "time", "output_dc",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_eff"):
                time_data.append(
                    plotter.make_graph(df, "time", "efficiency",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("t_amp"):
                shapes += amp_shapes
                annos += amp_annos
            if myConfig.get("t_ps"):
                shapes += ps_shapes
                annos += ps_annos
            if myConfig.get("t_volt_orig"):
                time_data.append(
                    plotter.make_graph(df, "time", "_voltage_1",
                                       " {}|{}".format(id, iteration)))
                time_data.append(
                    plotter.make_graph(df, "time", "_voltage_2",
                                       " {}|{}".format(id, iteration)))
                time_data.append(
                    plotter.make_graph(df, "time", "_voltage_3",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("rpm_c_dc"):
                rpm_data.append(
                    plotter.make_graph(df, "rpm", "current_dc",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("rpm_v_dc"):
                rpm_data.append(
                    plotter.make_graph(df, "rpm", "voltage_dc",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("rpm_c_ac_1"):
                rpm_data.append(
                    plotter.make_graph(df, "rpm", "current_1",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("rpm_c_ac_2"):
                rpm_data.append(
                    plotter.make_graph(df, "rpm", "current_2",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("rpm_c_ac_3"):
                rpm_data.append(
                    plotter.make_graph(df, "rpm", "current_3",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("rpm_v_ac_1"):
                rpm_data.append(
                    plotter.make_graph(df, "rpm", "voltage_1",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("rpm_v_ac_2"):
                rpm_data.append(
                    plotter.make_graph(df, "rpm", "voltage_2",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("rpm_v_ac_3"):
                rpm_data.append(
                    plotter.make_graph(df, "rpm", "voltage_3",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("rpm_torque"):
                rpm_data.append(
                    plotter.make_graph(df, "rpm", "torque",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("rpm_input"):
                rpm_data.append(
                    plotter.make_graph(df, "rpm", "input",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("rpm_output"):
                rpm_data.append(
                    plotter.make_graph(df, "rpm", "output",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("rpm_output_dc"):
                time_data.append(
                    plotter.make_graph(df, "time", "output_dc",
                                       " {}|{}".format(id, iteration)))
            if myConfig.get("rpm_eff"):
                rpm_data.append(
                    plotter.make_graph(df, "rpm", "efficiency",
                                       " {}|{}".format(id, iteration)))
            if time_data:
                i = 0
                htmlname = _filename
                while True:
                    if glob.glob("graphs/{}.{}".format(htmlname, ".html")):
                        i += 1
                        htmlname = htmlname.replace("({})".format(i - 1),
                                                    "") + "({})".format(i)
                        continue
                    break

                plotter.plot_it(time_data,
                                "graphs/{}.{}".format(htmlname,
                                                      "html"), shapes, annos)

            i = 0
            excelname = _filename
            while True:
                if glob.glob("excels/{}.{}".format(excelname, "xlsx")):
                    i += 1
                    excelname = excelname.replace("({})".format(i - 1),
                                                  "") + "({})".format(i)
                    continue
                break
            writer = pd.ExcelWriter("excels/{}.{}".format(excelname, "xlsx"))
            df.to_excel(writer)
            writer.save()
            rpm_str.append("{}-{}".format(id, iteration))
        if rpm_data:
            i = 0
            rpmname = "RPM " + "_".join(rpm_str)
            while True:
                if glob.glob("graphs/{}.".format(rpmname, "html")):
                    i += 1
                    rpmname = rpmname.replace("({})".format(i - 1),
                                              "") + "({})".format(i)
                    continue
                break
            plotter.plot_it(rpm_data, "graphs/{}.{}".format(rpmname, "html"),
                            shapes, annos)
Esempio n. 23
0
 def setUp(self):
     self.C = Calculator()
Esempio n. 24
0
 def test_multi(self):
     #result = Calculator().add(10,5)
     self.assertEqual(Calculator().multi(10, 5), 50)
     self.assertEqual(Calculator().multi(100, -5), -500)
Esempio n. 25
0
    def test_divide_two_numbers(self):
        calculator = Calculator()

        calculator.divide(1,0)
Esempio n. 26
0
 def test_div(self):
     #result = Calculator().add(10,5)
     self.assertEqual(Calculator().div(10, 5), 2)
     self.assertEqual(Calculator().div(100, 2), 50)
Esempio n. 27
0
from calc import Calculator
from calc import Advanced_calculator

my_calc = Calculator()

print(my_calc.add(5,4))
print(my_calc.add(4,6))
print(my_calc.history)
print(my_calc.result)
my_calc.memory_save()
print (my_calc.memory)
print(my_calc.add(4,None))

print(my_calc.mul(5,4))
print(my_calc.div(7,6))
print(my_calc.sub(10,6))

print(my_calc.div(7,0))


print(my_calc.history)
my_calc.clear_history()
print(my_calc.history)

my_calc.memory_save()
print (my_calc.memory, " add")
my_calc.clear_memory()
print (my_calc.memory, " clear")

print(my_calc.sub(10,15))
Esempio n. 28
0
 def test_add(self):
     #result = Calculator().add(10,5)
     self.assertEqual(Calculator().add(10, 5), 15)
     self.assertEqual(Calculator().add(100, -5), 95)
Esempio n. 29
0
 def setUp(self):
     self.calc = Calculator()
Esempio n. 30
0
 def test_sub(self):
     print('Test sub(self, num1, num2) ')
     calc = Calculator()
     result = calc.sub(20, 6)
     self.assertEqual(result, 14, 'Match expected value')