I added the code for the various functions

Checkpoint 2: It went okay. There were points where I couldn't figure out
what was going wrong so I had to look up the commands to make sure I was
using them as intended. Personally, coding is a lot of trial and error
for me in the learning process. I have to see what the code understands
and what it doesn't so I can rewrite it in a way that can be understood.
With practice I get used to its "lingo" for example the idententation
patterns, repetition, redefinition etc.

transform.py

@@ -5,39 +5,58 @@
 # None of them are finished; this is your job!
 
 def maximum(data):
-    "Returns the largest number in data"
+    highest = None
-    raise NotImplementedError
+    for number in data:
+        if highest is None:
+            highest = number
+        if number > highest:
+            highest = number
+    return highest
+
 
 def minimum(data):
-    "Returns the smallest number in data"
+    lowest = None
-    raise NotImplementedError
+    for number in data:
+        if lowest is None:
+            lowest = number
+        if number < lowest:
+            lowest = number
+    return lowest
 
 def bounds(data):
-    "Returns a list of the smallest and largest numbers in data"
+    bounds = [minimum(data), maximum(data)]
-    raise NotImplementedError
+    return bounds
 
+#I don't understand the point of the clamp function at this point. 
 def clamp(value, low, high):
-    """Clamps a value to a range from low to high. 
+    if value < low:
-    Returns value if it is between low and high.
+        return low
-    If value is lower than low, returns low. If value is higher than high, returns high.
+    if value > high:
-    """
+        return high
-    raise NotImplementedError
+    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.
+    low, high = min(start,end), max(start, end)
-    The return value is clamped to [0, 1], so even if value is lower than start, the return 
+    clampedval = clamp(value, low, high)
-    value will not be lower than 0.0.
+    ratio = (clampedval-start)/(end-start)
-    """
+    return ratio
-    raise NotImplementedError
+
 
 def scale(value, domain_min, domain_max, range_min, range_max):
-    "Given a value within a domain, returns the scaled equivalent within range."
+    ratio(value, domain_min, domain_max)
-    raise NotImplementedError
+    scaled = range_min + (ratio(value, domain_min, domain_max)*(range_max-range_min))
+    return scaled
 
 def get_x_values(points):
-    "Returns the first value for each point in points."
+    x_values=[]
-    raise NotImplementedError
+    for point in points:
+        x_values.append(point[0])
+    return x_values
 
 def get_y_values(points):
-    "Returns the second value for each point in points."
+    y_values=[]
-    raise NotImplementedError
+    for point in points:
+        y_values.append(point[1])
+        print(y_values)
+    return y_values