minimize_function/local_minimum.py - master - runamius/minimization

minimize_function/local_minimum.py
124 строки3 KB
runamius
tests completed
08 июл 2025, 10:02
08 июл 2025, 10:0219a12cf
from dataclasses import dataclass
from typing import Callable
from scipy.optimize import minimize_scalar

@dataclass
class Interval:
    left: float
    right: float


@dataclass
class LocalMinimum:
    argument: float
    function_value: float


ScalarFunction = Callable[[float], float]


def scipy_implementation(
        function_to_minimize: ScalarFunction,
        interval: Interval,
        tolerance: float = 1e-8,
) -> LocalMinimum:
    result = minimize_scalar(
        function_to_minimize,
        bounds=(interval.left, interval.right),
        method='bounded',
        options={'xatol': tolerance}
    )
    return LocalMinimum(argument=result.x, function_value=result.fun)

def bisection_implementation(
    function_to_minimize: ScalarFunction,
    interval: Interval,
    tolerance: float = 1e-8,
) -> LocalMinimum:
    x_left = min(interval.left, interval.right)
    x_right = max(interval.left, interval.right)
    delta = (x_right - x_left) / 2
    x_mid = x_left + delta

    S1 = function_to_minimize(x_left)
    S2 = function_to_minimize(x_mid)
    S3 = function_to_minimize(x_right)

    while delta > tolerance:

        if S1 <= S2 and S1 <= S3:
            k = 0
        elif S3 <= S2 and S3 <= S1:
            k = 2
        else:
            k = 1

        if k == 0:
            x_right = x_mid
            S3 = S2
            x_mid = x_left + delta
            S2 = function_to_minimize(x_mid)
        elif k == 2:
            x_left = x_mid
            S1 = S2
            x_mid = x_right - delta
            S2 = function_to_minimize(x_mid)
        else:
            left_x = x_mid - delta
            right_x = x_mid + delta
            y1 = function_to_minimize(left_x)
            y2 = function_to_minimize(right_x)

            if y1 < S2:
                x_right = x_mid
                S3 = S2
                x_mid = left_x
                S2 = y1
            elif y2 < S2:
                x_left = x_mid
                S1 = S2
                x_mid = right_x
                S2 = y2
            else:
                x_left = left_x
                x_right = right_x
                S1 = y1
                S3 = y2

        delta /= 2

    if S1 <= S2 and S1 <= S3:
        return LocalMinimum(argument=x_left, function_value=S1)
    elif S3 <= S2 and S3 <= S1:
        return LocalMinimum(argument=x_right, function_value=S3)
    else:
        return LocalMinimum(argument=x_mid, function_value=S2)


    x_min, f_min = result[0], result[1]
    return LocalMinimum(argument=float(x_min), function_value=float(f_min))




def brute_scipy_implementation(
    function_to_minimize: ScalarFunction,
    interval: Interval,
    Ns: int = 500,
) -> LocalMinimum:
    result = brute(func=function_to_minimize,
        ranges=((interval.left, interval.right),),
        Ns=Ns,
        full_output=True,
        finish=None
    )
    x, f = result[0], result[1]
    return LocalMinimum(argument=float(x), function_value=float(f))


def f(x):
    return x*x

result = bisection_implementation(f, Interval(-100000, 1000000))
print("Аргумент минимума:", result.argument)
print("Значение функции:", result.function_value)