
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

Un curso integral diseñado para estudiantes con sólidos conocimientos matemáticos y habilidades intermedias o avanzadas en Python, enfocado en aprovechar SciPy para la computación científica, optimización, integración y operaciones matemáticas avanzadas.

Explora la estructura, los módulos principales y las características esenciales de SciPy para la computación científica.

Sumérgete en las potentes capacidades de álgebra lineal de SciPy para resolver problemas matemáticos del mundo real.

Domina técnicas de optimización y algoritmos de búsqueda de raíces utilizando SciPy para problemas científicos e ingenieriles.

Explora operaciones matemáticas avanzadas, incluyendo integración, interpolación y procesamiento básico de señales con SciPy.

Desafío: Minimización de Funciones de Costo

Solución