quadratic_equations_complex_numbers.cpp File Reference

Calculate quadratic equation with complex roots, i.e. b^2 - 4ac < 0. More...

#include <array>
#include <cassert>
#include <cmath>
#include <complex>
#include <exception>
#include <iomanip>
#include <iostream>

Include dependency graph for quadratic_equations_complex_numbers.cpp:

Namespaces
namespace	math
	for IO operations

Functions
std::array< std::complex< long double >, 2 >	math::quadraticEquation (long double a, long double b, long double c)
	Quadratic equation calculator.
void	assertArray (std::array< std::complex< long double >, 2 > input, std::array< std::complex< long double >, 2 > expected, size_t precision=10)
	Asserts an array of complex numbers.
static void	test ()
	Self-test implementations to test quadraticEquation function.
int	main ()
	Main function.

Detailed Description

Calculate quadratic equation with complex roots, i.e. b^2 - 4ac < 0.

Author

Renjian-buchai

@description Calculates any quadratic equation in form ax^2 + bx + c.

Quadratic equation: x = (-b +/- sqrt(b^2 - 4ac)) / 2a

Function Documentation

assertArray()

void assertArray	(	std::array< std::complex< long double >, 2 >	input,
		std::array< std::complex< long double >, 2 >	expected,
		size_t	precision = 10 )

Asserts an array of complex numbers.

Parameters

input	Input array of complex numbers. .
expected	Expected array of complex numbers.
precision	Precision to be asserted. Default=10

Examples

/Users/runner/work/C-Plus-Plus/C-Plus-Plus/math/quadratic_equations_complex_numbers.cpp.

                                        {
    long double exponent = std::pow(10, precision);
    input[0].real(std::round(input[0].real() * exponent));
    input[1].real(std::round(input[1].real() * exponent));
    input[0].imag(std::round(input[0].imag() * exponent));
    input[1].imag(std::round(input[1].imag() * exponent));
 
    expected[0].real(std::round(expected[0].real() * exponent));
    expected[1].real(std::round(expected[1].real() * exponent));
    expected[0].imag(std::round(expected[0].imag() * exponent));
    expected[1].imag(std::round(expected[1].imag() * exponent));
 
    assert(input == expected);
}

Here is the call graph for this function:

main()

int main

(

void

)

Main function.

Returns

0 on exit

           {
    test();  // Run self-test implementation.
    return 0;
}

Here is the call graph for this function:

test()

static void test ( )

static

Self-test implementations to test quadraticEquation function.

Note

There are 4 different types of solutions: Real and equal, real, complex, complex and equal.

                   {
    // Values are equal and real.
    std::cout << "Input: \n"
                 "a=1 \n"
                 "b=-2 \n"
                 "c=1 \n"
                 "Expected output: \n"
                 "(1, 0), (1, 0)\n\n";
    std::array<std::complex<long double>, 2> equalCase{
        std::complex<long double>{1, 0}, std::complex<long double>{1, 0}};
    assert(math::quadraticEquation(1, -2, 1) == equalCase);
 
    // Values are equal and complex.
    std::cout << "Input: \n"
                 "a=1 \n"
                 "b=4 \n"
                 "c=5 \n"
                 "Expected output: \n"
                 "(-2, -1), (-2, 1)\n\n";
    std::array<std::complex<long double>, 2> complexCase{
        std::complex<long double>{-2, -1}, std::complex<long double>{-2, 1}};
    assert(math::quadraticEquation(1, 4, 5) == complexCase);
 
    // Values are real.
    std::cout << "Input: \n"
                 "a=1 \n"
                 "b=5 \n"
                 "c=1 \n"
                 "Expected output: \n"
                 "(-4.7912878475, 0), (-0.2087121525, 0)\n\n";
    std::array<std::complex<long double>, 2> floatCase{
        std::complex<long double>{-4.7912878475, 0},
        std::complex<long double>{-0.2087121525, 0}};
    assertArray(math::quadraticEquation(1, 5, 1), floatCase);
 
    // Values are complex.
    std::cout << "Input: \n"
                 "a=1 \n"
                 "b=1 \n"
                 "c=1 \n"
                 "Expected output: \n"
                 "(-0.5, -0.8660254038), (-0.5, 0.8660254038)\n\n";
    std::array<std::complex<long double>, 2> ifloatCase{
        std::complex<long double>{-0.5, -0.8660254038},
        std::complex<long double>{-0.5, 0.8660254038}};
    assertArray(math::quadraticEquation(1, 1, 1), ifloatCase);
 
    std::cout << "Exception test: \n"
                 "Input: \n"
                 "a=0 \n"
                 "b=0 \n"
                 "c=0\n"
                 "Expected output: Exception thrown \n";
    try {
        math::quadraticEquation(0, 0, 0);
    } catch (std::invalid_argument& e) {
        std::cout << "Exception thrown successfully \n";
    }
}

Here is the call graph for this function: