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

Beheers de wiskundige basisprincipes die essentieel zijn voor data science. Verken kernbegrippen in functies, calculus, lineaire algebra, kansrekening en dimensionaliteitsreductie. Bouw zowel theoretisch inzicht als praktische programmeerervaring op om het vermogen te versterken om data te analyseren, complexe systemen te modelleren en geavanceerde technieken in machine learning toe te passen.

Verken de basis van wiskundige functies. Maak kennis met verschillende typen algebraïsche en transcendente functies, hun eigenschappen en de implementatie ervan in Python voor het oplossen van praktijkproblemen.

Beheers de concepten van verzamelingen en reeksen, van basisbewerkingen tot praktische toepassingen. Doe praktische ervaring op met het implementeren van verzamelingbewerkingen en het werken met rekenkundige en meetkundige reeksen in Python.

Ontwikkel een grondig begrip van limieten, afgeleiden, integralen en partiële afgeleiden. Verbind theorie met praktijk door deze concepten te implementeren in Python en toe te passen op optimalisatie via gradient descent.

Solide kennis van vectoren, matrices en transformaties. Inzicht in ontbindingsmethoden en eigenwaardeanalyse, met versterking van concepten door Python-programmeeruitdagingen en praktische toepassingen in data science.

Verdiep u in kansrekening en statistiek. Bestudeer conditionele kans, de stelling van Bayes en statistische maten. Implementeer kernconcepten in Python, simuleer verdelingen en versterk uw vaardigheden met uitdagingen en quizzen.

Uitdaging: Maximaliseren van Winst met Behulp van Kwadratische Functies

Oplossing

Awesome!

Uitdaging: Maximaliseren van Winst met Behulp van Kwadratische Functies

Oplossing