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

Beherrschung der mathematischen Grundlagen, die für Data Science unerlässlich sind. Untersuchung zentraler Konzepte in Funktionen, Analysis, Linearer Algebra, Wahrscheinlichkeit und Dimensionsreduktion. Aufbau sowohl theoretischer Kenntnisse als auch praktischer Programmiererfahrung zur Stärkung der Fähigkeiten in Datenanalyse, Modellierung komplexer Systeme und Anwendung fortgeschrittener Methoden im maschinellen Lernen.

Erkunden Sie die Grundlagen mathematischer Funktionen. Verschiedene Typen algebraischer und transzendenter Funktionen, deren Eigenschaften sowie deren Implementierung in Python zur Lösung praxisnaher Probleme.

Beherrschen Sie die Konzepte von Mengen und Reihen, von grundlegenden Operationen bis zu praktischen Anwendungen. Sammeln Sie praktische Erfahrungen bei der Implementierung von Mengenoperationen sowie beim Arbeiten mit arithmetischen und geometrischen Reihen in Python.

Fundiertes Verständnis von Grenzwerten, Ableitungen, Integralen und partiellen Ableitungen. Verbindung von Theorie und Praxis durch Implementierung dieser Konzepte in Python und Anwendung auf Optimierung mittels Gradientenabstieg.

Fundierte Kenntnisse über Vektoren, Matrizen und Transformationen. Vermittlung von Zerlegungsmethoden und Eigenwertanalyse, mit Vertiefung der Konzepte durch Python-Programmierungsaufgaben und praxisnahe Anwendungen in der Datenwissenschaft.

Vertiefung in Wahrscheinlichkeitstheorie und Statistik. Untersuchung von bedingter Wahrscheinlichkeit, Satz von Bayes und statistischen Kennzahlen. Umsetzung zentraler Konzepte in Python, Simulation von Verteilungen sowie Festigung der Kenntnisse durch Herausforderungen und Quizfragen.

Herausforderung: Maximierung des Gewinns mit Quadratischen Funktionen

Lösung

Awesome!

Herausforderung: Maximierung des Gewinns mit Quadratischen Funktionen

Lösung