Du har udforsket forskellige interpolationsmetoder i SciPy og set, hvordan de kan bruges til at estimere værdier mellem kendte datapunkter. I virkelige eksperimenter indsamles data ofte med uregelmæssige intervaller, men analyse eller rapportering kan kræve værdier ved regelmæssige intervaller. **Interpolation** giver en praktisk løsning til at estimere disse manglende værdier. I denne udfordring skal du bruge `scipy.interpolate.interp1d` til at estimere temperaturværdier ved regelmæssige tidsintervaller ud fra et sæt målinger med uregelmæssig afstand.


import unittest
import user_code
import ast
import re   
import unittest
import numpy as np
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        importlib.reload(user_code)
        self.times = np.array([0, 3, 7, 10, 15])
        self.temperatures = np.array([22.0, 23.5, 24.0, 23.0, 22.5])
        self.regular_times = np.arange(0, 16, 1)
        self.result = user_code.interpolate_temperatures(self.times, self.temperatures, self.regular_times)

    def test_returns_numpy_array(self):
        _dynamic_test(
            self,
            isinstance(self.result, np.ndarray) and len(self.result) == len(self.regular_times),
            "Returns a NumPy array of the correct length.",
            f"Result is not a NumPy array of correct length: {type(self.result)}, {len(self.result)} vs {len(self.regular_times)}."
        )

    def test_first_and_last_value(self):
        _dynamic_test(
            self,
            np.isclose(self.result[0], self.temperatures[0]),
            "First value matches the original measurement.",
            f"First value {self.result[0]} does not match original {self.temperatures[0]}."
        )
        _dynamic_test(
            self,
            np.isclose(self.result[-1], self.temperatures[-1]),
            "Last value matches the original measurement.",
            f"Last value {self.result[-1]} does not match original {self.temperatures[-1]}."
        )

    def test_original_points_match(self):
        original_indices = [np.where(self.regular_times == t)[0][0] for t in self.times]
        for idx, temp in zip(original_indices, self.temperatures):
            _dynamic_test(
                self,
                np.isclose(self.result[idx], temp),
                f"Interpolated value at time {self.regular_times[idx]} matches original measurement.",
                f"Interpolated value at time {self.regular_times[idx]} is {self.result[idx]}, expected {temp}."
            )

    def test_linear_interpolation(self):
        # Check a value between 3 and 7 (e.g., at t=5)
        idx_5 = np.where(self.regular_times == 5)[0][0]
        # Linear interpolation between (3,23.5) and (7,24.0)
        t0, t1 = 3, 7
        y0, y1 = 23.5, 24.0
        expected_5 = y0 + (y1 - y0) * (5 - t0) / (t1 - t0)
        _dynamic_test(
            self,
            np.isclose(self.result[idx_5], expected_5),
            "Interpolated value at t=5 matches linear interpolation.",
            f"At t=5, expected {expected_5}, got {self.result[idx_5]}."
        )

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.

Challenge: Interpolering af Eksperimentelle Data

Løsning