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

A practical course designed for math students to harness the power of Python for solving mathematical problems, visualizing data, and applying computational thinking to real-world scenarios. Each section blends engaging theory with hands-on challenges, focusing on mathematical applications and problem-solving. 

Explore how Python can be used to perform numerical calculations, solve algebraic equations, and automate mathematical processes.

Learn how to visualize mathematical data and functions using Python, and apply these skills to real-world mathematical problems.

Apply Python to probability, statistics, and simulation, enabling students to model uncertainty and analyze data in mathematical contexts.

Challenge: Visualize Quadratic Functions

Ratkaisu

Challenge: Visualize Quadratic Functions

Ratkaisu