Understanding the Quadratic Region Concept | Maths Explanation for C# Kids
In this tutorial, you'll learn how to detect the region under a quadratic curve using C#. The curve is defined by the equation y = a x² + b x + c, and we'll use the discriminant method to find when a point or object lies within the quadratic region. This concept helps students connect algebraic reasoning with programming and visualization using the C# windows form.
What is a Quadratic Region? | Maths Explanation for C# Kids
A quadratic region in C# represents the area bounded by a quadratic curve.
Every quadratic equation has two x-values (roots) for any given y - except at its turning point (maximum or minimum).
We can use these roots as boundaries for region detection.
More technically, a quadratic region is the area defined by a quadratic inequality such as
y ≤ ax² + bx + c.
This concept is useful in computer graphics, physics simulations, and
quadratic curve collision detection (JS) projects.
Checking the Boundaries of a Quadratic Curve in C#
To visualize the region under a quadratic curve, we'll use C# to calculate the upper and lower limits dynamically. This makes it possible to detect when an object (like a moving ball) enters or exits the quadratic region.
As discussed in the Animating along a Straight Line in C# tutorial,
any quadratic equation always have two roots for any value of y (except at it's maximum or minimum point).
All we need to do is use these two roots (x values) as boundaries for our check.
y = ax2 + bx + c
ax2 + bx + (c-y) = 0
| x = | -b ± √(b2 - 4a(c-y)) |
| 2a |
Our range will then be:
| -b - √(b2 - 4a(c-y)) | ≤ x ≤ | -b + √(b2 - 4a(c-y)) |
| 2a | 2a |
where a, b, and c are constants.
We will reuse the moving ball graphic from the
Solving and Animating a Quadratic Equation in C#
tutorial and check for when it enters the region of our curve.
C# Code Example: Detecting Entrance into a Quadratic Region
To check for when our ball enters the quadratic curve, we will continually check the x position
of the ball against the x position gotten using the quadratic equation at the same y position
as that of the ball.
We'll designate the coordinates of the ball as (xb, yb),
and those of the curve as (xq, yq).
To detect a point inside a parabola using C#,
you can compare its coordinates to the quadratic curve.
We'll determine whether a moving ball lies within this region by solving
for x using the quadratic formula.
If y is less than or equal to the value of the quadratic equation,
the point lies within the region.
Create a new C# Windows Forms Application
project
;
call it Dymetric_CS.
Create 2 new C# classes;
Call them Dymetric and QuadraticRegion.
Type out the adjoining C# code for detecting the instance a travelling
body crosses the boundary of a quadratic curve.
Summary: Detecting Quadratic Boundaries with C#
In this senior secondary C# math tutorial, you've learnt how to identify whether a moving point lies inside a quadratic region. We've used simple algebra and the C# canvas to visualize and draw the quadratic region bounded by a parabolic curve.
Formula Recap:
The general form of a quadratic equation is y = a x² + b x + c. To find the region under the curve, we can rearrange this equation to get a x² + b x + (c - y) = 0 and use the discriminant D = b² - 4a(c - y).
For any given y-value, if D is positive, the quadratic crosses that y-level at two x-values. The region between these two x-values represents the quadratic region.
y = ax² + bx + c
⟹ ax² + bx + (c - y) = 0
⟹ x = (-b ± √(b² - 4a(c - y))) / 2a
Thus, the quadratic region boundaries are:
(-b - √(b² - 4a(c - y))) / 2a ≤ x ≤ (-b + √(b² - 4a(c - y))) / 2a
Understanding how to compute and visualize quadratic regions in C# bridges mathematical theory and practical coding. It helps students apply concepts from coordinate geometry in a real-world programming context.
Applying the Line Region Detection Logic in C#
This tutorial teaches you to:
- Compute the region under a quadratic function in C#
- Use real-time region detection to track an object's position
- Apply mathematical concepts like discriminants and boundaries in interactive graphics
To determine if a point lies inside a quadratic region, we've used a C# quadratic region detection function. This approach is often used in interactive canvas demos and collision detection algorithms.
So! C# Fun Practice Exercise - Detect Quadratic curve Boundary
As a fun practice exercise, try experimenting with different coefficients (a, b, and c)
to see how the quadratic region changes shape.
You can also animate a point moving across the screen to test when it enters or exits the region on the C# windows form.
Experiment with different equations and visualize how region boundaries change dynamically in C#.
This is a great way to explore the relationship between algebra and geometry in senior secondary mathematics.
C# Quadratic Curve Boundary Window Display Code Stub
C# Quadratic Curve Boundary Code for Dymetric Class
namespace Dymetric
{
class Dymetric
{
private QuadraticRegion quad_region;
private bool do_simulation;
public Dymetric(int screen_width, int screen_height)
{
quad_region = new QuadraticRegion(screen_width, screen_height);
do_simulation = false;
}
// decide what course of action to take
public void decideAction(PaintEventArgs e, bool click_check)
{
if (do_simulation && click_check)
{
// do animation
quad_region.inPlay(e);
do_simulation = false;
}
else
{
// Put ball on screen
quad_region.clearAndDraw(e);
do_simulation = true;
}
}
}
}
C# Animation Code for Quadratic Region Class
using System.Threading;
using System.Drawing;
using System.Windows.Forms;
namespace Dymetric
{
class QuadraticRegion
{
// ball coordinates
private int x_ball, y_ball, previous_x, previous_y;
private const int ballDIAMETER = 80;
// quadratic variables
private int xq_start, yq_start, xq_min, yq_min, xq_stop, x, y;
private double xq_lb, xq_ub; // curve lower and upper boundary
private double a, b, c, discriminant;
private const int dotDIAMETER = 5;
// we'll be drawing to and from a bitmap image
private Bitmap offscreen_bitmap;
Graphics offscreen_g;
private Brush ball_colour, dot_colour, bg_colour;
public QuadraticRegion(int screen_width, int screen_height)
{
ball_colour = new SolidBrush(Color.Yellow);
dot_colour = new SolidBrush(Color.Black);
bg_colour = new SolidBrush(Color.LightGray);
// Create bitmap image
offscreen_bitmap = new Bitmap(screen_width, screen_height - 55,
System.Drawing.Imaging.PixelFormat.Format24bppRgb);
// point graphic object to bitmap image
offscreen_g = Graphics.FromImage(offscreen_bitmap);
// Set background of bitmap graphic
offscreen_g.Clear(Color.LightGray);
previous_x = x_ball = 10;
previous_y = y_ball = offscreen_bitmap.Height / 2 - ballDIAMETER / 2;
xq_start = offscreen_bitmap.Width / 2 - 200;
yq_start = 10;
xq_min = offscreen_bitmap.Width / 2;
yq_min = offscreen_bitmap.Height - 70;
xq_stop = offscreen_bitmap.Width / 2 + 200;
// constants
a = (yq_start - yq_min) / Math.Pow((xq_start - xq_min), 2);
b = -2 * a * xq_min;
c = yq_min + a*Math.Pow(xq_min, 2);
discriminant = Math.Sqrt(b*b - 4*a*(c - (y_ball - ballDIAMETER / 2)));
if (a < 0) // a is negative
{
xq_lb = (-b + discriminant) / (2 * a); // lower boundary
xq_ub = (-b - discriminant) / (2 * a); // upper boundary
}
else
{
xq_lb = (-b - discriminant) / (2 * a); // lower boundary
xq_ub = (-b + discriminant) / (2 * a); // upper boundary
}
}
// draw first appearance of ball on the screen
public void clearAndDraw(PaintEventArgs e)
{
/*
* draw to offscreen bitmap
*/
// draw quadratic curve
for (x = xq_start; x <= xq_stop; x++)
{
y = (int)Math.Round(a * x * x + b * x + c);
// redraw dot
offscreen_g.FillEllipse(dot_colour, x, y, dotDIAMETER, dotDIAMETER);
}
// clear previous ball
offscreen_g.FillEllipse(bg_colour, previous_x, previous_y, ballDIAMETER, ballDIAMETER);
// draw ball
offscreen_g.FillEllipse(ball_colour, x_ball, y_ball, ballDIAMETER, ballDIAMETER);
previous_x = x_ball;
previous_y = y_ball;
// draw to screen
Graphics gr = e.Graphics;
gr.DrawImage(offscreen_bitmap, 0, 55, offscreen_bitmap.Width, offscreen_bitmap.Height);
}
// repetitively clear and draw ball on the screen - Simulate motion
public void inPlay(PaintEventArgs e)
{
// condition for continuing motion
while (x_ball < offscreen_bitmap.Width - ballDIAMETER)
{
// yellow outside the quadratic region
ball_colour = new SolidBrush(Color.Yellow);
if ((x_ball <= xq_lb && x_ball + ballDIAMETER >= xq_lb)
|| (x_ball <= xq_ub && x_ball + ballDIAMETER >= xq_ub))
{
// red on the quadratic outline
ball_colour = new SolidBrush(Color.Red);
}
else if (x_ball >= xq_lb && x_ball + ballDIAMETER <= xq_ub)
{
// green inside the quadratic region
ball_colour = new SolidBrush(System.Drawing.Color.Green);
}
// redraw ball
clearAndDraw(e);
x_ball += 5;
// take a time pause
Thread.Sleep(50);
}
x_ball = 10;
y_ball = offscreen_bitmap.Height / 2 - ballDIAMETER / 2;
}
}
}