Quadratic functions are a fundamental concept in mathematics, typically written in the form `y = ax^2 + bx + c`, where `a`, `b`, and `c` are real-number coefficients. The graph of a quadratic function is a curve called a **parabola**. The coefficient `a` determines whether the parabola opens upwards (`a > 0`) or downwards (`a < 0`), while `b` and `c` affect the position and orientation of the curve. Visualizing quadratic functions helps you understand their behavior, such as their vertex, axis of symmetry, and intercepts. Plotting these functions on a graph provides valuable insight into how changing the coefficients influences the shape and position of the parabola.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np

class TestTask(unittest.TestCase):
    def setUp(self):
        # Clear any existing figures
        plt.close('all')

    def test_plot_curve_exists(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_quadratic(1, -2, 1)
        figs = [plt.figure(i) for i in plt.get_fignums()]
        _dynamic_test(
            self,
            len(figs) > 0,
            "A plot figure was created.",
            "No plot figure was created by plot_quadratic."
        )

    def test_plot_curve_shape(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_quadratic(2, 0, 0)
        fig = plt.gcf()
        ax = fig.gca()
        lines = ax.get_lines()
        _dynamic_test(
            self,
            len(lines) > 0,
            "A curve was plotted on the axes.",
            "No curve was plotted on the axes."
        )
        xdata = lines[0].get_xdata()
        ydata = lines[0].get_ydata()
        _dynamic_test(
            self,
            isinstance(xdata, np.ndarray) and isinstance(ydata, np.ndarray) and len(xdata) == len(ydata),
            "x and y data arrays have equal lengths.",
            "x and y data arrays are missing or not of equal length."
        )
        _dynamic_test(
            self,
            len(xdata) >= 100,
            "x data covers a suitable range.",
            f"x data does not cover a suitable range: {len(xdata)} values."
        )

    def test_axis_labels(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_quadratic(1, 0, 0)
        fig = plt.gcf()
        ax = fig.gca()
        xlabel = ax.get_xlabel()
        ylabel = ax.get_ylabel()
        _dynamic_test(
            self,
            xlabel.lower() == "x",
            "x-axis is labeled 'x'.",
            f"x-axis label expected 'x', got '{xlabel}'."
        )
        _dynamic_test(
            self,
            ylabel.lower() == "y",
            "y-axis is labeled 'y'.",
            f"y-axis label expected 'y', got '{ylabel}'."
        )

    def test_title_includes_coefficients(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        a, b, c = 3, -5, 2
        user_code.plot_quadratic(a, b, c)
        fig = plt.gcf()
        ax = fig.gca()
        title = ax.get_title()
        expected = f"{a}x^2 + {b}x + {c}"
        _dynamic_test(
            self,
            expected in title,
            f"Plot title includes coefficients: {expected}.",
            f"Plot title does not include coefficients: {expected}. Actual: {title}"
        )

    def test_grid_visible(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_quadratic(1, 0, 0)
        fig = plt.gcf()
        ax = fig.gca()
        # Check if any gridlines are visible on either axis
        x_gridlines = ax.get_xgridlines()
        y_gridlines = ax.get_ygridlines()
        grid_visible = any(line.get_visible() for line in x_gridlines + y_gridlines)
        _dynamic_test(
            self,
            grid_visible,
            "Grid is visible on the plot.",
            "Grid is not visible on the plot."
        )

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()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        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] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

This beginner-level course focuses on the core mathematical operations in Python, including arithmetic, order of operations, and using built-in math functions. It provides hands-on practice and targeted instruction for learners new to programming or seeking to strengthen their Python math skills.

Challenge: Visualize Quadratic Functions

Рішення