Quadratic Equations in C++

Using the Equation of a Quadratic Curve in C++

The equation of a quadratic curve has the general form y = ax² + bx + c;
where a, b, c are constants.

Generating Quadratic Curves for C++

To generate a quadratic curve, all we will need is a starting point and the maximum / minimum (highest / lowest) point of the curve.

y = ax² + bx + c

^dy/_dx = y^I = 2ax + b
At maximum / minimum point, y^I = 0
y^I|_{(x = x_max)} = 0
2ax_max + b = 0
b = -2ax_max

Substituting b in the general equation
y = ax² + bx + c
  = ax² - 2ax_maxx + c

         At (x_start, y_start):
y_start = ax_start² - 2ax_maxx_start + c
         At (x_max, y_max):
y_max = ax_max² - 2ax_max² + c
    = -ax_max² + c     --------- (eqn *)

Subtracting both derived equations
y_start - y_max = ax_start² - 2ax_maxx_start + ax_max²
(x_start² - 2x_maxx_start + x_max²)a = y_start - y_max

Hence:

a =	y_start - y_max	=	y_start - y_max
	x_start² - 2x_maxx_start + x_max²		(x_start - x_max)²

b = -2ax_max
& from (eqn *)
c = y_max + ax_max²

Code to Animate a Graphic Object through a Quadratic Curve in C++

To make a graphic (dot) travel by the equation of a quadratic curve, continuously increment x by some interval, and use the equation to get the corresponding y value.
.

Create a new class;
Call it QuadraticPath.
Type out the adjoining C++ code for animating an image body through the path of a quadratic curve.

Facet class file

#include "stdafx.h"
#include "Facet.h"
#include "QuadraticPath.h"

QuadraticPath* qpath;

/*
* Our custom class that interfaces between the parent window
* and the subsequent daemonstrator classes
*/
Facet::Facet(HWND hWnd, int window_width, int window_height)
{
    qpath = new QuadraticPath(hWnd, window_width, window_height);
}

/*
* This guy decorates buttons with colour and title text
*/
bool Facet::decorateButton(WPARAM wParam, LPARAM lParam) {
    // button glide calling
    if (wParam == 12321)
    {
        LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)lParam;

        SetDCBrushColor(lpDIS->hDC, RGB(255, 192, 203));
        SelectObject(lpDIS->hDC, GetStockObject(DC_BRUSH));

        RECT rect = { 0 };
        rect.left = lpDIS->rcItem.left;
        rect.right = lpDIS->rcItem.right;
        rect.top = lpDIS->rcItem.top;
        rect.bottom = lpDIS->rcItem.bottom;

        RoundRect(lpDIS->hDC, rect.left, rect.top, rect.right, rect.bottom, 50, 50);
        // button text
        DrawText(lpDIS->hDC, TEXT("MOVE"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);

        return TRUE;
    }
    return FALSE;
}

/*
* Call the target class' draw method
*/
void Facet::informPaint() {
    qpath->paint();
}

/*
* Say there is more than a single push button,
* this guy picks out the correct button that got clicked
* and calls the corresponding apt function
*/
bool Facet::actionPerformed(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
    switch (LOWORD(wParam))
    {
    case 12321:
        qpath->moveQuadratic();
        return TRUE;
    default:
        return FALSE;
    }
}

Facet::~Facet()
{
    delete qpath;
}

QuadraticPath Header file

#pragma once

#define aWIDTH 10
#define aHEIGHT 10

class QuadraticPath
{
public:
    QuadraticPath(HWND, int, int);
    virtual ~QuadraticPath();
    void paint();
    void moveQuadratic();
protected:
    HWND hWindow;
    HDC hdc;
    int window_width;
    int window_height;
    COLORREF ball_colour;
    int x_start;
    int y_start;
    int x_max;
    int y_max;
    int x;
    int y;
    double a, b, c; // coefficients and constant
    HPEN ball_pen;
    HBRUSH ball_brush;
};

C++ code for QuadraticPath Class file

#include "stdafx.h"
#include "QuadraticPath.h"
#include <math.h>

QuadraticPath::QuadraticPath(HWND hWnd, int window_width, int window_height)
{
    hWindow = hWnd; // save away window handle
    this->window_width = window_width; // save away window width
    this->window_height = window_height; // save away window width

    ball_colour = RGB(255, 0, 0);
    x_start = 50;
    y_start = 400;
    x_max = 350;
    y_max = 150;
    x = x_start;
    y = y_start;

    // constants
    a = (double) (y_start - y_max) / pow((x_start - x_max), 2);
    b = -2 * a * x_max;
    c = y_max + a * pow(x_max, 2);

    // Pen and brush for travelling ball
    ball_pen = CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
    ball_brush = CreateSolidBrush(ball_colour);

    hdc = GetDC(hWindow);

    SelectObject(hdc, ball_pen); // select ball pen colour
    SelectObject(hdc, ball_brush); // select ball brush colour
}

/*
* draws the ball/circle using the apt color
*/
void QuadraticPath::paint() {
    // draw a dot
    Ellipse(hdc, x, y, x + aWIDTH, y + aHEIGHT);
}

/*
Repeatedly draws ball so as to simulate a continuous motion
*/
void QuadraticPath::moveQuadratic() {
    // condition for continuing motion
    while (x + aWIDTH <= window_width && y <= y_start) {
        paint();

        x += 20;
        y = (int)round(a*x*x + b*x + c);
        // introduce a delay between renderings
        Sleep(50);
    }
}

QuadraticPath::~QuadraticPath()
{
    DeleteObject(ball_pen);
    DeleteObject(ball_brush);

    ReleaseDC(hWindow, hdc);
}

I have a better version / See other versions.