Exemple #1
0
    def solve(self, diff: DifferentialEq, precision=4) -> Tuple[Function]:
        '''
        Returns tuple of (method-derived function, LTE function, GTE function)
        '''
        # getting result function and lte
        result, lte, _ = self.__execute_method(
            diff.f,
            diff.solution,
            diff.x_0,
            diff.y_0,
            diff.x_n,
            diff.n,
            precision=precision,
        )

        # calculate gte for all n from `n_start` to `n_end`
        gte = Function()
        for n in range(diff.n_start, diff.n_end + 1):
            _, _, gte_values = self.__execute_method(
                diff.f,
                diff.solution,
                diff.x_0,
                diff.y_0,
                diff.x_n,
                n,
                precision=precision,
            )
            gte.append(n, max(gte_values.Y))

        return result, lte, gte
Exemple #2
0
class KalmanFilter:
    f = Function()
    h = Function()
    x = 0
    P = 0

    def __init__(self, *args, **kwargs):
        if 'f' in kwargs: self.f = kwargs['f']
        if 'h' in kwargs: self.h = kwargs['h']
        if 'x' in kwargs: self.x = kwargs['x']
        if 'P' in kwargs: self.P = kwargs['P']

    def predict(self, Q):
        xhat = self.f.interpolate(self.x)
        P = self.f.D(self.x) * self.P * self.f.D(self.x) + Q
        return xhat, P

    def update(self, xhat, P, z, R):
        H = self.h.D(xhat)
        ytilde = z - self.h.interpolate(xhat)
        S = H * P * H + R
        K = P * H / S
        xhat_new = xhat + K * ytilde
        P_new = (1 - K * H) * P
        return xhat_new, P_new
Exemple #3
0
    def grow(self, depth=None):
        """ Grows a random child node by 1, limited by `depth` (if provided)
            and arity restrictions.  Returns the new node (or None if no
            node can be expanded).

        Args:
            depth: int (default=None)

        Returns:
            Node instance (or None)
        """
        # Creates a random permutation of child nodes
        nodes_depths = list(self.descendants_and_self_with_depths())
        shuffle(nodes_depths)

        for node, d in nodes_depths:
            if len(node.children) >= node.func.arity:
                continue

            if d >= depth:
                continue

            if d == depth - 1:
                func = Function.random_terminal()
            else:
                func = Function.random_function()
            child = Node(func)
            node.add_child(child)
            return child

        # If no children can be expanded, return None
        return None
Exemple #4
0
    def get_function(self, parameter):

        # find the appropriate set of data points

        lower_param = float("inf")
        upper_param = 0
        lower_data = []
        upper_data = []
        for d in self.data:
            print d
            if d[0] < lower_param:
                lower_param = d[0]
                lower_data = d[1]
            if d[0] > upper_param:
                upper_param = d[0]
                upper_data = d[1]

        print lower_data
        print upper_data

        # now split them into some sensible number of points

        num_points = max(len(lower_data), len(upper_data))
        lower_function = reslice_function(Function(data=lower_data), num_points)
        upper_function = reslice_function(Function(data=upper_data), num_points)

        lower_function.show()
        upper_function.show()
        
        return merge_functions(lower_function, upper_function,
                               (parameter - lower_param) / (upper_param - lower_param))
Exemple #5
0
def send_call_distance():
    Database = json.loads(R_data.get("My_data"))
    print('Begin')
    log_db = 'Log_API_FIND_DISTANCE'
    lat = request.args.get('latitude', type=float)  # lat
    lon = request.args.get('longitude', type=float)  # long
    filters = request.args.get('range', default=1.5, type=float)  # filter

    if type(lat) != float or type(lon) != float:
        log = {
            "timestamp": str(datetime.now()),
            "log": "error please check you reqeust message"
        }

        send_data(log_db, log)
        return jsonify({'message':
                        'error please check you reqeust message'}), 421

    else:
        input_1 = Function(lat, lon, filters, Database)
        data = input_1.think()

        res = {"res": data, "timestamp": str(datetime.now())}

        log = {"timestamp": str(datetime.now()), "log": data}
        print('before_send_log' + str(datetime.now()))
        send_data(log_db, log)
        print('after_send_log' + str(datetime.now()))
        return jsonify(res)
Exemple #6
0
    def invoke(self):
        functions = [
            Function("y = sin(x)", lambda x: np.sin(x)),
            Function("y = sin(x) + cos(x)", lambda x: np.sin(x) + np.cos(x)),
            Function("y = 3x^3 - 2x^2 + 2",
                     lambda x: 3 * np.power(x, 3) - 2 * np.power(x, 2) + 2)
        ]
        log(
            "> {} Welcome to interpolation world {}\n".format(
                self.DASH, self.DASH), COLOR.HEADER)
        log("> Please choose your function:\n", COLOR.OKGREEN)
        for i, func in enumerate(functions):
            print("> {}. {}".format(i, func.to_str()))
        log("> Enter your option: ", COLOR.OKGREEN)
        opt_func = int(input())

        chosen_func = functions[opt_func]

        log(self.DASH * 3 + '\n', COLOR.HEADER)
        log("> Please choose the way to generate interpolation points: \n",
            COLOR.OKGREEN)
        log("> 0. Manual\n")
        log("> 1. Auto generate (random points)\n")
        log("> Enter your option: ", COLOR.OKGREEN)
        opt_gene = int(input())

        x = self.generate(opt_gene)
        y_org = chosen_func.f(x)

        lagrange = Lagrange(x, y_org)
        y_lag = [lagrange.f(xi) for xi in x]

        self.draw(x, y_org, y_lag, chosen_func, lagrange)
    def get(self, fn, *args):
        """get returns the matching function from the virtual namespace.

        return None if it did not fund any matching function.
        """
        func = Function(fn, self)
        return self.function_map.get(func.key(args=args))
Exemple #8
0
    def grow(self, depth=None):
        """ Grows a random child node by 1, limited by `depth` (if provided)
            and arity restrictions.  Returns the new node (or None if no
            node can be expanded).

        Args:
            depth: int (default=None)

        Returns:
            Node instance (or None)
        """
        # Creates a random permutation of child nodes
        nodes_depths = list(self.descendants_and_self_with_depths())
        shuffle(nodes_depths)

        for node, d in nodes_depths:
            if len(node.children) >= node.func.arity:
                continue

            if d >= depth:
                continue

            if d == depth - 1:
                func = Function.random_terminal()
            else:
                func = Function.random_function()
            child = Node(func)
            node.add_child(child)
            return child

        # If no children can be expanded, return None
        return None
Exemple #9
0
 def __init__(self):
     Function.__init__(self)
     self.setupUi(self)
     self.setFixedSize(self.width(), self.height())  # 禁止窗口拉伸和最大化
     self.setWindowTitle('批量修改工具')
     # self.setWindowIcon(QIcon(QPixmap('./lib/img/smile_96px.png')))
     self.setWindowIcon(self.smileLogo())
     # self.pix = QPixmap('./res/img/long60x60.png')
     self.ico.setPixmap(self.chuanLogo())
     self.DirChoiceBtn_1.clicked.connect(self.SelectFile_1)
     self.DirChoiceBtn_2.clicked.connect(self.SelectFile_2)
     self.DirChoiceBtn_3.clicked.connect(self.SelectFile_3)
     self.DirChoiceBtn_4.clicked.connect(self.SelectFile_4)
     self.DirChoiceBtn_5.clicked.connect(self.SelectFile_5)
     self.DirChoiceBtn_6.clicked.connect(self.SelectFile_6)
     self.DirChoiceBtn_7.clicked.connect(self.SelectFile_7)
     self.DirChoiceBtn_8.clicked.connect(self.SelectFile_8)
     self.DirChoiceBtn_9.clicked.connect(self.SelectFile_9)
     self.DirChoiceBtn_10.clicked.connect(self.SelectFile_10)
     self.time = QTimer()  # 初始化计时器
     self.time.setInterval(6000)  # 设置计时器时间为6秒,一秒为1000毫秒
     self.IpChangeBtn.clicked.connect(self.change_func)  # 按钮激活计时开始,修改按钮文本
     self.time.timeout.connect(self.referch)  # 计时结束还原按钮文本
     self.pushButton.clicked.connect(self.clear_all)
     self.init_view_info()
Exemple #10
0
 def opcode_132(self, oparg):
     # define MAKE_FUNCTION           132
     name = self.stack.pop()
     mycode = self.stack.pop()
     f = Function(name, mycode)
     for i in f.freevars:
         f.dict[i] = self.dict[i]
     self.stack.push(f)
 def register(self, fn):
     """register the function in the virtual namespace and returns
     an instance of callable Function that wraps the
     function fn
     """
     func = Function(fn, self)
     self.function_map[func.key()] = fn
     return func
Exemple #12
0
 def test_cubic_derivative(self):
     a = cubic_derivative_approximation(
         Function.power(Function.identity(), Function.constant(3)),
         4, 10)
     self.assertAlmostEqual(a(0), 0)
     self.assertAlmostEqual(a(2), 8)
     self.assertAlmostEqual(a(5), 125)
     self.assertAlmostEqual(a(12), 1728)
     self.assertAlmostEqual(a(-3), -27)
Exemple #13
0
    def function_decl(self, tree):
        class_type_object = tree._meta
        if len(tree.children) == 4:
            ident = tree.children[1]
            formals = tree.children[2]
            stmt_block = tree.children[3]
        else:
            ident = tree.children[0]
            formals = tree.children[1]
            stmt_block = tree.children[2]

        symbol_table_object = SymbolTableObject(scope=stack[-1], name=ident)
        symbol_table[(
            stack[-1],
            ident.value,
        )] = self.counter
        self.counter += 1
        function = Function(name=ident.value,
                            label=stack[-1] + "/" + ident.value)

        if type(tree.children[0]) == lark.tree.Tree:
            object_type = tree.children[0]
            object_type._meta = symbol_table_object
            self.visit(object_type)
            function.return_type = symbol_table_object.type
        else:
            symbol_table_object.type.name = 'void'
            function.return_type.name = 'void'

        if class_type_object:
            this = Tree(data='variable',
                        children=[
                            Tree(data='type',
                                 children=[
                                     Token(type_='PRIMITIVE',
                                           value=class_type_object.name)
                                 ]),
                            Token(type_='IDENT', value='this')
                        ])
            temp = formals.children.copy()
            formals.children = [this] + temp

        stack.append(stack[-1] + "/" + ident)
        formals._meta = function
        self.visit(formals)
        stack.append(stack[-1] + "/_local")
        self.visit(stmt_block)
        stack.pop()  # pop _local
        stack.pop()  # pop formals

        if class_type_object:
            class_type_object.functions.append(function)
            pass
        else:
            function_table[function.name] = self.static_function_counter
            function_objects.append(function)
            self.static_function_counter += 1
Exemple #14
0
    def __init__(self, cursor, comment):
        Function.__init__(self, cursor, comment)

        self.static = cursor.is_static_method()
        self.virtual = cursor.is_virtual_method()

        self.abstract = True
        self._override = None

        self.update_abstract(cursor)
Exemple #15
0
    def __init__(self, cursor, comment):
        Function.__init__(self, cursor, comment)

        self.static = cursor.is_static_method()
        self.virtual = cursor.is_virtual_method()

        self.abstract = True
        self._override = None

        self.update_abstract(cursor)
Exemple #16
0
    def fixed_point(self, expr_g, x0, tolerance, n):
        '''
        It calculates an approximation to a root through finding an intersection
        between y = x and x = g(x) where g(x) is derivated from the function f.

        parameters:
            - x0 : initial point
            - expr_g: function expresion derivated from f
            - tolerance: maximum allowed error
            - n: number of iterations until failure
        '''

        if tolerance < 0:
            print(f"innapropiate tolerance = {tolerance}")
        elif n < 1:
            print(f"innapropiate number of iterations = {n}")
        else:
            fx = self.__function.eval(x0)
            count = 0
            error = tolerance + 1

            data = {
                "x": np.array([x0], dtype=np.float64),
                "f(x)": np.array([fx], dtype=np.float64),
                "E": np.array([np.NaN], dtype=np.float64)
            }

            g = Function(expr_g)

            while fx != 0 and error > tolerance and count < n:
                xn = g.eval(x0)
                fx = self.__function.eval(xn)
                error = self.__error(x0, xn)
                x0 = xn
                count += 1

                data["x"] = np.append(data["x"], [xn])
                data["f(x)"] = np.append(data["f(x)"], [fx])
                data["E"] = np.append(data["E"], [error])
            if fx == 0:
                print(f"{x0} is a root")

            elif error < tolerance:
                print(
                    f"{x0} is an approximation to a root with tolerance = {tolerance}"
                )
            else:
                print(f"failure in {n} iterations")

            data_frame = pd.DataFrame(data,
                                      columns=("x", "f(x)", "E"),
                                      dtype=np.float64)
            data_frame.index.name = "n"
            print(data_frame)
Exemple #17
0
    def mutate_float(node, score_tree, eps=1e-1):
        """ Takes a Node object and optimizes floats greedily.
            Returns a new tree.

            Args:
                node: Node object to operate on
                score_tree: function that takes a tree
                    and returns a fitness (as float)
                eps: learning rate (as float) (default=1e-1)

            Returns:
                Node object
        """
        # Copy the tree
        new_tree = node.deepcopy()

        # Find all floating leaves
        floats = new_tree.all_floats()
        if floats == []:
            return None

        has_changed = False

        for f in floats:
            value = f.func.func()
            left_value = value - eps
            right_value = value + eps

            func = f.func
            left_func = Function.make_float_function(left_value)
            left_func = Function(left_func, 0, str(left_value))
            right_func = Function.make_float_function(right_value)
            right_func = Function(right_func, 0, str(right_value))

            score = score_tree(new_tree)
            f.func = left_func
            left_score = score_tree(new_tree)
            f.func = right_func
            right_score = score_tree(new_tree)

            max_ = max(left_score, score, right_score)
            if abs(max_ - left_score) < 1e-10:
                f.func = left_func
                has_changed = True
            elif abs(max_ - right_score) < 1e-10:
                f.func = right_func
                has_changed = True
            else:
                f.func = func

        if not has_changed:
            return None

        return new_tree
Exemple #18
0
    def mutate_float(node, score_tree, eps=1e-1):
        """ Takes a Node object and optimizes floats greedily.
            Returns a new tree.

            Args:
                node: Node object to operate on
                score_tree: function that takes a tree
                    and returns a fitness (as float)
                eps: learning rate (as float) (default=1e-1)

            Returns:
                Node object
        """
        # Copy the tree
        new_tree = node.deepcopy()

        # Find all floating leaves
        floats = new_tree.all_floats()
        if floats == []:
            return None

        has_changed = False

        for f in floats:
            value = f.func.func()
            left_value = value - eps
            right_value = value + eps

            func = f.func
            left_func = Function.make_float_function(left_value)
            left_func = Function(left_func, 0, str(left_value))
            right_func = Function.make_float_function(right_value)
            right_func = Function(right_func, 0, str(right_value))

            score = score_tree(new_tree)
            f.func = left_func
            left_score = score_tree(new_tree)
            f.func = right_func
            right_score = score_tree(new_tree)

            max_ = max(left_score, score, right_score)
            if abs(max_ - left_score) < 1e-10:
                f.func = left_func
                has_changed = True
            elif abs(max_ - right_score) < 1e-10:
                f.func = right_func
                has_changed = True
            else:
                f.func = func

        if not has_changed:
            return None

        return new_tree
Exemple #19
0
class Manager:
    '''
    Class for managing changes of values of diff. eq
    '''
    def __init__(self, diff: DifferentialEq, methods: List[Method],
                 solution_color):
        self.diff = diff
        self.methods = methods
        self.functions: Dict[List[Function]] = {
            str(method):
            [Function(name=str(method), color=method.color) for _ in range(3)]
            for method in methods
        }
        self.solution = Function(name='Analytical solution',
                                 color=solution_color)
        self.update()

    def update(self,
               x_0=None,
               y_0=None,
               x_n=None,
               n=None,
               n_start=None,
               n_end=None):
        logging.info(
            f"Update differential eq with {x_0}, {y_0}, {x_n}, {n}, {n_start}, {n_end}"
        )
        self.diff.x_0 = x_0 or self.diff.x_0
        self.diff.y_0 = y_0 or self.diff.y_0
        self.diff.x_n = x_n or self.diff.x_n
        self.diff.n = n or self.diff.n
        self.diff.n_start = n_start or self.diff.n_start
        self.diff.n_end = n_end or self.diff.n_end

        for method in self.methods:
            for func, new_func in zip(self.functions[method.__str__()],
                                      method.solve(self.diff)):

                #logging.debug(f"Function assign {func} {new_func}")
                func.assign(new_func)

        self.__update_solution()

    def __update_solution(self):
        new_solution = Function(func=self.diff.solution,
                                start=self.diff.x_0,
                                stop=self.diff.x_n,
                                num=self.diff.n)
        self.solution.assign(new_solution)

    def hide_methods(self, methods: Dict[str, bool]):
        for method in methods:
            for func in self.functions[method]:
                func.hide = methods[method]
Exemple #20
0
def function_handler():
    data = request.get_json()
    print data
    commands = data.pop('commands', None)
    if commands is None:
        return jsonify({'status': 1, 'message': "错误的指令序列!", 'data': data})

    func = Function(commands)
    func.run()

    return jsonify({'status': 1, 'message': "success", 'data': data})
Exemple #21
0
def recursively_generate_cubics(f, left, right, depth = 5):
    for a in approximate(f, left, right):
        if is_bounded(Function.sum(f, Function.product(
                    Function.constant(-1), a)), Interval(left, right),
                      Interval(-.008, .008)):
            return [a]
    if depth == 0:
        return []
    middle = (left + right) / 2
    return recursively_generate_cubics(f, left, middle, depth-1) + \
        recursively_generate_cubics(f, middle, right, depth-1)
Exemple #22
0
 def __init__(self, diff: DifferentialEq, methods: List[Method],
              solution_color):
     self.diff = diff
     self.methods = methods
     self.functions: Dict[List[Function]] = {
         str(method):
         [Function(name=str(method), color=method.color) for _ in range(3)]
         for method in methods
     }
     self.solution = Function(name='Analytical solution',
                              color=solution_color)
     self.update()
Exemple #23
0
    def create_functions(self):
        self.functions.append(Function(0, 0, 1, dummy=True))
        for i in range(1, self.num_functions+1):
            if i==1:
                self.functions.append(
                    Function(i, self.func_cost[i], self.func_sel[i], is_first=True))
            else:
                self.functions.append(
                    Function(i, self.func_cost[i], self.func_sel[i], is_last=False, prev_func=self.functions[i - 1]))

            self.functions[i-1].next_func = self.functions[i]
        self.functions[self.num_functions].is_last = True
Exemple #24
0
 def set_data(self, data):
     """set_data
     Set the data value of the current node
     :param data: The data
     """
     self.data = data
     self.head = self.data
     self.part0 = self.head.part0
     self.part1 = self.head.part1
     self.others = [Function(x) for x in self.get_paths_to_leaves()]
     if len(self.others) == 0:
         self.others.append(Function([]))
 def __init__(self, master):
     self.fun = Function()
     self.cf = configparser.ConfigParser()
     self.root = master
     self.root.title('Reptile Douyin')
     self.root.resizable(width=False, height=False)
     width = 500
     height = 180
     self.root.geometry('%dx%d' % (width, height))
     self.create_window()
     self.root.protocol("WM_DELETE_WINDOW",
                        self.on_closing)  # 协议,处理与Windows的互动
    def setUp(self):
        # Setting up some functions
        data1 = {"x": [1.0, 2.0, 3.0], "y": [5.0, 6.0, 7.0]}
        self.dataframe1 = pd.DataFrame(data=data1)

        data2 = {"x": [1.0, 2.0, 3.0], "y": [7.0, 8.0, 9.0]}
        self.dataframe2 = pd.DataFrame(data=data2)

        self.function1 = Function("name")
        self.function1.dataframe = self.dataframe1

        self.function2 = Function("name")
        self.function2.dataframe = self.dataframe2
 def __init__(self, head, others, name="tf"):
     """__init__
     Initialize a fake tree function. For now, the order of the nodes which
     are not the head is not important.
     :param head: The head of the tree. It is a path
     :param others: The other paths
     :param name:
     """
     self.head = Function(head)
     self.others = [Function(x) for x in others]
     self.part0 = self.head.part0
     self.part1 = self.head.part1
     self.name = name
def run(step, point_type, lambda_p, method):

    f = Function(lambda_p)

    n = f.get_size()  # x size

    # Initial point
    if point_type == "const":
        x0 = np.ones(n)
    else:
        x0 = np.random.uniform(-2, 2, n)

    mxitr = 50000  # Max number of iterations

    tol_g = 1e-8  # Tolerance for gradient

    tol_x = 1e-8  # Tolerance for x

    tol_f = 1e-8  # Tolerance for function

    # Method for step update
    if step == "fijo":
        msg = "StepFijo"

    elif step == "hess":
        msg = "StepHess"

    else:
        msg = "Backtracking"

    step_size = 1  # Gradient step size for "StepFijo" method

    # Estimate minimum point through optimization method chosen
    if method == "gd":
        alg = GD()
    elif method == "newton":
        alg = Newton()
    else:
        print("\n Error: Invalid optimization method: %s\n" % method)
        return

    xs = alg.iterate(x0, mxitr, tol_g, tol_x, tol_f, f, msg, step_size)

    # Print point x found and function value f(x)
    # print("\nPoint x found: ", xs[-1])
    print("\nf(x) =  ", f.eval(xs[-1]))

    plt.plot(np.array(range(n)), xs[-1])
    plt.plot(np.array(range(n)), f.y)
    plt.legend(['x*', 'y'], loc = 'best')
    plt.show()
Exemple #29
0
 def __init__(self, parent=None):
     super(MainWindow, self).__init__(parent)
     self.setupUi(self)
     self.function = Function()
     self.endDateEdt.setDate(QDate.currentDate())
     self.initSlots()
     self.chargeTable.setHorizontalHeaderLabels(
         ['id', '成员', '类型', '金额(元)', '日期', '备注'])
     self.memberTable.setHorizontalHeaderLabels(['id', '姓名', '备注'])
     self.memberTable.setColumnHidden(0, True)
     self.chargeTable.setColumnHidden(0, True)
     self.updateMemberUI()
     self.updateTypeUI()
     self.updateChargeTable()
Exemple #30
0
def main():
    obj_func = Function('../target_code')

    best_styles = {}
    if os.path.exists('../.clang-format'):
        with open('../.clang-format') as f:
            best_styles = yaml.load(f)

    maps = style_maps()
    keys = []
    for key, vals in maps.items():
        keys.append(key)
    keys = sorted(keys)

    exclusion_keys = [key for key in best_styles.keys() if not (key in keys)]
    for key in exclusion_keys:
        best_styles.pop(key)

    best_styles = convert(best_styles)
    best_fval = obj_func.evaluate(best_styles)
    print('best styles: %s, best fval: %f\n' % (best_styles, best_fval))

    influential_keys = []
    uninfluential_keys = []

    for key in keys:
        is_influential = False
        vals = maps[key]
        vals = [val for val in vals if val != best_styles[key]]

        for val in vals:
            styles = deepcopy(best_styles)
            styles[key] = val
            fval = obj_func.evaluate(styles)
            print('key: %s, val: %s, fval: %f' % (key, val, fval))
            if fval != best_fval:
                is_influential = True

        print('%s is %s\n' %
              (key, 'influential' if is_influential else 'uninfluential'))

        if is_influential:
            influential_keys.append(key)
        else:
            uninfluential_keys.append(key)

    print('influential keys: %s\n' % influential_keys)
    print('uninfluential keys: %s\n' % uninfluential_keys)
Exemple #31
0
 def get_function(self) -> Function:
     """get_function
     Gets the function representation of the node
     :return: The function representation of the node
     :rtype: Function
     """
     return Function(self.value)
Exemple #32
0
 def add_function(self, *args, **kwargs):
     """
     Add a function to the module/namespace. See the documentation for
     :meth:`Function.__init__` for information on accepted parameters.
     """
     if len(args) >= 1 and isinstance(args[0], Function):
         func = args[0]
         warnings.warn(
             "add_function has changed API; see the API documentation",
             DeprecationWarning,
             stacklevel=2)
         if len(args) == 2:
             func.custom_name = args[1]
         elif 'name' in kwargs:
             assert len(args) == 1
             func.custom_name = kwargs['name']
         else:
             assert len(args) == 1
             assert len(kwargs) == 0
     else:
         try:
             func = Function(*args, **kwargs)
         except utils.SkipWrapper:
             return None
     self._add_function_obj(func)
     return func
Exemple #33
0
    def __init__(self):
        '''Metodo de inicializacion'''
        self.functions = {}
        self.functions['global'] = Function()
        self.scope = 'global'

        # Define si se esta evaluando la existencia de variables o se estan agregando al directorio
        self.evaluating = True

        # Indica si es necesario acutlaizar la lista de prametros de una funcion
        self.updating_params = False

        # Indica si se va a leer variable con funcion read
        self.reading = False

        # Ultimo token ID, usado para el read
        self.last_id = Stack()

        # Ultimo token de tipo que fue leido por el directorio de funciones
        self.last_type = None
        '''Funciones que estan siendo llamadas.
        Se utiliza una pila para llamadas nesteadas a funciones'''
        self.call_function = Stack()
        '''Cantidad de argumentos que estan siendo utilizados al llamar a una funcion.
        Se utiliza una pilla para llamadas nesteadas'''
        self.call_arguments = Stack()

        self.last_read = Stack()
Exemple #34
0
 def addFunc(self, ast_node):
   func = Function(ast_node, self)
   if func.name in self.funcs:
     raise Exception('Function %s is already defined' % name)
   else:
     self.funcs[func.name] = func
   return func
Exemple #35
0
 def __init__(self, head: Node, sons=None, name: str = "regf") -> None:
     """__init__
     Initialize the synthax tree
     :param head: The head of the tree
     :param sons: The sons of the root node
     :param name: The name of the tree
     :type head: a Node, a string representing a regex or a string \
                 for * (kleen),\
                 . (concatenation) or | (or) or anything else
     :type sons: A list of RegexTree
     :type name: str
     """
     self.name = name
     if head.is_str() and head.get_str() == "":
         # If the head is the empty string, we stop
         self.head = Node(Function([]))
         if sons:
             self.sons = sons[:]
         else:
             self.sons = []
         self.original_string = ""
     elif head.is_str() and head.get_str() not in ["|", "*", "."]:
         # We have a string representing a regex to parse
         new_head = head.get_str()
         self.init_from_string(new_head)
         self.original_string = new_head
         self.post_processing()
     else:
         self.head = head
         if sons:
             self.sons = sons[:]
         else:
             self.sons = []
         self.original_string = ""
Exemple #36
0
	def __init__(self, pt_left_bot, pt_right_top, win):
		self.function = Function("0")
		self.p1 = pt_left_bot
		self.p2 = pt_right_top
		self.graph_area = Rectangle(self.p1, self.p2)
		self.win = win
		self.accuracy = 0.1
		self.objects_drawn = []
Exemple #37
0
 def test_depth(self):
     f = Function.sum(Function.power(Function.identity(),
                                     Function.constant(2)),
                      Function.identity())
     # This requires splitting in half
     self.assertTrue(is_bounded(f, Interval(-1,0), Interval(-3/4,1/2), 1))
     self.assertEqual(is_bounded(f, Interval(-1,0), Interval(-3/4,1/2), 0),
                      None)
     # This requires 3 levels of recursion
     self.assertTrue(is_bounded(f, Interval(-1,0), Interval(-3/8,1/8), 3))
     self.assertEqual(is_bounded(f, Interval(-1,0), Interval(-3/8,1/8), 2),
                      None)
     # This requires 8 levels of recursion
     self.assertTrue(is_bounded(f, Interval(-1,0), Interval(-65/256,1/256),
                                8))
     self.assertEqual(is_bounded(f, Interval(-1,0), Interval(-65/256,1/256),
                                 7), None)
Exemple #38
0
def main():
	Maths.generateMathExpressions()
	print("Available operators:")
	for o in Maths.Expressions:
		print(Maths.Expressions[o].getAbbreviation())

	print("-------------------------")
	f = Function("cos(3*x)+6/4*(x+3)", False)
	print("RPN String", f.getRpnString())
	for x in range (2, 11):
		f.compute(x)

	print("-------------------------")

	f = Function("56*((6+2)/(8-x)*2^3", False)
	print("RPN String", f.getRpnString()) #should give 56 6 2 + 8 7 - / 2 3 ^ * *


	mainwindow = MainWindow("Function Drawer", 992, 512)
	fx = f.computeRange(0, 10)
	max_y = max(fx.values())
	min_y = min(fx.values())

	print(min_y, max_y)
	mainwindow.setCoords(-1, min_y, 11, max_y)
	for x in range(0, 11):
		print(fx[x])
		p = Point(x, fx[x])
		p.draw(mainwindow)

	input("Press a key to quit")
Exemple #39
0
    def test_approx(self):
        f = Function.identity()
        for a in approximate(f, 0, 1):
            self.assertTrue(isinstance(a, Function))
            self.assertTrue(isinstance(a, CubicSpline))
            # We may someday generate approximations that don't go through
            # the endpoints, and remove these tests.  Until then, they
            # help verify that the approximation formulas are correct.
            self.assertEqual(a(0.0), 0.0)
            self.assertEqual(a(1.0), 1.0)

        # (-x^2 - 1) ^ .5
        bad = Function.power(Function.sum(Function.product(
                Function.constant(-1),
                Function.power(Function.identity(), Function.constant(2))),
                                          Function.constant(-1)),
                             Function.constant(.5))
        self.assertEqual(list(approximate(bad, 0, 1)), [])
    def create_full_tree(depth):
        """ Creates a tree using the full method with depth `depth`.
            Returns the root node.

        Args:
            depth: int

        Returns:
            Node instance
        """
        if depth == 0:
            # Generate a leaf node
            terminal = Function.random_terminal()
            node = Node(terminal)
            return node
        else:
            # Generate an intermediate node
            func = Function.random_function()
            node = Node(func)

            for _ in range(func.arity):
                node.add_child(TreeMethods.create_full_tree(depth - 1))
            return node
Exemple #41
0
    def __init__(self, t0, t1, f0, c0, c1, f1):
        self.__t0 = t0
        self.__t1 = t1
        self.__f0 = f0
        self.__c0 = c0
        self.__c1 = c1
        self.__f1 = f1

        # The specific functional form will have consequences for the
        # efficiency of interval arithmetic (and thus, slicing).

        # t' = (t-t0)/(t1-t0)
        t = Function.product(Function.sum(Function.identity(), Function.constant(-t0)),
                             Function.constant(1.0/(t1-t0)))

        omt = Function.sum(Function.constant(1), Function.product(Function.constant(-1), t))
        def term(const, f):
            return Function.sum(Function.constant(const), Function.product(t, f))
        a = -f0 + 3*c0 - 3*c1 + f1
        b = 3*f0 - 6*c0 + 3*c1
        c = -3*f0 + 3*c0
        d = f0

        WrappedFunction.__init__(self, term(d, term(c, term(b, Function.constant(a)))).weak_simplify())
Exemple #42
0
 def test_simple(self):
     self.assertTrue(is_bounded(Function.identity(), Interval(0,1),
                                Interval(0,1)))
     self.assertFalse(is_bounded(Function.identity(), Interval(0,2),
                                 Interval(0,1)))
     self.assertFalse(is_bounded(Function.identity(), Interval(-1,1),
                                 Interval(0,1)))
     self.assertFalse(is_bounded(Function.identity(), Interval(-1,2),
                                 Interval(0,1)))
     self.assertTrue(is_bounded(Function.constant(0.), Interval(3,4),
                                Interval(0,1)))
     self.assertFalse(is_bounded(Function.constant(2.), Interval(3,4),
                                 Interval(0,1)))
    def create_grow_tree(depth):
        """ Creates a tree using the grow method with depth `depth`. Note
        that since grow ends when all leaf nodes are 0-arity, it is
        possible that the tree generated by this method has a depth
        less than `depth`.

        Args:
            depth: int

        Returns:
            Node instance
        """
        func = Function.random_function()
        root = Node(func)

        while True:
            if root.grow(depth) is None:
                break

        return root
Exemple #44
0
    def initialize_traj(self, mode):
        # see comment at top of ll_prob.py for mode options
        if self.trust_region_cnt is not None:
            self.model.remove(self.trust_region_cnt)
        self.clean(self.trust_temp)

        for constraint in self.constraints:
            constraint.clean()

        obj = grb.QuadExpr()
        for var in self.vars:
            if var.get_val() is not None and var.recently_sampled:
                obj += 1e5 * self.l2_norm_diff_squared(self.model, var)
            elif var.get_val() is not None and var.is_resampled:
                obj += 1 * self.l2_norm_diff_squared(self.model, var)
        if mode == "straight":
            obj += grb.quicksum(self.obj_quad)
        elif mode == "l2":
            for var in self.vars:
                if var.get_val() is not None:
                    obj += self.l2_norm_diff_squared(self.model, var)
        elif mode == "minvel":
            for var in self.vars:
                if var.hl_param.is_traj:
                    K = var.hl_param.num_dofs()
                    T = var.hl_param.num_timesteps()
                    KT = K * T
                    v = -1 * np.ones((KT - K, 1))
                    d = np.vstack((np.ones((KT - K, 1)), np.zeros((K, 1))))
                    # [:,0] allows numpy to see v and d as one-dimensional so
                    # that numpy will create a diagonal matrix with v and d as a diagonal
                    P = np.diag(v[:, 0], K) + np.diag(d[:, 0])
                    # minimum-velocity finite difference
                    Q = np.dot(np.transpose(P), P)
                    obj += Function.quad_expr((var.get_grb_vars(self) - var.get_val()).flatten(order="f"), Q)
        else:
            raise NotImplementedError

        return self.optimize(objective=obj)
Exemple #45
0
#!/usr/bin/env python
# -*- coding:utf-8 -*-

# print 'team:%s,name:%s'%(self.team, self.name)

from function import Function
import function


if __name__=="__main__":
	
	print "please input the number that a,b,c,d for function"
	a,b,c,d = map(int, raw_input('input a,b,c,d=').split(","))
	func=Function(a,b,c,d)
	
	func.showinfo()

	while True:
		print "input l,r | l<r & f(l)*f(r)<0"
		l,r = map(float,raw_input('input l,r=').split(","))
	
		if (func.fnf(l)<func.fnf(r)) and (func.fnf(l)*func.fnf(r)<0):
			print "correct"
			break
		else:
			print "wrong numbers (l>r or f(l)*f(r)>=0)"

	th = float(raw_input('please input threshold:'))
	

	k=0
Exemple #46
0
#!/usr/bin/env python
# -*- coding:utf-8 -*-

import math

from function import Function
import function

if __name__ == '__main__':

	print "please input the number that a,b,c,d for function"
	a,b,c,d = map(int, raw_input('input a,b,c,d=').split(","))
	func=Function(a,b,c,d)

	func.showinfo()

	while True:
		print "input x,r | x<r & f(x)*f(r)<0"
		x,r = map(float,raw_input('input x,r=').split(","))
	
		if (func.fnf(x)<func.fnf(r)) and (func.fnf(x)*func.fnf(r)<0):
			print "correct"
			break
		else:
			print "wrong numbers (x>r or f(x)*f(r)>=0)"

	th = float(raw_input('please input threshold:'))


	k=0
Exemple #47
0
def solve(n_cells, degree=3, with_plot=False):
    # Problem
    w = 3 * np.pi
    x = Symbol("x")
    u = sin(w * x)
    f = -u.diff(x, 2)

    # As Expr
    u = Expression(u)
    f = Expression(f)

    # Space
    # element = HermiteElement(degree)
    poly_set = leg.basis_functions(degree)
    dof_set = chebyshev_points(degree)
    element = LagrangeElement(poly_set, dof_set)

    mesh = IntervalMesh(a=-1, b=1, n_cells=n_cells)
    V = FunctionSpace(mesh, element)
    bc = DirichletBC(V, u)

    # Need mass matrix to intefrate the rhs
    M = assemble_matrix(V, "mass", get_geom_tensor=None, timer=0)
    # NOTE We cannot you apply the alpha transform idea because the functions
    # are mapped with this selective weight on 2nd, 3rd functions. So some rows
    # of alpha would have to be multiplied by weights which are cell specific.
    # And then on top of this there would be a dx = J*dy term. Better just to
    # use the qudrature representations
    # Mpoly_matrix = leg.mass_matrix(degree)
    # M_ = assemble_matrix(V, Mpoly_matrix, Mget_geom_tensor, timer=0)

    # Stiffness matrix for Laplacian
    A = assemble_matrix(V, "stiffness", get_geom_tensor=None, timer=0)
    # NOTE the above
    # Apoly_matrix = leg.stiffness_matrix(degree)
    # A_ = assemble_matrix(V, Apoly_matrix, Aget_geom_tensor, timer=0)

    # Interpolant of source
    fV = V.interpolate(f)
    # Integrate in L2 to get the vector
    b = M.dot(fV.vector)

    # Apply boundary conditions
    bc.apply(A, b, True)
    x = spsolve(A, b)

    # As function
    uh = Function(V, x)

    # This is a (slow) way of plotting the high order
    if with_plot:
        fig = plt.figure()
        ax = fig.gca()
        uV = V.interpolate(u)

        for cell in Cells(mesh):
            a, b = cell.vertices[0, 0], cell.vertices[1, 0]
            x = np.linspace(a, b, 100)

            y = uh.eval_cell(x, cell)
            ax.plot(x, y, color=random.choice(["b", "g", "m", "c"]))

            y = uV.eval_cell(x, cell)
            ax.plot(x, y, color="r")

            y = u.eval_cell(x, cell)
            ax.plot(x, y, color="k")

        plt.show()

    # Error norm in CG high order
    fine_degree = degree + 3
    poly_set = leg.basis_functions(fine_degree)
    dof_set = chebyshev_points(fine_degree)
    element = LagrangeElement(poly_set, dof_set)

    V_fine = FunctionSpace(mesh, element)
    # Interpolate exact solution to fine
    u_fine = V_fine.interpolate(u)
    # Interpolate approx solution fine
    uh_fine = V_fine.interpolate(uh)

    # Difference vector
    e = u_fine.vector - uh_fine.vector

    # L2
    if False:
        Apoly_matrix = leg.mass_matrix(fine_degree)
        get_geom_tensor = lambda cell: 1.0 / cell.Jac

    # Need matrix for integration of H10 norm
    else:
        Apoly_matrix = leg.stiffness_matrix(fine_degree)
        get_geom_tensor = lambda cell: cell.Jac

    A_fine = assemble_matrix(V_fine, Apoly_matrix, get_geom_tensor, timer=0)

    # Integrate the error
    e = sqrt(np.sum(e * A_fine.dot(e)))
    # Mesh size
    hmin = mesh.hmin()

    # Add the cond number
    kappa = np.linalg.cond(A.toarray())

    return hmin, e, kappa, A.shape[0]
Exemple #48
0
 def get(self):
     func = _lib.myelin_vtable_get(self)
     return Function.from_pointer(func)
Exemple #49
0
def prepare(code):
    lines = filter(lambda line: not re.match(r'^\s*//.*', line), code.split('\n'))
    lines = re.sub(r'\s+', ' ', ''.join(lines)).strip().split(';')
    lines = filter(lambda line: not re.match(r'^\s*$', line), lines)
    return [Function.parse(line) for line in lines]
def parseFunction(fp,dataset):
    """
    FUNCTION IfcVectorSum
	(Arg1, Arg2 : IfcVectorOrDirection)
	: IfcVector;
    """
    func=Function()      
    
    #Function name 
    name=geti(fp)   

    #args begin
    token=geti(fp)
    if token!='(':
        log.error('Function has no args, line %d'%common.counter)
        return

    #args
    token=geti(fp)
    while True:
        args=[token]
        token=geti(fp)
        if token==',':
            while token!=':':   
                token=geti(fp)
                args.append(token)
                token=geti(fp)
        if token==':':
            value=''
            token=geti(fp)              
            while token!=';' and token!=')':
                value+=token+' '
                token=geti(fp)              
            
        for arg in args:
            func.arg[arg]=value.strip()
        
        if token==')':
            break

        #next element
        token=geti(fp)
    
    #:
    token=geti(fp)
    if token!=':':
        log.error('Function ret has no :, line %d'%common.counter)
        return

    #ret
    ret=''
    token=geti(fp)
    while token!=';':
        ret+=token+' '
        token=geti(fp)

    func.ret=ret.strip()
    
    #local
    parseLocal(fp,func)

    #code
    parseCode(fp,func)

    # where clause
    func.where=parseWhere(fp)       

    #parse END_TYPE
    token=geti(fp)
    if token!='END_FUNCTION':
        log.error('FUNCTION Defination has no END_FUNCTION, line %d'%common.counter)
        return
    token=geti(fp)#skip ;   
    if token!=';':
        log.error('FUNCTION Defination does not end with ;, line %d'%common.counter)
        return

    dataset.functions[name]=func
                    # Can't cast a primitive.
                    shouldUseConstructor = True
                elif args[0].func != ctor:
                    # We haven't already called the constructor on this object.
                    shouldUseConstructor = True

        # Apply our decision.
        if shouldUseConstructor:
            # Call ctor manually to avoid having promote() called on the output.
            ComputedObject.__init__(self, ctor, ctor.promoteArgs(ctor.nameArgs(args)))
        else:
            # Just cast and hope for the best.
            if not onlyOneArg:
                # We don't know what to do with multiple args.
                raise EEException("Too many arguments for ee.%s(): %s" % (name, args))
            elif firstArgIsPrimitive:
                # Can't cast a primitive.
                raise EEException("Invalid argument for ee.%s(): %s.  Must be a ComputedObject." % (name, args))
            else:
                result = args[0]
            ComputedObject.__init__(self, result.func, result.args, result.varName)

    properties = {"__init__": init, "name": lambda self: name}
    new_class = type(str(name), (ComputedObject,), properties)
    ApiFunction.importApi(new_class, name, name)
    return new_class


# Set up type promotion rules as soon the package is loaded.
Function._registerPromoter(_Promote)  # pylint: disable=protected-access
Exemple #52
0
 def test_split(self):
     # If this ever breaks, we should solve the problem by writing a
     # new kind of Function that turns a lambda expression into a
     # Function.  That way, it will never be simplified.
     # f = x^2 + x
     f = Function.sum(Function.power(Function.identity(),
                                     Function.constant(2)),
                      Function.identity())
     # f(-1) = 0, f(0) = 0, f(-.5) = -.25
     # The range of f on [-1,0] is [-.25,0]
     # f([-1,0]) = [-1,1]
     # f([-1,-.5]) = [-.75,.5]
     # f([-.5,0]) = [-.5,.25]
     # This will never finish, since it asks for the exact bounds
     self.assertTrue(is_bounded(f, Interval(-1,0), Interval(-1/4,0))
                     is None)
     # g = 1/2*x^3-3/2*x
     g = Function.sum(Function.product(
             Function.constant(.5),
             Function.power(Function.identity(),
                            Function.constant(3))),
         Function.product(Function.constant(-1.5),
                          Function.identity()))
     self.assertEqual(is_bounded(g, Interval(-1.5,1.5), Interval(-.9,1)),
                      False)
     # This encounters a ValueError on the first split so should
     # return None
     h = Function.quotient(Function.constant(1), Function.identity())
     self.assertTrue(is_bounded(h, Interval(-1,1), Interval(-5,5)) is None)
Exemple #53
0
 def term(const, f):
     return Function.sum(Function.constant(const), Function.product(t, f))
Exemple #54
0
def solve(n_cells, degree=3, with_plot=False):
    # Problem
    x = Symbol('x')
    vvvv = -0.0625*x**3/pi**3 + 0.0625*x/pi**3 + sin(2*pi*x)/(16*pi**4)
    u = -vvvv.diff(x, 2)
    f = sin(2*pi*x)

    # As Expr
    u = Expression(u)
    f = Expression(f)
    vvvv = Expression(vvvv)

    # Space
    element = HermiteElement(degree)

    mesh = IntervalMesh(a=-1, b=1, n_cells=n_cells)
    V = FunctionSpace(mesh, element)
    bc = DirichletBC(V, vvvv)

    # Need mass matrix to intefrate the rhs
    M = assemble_matrix(V, 'mass', get_geom_tensor=None, timer=0)
    # NOTE We cannot you apply the alpha transform idea because the functions
    # are mapped with this selective weight on 2nd, 3rd functions. So some rows
    # of alpha would have to be multiplied by weights which are cell specific.
    # And then on top of this there would be a dx = J*dy term. Better just to
    # use the qudrature representations
    # Mpoly_matrix = leg.mass_matrix(degree)
    # M_ = assemble_matrix(V, Mpoly_matrix, Mget_geom_tensor, timer=0)
    
    # Stiffness matrix for Laplacian
    A = assemble_matrix(V, 'bending', get_geom_tensor=None, timer=0)
    # NOTE the above
    # Apoly_matrix = leg.stiffness_matrix(degree)
    # A_ = assemble_matrix(V, Apoly_matrix, Aget_geom_tensor, timer=0)
  
    # Interpolant of source
    fV = V.interpolate(f)
    # Integrate in L2 to get the vector
    b = M.dot(fV.vector)
    
    # Apply boundary conditions
    bc.apply(A, b, True)
    x = spsolve(A, b)

    print '>>>>', np.linalg.norm(x - V.interpolate(vvvv).vector)

    ALaplace = assemble_matrix(V, 'stiffness', get_geom_tensor=None, timer=0)

    c = ALaplace.dot(x)
    y = spsolve(M, c)
    uh = Function(V, y)

    # This is a (slow) way of plotting the high order
    if with_plot:
        fig = plt.figure()
        ax = fig.gca()
        uV = V.interpolate(u)
        
        for cell in Cells(mesh):
            a, b = cell.vertices[0, 0], cell.vertices[1, 0]
            x = np.linspace(a, b, 100)

            y = uh.eval_cell(x, cell)
            ax.plot(x, y, color=random.choice(['b', 'g', 'm', 'c']))
            
            y = uV.eval_cell(x, cell)
            ax.plot(x, y, color='r')

            y = u.eval_cell(x, cell)
            ax.plot(x, y, color='k')

        plt.show()

    # Error norm
    fine_degree = degree + 3
    element = HermiteElement(fine_degree)
    
    V_fine = FunctionSpace(mesh, element)
    # Interpolate exact solution to fine
    u_fine = V_fine.interpolate(u)
    # Interpolate approx solution fine
    uh_fine = V_fine.interpolate(uh)

    # Difference vector
    e = u_fine.vector - uh_fine.vector

    # Integrate the error
    A_fine = assemble_matrix(V_fine, 'mass', get_geom_tensor=None, timer=0)
    e = sqrt(np.sum(e*A_fine.dot(e)))
    # Mesh size
    hmin = mesh.hmin()

    # Add the cond number
    kappa = np.linalg.cond(A.toarray())

    return hmin, e, kappa, A.shape[0]
Exemple #55
0
class GraphWidget:
	def __init__(self, pt_left_bot, pt_right_top, win):
		self.function = Function("0")
		self.p1 = pt_left_bot
		self.p2 = pt_right_top
		self.graph_area = Rectangle(self.p1, self.p2)
		self.win = win
		self.accuracy = 0.1
		self.objects_drawn = []

	def getFunction(self):
		return self.func
	def setFunction(self, func):
		self.function = func

	def draw(self, xa, xb):
		self.cleanGraph()
		#Compute function and draw it
		x_min = min(xa, xb)
		x_max = max(xa, xb)
		
		#Compute all the values for f functon, accuracy give the step for computation
		fx = self.function.computeRange(x_min, x_max, self.accuracy)
		y_max = max(fx.values())
		y_min = min(fx.values())
		print(y_max, y_min)
		self.win.setCoords(x_min-(1/10)*x_max, y_min-(1/10)*y_max, x_max+(1/10)*x_max, y_max+(4/10)*y_max)

		x = x_min
		end = x_max
		prevfx = fx[x]
		k = 0
		while x < (end+self.accuracy):
			#p = Point(x, fx)
			#p.draw(mainwindow)
			u = fx[x]
			if k > 0:
				self.drawLine(x-self.accuracy, prevfx, x, u)
			prevfx = u
			x += self.accuracy
			k += 1

		self.drawAxis(x_min, x_max, y_min, y_max)
		


	def drawLine(self, x1, y1, x2, y2):
		l = Line(Point(x1, y1), Point(x2, y2))
		self.objects_drawn.append(l)
		drawer = DrawerThread()
		l.setOutline("blue")
		drawer.run(l, self.win)
		return

	def drawAxis(self, x_min, x_max, y_min, y_max):
		#Draw axes
		#draw x axs first
		#we first consider we will draw it where y=0
		x_axis = Line(Point(x_min, 0), Point(x_max, 0))
		if y_max < 0:
			#if all the x values are under 0
			#then we draw the on the top
			x_axis = Line(Point(x_min, y_max), Point(x_max, y_max))
		elif y_min > 0:
			#if all the x values are over 0
			#then we draw it at the bottom
			x_axis = Line(Point(x_min, y_min), Point(x_max, y_min))
		drawer = DrawerThread()
		drawer.run(x_axis, self.win)
		self.objects_drawn.append(x_axis)

		#we consider we will draw where x=0
		y_axis = Line(Point(0, y_min), Point(0, y_max))
		if x_max < 0:
			#if all the y values are under 0
			#then we draw the on right
			y_axis = Line(Point(x_max, y_min), Point(x_max, y_max))
		elif x_min > 0:
			#if all the y values are over 0
			#then we draw it at the bottom
			y_axis = Line(Point(x_min, y_min), Point(x_min, y_max))
		
		drawer = DrawerThread()
		drawer.run(y_axis, self.win)
		self.objects_drawn.append(y_axis)

		#draw x labels
		y_ax = x_axis.getP1().getY()
		x_step = x_max*(0.1)
		x_size = y_max*.01
		#from 0 to x_max
		x = 0
		togo = x_max+0.1
		while x < togo:
			sign = Line(Point(x, y_ax-x_size), Point(x, y_ax+x_size))
			drawer = DrawerThread()
			drawer.run(sign, self.win)
			self.objects_drawn.append(sign)
			if x != 0:
				text = str(int(x))
				if abs(x) < 1:
					text = ("{0:.1f}").format(x)
				label = Text(Point(x, y_ax-6*x_size), text)
				label.setSize(8)
				label.draw(self.win)
				self.objects_drawn.append(label)
			x += x_step
		#from 0 to x_min
		x = 0
		togo = x_min-(0.1)
		while x > togo:
			sign = Line(Point(x, y_ax-x_size), Point(x, y_ax+x_size))
			drawer = DrawerThread()
			drawer.run(sign, self.win)
			self.objects_drawn.append(sign)
			if x != 0:
				text = str(int(x))
				if abs(x) < 1:
					text = ("{0:.1f}").format(x)
				label = Text(Point(x, y_ax-6*x_size), text)
				label.setSize(8)
				label.draw(self.win)
				self.objects_drawn.append(label)
			x -= x_step
		#draw y labels
		x_ax = y_axis.getP1().getX()
		y_step = y_max*(0.1)
		y_size = x_max*(0.01)
		#from 0 to y_max
		y = 0
		togo = y_max+0.1
		while y < togo:
			print(y)
			sign = Line(Point(x_ax-y_size, y), Point(x_ax+y_size, y))
			drawer = DrawerThread()
			drawer.run(sign, self.win)
			self.objects_drawn.append(sign)
			if y != 0:
				text = str(int(y))
				if abs(y) < 1:
					text = ("{0:.1f}").format(y)
					y = float(text)
				label = Text(Point(x_ax-6*y_size, y), text)
				label.setSize(8)
				label.draw(self.win)
				self.objects_drawn.append(label)
			y = y+y_step
		#from 0 to y_min
		y = 0
		print(y_max, y)
		togo = y_min-0.1
		while y > togo:
			sign = Line(Point(x_ax-y_size, y), Point(x_ax+y_size, y))
			drawer = DrawerThread()
			drawer.run(sign, self.win)
			self.objects_drawn.append(sign)
			if y != 0:
				text = str(int(y))
				if abs(y) < 1:
					text = ("{0:.1f}").format(y)
					y = float(text)
				label = Text(Point(x_ax-6*y_size, y), text)
				label.setSize(8)
				label.draw(self.win)
				self.objects_drawn.append(label)
			y = y-y_step

	def cleanGraph(self):
		undrawer = UndrawerThread()
		undrawer.run(self.objects_drawn)
		self.objects_drawn = []

	def drawWuLine(self, x1, y1, x2, y2):
		xd = x2-x1
		yd = y2-y1
		if xd == 0 or yd == 0:
			print("Normal line")
			self.drawLine(x1, y1, x2, y2)

		else:
			if abs(xd) > abs(yd):
				#this is a vertical line
				#so we switch x and y

				if x1 < x2: #algorithm works only from min to max
					swap(x1, x2)
					swap(y1, y2)
		
				grad = yd/xd

				#first end point
				xend = round(x1)
				yend = y1+grad+(xend-x1)
				xgap = rfpart(x1+0.5)
				ix1 = round(xend)
				iy1 = int(yend)
				self.drawPixel(ix1, iy1, rfpart(yend)*xgap)
				self.drawPixel(ix1, iy1+1, fpart(yend)*xgap)
				yf = yend+grad

				#second end point
				xend = round(x2)
				yend = y2+grad*(xend-x2)
				xgap = fpart(x2+0.5)
				ix2 = round(xend)
				iy2 = int(yend)
				self.drawPixel(ix2, iy2, rfpart(yend)*xgap)
				self.drawPixel(ix2, iy2+1, fpart(yend)*xgap)

				#main loop
				x = ix1+1
				while x<(ix2-1):
					self.drawPixel(x, int(yf), rfpart(yf))
					self.drawPixel(x, int(yf)+1, fpart(yf))
					yf += grad
					x += 1
			elif abs(xd) < abs(yd):
				#this is a vertical line
				#so we switch x and y

				if y1 < y2: #algorithm works only from min to max
					swap(x1, x2)
					swap(y1, y2)
		
				grad = xd/yd

				#first end point
				yend = round(y1)
				xend = x1+grad+(yend-y1)
				ygap = rfpart(y1+0.5)
				iy1 = round(yend)
				ix1 = int(xend)
				self.drawPixel(ix1, iy1, rfpart(yend)*ygap)
				self.drawPixel(ix1, iy1+1, fpart(yend)*ygap)
				xf = xend+grad

				#second end point
				yend = round(y2)
				xend = x2+grad*(yend-y2)
				ygap = fpart(y2+0.5)
				iy2 = round(yend)
				ix2 = int(xend)
				self.drawPixel(ix2, iy2, rfpart(xend)*ygap)
				self.drawPixel(ix2, iy2+1, fpart(xend)*ygap)

				#main loop
				y = iy1+1
				while y<(iy2-1):
					self.drawPixel(int(xf), y, rfpart(xf))
					self.drawPixel(int(xf)+1, y, fpart(xf))
					xf += grad
					y += 1			

	def drawPixel(self, x, y, c):
   		p = Point(x, y)
   		#we convert the transparence c(0 to 1) to a rgb value(0 to 255)
   		c = math.floor(255*(1-c))
   		p.draw(self.win)
Exemple #56
0
 def test_linear(self):
     a = linear_approximation(Function.identity(), 0, 1)
     self.assertEqual(a(3), 3)
     self.assertEqual(a(44), 44)
Exemple #57
0
	def __init__(self,x,y,*args,**kwargs):
		Function.__init__(self,"B-spline",x,y,*args,**kwargs)
        break
    spl = l.split(',')
    try:
        if spl[0].strip() != "nan" and spl[1].strip() != "nan":
            wh = float(spl[0].strip())
            v = float(spl[1].strip())
            min_v = min(min_v, v)
            max_v = max(max_v, v)
            min_wh = min(min_wh, wh)
            max_wh = max(max_wh, wh)
            data.append((v,wh))
    except Exception, e:
        print "An exception occurred: " + str(e)
        print "It's probably ok"

f = Function(data=data)

for i in xrange(len(data)):
    v = data[i][0]
    wh = data[i][1]
    data[i] = (v, (wh - min_wh) / (max_wh - min_wh))

SPACING = (max_v - min_v) / 100

fout.write('[\n')

v = min_v
while v <= max_v:
    interpolated_wh = f.interpolate(v)
    fout.write("{%d,%d},\n" % (int(v*1000000), int(interpolated_wh*1000000)))
    v += SPACING
Exemple #59
0
            t = float(spl[3].strip())

        if t == cur_time and cur_voltage_drain > 0 and cur_voltage_actual > 0:
            data.append((cur_voltage_drain, cur_voltage_actual))

        cur_time = t
    except Exception, e:
        print "An exception occurred: " + str(e)
        print "It's probably ok"

fin.close()
fout.close()

exit(0)

f = Function(data=data)

fo = open("function.csv", 'w')

for d in data:
    fo.write("%f,%f\n" % (d[0],d[1]))

fo.close()

exit(0)

# now read in 1A.csv to get voltage_actual against wh
# in = time, voltage_drain, current

last_time = 0
total_wh = 0