ground_to_ground_projectile_motion.cpp File Reference

Ground to ground projectile motion equation implementations. More...

#include <cassert>
#include <cmath>
#include <iostream>

Include dependency graph for ground_to_ground_projectile_motion.cpp:

Go to the source code of this file.

Namespaces
namespace	physics
	for IO operations
namespace	ground_to_ground_projectile_motion
	Functions for the Ground to ground projectile motion equation.

Macros
#define	_USE_MATH_DEFINES
	for assert()

Functions
double	physics::ground_to_ground_projectile_motion::degrees_to_radians (double degrees)
	Convert radians to degrees.
template<typename T >
T	physics::ground_to_ground_projectile_motion::time_of_flight (T initial_velocity, T angle, double gravity=9.81)
	Calculate the time of flight.
template<typename T >
T	physics::ground_to_ground_projectile_motion::horizontal_range (T initial_velocity, T angle, T time)
	Calculate the horizontal distance that the projectile travels.
template<typename T >
T	physics::ground_to_ground_projectile_motion::max_height (T initial_velocity, T angle, double gravity=9.81)
	Calculate the max height of the projectile.
static void	test ()
	Self-test implementations.
int	main ()
	Main function.

Detailed Description

Ground to ground projectile motion equation implementations.

Ground to ground projectile motion is when a projectile's trajectory starts at the ground, reaches the apex, then falls back on the ground.

Author

Focusucof

Definition in file ground_to_ground_projectile_motion.cpp.

Macro Definition Documentation

_USE_MATH_DEFINES

#define _USE_MATH_DEFINES

for assert()

Definition at line 13 of file ground_to_ground_projectile_motion.cpp.

Function Documentation

degrees_to_radians()

double physics::ground_to_ground_projectile_motion::degrees_to_radians

(

double

degrees

)

Convert radians to degrees.

Parameters

radian

Angle in radians

Returns

Angle in degrees

Definition at line 34 of file ground_to_ground_projectile_motion.cpp.

                                         {
    double radians = degrees * (M_PI / 180);
    return radians;
}

horizontal_range()

template<typename T >

T physics::ground_to_ground_projectile_motion::horizontal_range	(	T	initial_velocity,
		T	angle,
		T	time )

Calculate the horizontal distance that the projectile travels.

Parameters

initial_velocity	The starting velocity of the projectile
time	The time that the projectile is in the air

Returns

Horizontal distance that the projectile travels

Definition at line 59 of file ground_to_ground_projectile_motion.cpp.

                                                        {
    double Vix = initial_velocity * (std::cos(degrees_to_radians(angle))); // calculate x component of the initial velocity
    return Vix * time;
}

main()

int main

(

void

)

Main function.

Returns

0 on exit

Definition at line 138 of file ground_to_ground_projectile_motion.cpp.

           {
    test();  // run self-test implementations
    return 0;
}

max_height()

template<typename T >

T physics::ground_to_ground_projectile_motion::max_height	(	T	initial_velocity,
		T	angle,
		double	gravity = 9.81 )

Calculate the max height of the projectile.

Parameters

initial_velocity	The starting velocity of the projectile
angle	The angle that the projectile is launched at in degrees
gravity	The value used for the gravity constant

Returns

The max height that the projectile reaches

Definition at line 72 of file ground_to_ground_projectile_motion.cpp.

                                                                 {
    double Viy = initial_velocity * (std::sin(degrees_to_radians(angle))); // calculate y component of the initial velocity
    return (std::pow(Viy, 2) / (2.0 * gravity));
}

test()

static void test ( )

static

Self-test implementations.

Returns

void

Definition at line 83 of file ground_to_ground_projectile_motion.cpp.

                   {
    // initial input variables
    double initial_velocity = 5.0;  // double initial_velocity input
    double angle = 40.0;            // double angle input
 
    // 1st test
    double expected_time_of_flight = 0.655;  // expected time output
    double flight_time_output =
        std::round(physics::ground_to_ground_projectile_motion::time_of_flight(initial_velocity, angle) * 1000.0) /
        1000.0;  // round output to 3 decimal places
 
    std::cout << "Projectile Flight Time (double)" << std::endl;
    std::cout << "Input Initial Velocity: " << initial_velocity << std::endl;
    std::cout << "Input Angle: " << angle << std::endl;
    std::cout << "Expected Output: " << expected_time_of_flight << std::endl;
    std::cout << "Output: " << flight_time_output << std::endl;
    assert(flight_time_output == expected_time_of_flight);
    std::cout << "TEST PASSED" << std::endl << std::endl;
 
    // 2nd test
    double expected_horizontal_range = 2.51; // expected range output
    double horizontal_range_output =
        std::round(physics::ground_to_ground_projectile_motion::horizontal_range(initial_velocity, angle,
                                             flight_time_output) *
                   100.0) /
        100.0;  // round output to 2 decimal places
 
    std::cout << "Projectile Horizontal Range (double)" << std::endl;
    std::cout << "Input Initial Velocity: " << initial_velocity << std::endl;
    std::cout << "Input Angle: " << angle << std::endl;
    std::cout << "Input Time Of Flight: " << flight_time_output << std::endl;
    std::cout << "Expected Output: " << expected_horizontal_range << std::endl;
    std::cout << "Output: " << horizontal_range_output << std::endl;
    assert(horizontal_range_output == expected_horizontal_range);
    std::cout << "TEST PASSED" << std::endl << std::endl;
 
    // 3rd test
    double expected_max_height = 0.526; // expected height output
    double max_height_output =
        std::round(physics::ground_to_ground_projectile_motion::max_height(initial_velocity, angle) * 1000.0) /
        1000.0;  // round output to 3 decimal places
 
    std::cout << "Projectile Max Height (double)" << std::endl;
    std::cout << "Input Initial Velocity: " << initial_velocity << std::endl;
    std::cout << "Input Angle: " << angle << std::endl;
    std::cout << "Expected Output: " << expected_max_height << std::endl;
    std::cout << "Output: " << max_height_output << std::endl;
    assert(max_height_output == expected_max_height);
    std::cout << "TEST PASSED" << std::endl << std::endl;
}

time_of_flight()

template<typename T >

T physics::ground_to_ground_projectile_motion::time_of_flight	(	T	initial_velocity,
		T	angle,
		double	gravity = 9.81 )

Calculate the time of flight.

Parameters

initial_velocity	The starting velocity of the projectile
angle	The angle that the projectile is launched at in degrees
gravity	The value used for the gravity constant

Returns

The time that the projectile is in the air for

Definition at line 47 of file ground_to_ground_projectile_motion.cpp.

                                                                     {
    double Viy = initial_velocity * (std::sin(degrees_to_radians(angle))); // calculate y component of the initial velocity
    return 2.0 * Viy / gravity;
}