One of the projects in my Python 3 course on Codecademy was to calculate the linear regression of any given line in a set. This is my journey of doing just that, following their instructions. The goal, is to calculate the bounciness of different balls with the least error possible.

Starting with y = m*x + b

We can determine the y of a point pretty easily if we have the slope of the line (m) and the intercept (b). Thus, we can write a basic function to calculate the y:

def get_y(m, b, x):
  y = m*x + b
  return y

print(get_y(1, 0, 7) == 7)
print(get_y(5, 10, 3) == 25)

We can then use that to calculate the linear regression of a line:

def calculate_error(m, b, point):
    x_point = point[0]
    y_point = point[1]

    y2 = get_y(m, b, x_point)

    y_diff = y_point - y2
    y_diff = abs(y_diff)
    return y_diff

To get a more accurate result, we need a function that will parse several points at a time:

def calculate_all_error(m, b, points):
    totalerror = 0
    for point in points:
        totalerror += calculate_error(m, b, point)

    return abs(totalerror)

We can test it using the examples they provided:

#every point in this dataset lies upon y=x, so the total error should be zero:
datapoints = [(1, 1), (3, 3), (5, 5), (-1, -1)]
print(calculate_all_error(1, 0, datapoints))

#every point in this dataset is 1 unit away from y = x + 1, so the total error should be 4:
datapoints = [(1, 1), (3, 3), (5, 5), (-1, -1)]
print(calculate_all_error(1, 1, datapoints))

#every point in this dataset is 1 unit away from y = x - 1, so the total error should be 4:
datapoints = [(1, 1), (3, 3), (5, 5), (-1, -1)]
print(calculate_all_error(1, -1, datapoints))


#the points in this dataset are 1, 5, 9, and 3 units away from y = -x + 1, respectively, so total error should be
# 1 + 5 + 9 + 3 = 18
datapoints = [(1, 1), (3, 3), (5, 5), (-1, -1)]
print(calculate_all_error(-1, 1, datapoints))

You can save all possible m and b values between -10 and 10 (m values), as well as -20 and 20 (b values) using:

possible_ms = [mv * 0.1 for mv in range(-100, 100)] #your list comprehension here
possible_bs = [bv * 0.1 for bv in range(-200, 200)] #your list comprehension here

We can find the combination that produces the least error, which is:

    m = 0.3
    b = 1.7
    x = 6

The goal was to calculate the bounciness of different balls with the least error possible. With this data, we can calculate how far a given ball would bounce. For example, a 6 cm ball would bounce 3.5 cm. We know this because we can plug in the numbers like this:

get_y(0.3, 1.7, 6)