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

Master the mathematical foundations essential for data science. Explore core concepts in functions, calculus, linear algebra, probability, and dimensionality reduction. Build both theoretical understanding and practical coding experience to strengthen your ability to analyze data, model complex systems, and apply advanced techniques in machine learning.

Explore the foundation of mathematical functions. Learn different types of algebraic and transcendental functions, their properties, and how to implement them in Python to solve real-world problems.

Master the concepts of sets and series, from basic operations to practical applications. Gain hands-on experience implementing set operations and working with arithmetic and geometric series in Python.

Develop a solid understanding of limits, derivatives, integrals, and partial derivatives. Connect theory to practice by implementing these concepts in Python and applying them to optimization through gradient descent.

Build strong knowledge of vectors, matrices, and transformations. Learn decomposition methods and eigenvalue analysis, while reinforcing concepts with Python coding challenges and practical data science applications.

Dive into probability theory and statistics. Study conditional probability, Bayes' theorem, and statistical measures. Implement key concepts in Python, simulate distributions, and strengthen your skills through challenges and quizzes.

Challenge: Maximizing Profit Using Quadratic Functions

Solução

Awesome!

Challenge: Maximizing Profit Using Quadratic Functions

Solução

Awesome!