When working on engineering problems, you often encounter mathematical functions that are difficult or impossible to compute exactly using elementary operations. SciPy's `scipy.special` submodule provides access to a wide range of special functions that are widely used in engineering, physics, and probability theory. One such function is the **gamma function**, which generalizes the factorial function to non-integer values and appears frequently in probability distributions and statistical calculations.


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

class TestTask(unittest.TestCase):
    def test_gamma_positive_integer(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.compute_gamma(5)
        expected = math.gamma(5)
        _dynamic_test(
            self,
            abs(result - expected) < 1e-10,
            "Correct gamma value for integer input (5)",
            f"Expected gamma(5)={expected}, got {result}",
        )

    def test_gamma_positive_noninteger(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.compute_gamma(2.7)
        expected = math.gamma(2.7)
        _dynamic_test(
            self,
            abs(result - expected) < 1e-10,
            "Correct gamma value for non-integer input (2.7)",
            f"Expected gamma(2.7)={expected}, got {result}",
        )

    def test_gamma_half(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.compute_gamma(0.5)
        expected = math.gamma(0.5)
        _dynamic_test(
            self,
            abs(result - expected) < 1e-10,
            "Correct gamma value for input 0.5",
            f"Expected gamma(0.5)={expected}, got {result}",
        )

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: Special Functions in Engineering

Ratkaisu

Awesome!

Challenge: Special Functions in Engineering

Ratkaisu