tests/test_local_minimum.py - master - runamius/minimization

tests/test_local_minimum.py
91 строка3 KB
runamius
tests completed
08 июл 2025, 10:02
08 июл 2025, 10:0219a12cf
import unittest
import math
import numpy as np
from parameterized import parameterized
from scipy.optimize import brute
from minimize_function.local_minimum import (
    scipy_implementation,
    bisection_implementation,
    LocalMinimum,
    Interval,
    ScalarFunction,
)


def _get_test_parameters():
    return [
        (
            lambda x: (x - 2) * x * (x + 2) ** 2,
            Interval(left=0.0, right=2.0),
            LocalMinimum(argument=1.2807764, function_value=-9.9149496),
        ),
        (
            lambda x: (x - 2) * x * (x + 2) ** 2,
            Interval(left=-5, right=-1.0),
            LocalMinimum(argument=-2.0, function_value=0.0),
        ),
        (
            lambda x: math.sin(x) + math.cos(math.sqrt(2 * x)) + math.sin(math.sqrt(3 * x)),
            Interval(left=2.0, right=6.0),
            LocalMinimum(argument=4.9983516, function_value=-2.6266173),
        ),
        (
            lambda x: x * x,
            Interval(left=-10 ** 5, right=10 ** 6),
            LocalMinimum(argument=0.0, function_value=0.0),
        ),
        (
            lambda x: x * x,
            Interval(left=-(10 ** -12), right=10 ** -12),
            LocalMinimum(argument=0.0, function_value=0.0),
        ),
        (
            lambda x: x * x,
            Interval(left=11, right=11),
            LocalMinimum(argument=11, function_value=121),
        ),
        (
            lambda x: x,
            Interval(left=0.0, right=5),
            LocalMinimum(argument=0.0, function_value=0.0),
        ),
        (
            lambda x: -x,
            Interval(left=-3.0, right=2.0),
            LocalMinimum(argument=2.0, function_value=-2.0),
        ),
    ]


class LocalMinimumTestCase(unittest.TestCase):
    @parameterized.expand(_get_test_parameters())
    def test_one(self, function_to_minimize: ScalarFunction, interval: Interval, expected_result: LocalMinimum):
        tolerance = 10 ** -8
        for algorithm in scipy_implementation, bisection_implementation:
            with self.subTest(msg=algorithm.__name__):
                result: LocalMinimum = algorithm(function_to_minimize, interval, tolerance)
                self.assertAlmostEqual(expected_result.argument, result.argument, delta=10 ** -6)
                self.assertAlmostEqual(expected_result.function_value, result.function_value, delta=10 ** -6)

    def test_two(self):
        interval = Interval(left=12, right=50)
        step = (interval.right - interval.left) / 100
        grid = (slice(interval.left, interval.right, step),)
        brute_result = brute(
            lambda x: np.sin(x) + np.cos(np.sqrt(2 * x)) + np.sin(np.sqrt(3 * x)),
            ranges=grid,
            full_output=True,
            finish=None
        )
        rough_x = brute_result[0]
        new_interval = Interval(left=max(interval.left, rough_x - step / 2),
                                right=min(interval.right, rough_x + step / 2))

        result = bisection_implementation(
            lambda x: math.sin(x) + math.cos(math.sqrt(2 * x)) + math.sin(math.sqrt(3 * x)),
            new_interval,
            tolerance=1e-8
        )

        self.assertAlmostEqual(42.3977447, result.argument, delta=1e-6)
        self.assertAlmostEqual(-2.9369797, result.function_value, delta=1e-6)