For checkpoint 2, I finished the functions in transform.py to fix the error when testing it.

Checkpoint 2:
Writing some more complex functions have proven to be a challenge but
 also quite interesting. The new and more complex functions looked
 intimidating at first because it looked like everything was all
 over the place. My biggest struggle was figuring out what each
 part of the new complex functions did and how they work with other
 functions. In order to make progress I looked up information
 related to the complex functions to get a better understanding
 of what each part is meant for and how it work within itself and
 other functions. Like previous checkpoints, this task required
 me to think outside the box and seek outside clarification to be
 successful.

transform.py

@@ -6,38 +6,70 @@
 
 def maximum(data):
     "Returns the largest number in data"
-    raise NotImplementedError
+    highest = None 
+    for number in data:
+        if highest is None or number > highest:
+            highest = number
+    return highest
 
 def minimum(data):
     "Returns the smallest number in data"
-    raise NotImplementedError
+    lowest = None
+    for number in data:
+        if lowest is None or number < lowest:
+            lowest = number
+    return lowest
 
 def bounds(data):
     "Returns a list of the smallest and largest numbers in data"
-    raise NotImplementedError
+    return [minimum(data),maximum(data)]
 
 def clamp(value, low, high):
     """Clamps a value to a range from low to high. 
     Returns value if it is between low and high.
     If value is lower than low, returns low. If value is higher than high, returns high.
     """
-    raise NotImplementedError
+    if value < low: 
+        return low
+    elif value > high:
+        return high
+    else:
+        return value
 
 def ratio(value, start, end):
     """Returns a number from 0.0 to 1.0, representing how far along value is from start to end.
     The return value is clamped to [0, 1], so even if value is lower than start, the return 
     value will not be lower than 0.0.
     """
-    raise NotImplementedError
+    if start == end:
+        return 0.0
+
+    value = clamp(value, min(start,end),max(start,end))
+
+    r = (value-start) / (end-start)
+
+    r = clamp(r,0.0,1.0)
+
+    return round(r,2)
 
 def scale(value, domain_min, domain_max, range_min, range_max):
     "Given a value within a domain, returns the scaled equivalent within range."
-    raise NotImplementedError
+    if domain_max == domain_min:
+        return range_min
+    r = ratio(value,domain_min,domain_max)
+
+    return round(range_min + r * (range_max - range_min),2)
 
 def get_x_values(points):
     "Returns the first value for each point in points."
-    raise NotImplementedError
+    x_values = []
+    for x,y in points:
+        x_values.append(x)
+    return x_values
 
 def get_y_values(points):
     "Returns the second value for each point in points."
-    raise NotImplementedError
+    y_values = []
+    for x,y in points: 
+        y_values.append(y)
+    return y_values