From 618d9687c2e2a42528fecd2f486957e28315622b Mon Sep 17 00:00:00 2001
From: Pat Wick <pjwick@buffalo.edu>
Date: Thu, 3 Aug 2023 14:26:42 -0400
Subject: [PATCH] edited transform.py and modified test_transform.py

I was getting errors when running test_transform.py not because of transform.py
(I think) but instead because of how the arguments were being passed into the
functions within. I removed the list-in-a-list from the clamp(), ratio(), and
scale() tests and things seem to be working as expected.

A lot of the extra thinking for checkpoint 2 was related to my attempt to avoid
overthinking the problem. I found myself more than once starting to rewrite functions
that I had already made, so upon taking another look at my plan, I realized the
easier route would be to use things like the clamp() or minimum() function, for example,
in order to save myself time and possible hard-to-diagnose bugs later on. Keeping
with the theme of top-down design, breaking the problem up into smaller, simpler pieces
also makes things easier to test as progress is made. The biggest strategy I employed
was writing down, in English/pseudocode, what I wanted to do, then as I started to write
out my code, I would explain to myself what was supposed to happen, which is where I
started to go back to my previous functions to continue using them in the next function
to be made.
---
 test_transform.py | 18 ++++++++---------
 transform.py      | 49 +++++++++++++++++++++++++++++++++++++++--------
 2 files changed, 50 insertions(+), 17 deletions(-)

diff --git a/test_transform.py b/test_transform.py
index 8d46afe..9dd49b2 100644
--- a/test_transform.py
+++ b/test_transform.py
@@ -21,14 +21,14 @@ 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)
-test(clamp, [[-10, 0, 100]], 0)
-test(clamp, [[104, 0, 100]], 100)
-test(ratio, [[5, 0, 10]], 0.5)
-test(ratio, [[167, 100, 200]], 0.67)
-test(ratio, [[8, 10, 0]], 0.2)
-test(ratio, [[4, 10, 20]], 0.0)
-test(scale, [[4, 0, 10, 0, 100]], 40)
-test(scale, [[180, 120, 240, 0, 100]], 50)
+test(clamp, [10, 0, 100], 10)
+test(clamp, [-10, 0, 100], 0)
+test(clamp, [104, 0, 100], 100)
+test(ratio, [5, 0, 10], 0.5)
+test(ratio, [167, 100, 200], 0.67)
+test(ratio, [8, 10, 0], 0.2)
+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])
diff --git a/transform.py b/transform.py
index 64819b7..d230882 100644
--- a/transform.py
+++ b/transform.py
@@ -6,38 +6,71 @@
 
 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
+    min = minimum(data)
+    max = maximum(data)
+    return [min,max]
 
 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 > high:
+        return high
+    elif value < low:
+        return low
+    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
+    low = minimum([start,end])
+    high = maximum([start,end])
+    value = clamp(value,low,high)
+
+    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
+    r = ratio(value, domain_min, domain_max)
+    
+    return range_min + (r * (range_max - range_min))
 
 def get_x_values(points):
     "Returns the first value for each point in points."
-    raise NotImplementedError
+    pointX = []
+    for x, y in points:
+        pointX.append(x)
+    
+    return pointX
 
 def get_y_values(points):
     "Returns the second value for each point in points."
-    raise NotImplementedError
+    pointY = []
+    for x, y in points:
+        pointY.append(y)
+    
+    return pointY
\ No newline at end of file