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:

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

Functions
double	physics::ground_to_ground_projectile_motion::degrees_to_radians (double radian, double PI=3.14)
	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

Function Documentation

degrees_to_radians()

double physics::ground_to_ground_projectile_motion::degrees_to_radians	(	double	radian,
		double	PI = 3.14 )

Convert radians to degrees.

Parameters

radian	Angle in radians
PI	The definition of the constant PI

Returns

Angle in degrees

                                                           {
    return (radian * (PI / 180));
}

Here is the call graph for this function:

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

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

Here is the call graph for this function:

main()

int main

(

void

)

Main function.

Returns

0 on exit

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

Here is the call graph for this function:

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

                                                                 {
    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));
}

Here is the call graph for this function:

test()

static void test ( )

static

Self-test implementations.

Returns

void

                   {
    // 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;
}

Here is the call graph for this function:

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

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

Here is the call graph for this function: