Module game_qu.math.physics_function

Expand source code
import math

from game_qu.base.utility_functions import get_kwarg_item, solve_quadratic
from game_qu.math.indefinite_integral import IndefiniteIntegral
from game_qu.math.quadratic_function import QuadraticFunction


class PhysicsFunction:
    """A class that uses common physics equations for initial_velocity, acceleration, and initial_distance"""

    acceleration = 0
    initial_velocity = 0
    initial_distance = 0

    def get_time_to_vertex(self):
        """ Gets the time it takes to reach the vertex knowing that the final initial_velocity is 0, so the time is -initial_velocity / acceleration
     
            Returns:
                float: the time to reach the vertex
        """

        return -self.initial_velocity / self.acceleration

    def set_acceleration_with_displacement(self, time, displacement):
        """ Sets the acceleration knowing that d = 1/2 * a * t^2 where d is displacement, a is acceleration, and t is time.
            This is assuming initial_velocity is 0

            Args:
                time (float): the amount of time that it should take to go that amount (displacement)
                displacement (float): the distance (up being positive and down being negative) that it should travel
     
            Returns:
                None
        """

        self.acceleration = (2 * displacement) / pow(time, 2)

    def set_velocity_with_displacement(self, displacement):
        """ Sets the initial velocity of the function knowing that vf^2 = vi^2 + 2ad and we know that vf is 0
            a is acceleration, t is time, and v is initial_velocity

            Args:
                displacement (float): the distance (up being positive and down being negative) that it should travel
     
            Returns:
                None
        """

        # Solved for vi knowing vf = 0 in vf^2 = vi^2 + 2ad
        self.initial_velocity = math.sqrt(2 * self.acceleration * displacement)


    def set_acceleration_with_velocity(self, time, velocity_change):
        """Sets the acceleration knowing that vf = vi + at"""

        self.acceleration = velocity_change / time

    def set_all_variables(self, vertex, time, initial_distance):
        """ Sets all the variables; calls set_velocity and set_gravity_acceleration

            Args:
                vertex (float): the highest/lowest point of the parabola
                time (float): the time it takes to get to the vertex/go the acceleration_distance
                initial_distance (float): the initial distance
     
            Returns:
                None
        """

        self.initial_distance = initial_distance

        # Gotten using math
        self.initial_velocity = (-2 * initial_distance + 2 * vertex) / time
        self.acceleration = 2 * (initial_distance - vertex) / pow(time, 2)

    def set_variables(self, **kwargs):
        """ Sets the variables to the number provided

            possible parameters:
                acceleration (float): the acceleration (can be positive or negative) | a in 1/2 * ax^2 + bx + c
                initial_velocity (float): the initial_velocity (can be positive or negative) | b in 1/2 * ax^2 + bx + c
                initial_distance (float): the starting point (can be positive or negative) | c in 1/2 * ax^2 + bx + c

            Returns:
                None
        """

        self.acceleration = get_kwarg_item(kwargs, "acceleration", self.acceleration)
        self.initial_velocity = get_kwarg_item(kwargs, "initial_velocity", self.initial_velocity)
        self.initial_distance = get_kwarg_item(kwargs, "initial_distance", self.initial_distance)

    def get_distance(self, time):
        """ Finds the number by plugging x into the equation 1/2 * at^2 + vt + d
            where a is acceleration, t is time, v is initial_velocity, and d is initial_distance

            Args:
                time (float): the amount of time that has passed

            Returns:
                float: the number that is gotten when time is plugged into the equation
        """
        return 1 / 2 * self.acceleration * pow(time, 2) + self.initial_velocity * time + self.initial_distance

    def get_velocity_using_time(self, time):
        """ Uses the fact that the initial_velocity is equal to vi - at^2 where vi is the initial initial_velocity, a is acceleration, and t is time
            to find the initial_velocity

            Args:
                time (float): the amount of time that the initial_velocity has been affected by acceleration
     
            Returns:
                float: the initial_velocity after affected by acceleration
        """

        return self.initial_velocity + self.acceleration * time

    def get_velocity_using_displacement(self, displacement):
        """ Uses the formula vf^2 = vi^2 + 2ax to find the initial_velocity
            where vf is final initial_velocity, vi is initial initial_velocity, a is acceleration, and x is displacement

            Args:
                displacement (float): the amount that the ball has traveled (upwards is positive and downwards is negative)
     
            Returns:
                float: the final initial_velocity
        """

        final_velocity_squared = pow(self.initial_velocity, 2) + 2 * self.acceleration * displacement
        # Reduces the risk of a rounding error like -1*e^-15 would cause an imaginary number exception
        return pow(int(final_velocity_squared), 1 / 2)

    def get_vertex(self):
        """
             Returns:
                float: the vertex of this physics equation"""

        return self.get_distance(self.get_time_to_vertex())

    def get_times_to_point(self, distance):
        """ Finds the number by plugging in 'distance' into the equation 1/2 * at^2 + vt + d
            where a is acceleration, t is time, v is initial_velocity, and d is initial_distance

            Args:
                distance (float): the distance that is wanted
     
            Returns:
                float[]: the times that the parabola is at that y coordinate
        """
        return solve_quadratic(1 / 2 * self.acceleration, self.initial_velocity, self.initial_distance - distance)

    def get_full_cycle_time(self):
        """
             Returns:
                float: the amount of time it takes the parabola to go from start_location -> start_location"""

        return self.get_time_to_vertex() * 2

    def get_indefinite_integral_of_position_equation(self):
        """
             Returns:
                Function: the indefinite integral of the position equation: x = 1/2at^2 + vt + xi"""

        a, b, c = self.get_a_b_and_c()
        return QuadraticFunction.get_indefinite_integral_using_quadratic_form(a, b, c)

    def get_a_b_and_c(self):
        """
             Returns:
                list[float]: {a, b, c}; the a, b, and c values of this equation if it was in quadratic form: ax^2 + bx + c"""

        a = 1/2 * self.acceleration
        b = self.initial_velocity
        c = self.initial_distance

        return [a, b, c]

    def get_displacement(self, start_time, end_time):
        """
             Returns:
                float: the displacement of the object from start_time -> end_time (the integral from start_time to end_time)"""

        indefinite_integral = self.get_indefinite_integral_of_position_equation()
        return indefinite_integral.get_y_coordinate(end_time) - indefinite_integral.get_y_coordinate(start_time)

    def get_indefinite_integral_of_velocity_equation(self):
        """
             Returns:
                Function: the indefinite integral of the velocity equation: vt -> vt^2/2"""

        return QuadraticFunction.get_indefinite_integral_using_quadratic_form(0, self.initial_velocity, 0)

    def get_displacement_due_to_velocity(self, start_time, end_time):
        """
             Returns:
                float: the displacement of the object from start_time -> end_time only based upon velocity (the integral from start_time to end_time)"""

        indefinite_integral = self.get_indefinite_integral_of_velocity_equation()
        return indefinite_integral.get(end_time) - indefinite_integral.get(start_time)

    def get_indefinite_integral_of_acceleration_equation(self):
        """
             Returns:
                Function: the indefinite integral of the acceleration equation: 1/2at^2 -> 1/6at^3"""

        return QuadraticFunction.get_indefinite_integral_using_quadratic_form(1/2 * self.acceleration, 0, 0)

    def get_displacement_due_to_acceleration(self, start_time, end_time):
        """
             Returns:
                float: the displacement of the object from start_time -> end_time only based upon acceleration (the integral from start_time to end_time)"""

        indefinite_integral = self.get_indefinite_integral_of_acceleration_equation()
        return indefinite_integral.get(end_time) - indefinite_integral.get(start_time)

    def __str__(self):
        return f"[{self.acceleration},{self.initial_velocity},{self.initial_distance},]"

    def __eq__(self, other):
        return (self.acceleration == other.acceleration and self.initial_velocity == other.initial_velocity and
                self.initial_distance == other.initial_distance)

Classes

class PhysicsFunction

A class that uses common physics equations for initial_velocity, acceleration, and initial_distance

Expand source code
class PhysicsFunction:
    """A class that uses common physics equations for initial_velocity, acceleration, and initial_distance"""

    acceleration = 0
    initial_velocity = 0
    initial_distance = 0

    def get_time_to_vertex(self):
        """ Gets the time it takes to reach the vertex knowing that the final initial_velocity is 0, so the time is -initial_velocity / acceleration
     
            Returns:
                float: the time to reach the vertex
        """

        return -self.initial_velocity / self.acceleration

    def set_acceleration_with_displacement(self, time, displacement):
        """ Sets the acceleration knowing that d = 1/2 * a * t^2 where d is displacement, a is acceleration, and t is time.
            This is assuming initial_velocity is 0

            Args:
                time (float): the amount of time that it should take to go that amount (displacement)
                displacement (float): the distance (up being positive and down being negative) that it should travel
     
            Returns:
                None
        """

        self.acceleration = (2 * displacement) / pow(time, 2)

    def set_velocity_with_displacement(self, displacement):
        """ Sets the initial velocity of the function knowing that vf^2 = vi^2 + 2ad and we know that vf is 0
            a is acceleration, t is time, and v is initial_velocity

            Args:
                displacement (float): the distance (up being positive and down being negative) that it should travel
     
            Returns:
                None
        """

        # Solved for vi knowing vf = 0 in vf^2 = vi^2 + 2ad
        self.initial_velocity = math.sqrt(2 * self.acceleration * displacement)


    def set_acceleration_with_velocity(self, time, velocity_change):
        """Sets the acceleration knowing that vf = vi + at"""

        self.acceleration = velocity_change / time

    def set_all_variables(self, vertex, time, initial_distance):
        """ Sets all the variables; calls set_velocity and set_gravity_acceleration

            Args:
                vertex (float): the highest/lowest point of the parabola
                time (float): the time it takes to get to the vertex/go the acceleration_distance
                initial_distance (float): the initial distance
     
            Returns:
                None
        """

        self.initial_distance = initial_distance

        # Gotten using math
        self.initial_velocity = (-2 * initial_distance + 2 * vertex) / time
        self.acceleration = 2 * (initial_distance - vertex) / pow(time, 2)

    def set_variables(self, **kwargs):
        """ Sets the variables to the number provided

            possible parameters:
                acceleration (float): the acceleration (can be positive or negative) | a in 1/2 * ax^2 + bx + c
                initial_velocity (float): the initial_velocity (can be positive or negative) | b in 1/2 * ax^2 + bx + c
                initial_distance (float): the starting point (can be positive or negative) | c in 1/2 * ax^2 + bx + c

            Returns:
                None
        """

        self.acceleration = get_kwarg_item(kwargs, "acceleration", self.acceleration)
        self.initial_velocity = get_kwarg_item(kwargs, "initial_velocity", self.initial_velocity)
        self.initial_distance = get_kwarg_item(kwargs, "initial_distance", self.initial_distance)

    def get_distance(self, time):
        """ Finds the number by plugging x into the equation 1/2 * at^2 + vt + d
            where a is acceleration, t is time, v is initial_velocity, and d is initial_distance

            Args:
                time (float): the amount of time that has passed

            Returns:
                float: the number that is gotten when time is plugged into the equation
        """
        return 1 / 2 * self.acceleration * pow(time, 2) + self.initial_velocity * time + self.initial_distance

    def get_velocity_using_time(self, time):
        """ Uses the fact that the initial_velocity is equal to vi - at^2 where vi is the initial initial_velocity, a is acceleration, and t is time
            to find the initial_velocity

            Args:
                time (float): the amount of time that the initial_velocity has been affected by acceleration
     
            Returns:
                float: the initial_velocity after affected by acceleration
        """

        return self.initial_velocity + self.acceleration * time

    def get_velocity_using_displacement(self, displacement):
        """ Uses the formula vf^2 = vi^2 + 2ax to find the initial_velocity
            where vf is final initial_velocity, vi is initial initial_velocity, a is acceleration, and x is displacement

            Args:
                displacement (float): the amount that the ball has traveled (upwards is positive and downwards is negative)
     
            Returns:
                float: the final initial_velocity
        """

        final_velocity_squared = pow(self.initial_velocity, 2) + 2 * self.acceleration * displacement
        # Reduces the risk of a rounding error like -1*e^-15 would cause an imaginary number exception
        return pow(int(final_velocity_squared), 1 / 2)

    def get_vertex(self):
        """
             Returns:
                float: the vertex of this physics equation"""

        return self.get_distance(self.get_time_to_vertex())

    def get_times_to_point(self, distance):
        """ Finds the number by plugging in 'distance' into the equation 1/2 * at^2 + vt + d
            where a is acceleration, t is time, v is initial_velocity, and d is initial_distance

            Args:
                distance (float): the distance that is wanted
     
            Returns:
                float[]: the times that the parabola is at that y coordinate
        """
        return solve_quadratic(1 / 2 * self.acceleration, self.initial_velocity, self.initial_distance - distance)

    def get_full_cycle_time(self):
        """
             Returns:
                float: the amount of time it takes the parabola to go from start_location -> start_location"""

        return self.get_time_to_vertex() * 2

    def get_indefinite_integral_of_position_equation(self):
        """
             Returns:
                Function: the indefinite integral of the position equation: x = 1/2at^2 + vt + xi"""

        a, b, c = self.get_a_b_and_c()
        return QuadraticFunction.get_indefinite_integral_using_quadratic_form(a, b, c)

    def get_a_b_and_c(self):
        """
             Returns:
                list[float]: {a, b, c}; the a, b, and c values of this equation if it was in quadratic form: ax^2 + bx + c"""

        a = 1/2 * self.acceleration
        b = self.initial_velocity
        c = self.initial_distance

        return [a, b, c]

    def get_displacement(self, start_time, end_time):
        """
             Returns:
                float: the displacement of the object from start_time -> end_time (the integral from start_time to end_time)"""

        indefinite_integral = self.get_indefinite_integral_of_position_equation()
        return indefinite_integral.get_y_coordinate(end_time) - indefinite_integral.get_y_coordinate(start_time)

    def get_indefinite_integral_of_velocity_equation(self):
        """
             Returns:
                Function: the indefinite integral of the velocity equation: vt -> vt^2/2"""

        return QuadraticFunction.get_indefinite_integral_using_quadratic_form(0, self.initial_velocity, 0)

    def get_displacement_due_to_velocity(self, start_time, end_time):
        """
             Returns:
                float: the displacement of the object from start_time -> end_time only based upon velocity (the integral from start_time to end_time)"""

        indefinite_integral = self.get_indefinite_integral_of_velocity_equation()
        return indefinite_integral.get(end_time) - indefinite_integral.get(start_time)

    def get_indefinite_integral_of_acceleration_equation(self):
        """
             Returns:
                Function: the indefinite integral of the acceleration equation: 1/2at^2 -> 1/6at^3"""

        return QuadraticFunction.get_indefinite_integral_using_quadratic_form(1/2 * self.acceleration, 0, 0)

    def get_displacement_due_to_acceleration(self, start_time, end_time):
        """
             Returns:
                float: the displacement of the object from start_time -> end_time only based upon acceleration (the integral from start_time to end_time)"""

        indefinite_integral = self.get_indefinite_integral_of_acceleration_equation()
        return indefinite_integral.get(end_time) - indefinite_integral.get(start_time)

    def __str__(self):
        return f"[{self.acceleration},{self.initial_velocity},{self.initial_distance},]"

    def __eq__(self, other):
        return (self.acceleration == other.acceleration and self.initial_velocity == other.initial_velocity and
                self.initial_distance == other.initial_distance)

Subclasses

Class variables

var acceleration
var initial_distance
var initial_velocity

Methods

def get_a_b_and_c(self)

Returns

list[float]
{a, b, c}; the a, b, and c values of this equation if it was in quadratic form: ax^2 + bx + c
Expand source code
def get_a_b_and_c(self):
    """
         Returns:
            list[float]: {a, b, c}; the a, b, and c values of this equation if it was in quadratic form: ax^2 + bx + c"""

    a = 1/2 * self.acceleration
    b = self.initial_velocity
    c = self.initial_distance

    return [a, b, c]
def get_displacement(self, start_time, end_time)

Returns

float
the displacement of the object from start_time -> end_time (the integral from start_time to end_time)
Expand source code
def get_displacement(self, start_time, end_time):
    """
         Returns:
            float: the displacement of the object from start_time -> end_time (the integral from start_time to end_time)"""

    indefinite_integral = self.get_indefinite_integral_of_position_equation()
    return indefinite_integral.get_y_coordinate(end_time) - indefinite_integral.get_y_coordinate(start_time)
def get_displacement_due_to_acceleration(self, start_time, end_time)

Returns

float
the displacement of the object from start_time -> end_time only based upon acceleration (the integral from start_time to end_time)
Expand source code
def get_displacement_due_to_acceleration(self, start_time, end_time):
    """
         Returns:
            float: the displacement of the object from start_time -> end_time only based upon acceleration (the integral from start_time to end_time)"""

    indefinite_integral = self.get_indefinite_integral_of_acceleration_equation()
    return indefinite_integral.get(end_time) - indefinite_integral.get(start_time)
def get_displacement_due_to_velocity(self, start_time, end_time)

Returns

float
the displacement of the object from start_time -> end_time only based upon velocity (the integral from start_time to end_time)
Expand source code
def get_displacement_due_to_velocity(self, start_time, end_time):
    """
         Returns:
            float: the displacement of the object from start_time -> end_time only based upon velocity (the integral from start_time to end_time)"""

    indefinite_integral = self.get_indefinite_integral_of_velocity_equation()
    return indefinite_integral.get(end_time) - indefinite_integral.get(start_time)
def get_distance(self, time)

Finds the number by plugging x into the equation 1/2 * at^2 + vt + d where a is acceleration, t is time, v is initial_velocity, and d is initial_distance

Args

time : float
the amount of time that has passed

Returns

float
the number that is gotten when time is plugged into the equation
Expand source code
def get_distance(self, time):
    """ Finds the number by plugging x into the equation 1/2 * at^2 + vt + d
        where a is acceleration, t is time, v is initial_velocity, and d is initial_distance

        Args:
            time (float): the amount of time that has passed

        Returns:
            float: the number that is gotten when time is plugged into the equation
    """
    return 1 / 2 * self.acceleration * pow(time, 2) + self.initial_velocity * time + self.initial_distance
def get_full_cycle_time(self)

Returns

float
the amount of time it takes the parabola to go from start_location -> start_location
Expand source code
def get_full_cycle_time(self):
    """
         Returns:
            float: the amount of time it takes the parabola to go from start_location -> start_location"""

    return self.get_time_to_vertex() * 2
def get_indefinite_integral_of_acceleration_equation(self)

Returns

Function
the indefinite integral of the acceleration equation: 1/2at^2 -> 1/6at^3
Expand source code
def get_indefinite_integral_of_acceleration_equation(self):
    """
         Returns:
            Function: the indefinite integral of the acceleration equation: 1/2at^2 -> 1/6at^3"""

    return QuadraticFunction.get_indefinite_integral_using_quadratic_form(1/2 * self.acceleration, 0, 0)
def get_indefinite_integral_of_position_equation(self)

Returns

Function
the indefinite integral of the position equation: x = 1/2at^2 + vt + xi
Expand source code
def get_indefinite_integral_of_position_equation(self):
    """
         Returns:
            Function: the indefinite integral of the position equation: x = 1/2at^2 + vt + xi"""

    a, b, c = self.get_a_b_and_c()
    return QuadraticFunction.get_indefinite_integral_using_quadratic_form(a, b, c)
def get_indefinite_integral_of_velocity_equation(self)

Returns

Function
the indefinite integral of the velocity equation: vt -> vt^2/2
Expand source code
def get_indefinite_integral_of_velocity_equation(self):
    """
         Returns:
            Function: the indefinite integral of the velocity equation: vt -> vt^2/2"""

    return QuadraticFunction.get_indefinite_integral_using_quadratic_form(0, self.initial_velocity, 0)
def get_time_to_vertex(self)

Gets the time it takes to reach the vertex knowing that the final initial_velocity is 0, so the time is -initial_velocity / acceleration

Returns

float
the time to reach the vertex
Expand source code
def get_time_to_vertex(self):
    """ Gets the time it takes to reach the vertex knowing that the final initial_velocity is 0, so the time is -initial_velocity / acceleration
 
        Returns:
            float: the time to reach the vertex
    """

    return -self.initial_velocity / self.acceleration
def get_times_to_point(self, distance)

Finds the number by plugging in 'distance' into the equation 1/2 * at^2 + vt + d where a is acceleration, t is time, v is initial_velocity, and d is initial_distance

Args

distance : float
the distance that is wanted

Returns

float[]
the times that the parabola is at that y coordinate
Expand source code
def get_times_to_point(self, distance):
    """ Finds the number by plugging in 'distance' into the equation 1/2 * at^2 + vt + d
        where a is acceleration, t is time, v is initial_velocity, and d is initial_distance

        Args:
            distance (float): the distance that is wanted
 
        Returns:
            float[]: the times that the parabola is at that y coordinate
    """
    return solve_quadratic(1 / 2 * self.acceleration, self.initial_velocity, self.initial_distance - distance)
def get_velocity_using_displacement(self, displacement)

Uses the formula vf^2 = vi^2 + 2ax to find the initial_velocity where vf is final initial_velocity, vi is initial initial_velocity, a is acceleration, and x is displacement

Args

displacement : float
the amount that the ball has traveled (upwards is positive and downwards is negative)

Returns

float
the final initial_velocity
Expand source code
def get_velocity_using_displacement(self, displacement):
    """ Uses the formula vf^2 = vi^2 + 2ax to find the initial_velocity
        where vf is final initial_velocity, vi is initial initial_velocity, a is acceleration, and x is displacement

        Args:
            displacement (float): the amount that the ball has traveled (upwards is positive and downwards is negative)
 
        Returns:
            float: the final initial_velocity
    """

    final_velocity_squared = pow(self.initial_velocity, 2) + 2 * self.acceleration * displacement
    # Reduces the risk of a rounding error like -1*e^-15 would cause an imaginary number exception
    return pow(int(final_velocity_squared), 1 / 2)
def get_velocity_using_time(self, time)

Uses the fact that the initial_velocity is equal to vi - at^2 where vi is the initial initial_velocity, a is acceleration, and t is time to find the initial_velocity

Args

time : float
the amount of time that the initial_velocity has been affected by acceleration

Returns

float
the initial_velocity after affected by acceleration
Expand source code
def get_velocity_using_time(self, time):
    """ Uses the fact that the initial_velocity is equal to vi - at^2 where vi is the initial initial_velocity, a is acceleration, and t is time
        to find the initial_velocity

        Args:
            time (float): the amount of time that the initial_velocity has been affected by acceleration
 
        Returns:
            float: the initial_velocity after affected by acceleration
    """

    return self.initial_velocity + self.acceleration * time
def get_vertex(self)

Returns

float
the vertex of this physics equation
Expand source code
def get_vertex(self):
    """
         Returns:
            float: the vertex of this physics equation"""

    return self.get_distance(self.get_time_to_vertex())
def set_acceleration_with_displacement(self, time, displacement)

Sets the acceleration knowing that d = 1/2 * a * t^2 where d is displacement, a is acceleration, and t is time. This is assuming initial_velocity is 0

Args

time : float
the amount of time that it should take to go that amount (displacement)
displacement : float
the distance (up being positive and down being negative) that it should travel

Returns

None

Expand source code
def set_acceleration_with_displacement(self, time, displacement):
    """ Sets the acceleration knowing that d = 1/2 * a * t^2 where d is displacement, a is acceleration, and t is time.
        This is assuming initial_velocity is 0

        Args:
            time (float): the amount of time that it should take to go that amount (displacement)
            displacement (float): the distance (up being positive and down being negative) that it should travel
 
        Returns:
            None
    """

    self.acceleration = (2 * displacement) / pow(time, 2)
def set_acceleration_with_velocity(self, time, velocity_change)

Sets the acceleration knowing that vf = vi + at

Expand source code
def set_acceleration_with_velocity(self, time, velocity_change):
    """Sets the acceleration knowing that vf = vi + at"""

    self.acceleration = velocity_change / time
def set_all_variables(self, vertex, time, initial_distance)

Sets all the variables; calls set_velocity and set_gravity_acceleration

Args

vertex : float
the highest/lowest point of the parabola
time : float
the time it takes to get to the vertex/go the acceleration_distance
initial_distance : float
the initial distance

Returns

None

Expand source code
def set_all_variables(self, vertex, time, initial_distance):
    """ Sets all the variables; calls set_velocity and set_gravity_acceleration

        Args:
            vertex (float): the highest/lowest point of the parabola
            time (float): the time it takes to get to the vertex/go the acceleration_distance
            initial_distance (float): the initial distance
 
        Returns:
            None
    """

    self.initial_distance = initial_distance

    # Gotten using math
    self.initial_velocity = (-2 * initial_distance + 2 * vertex) / time
    self.acceleration = 2 * (initial_distance - vertex) / pow(time, 2)
def set_variables(self, **kwargs)

Sets the variables to the number provided

possible parameters: acceleration (float): the acceleration (can be positive or negative) | a in 1/2 * ax^2 + bx + c initial_velocity (float): the initial_velocity (can be positive or negative) | b in 1/2 * ax^2 + bx + c initial_distance (float): the starting point (can be positive or negative) | c in 1/2 * ax^2 + bx + c

Returns

None

Expand source code
def set_variables(self, **kwargs):
    """ Sets the variables to the number provided

        possible parameters:
            acceleration (float): the acceleration (can be positive or negative) | a in 1/2 * ax^2 + bx + c
            initial_velocity (float): the initial_velocity (can be positive or negative) | b in 1/2 * ax^2 + bx + c
            initial_distance (float): the starting point (can be positive or negative) | c in 1/2 * ax^2 + bx + c

        Returns:
            None
    """

    self.acceleration = get_kwarg_item(kwargs, "acceleration", self.acceleration)
    self.initial_velocity = get_kwarg_item(kwargs, "initial_velocity", self.initial_velocity)
    self.initial_distance = get_kwarg_item(kwargs, "initial_distance", self.initial_distance)
def set_velocity_with_displacement(self, displacement)

Sets the initial velocity of the function knowing that vf^2 = vi^2 + 2ad and we know that vf is 0 a is acceleration, t is time, and v is initial_velocity

Args

displacement : float
the distance (up being positive and down being negative) that it should travel

Returns

None

Expand source code
def set_velocity_with_displacement(self, displacement):
    """ Sets the initial velocity of the function knowing that vf^2 = vi^2 + 2ad and we know that vf is 0
        a is acceleration, t is time, and v is initial_velocity

        Args:
            displacement (float): the distance (up being positive and down being negative) that it should travel
 
        Returns:
            None
    """

    # Solved for vi knowing vf = 0 in vf^2 = vi^2 + 2ad
    self.initial_velocity = math.sqrt(2 * self.acceleration * displacement)