Checkpoint 2: I was very frustrated with the ratio function. I could not figure out how to not get my answer to stop coming out to -0.0.

transform.py

@@ -5,39 +5,55 @@
 # None of them are finished; this is your job!
 
 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
+    lower_bound = minimum(data)
+    Upper_bound = maximum(data)
+    return [lower_bound, Upper_bound]
+    
 
 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 
+    if 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
+    clamped_value = clamp(value, start, end)
+    result = (clamped_value - start)/(end - start)
+    return result
 
 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
+    r = ratio(value, domain_min, domain_max)
+    scaled_value = range_min + r * (range_max - range_min)
+    return scaled_value
 
 def get_x_values(points):
-    "Returns the first value for each point in points."
-    raise NotImplementedError
+    x_values = [point[0] for point in points]
+    return x_values
 
 def get_y_values(points):
-    "Returns the second value for each point in points."
-    raise NotImplementedError
+    y_values = [point[1] for point in points]
+    return y_values