updated transform

The first several one went very well, I also enjoy solving the problems.
I was stuck with 6 a bit, trying to understand the meaning of it.
I took longer time on the last two tasks, my initial plan is to redefine [x,y] = value, then let it return x
Then I found that there was a problem of return a list, i asked ChatGpt's help when I was stuck on it
it gave me a great suggestions on how to fix it. It also provides a much concise way to solve the problem: return [point[0] for point in points]
 I thinl the thinking way is different especially for 6. I also think the concise coding might be better to adpot in the future

transform.py

@@ -6,38 +6,71 @@
 
 def maximum(data):
     "Returns the largest number in data"
-    raise NotImplementedError
+    biggest = None
+    for number in data:
+        if biggest is None:
+            biggest = number
+        if number > biggest:
+            biggest = number
+    return biggest
 
 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
+    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
+    if value > high:
+         return high
+    if value > low and value < high:
+         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 (value - start)/(end - start) < 0:
+         return 0
+    if (value - start)/(end - start) > 0:
+         return (value - start)/(end - start)
 
 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 = (value - domain_min) / (domain_max - domain_min)
+    "caculate the ratio first"
+    return range_min + ratio * (range_max - range_min)
+    
 
 def get_x_values(points):
     "Returns the first value for each point in points."
-    raise NotImplementedError
+    x_values = []
+    for point in points:
+         [x, y] = point
+         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 point in points:
+         [x, y] = point
+         y_values.append(y)
+    return y_values