Lors de la résolution de problèmes d'ingénierie, il est fréquent de rencontrer des fonctions mathématiques difficiles, voire impossibles à calculer exactement à l'aide d'opérations élémentaires. Le sous-module `scipy.special` de SciPy offre l'accès à une large gamme de fonctions spéciales largement utilisées en ingénierie, en physique et en théorie des probabilités. L'une de ces fonctions est la **fonction gamma**, qui généralise la fonction factorielle aux valeurs non entières et apparaît fréquemment dans les distributions de probabilité et les calculs statistiques.


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

Un cours complet conçu pour les étudiants ayant de solides bases en mathématiques et des compétences intermédiaires à avancées en Python, axé sur l'utilisation de SciPy pour le calcul scientifique, l'optimisation, l'intégration et les opérations mathématiques avancées.

Découvrez la structure, les modules principaux et les fonctionnalités essentielles de SciPy pour le calcul scientifique.

Plongez dans les puissantes capacités d'algèbre linéaire de SciPy pour résoudre des problèmes mathématiques concrets.

Maîtriser les techniques d'optimisation et les algorithmes de recherche de racines avec SciPy pour des problèmes scientifiques et d'ingénierie.

Explorez des opérations mathématiques avancées, y compris l'intégration, l'interpolation et le traitement du signal de base avec SciPy.

Défi : Fonctions spéciales en ingénierie

Solution