Add tests for functions 19-32 LA01

Author: christian-byrne

src/large_assignment_01/large_assignment_01.sml

@@ -33,11 +33,11 @@ fun triangle(0, _, _) = false
 fun triangleR(a, b, c) = 
   let
     val epsilon = 1.0E~10
-    fun is_zero(x) = abs(x) < epsilon
-    fun sum_geq_to(a, b, to) = a + b >= to
+    fun isZero(x) = abs(x) < epsilon
+    fun sumGeqTo(a, b, to) = a + b >= to
   in
-    not(is_zero(a)) andalso not(is_zero(b)) andalso not(is_zero(c)) andalso
-    sum_geq_to(a, b, c) andalso sum_geq_to(a, c, b) andalso sum_geq_to(b, c, a)
+    not(isZero(a)) andalso not(isZero(b)) andalso not(isZero(c)) andalso
+    sumGeqTo(a, b, c) andalso sumGeqTo(a, c, b) andalso sumGeqTo(b, c, a)
   end;
 
 
@@ -71,8 +71,8 @@ fun triangleR(a, b, c) =
  *        contains all the elements in l that are greater than
  *        n. Keep the same relative order of items.
  *)
- fun gtList(_, []) = []
-  | gtList(n, x::li) = if x > n then x::gtList(n, li) else gtList(n, li);
+ fun gtList([], _) = []
+  | gtList(x::li, n) = if x > n then x::gtList(li, n) else gtList(li, n);
 
 
 (*
@@ -316,6 +316,7 @@ fun dropNth _ [] = []
       else subList(li, 0, n - 2) @ dropNth n (subList(li, n, liLen - 1))
     end;
 
+
 (*
  *  Type: `'a list list → 'a list`
  *  Desc: Takes a list of lists and flattens it so that it is
@@ -335,7 +336,7 @@ fun flatten li = foldr (fn(cur, acc) => cur @ acc) [] li;
  *        list of the results for each inner list. This should
  *        be a one-liner using map, foldr, and/or foldl.
  *)
-fun condenseLists f startVal li = foldl (fn(cur, acc) => f(cur, acc)) startVal li;
+fun condenseLists f startVal li = foldr (fn(cur, acc) => collapse(cur, startVal, f)::acc) [] li;
 
 
 (*
@@ -360,8 +361,8 @@ fun triplist li = foldr (fn(cur, acc) => cur::cur::cur::acc) [] li;
  *  Desc: Take a list l and an integer n and create a list that
  *        repeats l n times.
  *)
-fun repeat _ 0 = []
-  | repeat li n = li @ repeat(li, n - 1);
+fun repeat li 0 = []
+  | repeat li n = li @ repeat li (n - 1);
 
 
 (*
@@ -371,7 +372,7 @@ fun repeat _ 0 = []
  *        which f is true have g applied to them. You should do
  *        this in one line with map, foldr, and/or foldl.
  *)
-fun filterApply li f g = foldl (fn(cur, acc) => if f(cur) then g(cur)::acc else cur::acc) [] li;
+fun filterApply li f g = foldr (fn(cur, acc) => if f(cur) then g(cur)::acc else cur::acc) [] li;
 
 
 (*
@@ -402,17 +403,7 @@ fun element x [] = false
  *        otherwise.
  *)
 fun isSet([]) = true
-  | isSet(x::li) =
-    let
-      fun countOccurences(target, []) = 0
-        | countOccurences(target, x::li) = 
-          if target = x 
-          then 1 + countOccurences(target, li) 
-          else countOccurences(target, li)
-    in
-      if countOccurences(x, li) > 0 then false
-      else isSet(li)
-    end;
+  | isSet(x::li) = if indexOf x li = ~1 then isSet(li) else false
 
 
 (*
@@ -421,10 +412,10 @@ fun isSet([]) = true
  *        sets, to produce the union of the two sets. The
  *        resulting order of the elements does not matter.
  *)
-fun union([], []) = [];
-  | union(x::li1, []) = x::li1
-  | union([], y::li2) = y::li2
-  | union(x::li1, y::li2) = if element x li2 then union(li1, y::li2) else x::union(li1, y::li2)
+fun union([], []) = []
+  | union(li1, []) = li1
+  | union([], li2) = li2
+  | union(x::li1, li2) = if element x li2 then union(li1, li2) else x::union(li1, li2);
 
 
 (*

tests/tests-large_assignment_01/test_apply.sml renamed to src/sml_practice/staging/test_apply.sml

@@ -9,6 +9,8 @@ val testCasesApplyInt = [
 
   (* 2. Single-element list *)
   (apply, ([2], fn x => x * 2), [4]),
+  
+  (apply, ([1,2,3,4,5], fn x => x + 2), [3,4,5,6,7]),
 
   (* 3. List of integers with addition function *)
   (apply, ([1, 2, 3], fn x => x + 1), [2, 3, 4])

src/sml_practice/staging/test_arithSeq.sml

@@ -0,0 +1,61 @@
+(* Large Assignment 01 Tests *)
+
+use "src/large_assignment_01/large_assignment_01.sml";
+use "tests/utils.sml";
+
+(* Test cases for arithSeq *)
+val testCasesArithSeq = [
+  (* 1. Basic arithmetic sequence starting at 1 with a difference of 2 *)
+  (fn (a, d, l) => arithSeq a d l, (1, 2, 5), [1, 3, 5, 7, 9]),
+
+  (* 2. Arithmetic sequence with a negative difference *)
+  (fn (a, d, l) => arithSeq a d l, (10, ~2, 5), [10, 8, 6, 4, 2]),
+
+  (* 3. Sequence with a difference of 0 (all elements are the same) *)
+  (fn (a, d, l) => arithSeq a d l, (5, 0, 4), [5, 5, 5, 5]),
+
+  (* 4. Sequence of length 1 *)
+  (fn (a, d, l) => arithSeq a d l, (7, 3, 1), [7]),
+
+  (* 5. Empty sequence (length 0) *)
+  (fn (a, d, l) => arithSeq a d l, (1, 1, 0), []),
+
+  (* 6. Sequence with a starting value of 0 and a positive difference *)
+  (fn (a, d, l) => arithSeq a d l, (0, 4, 3), [0, 4, 8]),
+
+  (* 7. Sequence with a negative starting value *)
+  (fn (a, d, l) => arithSeq a d l, (~3, 2, 4), [~3, ~1, 1, 3]),
+
+  (* 8. Large sequence to test performance *)
+  (fn (a, d, l) => arithSeq a d l, (1, 1, 100), List.tabulate(100, fn i => i + 1)),
+  
+  (fn (a, d, l) => arithSeq a d l, (0, 5, 4), [0,5,10,15]),
+
+  (* 9. Sequence where the common difference is larger than the starting value *)
+  (fn (a, d, l) => arithSeq a d l, (2, 10, 3), [2, 12, 22]),
+
+  (* 10. Sequence with a large negative difference *)
+  (fn (a, d, l) => arithSeq a d l, (100, ~20, 4), [100, 80, 60, 40]),
+
+  (* 11. Sequence with large positive starting value and difference *)
+  (fn (a, d, l) => arithSeq a d l, (1000, 500, 3), [1000, 1500, 2000]),
+
+  (* 12. Edge case: Sequence with starting value and common difference both 0 *)
+  (fn (a, d, l) => arithSeq a d l, (0, 0, 5), [0, 0, 0, 0, 0]),
+
+  (* 13. Large sequence with a mix of positive and negative terms *)
+  (fn (a, d, l) => arithSeq a d l, (50, ~5, 10), [50, 45, 40, 35, 30, 25, 20, 15, 10, 5]),
+
+  (* 14. Common difference larger than sequence length *)
+  (fn (a, d, l) => arithSeq a d l, (1, 10, 2), [1, 11]),
+
+  (* 15. Large sequence with only decreasing values *)
+  (fn (a, d, l) => arithSeq a d l, (500, ~50, 5), [500, 450, 400, 350, 300])
+];
+
+runTestsCustomComparator(
+  testCasesArithSeq,
+  fn (a, d, l) => "arithSeq(" ^ Int.toString a ^ ", " ^ Int.toString d ^ ", " ^ Int.toString l ^ ")",
+  valueToStringIntList,
+  isEqualList
+);

tests/tests-large_assignment_01/test_bubbleSort.sml renamed to src/sml_practice/staging/test_bubbleSort.sml

@@ -10,6 +10,9 @@ val testCasesBubbleSortInt = [
   (fn li => bubbleSort (fn (a, b) => a < b) li, [5, 4, 3, 2, 1], [1, 2, 3, 4, 5]),
   (fn li => bubbleSort (fn (a, b) => a < b) li, [3, 1, 4, 1, 5], [1, 1, 3, 4, 5]),
   (fn li => bubbleSort (fn (a, b) => a > b) li, [1, 2, 3, 4, 5], [5, 4, 3, 2, 1]),
+  
+  (fn li => bubbleSort (op >=) li, [1,1,4,2,3], [4,3,2,1,1]),
+  
   (fn li => bubbleSort (fn (a, b) => a < b) li, [3, ~1, ~2, 5, 0], [~2, ~1, 0, 3, 5]),
   (fn li => bubbleSort (fn (a, b) => a < b) li, [], []),
   (fn li => bubbleSort (fn (a, b) => a < b) li, [1, 1, 1, 1], [1, 1, 1, 1])

tests/tests-large_assignment_01/test_collapse.sml renamed to src/sml_practice/staging/test_collapse.sml

@@ -15,6 +15,8 @@ val testCasesCollapseInt = [
 
   (* 4. Product of multiple elements *)
   (collapse, ([1, 2, 3, 4], 1, op * ), 24),
+  
+  (collapse, ([1,2,3,4], 5, op + ), 15),
 
   (* 5. List with negative numbers (sum) *)
   (collapse, ([~1, ~2, ~3], 0, op +), ~6),

src/sml_practice/staging/test_condenseLists.sml

@@ -0,0 +1,53 @@
+(* Large Assignment 01 Tests *)
+
+use "src/large_assignment_01/large_assignment_01.sml";
+use "tests/utils.sml";
+
+(* Test cases for integer lists *)
+val testCasesCondenseListsInt = [
+  (* 1. Condense with addition (sum) *)
+  (fn li => condenseLists (op +) 0 li, [[1, 2], [3, 4], [5, 6]], [3, 7, 11]),
+
+  (* 2. Condense with multiplication *)
+  (fn li => condenseLists (op * ) 1 li, [[1, 2], [3, 4], [5, 6]], [2, 12, 30]),
+
+  (* 3. Condense with addition and empty lists *)
+  (fn li => condenseLists (op +) 0 li, [[], [1, 2, 3], []], [0, 6, 0]),
+  
+  (fn li => condenseLists (op +) 0 li, [[], [1, 2, 3, 4], [5,6]], [0, 10, 11]),
+
+  (* 4. Condense single-element lists *)
+  (fn li => condenseLists (op +) 0 li, [[1], [2], [3]], [1, 2, 3]),
+
+  (* 5. Condense with multiplication on nested lists *)
+  (fn li => condenseLists (op * ) 1 li, [[2], [3, 3], [4, 5]], [2, 9, 20])
+];
+
+runTestsCustomComparator(
+  testCasesCondenseListsInt,
+  fn li => "condenseLists (op +) 0 " ^ valueToStringIntListList li,
+  valueToStringIntList,
+  isEqualList
+);
+
+(* Test cases for string lists *)
+val testCasesCondenseListsString = [
+  (* 1. Condense with string concatenation *)
+  (fn li => condenseLists (op ^) "" li, [["a"], ["b", "c"], ["d"]], ["a", "bc", "d"]),
+
+  (* 2. Concatenate with separator *)
+  (fn li => condenseLists (fn (x, acc) => x ^ ", " ^ acc) "" li, [["a"], ["b", "c"], ["d"]], ["a, ", "b, c, ", "d, "]),
+
+  (* 3. Condense with empty strings *)
+  (fn li => condenseLists (op ^) "" li, [[""], ["a"], ["b", ""]], ["", "a", "b"]),
+
+  (* 4. Condense a single-element list *)
+  (fn li => condenseLists (op ^) "" li, [["hello"]], ["hello"])
+];
+
+runTestsCustomComparator(
+  testCasesCondenseListsString,
+  fn li => "condenseLists (op ^) \"\" " ^ valueToStringStringListList li,
+  valueToStringStringList,
+  isEqualList
+);

tests/tests-large_assignment_01/test_cycle.sml renamed to src/sml_practice/staging/test_cycle.sml

@@ -9,6 +9,8 @@ val testCycle = [
 
   (* 2. Cycling by 0 should return the list unchanged *)
   (cycle, (0, [1,2,3,4,5,6,7]), [1,2,3,4,5,6,7]),
+  
+  (cycle, (4, [1,2,3,4,5]), [5,1,2,3,4]),
 
   (* 3. Cycling by 1 should move the first element to the end *)
   (cycle, (1, [1,2,3,4,5]), [2,3,4,5,1]),

tests/tests-large_assignment_01/test_dec2BaseN.sml renamed to src/sml_practice/staging/test_dec2BaseN.sml

@@ -17,6 +17,9 @@ val testCasesToBaseN = [
 
   (* 3. Convert a number to binary (base 2) *)
   (fn (base, num) => dec2BaseN base num, (2, 5), "101"),
+  
+  (fn (base, num) => dec2BaseN base num, (2, 12), "1100"),
+  
   (fn (base, num) => dec2BaseN base num, (2, 13), "1101"),
   (fn (num, base) => dec2BaseN num base, (2, 10), "1010"),
 

src/sml_practice/staging/test_difference.sml

@@ -0,0 +1,89 @@
+(* Large Assignment 01 Tests *)
+
+use "src/large_assignment_01/large_assignment_01.sml";
+use "tests/utils.sml";
+
+(* Helper function to compare lists as sets (order doesn't matter) *)
+fun isEqualSet([], []) = true
+  | isEqualSet(x::xs, ys) = List.exists (fn y => y = x) ys 
+                            andalso isEqualSet(xs, List.filter (fn y => y <> x) ys)
+  | isEqualSet(_, _) = false;
+
+(* Test cases for integer lists *)
+val testCasesDifferenceInt = [
+  (* 1. Difference of two disjoint sets (should return the first set) *)
+  (fn (li1, li2) => difference(li1, li2), ([1, 2], [3, 4]), [1, 2]),
+
+  (* 2. Difference of two sets with some common elements *)
+  (fn (li1, li2) => difference(li1, li2), ([1, 2, 3], [2, 3, 4]), [1]),
+
+  (* 3. Difference when the first set is empty *)
+  (fn (li1, li2) => difference(li1, li2), ([], [1, 2, 3]), []),
+  
+  (fn (li1, li2) => difference(li1, li2), ([1, 2, 3], [2, 3, 4, 5]), [1]),
+
+  (* 4. Difference when the second set is empty *)
+  (fn (li1, li2) => difference(li1, li2), ([1, 2, 3], []), [1, 2, 3]),
+
+  (* 5. Difference of two identical sets (should return empty) *)
+  (fn (li1, li2) => difference(li1, li2), ([1, 2, 3], [1, 2, 3]), []),
+
+  (* 6. Difference with negative numbers *)
+  (fn (li1, li2) => difference(li1, li2), ([~1, ~2, 3], [3]), [~1, ~2]),
+
+  (* 7. List 1 longer by more than 3 elements *)
+  (fn (li1, li2) => difference(li1, li2), ([1, 2, 3, 4, 5, 6], [2, 4]), [1, 3, 5, 6]),
+
+  (* 8. List 2 longer by more than 3 elements *)
+  (fn (li1, li2) => difference(li1, li2), ([1, 2], [2, 3, 4, 5, 6]), [1]),
+
+  (* 9. List 1 longer by 1 element *)
+  (fn (li1, li2) => difference(li1, li2), ([1, 2, 3], [2, 3]), [1]),
+
+  (* 10. List 2 longer by 1 element *)
+  (fn (li1, li2) => difference(li1, li2), ([2, 3], [1, 2, 3]), [])
+];
+
+runTestsCustomComparator(
+  testCasesDifferenceInt,
+  fn (li1, li2) => "difference(" ^ valueToStringIntList li1 ^ ", " ^ valueToStringIntList li2 ^ ")",
+  valueToStringIntList,
+  isEqualSet
+);
+
+(* Test cases for string lists *)
+val testCasesDifferenceString = [
+  (* 1. Difference of two disjoint sets of strings (should return the first set) *)
+  (fn (li1, li2) => difference(li1, li2), (["a", "b"], ["c", "d"]), ["a", "b"]),
+
+  (* 2. Difference of two sets with some common strings *)
+  (fn (li1, li2) => difference(li1, li2), (["a", "b", "c"], ["b", "c", "d"]), ["a"]),
+
+  (* 3. Difference when the first set is empty *)
+  (fn (li1, li2) => difference(li1, li2), ([], ["a", "b", "c"]), []),
+
+  (* 4. Difference when the second set is empty *)
+  (fn (li1, li2) => difference(li1, li2), (["a", "b", "c"], []), ["a", "b", "c"]),
+
+  (* 5. Difference of two identical sets of strings (should return empty) *)
+  (fn (li1, li2) => difference(li1, li2), (["a", "b", "c"], ["a", "b", "c"]), []),
+
+  (* 6. Difference with one common element *)
+  (fn (li1, li2) => difference(li1, li2), (["x", "y"], ["y", "z"]), ["x"]),
+
+  (* 7. List 1 longer by more than 3 elements *)
+  (fn (li1, li2) => difference(li1, li2), (["a", "b", "c", "d", "e", "f"], ["c", "e"]), ["a", "b", "d", "f"]),
+
+  (* 8. List 2 longer by more than 3 elements *)
+  (fn (li1, li2) => difference(li1, li2), (["a", "b"], ["b", "c", "d", "e", "f"]), ["a"]),
+
+  (* 9. Difference with repeated strings (sets are assumed) *)
+  (fn (li1, li2) => difference(li1, li2), (["foo"], ["foo"]), [])
+];
+
+runTestsCustomComparator(
+  testCasesDifferenceString,
+  fn (li1, li2) => "difference(" ^ valueToStringStringList li1 ^ ", " ^ valueToStringStringList li2 ^ ")",
+  valueToStringStringList,
+  isEqualSet
+);

tests/tests-large_assignment_01/test_dropNth.sml renamed to src/sml_practice/staging/test_dropNth.sml

@@ -16,6 +16,8 @@ val testCasesDropNthInt = [
 
   (* 4. Drop every nth element where n > length of list (should return the same list) *)
   (fn (n, li) => dropNth n li, (10, [1, 2, 3, 4, 5]), [1, 2, 3, 4, 5]),
+  
+  (fn (n, li) => dropNth n li, (2, [1, 2, 3, 4, 5]), [1, 3, 5]),
 
   (* 5. Drop every nth element for an empty list *)
   (fn (n, li) => dropNth n li, (3, []), []),