import unittest
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from matplotlib.collections import PathCollection
import user_code  # Ð²Ð¸ÐºÐ¾Ð½ÑÑ ÐºÐ¾Ð´ ÐºÐ¾ÑÐ¸ÑÑÑÐ²Ð°ÑÐ°

def _dynamic(tc, ok, ok_msg, fail_msg):
    tc._testMethodName = ok_msg if ok else fail_msg
    (tc.assertTrue if ok else tc.fail)(tc._testMethodName)

A, B, C = -1, 12, -20
XV_EXPECT, MP_EXPECT = 6.0, 16.0
ROOTS_EXPECT = (2.0, 10.0)
DELTA = 1e-6

class TestProfitCompact(unittest.TestCase):

    def test_standard_checks(self):
        reasons = []

        # coefficients present & correct
        a, b, c = getattr(user_code, 'a', None), getattr(user_code, 'b', None), getattr(user_code, 'c', None)
        if (a, b, c) != (A, B, C):
            reasons.append(f"coeffsâ (-1,12,-20), got {(a,b,c)}")

        # x,y arrays correct
        x = getattr(user_code, 'x', None)
        y = getattr(user_code, 'y', None)
        if not (isinstance(x, np.ndarray) and x.size == 100 and abs(x.min())<1e-9 and abs(x.max()-12.0)<1e-9):
            reasons.append("x must be linspace(0,12,100)")
        if not (isinstance(y, np.ndarray) and isinstance(x, np.ndarray) and np.allclose(y, A*x**2 + B*x + C, atol=1e-8)):
            reasons.append("y must equal a*x**2 + b*x + c")

        # plot elements present
        ax = plt.gca()
        lines = {ln.get_label(): ln for ln in ax.get_lines() if isinstance(ln, Line2D)}
        if "Profit Function" not in lines:
            reasons.append("missing line 'Profit Function'")
        if not (ax.get_xlabel()=="Units Sold" and ax.get_ylabel()=="Profit ($1000)" and ax.get_title()=="Profit Maximization Analysis"):
            reasons.append("labels/title incorrect")

        _dynamic(self, len(reasons)==0, "PASS: standard checks", "FAIL: " + "; ".join(reasons))

    def test_optimal_units_vertex(self):
        reasons = []
        xv = getattr(user_code, 'x_vertex', None)
        mp = getattr(user_code, 'max_profit', None)
        if not (xv is not None and abs(xv - XV_EXPECT) < DELTA):
            reasons.append(f"x_vertex {xv} â  {XV_EXPECT}")
        if not (mp is not None and abs(mp - MP_EXPECT) < DELTA):
            reasons.append(f"max_profit {mp} â  {MP_EXPECT}")

        # optional: vertex marker at correct point if plotted
        ax = plt.gca()
        scatters = {c.get_label(): c for c in ax.collections if isinstance(c, PathCollection)}
        sc_v = scatters.get("Max Profit")
        if sc_v is not None:
            ok = sc_v.get_offsets().shape[0] >= 1 and np.allclose(sc_v.get_offsets()[0], [xv, mp], atol=DELTA)
            if not ok:
                reasons.append("vertex marker not at (x_vertex, max_profit)")

        _dynamic(self, len(reasons)==0, "PASS: optimal units (vertex) correct",
                 "FAIL: " + "; ".join(reasons))

    def test_breakeven_points(self):
        reasons = []

        disc = getattr(user_code, 'discriminant', None)
        if not (disc is not None and abs(disc - 64.0) < DELTA):
            reasons.append(f"discriminant {disc} â  64")

        x1 = getattr(user_code, 'x1', None)
        x2 = getattr(user_code, 'x2', None)
        roots_user = tuple(sorted([x1, x2])) if (x1 is not None and x2 is not None) else None
        if not (roots_user and np.allclose(roots_user, sorted(ROOTS_EXPECT), atol=DELTA)):
            reasons.append(f"roots {roots_user} â  {sorted(ROOTS_EXPECT)}")

        be = getattr(user_code, 'breakeven_points', None)
        if not (isinstance(be, tuple) and len(be)==2 and np.allclose(sorted(be), sorted(ROOTS_EXPECT), atol=DELTA)):
            reasons.append(f"breakeven_points {be} â  {ROOTS_EXPECT}")

        # optional: markers at y=0 for both roots
        ax = plt.gca()
        scatters = {c.get_label(): c for c in ax.collections if isinstance(c, PathCollection)}
        sc_be = scatters.get("Breakeven Points")
        if sc_be is not None:
            offs = np.array(sc_be.get_offsets())
            ok = offs.shape[0] >= 2 and np.allclose(np.sort(offs[:,0]), sorted(ROOTS_EXPECT), atol=DELTA) and np.allclose(offs[:,1], 0.0, atol=1e-9)
            if not ok:
                reasons.append("breakeven markers not at y=0 and x=2,10")

        _dynamic(self, len(reasons)==0, "PASS: breakeven points correct",
                 "FAIL: " + "; ".join(reasons))


test_code.py

Maîtrisez les bases mathématiques essentielles à la science des données. Explorez les concepts fondamentaux des fonctions, du calcul différentiel et intégral, de l’algèbre linéaire, de la probabilité et de la réduction de dimensionnalité. Développez à la fois une compréhension théorique et une expérience pratique du codage pour renforcer votre capacité à analyser des données, modéliser des systèmes complexes et appliquer des techniques avancées en apprentissage automatique.

Explorez les bases des fonctions mathématiques. Découvrez différents types de fonctions algébriques et transcendantes, leurs propriétés, ainsi que leur implémentation en Python pour résoudre des problèmes concrets.

Maîtrise des concepts d'ensembles et de séries, des opérations de base aux applications pratiques. Expérience pratique de la mise en œuvre des opérations sur les ensembles et du travail avec les séries arithmétiques et géométriques en Python.

Acquérir une compréhension approfondie des limites, dérivées, intégrales et dérivées partielles. Relier la théorie à la pratique en implémentant ces concepts en Python et en les appliquant à l’optimisation via la descente de gradient.

Acquisition de connaissances solides sur les vecteurs, les matrices et les transformations. Étude des méthodes de décomposition et de l'analyse des valeurs propres, avec consolidation des concepts à travers des exercices de programmation Python et des applications pratiques en science des données.

Approfondissement de la théorie des probabilités et des statistiques. Étude de la probabilité conditionnelle, du théorème de Bayes et des mesures statistiques. Mise en œuvre des concepts clés en Python, simulation de distributions et consolidation des compétences par des exercices et des quiz.

Défi : Maximisation du Profit à l'Aide de Fonctions Quadratiques

Solution

Awesome!

Défi : Maximisation du Profit à l'Aide de Fonctions Quadratiques

Solution