Example #1
0
def third_task():
    implicit_limit1 = InequationLimit(lambda x, y: y - x)
    implicit_limit2 = InequationLimit(lambda x, y: 2 - x)
    explicit_limit1 = LowerLimit([-100, -100])
    explicit_limit2 = UpperLimit([100, 100])

    print_headers('BOX', '$' * 20)

    print_headers('First function', '-' * 10)
    func, start_point = get_function_and_start_point(1)
    securely_call_function_and_print_result(box,
                                            func,
                                            start_point,
                                            [implicit_limit1, implicit_limit2],
                                            [explicit_limit1, explicit_limit2],
                                            enable_output=True)
    # result = box(func, start_point, [implicit_limit1, implicit_limit2], [explicit_limit1, explicit_limit2], enable_output=True)
    # print_result(result, func)

    print_headers('Second function', '-' * 10)
    func, start_point = get_function_and_start_point(2)
    securely_call_function_and_print_result(box,
                                            func,
                                            start_point,
                                            [implicit_limit1, implicit_limit2],
                                            [explicit_limit1, explicit_limit2],
                                            enable_output=True)
Example #2
0
def first_task_golden():
    print_headers('Using golden step', '-' * 10)
    func, start_point = get_function_and_start_point(3)
    securely_call_function_and_print_result(gradient,
                                            func,
                                            start_point,
                                            shift_type='golden',
                                            enable_output=PRINT_STEPS)
Example #3
0
def second_task():
    print_headers('GRADIENT', '$' * 20)

    print_headers('First function', '-' * 10)
    func, start_point = get_function_and_start_point(1)
    securely_call_function_and_print_result(gradient,
                                            func,
                                            start_point,
                                            shift_type='golden',
                                            enable_output=PRINT_STEPS)
    # result = gradient(func, start_point, shift_type='golden', enable_output=PRINT_STEPS)
    # print_result(result, func)

    print_headers('Second function', '-' * 10)
    func, start_point = get_function_and_start_point(2)
    securely_call_function_and_print_result(gradient,
                                            func,
                                            start_point,
                                            shift_type='golden',
                                            enable_output=PRINT_STEPS)
    # result = gradient(func, start_point, shift_type='golden', enable_output=PRINT_STEPS)
    # print_result(result, func)

    print_headers('NEWTON-RAPHSON', '$' * 20)

    print_headers('First function', '-' * 10)
    func, start_point = get_function_and_start_point(1)
    securely_call_function_and_print_result(newton_raphson,
                                            func,
                                            start_point,
                                            shift_type='golden',
                                            enable_output=PRINT_STEPS)
    # result = newton_raphson(func, start_point, shift_type='golden', enable_output=PRINT_STEPS)
    # print_result(result, func)

    print_headers('Second function', '-' * 10)
    func, start_point = get_function_and_start_point(2)
    securely_call_function_and_print_result(newton_raphson,
                                            func,
                                            start_point,
                                            shift_type='golden',
                                            enable_output=PRINT_STEPS)
Example #4
0
def fifth_task():
    implicit_limit1 = InequationLimit(lambda x, y: 3 - x - y)
    implicit_limit2 = InequationLimit(lambda x, y: 3 + 1.5 * x - y)
    implicit_limit3 = EquationLimit(lambda x, y: y - 1)

    func, _ = get_function_and_start_point(4)
    start_point = (5, 5)
    securely_call_function_and_print_result(
        transformation,
        func,
        start_point, [implicit_limit1, implicit_limit2, implicit_limit3],
        enable_output=True)
Example #5
0
def fourth_task():
    implicit_limit1 = InequationLimit(lambda x, y: y - x)
    implicit_limit2 = InequationLimit(lambda x, y: 2 - x)

    print_headers('First function', '-' * 10)
    func, start_point = get_function_and_start_point(1)
    securely_call_function_and_print_result(transformation,
                                            func,
                                            start_point,
                                            [implicit_limit1, implicit_limit2],
                                            enable_output=True)
    # result = transformation(func, start_point, [implicit_limit1, implicit_limit2], enable_output=True)
    # print_result(result, func)

    print_headers('Second function', '-' * 10)
    func, start_point = get_function_and_start_point(2)
    securely_call_function_and_print_result(transformation,
                                            func,
                                            start_point,
                                            [implicit_limit1, implicit_limit2],
                                            enable_output=True)
Example #6
0
                if enable_output:
                    print(output)
                raise ArithmeticError('It exceeded maximum nr of iterations')

        total_iterations += 1

    if enable_output:
        print(output)

    return current_point


def calculate_shift_for_classic(gradient):
    shift = deepcopy(gradient)
    shift = multiply_each_element(shift, -1)
    return shift


def calculate_shift_for_golden(function, current_point, gradient):
    lambda_function = LambdaFunction(function, current_point, gradient)
    return multiply_each_element(
        gradient,
        golden_section.find_function_min(lambda_function, start_point=0))


if __name__ == '__main__':
    print(
        find_function_min(*get_function_and_start_point(3),
                          shift_type='golden',
                          enable_output=True))
Example #7
0
def first_task():
    print_headers('Using whole gradient step', '-' * 10)
    securely_call_function_and_print_result(gradient,
                                            *get_function_and_start_point(3),
                                            enable_output=False)