transform.py test_transform.py

test_transform.py

@@ -1,24 +1,26 @@
 from transform import (
     maximum, 
     minimum,
-    bounds, 
+    bounds,   
     clamp,
-    ratio, 
+    ratio,
     scale,
     get_x_values,
     get_y_values,
 )
 
+
 def test(function, arguments, expected):
     observed = function(*arguments)
     if observed != expected:
-        args = ', '.join(str(arg) for arg in arguments) 
-        print(f"Error: Expected {function}({args}) to equal {expected}, but it was {observed}")
+       args = ', '.join(str(arg) for arg in arguments) 
+       print(f"Error: Expected {function}({args}) to equal {expected}, but it was {observed}")
+
 
-test(minimum, [[0, 1, 2, 3]], 0)
-test(minimum, [[-10, -20, -30]], -30)
 test(maximum, [[0, 1, 2, 3]], 3)
 test(maximum, [[-10, -20, -30]], -10)
+test(minimum, [[0, 1, 2, 3]], 0)
+test(minimum, [[-10, -20, -30]], -30)
 test(bounds, [[0, 1, 2, 3]], [0, 3])
 test(bounds, [[-10, -20, -30]], [-30, -10])
 test(clamp, [10, 0, 100], 10)
@@ -31,4 +33,4 @@ test(ratio, [4, 10, 20], 0.0)
 test(scale, [4, 0, 10, 0, 100], 40)
 test(scale, [180, 120, 240, 0, 100], 50)
 test(get_x_values, [[[0, 5], [1, 5], [2, 5]]], [0, 1, 2])
-test(get_y_values, [[[0, 5], [1, 5], [2, 5]]], [5, 5, 5])
+test(get_y_values, [[[0, 5], [1, 5], [2, 5]]], [5, 5, 5])

transform.py

@@ -4,40 +4,69 @@
 # The functions in this module transform data. 
 # None of them are finished; this is your job!
 
-def maximum(data):
-    "Returns the largest number in data"
-    raise NotImplementedError
+import sys
 
+def maximum(data):
+    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
-
+    highest = None
+    lowest = None
+    for number in data:
+        if highest is None:
+            highest = number
+        if lowest is None:
+            lowest = number
+        if number > highest:
+            highest = number
+        if number < lowest:
+            lowest = number
+    return [lowest, highest]
+   
 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 and value <= high:
+        return value
+    elif value < low:
+        return low
+    elif 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)
+    return clamp(ratio,0,1)
+
+
 
 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
+    scale = range_min + (ratio(value, domain_min, domain_max)) * (range_max - range_min)
+    return scale
+
 
 def get_x_values(points):
-    "Returns the first value for each point in points."
-    raise NotImplementedError
-
+    for (x, y) in points:
+        return ([x], )
+    
 def get_y_values(points):
-    "Returns the second value for each point in points."
-    raise NotImplementedError
+    for (x, y) in points:
+        return ([y], )
+       
+    
+