Fitting models to experimental data is a fundamental task in scientific computing, enabling you to extract meaningful trends from noisy measurements. In previous chapters, you explored optimization and root-finding methods, and learned about curve fitting and least squares approaches. Now, you will put these concepts into practice by using `scipy.optimize.curve_fit` to fit a polynomial model to a set of noisy data points. This hands-on challenge will help you solidify your understanding of data fitting and model parameter extraction.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import numpy as np

class TestTask(unittest.TestCase):
    def test_coefficients_tuple_length_and_type(self):
        import user_code
        importlib.reload(user_code)
        coeffs = getattr(user_code, 'coefficients', None)
        _dynamic_test(
            self,
            isinstance(coeffs, tuple) and len(coeffs) == 3 and all(isinstance(x, (int, float, np.floating, np.integer)) for x in coeffs),
            "Returned coefficients are a tuple of three numeric values.",
            f"Expected a tuple of three numbers, got: {coeffs}",
        )

    def test_coefficients_approximate_true_values(self):
        import user_code
        importlib.reload(user_code)
        coeffs = getattr(user_code, 'coefficients', None)
        expected = [2.5, -1.3, 0.5]
        tolerance = [0.4, 0.6, 0.7]
        _dynamic_test(
            self,
            coeffs is not None and all(abs(c - e) < t for c, e, t in zip(coeffs, expected, tolerance)),
            "Fitted coefficients are within acceptable tolerance of true values.",
            f"Fitted coefficients {coeffs} are not close to true values {expected}",
        )

    def test_function_works_for_different_data(self):
        import user_code
        import importlib
        import numpy as np
        importlib.reload(user_code)
        fit_func = getattr(user_code, 'fit_noisy_data', None)
        _dynamic_test(
            self,
            callable(fit_func),
            "fit_noisy_data function exists and is callable.",
            "fit_noisy_data function is not defined.",
        )
        np.random.seed(42)
        x = np.linspace(-3, 3, 20)
        y = 1.8 * x**2 + 0.7 * x - 2.2 + np.random.normal(scale=2.0, size=x.shape)
        coeffs = fit_func(x, y)
        expected = [1.8, 0.7, -2.2]
        tolerance = [0.15, 0.7, 0.7]  # Adjusted tolerance for b and c due to noise
        _dynamic_test(
            self,
            isinstance(coeffs, tuple) and len(coeffs) == 3 and all(abs(c - e) < t for c, e, t in zip(coeffs, expected, tolerance)),
            "fit_noisy_data works correctly for new data arrays.",
            f"Returned coefficients {coeffs} are not close to expected {expected} for new data.",
        )

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

A comprehensive course designed for students with strong math backgrounds and intermediate to advanced Python skills, focusing on leveraging SciPy for scientific computing, optimization, integration, and advanced mathematical operations.

Explore the structure, core modules, and essential features of SciPy for scientific computing.

Dive into SciPy's powerful linear algebra capabilities for solving real-world mathematical problems.

Master optimization techniques and root-finding algorithms using SciPy for scientific and engineering problems.

Explore advanced mathematical operations including integration, interpolation, and basic signal processing with SciPy.

Challenge: Data Fitting in Practice

Soluzione

Awesome!

Challenge: Data Fitting in Practice

Soluzione