
import unittest
import user_code
import ast
import re   
import unittest
import importlib
import math

class TestTask(unittest.TestCase):
    def test_cost_function_value(self):
        import user_code
        importlib.reload(user_code)
        # Test at x = 3
        val = user_code.cost_function([3])
        expected = 2 * 3 ** 2 - 12 * 3 + 50
        _dynamic_test(
            self,
            math.isclose(val, expected, rel_tol=1e-7),
            "cost_function returns correct value for x=3",
            f"Expected {expected} for x=3, got {val}"
        )
        # Test at x = 0
        val0 = user_code.cost_function([0])
        expected0 = 2 * 0 ** 2 - 12 * 0 + 50
        _dynamic_test(
            self,
            math.isclose(val0, expected0, rel_tol=1e-7),
            "cost_function returns correct value for x=0",
            f"Expected {expected0} for x=0, got {val0}"
        )

    def test_minimize_finds_minimum(self):
        import user_code
        importlib.reload(user_code)
        # The minimum of 2x^2 - 12x + 50 is at x = 3
        result = getattr(user_code, 'result', None)
        _dynamic_test(
            self,
            result is not None and hasattr(result, 'x'),
            "minimize returns a result with attribute 'x'",
            f"minimize did not return a result with attribute 'x'"
        )
        min_x = result.x[0]
        _dynamic_test(
            self,
            math.isclose(min_x, 3.0, rel_tol=1e-4),
            "minimize finds the correct minimum at x=3",
            f"Expected minimum at x=3, got x={min_x}"
        )

    def test_optimal_production_type(self):
        import user_code
        importlib.reload(user_code)
        optimal_production = getattr(user_code, 'optimal_production', None)
        _dynamic_test(
            self,
            isinstance(optimal_production, float),
            "optimal_production is a float",
            f"optimal_production should be float, got {type(optimal_production)}"
        )

    def test_minimum_cost_value(self):
        import user_code
        importlib.reload(user_code)
        result = getattr(user_code, 'result', None)
        _dynamic_test(
            self,
            result is not None and hasattr(result, 'fun'),
            "minimize result has attribute 'fun'",
            f"minimize result missing attribute 'fun'"
        )
        min_cost = result.fun
        # The minimum cost at x=3 is 2*9 - 12*3 + 50 = 18 - 36 + 50 = 32
        _dynamic_test(
            self,
            math.isclose(min_cost, 32.0, rel_tol=1e-4),
            "result.fun matches minimum cost value",
            f"Expected minimum cost 32.0, got {min_cost}"
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

Et omfattende kursus designet til studerende med stærke matematiske forudsætninger og mellemliggende til avancerede Python-færdigheder, med fokus på at udnytte SciPy til videnskabelig databehandling, optimering, integration og avancerede matematiske operationer.

Udforsk strukturen, kernemodulerne og de væsentlige funktioner i SciPy til videnskabelig databehandling.

Dyk ned i SciPys kraftfulde lineære algebrafunktioner til løsning af virkelige matematiske problemer.

Behersk optimeringsteknikker og rodfindingsalgoritmer ved hjælp af SciPy til videnskabelige og ingeniørmæssige problemer.

Udforsk avancerede matematiske operationer, herunder integration, interpolation og grundlæggende signalbehandling med SciPy.

Udfordring: Minimering af Omkostningsfunktioner

Løsning