In practical scientific computing, signals are often contaminated with noise, making it challenging to extract meaningful features. Filtering and peak detection are essential tools for analyzing such noisy data. In this challenge, you will use `scipy.signal` to process a time series by removing noise and then identifying significant peaks, which are often of interest in engineering and scientific applications.


import unittest
import user_code
import ast
import re   
import unittest
import numpy as np
from scipy import signal
import importlib

class TestTask(unittest.TestCase):
    def setUp(self):
        self.time = np.linspace(0, 10, 500)
        np.random.seed(0)
        self.clean_signal = np.sin(2 * np.pi * 1.5 * self.time)
        self.noise = np.random.normal(0, 0.5, self.time.shape)
        self.noisy_signal = self.clean_signal + self.noise

    def test_returns_indices(self):
        import user_code
        importlib.reload(user_code)
        indices = user_code.filter_and_find_peaks(self.time, self.noisy_signal)
        _dynamic_test(
            self,
            isinstance(indices, (list, np.ndarray)),
            "Function returns a list or array of indices.",
            f"Expected a list or array, got {type(indices)}."
        )
        _dynamic_test(
            self,
            all(isinstance(i, (int, np.integer)) for i in indices),
            "All returned values are integer indices.",
            "Returned indices are not all integers."
        )

    def test_filter_is_used(self):
        import user_code
        importlib.reload(user_code)
        # Get filtered signal by re-implementing expected filter
        b, a = signal.butter(N=4, Wn=0.1, btype='low')
        filtered = signal.filtfilt(b, a, self.noisy_signal)
        # Find peaks in filtered signal
        expected_peaks, _ = signal.find_peaks(filtered)
        result_peaks = user_code.filter_and_find_peaks(self.time, self.noisy_signal)
        # Test that result is not just peaks from original noisy data
        noisy_peaks, _ = signal.find_peaks(self.noisy_signal)
        # Compare overlap with expected
        overlap = len(set(result_peaks).intersection(set(expected_peaks)))
        _dynamic_test(
            self,
            overlap >= len(expected_peaks) * 0.8,
            "Detected peaks match those found after correct filtering.",
            f"Detected peaks do not match expected peaks after filtering. Overlap: {overlap} / {len(expected_peaks)}"
        )
        # Should not just return peaks from noisy data
        overlap_noisy = len(set(result_peaks).intersection(set(noisy_peaks)))
        _dynamic_test(
            self,
            overlap > overlap_noisy,
            "Peak detection is performed on filtered signal, not raw data.",
            "Peak detection appears to be performed on raw data, not filtered signal."
        )

    def test_indices_are_local_maxima(self):
        import user_code
        importlib.reload(user_code)
        b, a = signal.butter(N=4, Wn=0.1, btype='low')
        filtered = signal.filtfilt(b, a, self.noisy_signal)
        peaks = user_code.filter_and_find_peaks(self.time, self.noisy_signal)
        for idx in peaks:
            if 1 <= idx < len(filtered) - 1:
                cond = filtered[idx] > filtered[idx-1] and filtered[idx] > filtered[idx+1]
                _dynamic_test(
                    self,
                    cond,
                    f"Index {idx} is a local maximum in the filtered signal.",
                    f"Index {idx} is not a local maximum in the filtered signal."
                )

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: Signal Filtering and Analysis

Ratkaisu

Challenge: Signal Filtering and Analysis

Ratkaisu