Checkpoint 2

I found some of these functions in checkpoint 2 to be a little bit
trickier to write. I wasn’t always sure what was going on with each
function and often had to look back and really think about what each
function was doing. Particularly with the clamp and ratio functions I
had a more difficult time understanding what the purpose of the function
was in the grand picture of making the scatter plot, but the more I
played around with the functions the more sense it made. I did get stuck
once with the lists for the get_x and get_y values and while I thought I
needed to create a list, I was missing the piece about how to add to
the list. Checking in with classmates on Discord helped me to move
past that roadblock.

scatterplot.py

@@ -39,6 +39,7 @@ def draw_axes(data):
 def draw_points(data, color, size):
     "Draws the scatter plot's points."
 
+
 with no_delay():
     data = generate_data(50, 10, 500, 5, 400, 1000)
     draw_scatterplot(data, size=5, color="blue")

transform.py

@@ -6,38 +6,69 @@
 
 def maximum(data):
     "Returns the largest number in data"
-    raise NotImplementedError
+    highest = None
+    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"
-    raise NotImplementedError
+    lowest = None
+    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"
-    raise NotImplementedError
+    bounds = [minimum(data),maximum(data)]
+    return bounds
 
 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 low < value < high:
+        return value
+    if value < low:
+        return low
+    if value > high:
+        return high
 
 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
+    ratio = ((value-start)/(end-start))
+    ratio_2 = clamp(ratio,0,1)       
+    return ratio_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
+    ratio_2 = ratio(value, domain_min, domain_max)
+    scale = range_min + ratio_2*(range_max-range_min)
+    return scale
 
 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