04.test.sml

use "unittest.sml";
use "63130148-04.sml";

val _ = (

    (* Podan seznam xs agregira z začetno vrednostjo z
    in funkcijo f v vrednost f(f(f(z, xs_1),  xs_2), xs_3) ... *)
    test("fun reduce (f: 'a * 'b -> 'a, z: 'a, xs: 'b list): 'a", [
        assert_eq(reduce(fn (agg, value) => agg + value, 0, []), 0),
        assert_eq(reduce(fn (agg, value) => agg + value, 0, [1, 2, 3, 4, 5]), 15),
        assert_eq(reduce(fn (agg, value) => agg ^ " " ^ Int.toString(value), "", [1, 2, 3, 4, 5]), " 1 2 3 4 5"),
        assert_eq(reduce(fn (agg, value) => agg + value, 0, []), 0)
    ]);

    (* Vrne seznam, ki vsebuje kvadrate števil
    iz vhodnega seznama. Uporabite List.map. *)
    test("fun squares (xs: int list): int list", [
        assert_eq(squares [], []),
        assert_eq(squares [1, 2, 3, 4, 5], [1, 4, 9, 16, 25])
    ]);

    (* Vrne seznam, ki vsebuje vsa soda števila
    iz vhodnega seznama. Uporabite List.filter. *)
    test("fun onlyEven (xs: int list): int list", [
        assert_eq(onlyEven [], []),
        assert_eq(onlyEven [1, 2, 3, 4, 5], [2, 4])
    ]);

    (* Vrne najboljši niz glede na funkcijo f. Funkcija f primerja dva niza
    in vrne true, če je prvi niz boljši od drugega. Uporabite List.foldl.
    Najboljši niz v praznem seznamu je prazen niz. *)
    test("fun bestString (f: string * string -> bool, xs: string list): string", [
        assert_eq(bestString(fn (l, r) => l > r, []), ""),
        assert_eq(bestString(fn (l, r) => l > r, ["a", "b", "c", "d"]), "d"),
        assert_eq(bestString(fn (l, r) => l < r, ["a", "b", "c", "d"]), "a"),
        assert_eq(bestString(fn (l, r) => l < r, ["g", "u", "d", "a", "o", "v", "i", "l", "t"]), "a")
    ]);

    (* Vrne leksikografsko največji niz. Uporabite bestString. *)
    test("fun largestString (xs: string list): string", [
        assert_eq(largestString [], ""),
        assert_eq(largestString ["a", "b", "c", "d"], "d"),
        assert_eq(largestString ["Matej", "Alen", "Nejc", "Žiga"], "Žiga")
    ]);

    (* Vrne najdaljši niz. Uporabite bestString. *)
    test("fun longestString (xs: string list): string", [
        assert_eq(longestString [], ""),
        assert_eq(longestString ["avasd", "bsdssd", "c", "dasd"], "bsdssd"),
        assert_eq(longestString ["Matej", "Alen", "Nejc", "Žiga"], "Matej")
    ]);

    (* Seznam uredi naraščajoče z algoritmom quicksort. *)
    test("fun quicksort (xs: int list): int list", [
        assert_eq(quicksort [], []),
        assert_eq(quicksort [1,2,3,4,5], [1,2,3,4,5]),
        assert_eq(quicksort [5,4,3,2,1], [1,2,3,4,5]),
        assert_eq(quicksort [2,4,3,5,1], [1,2,3,4,5])
    ]);

    (* Vrne skalarni produkt dveh vektorjev.
    Uporabite List.foldl in ListPair.map. *)
    test("fun dot (xs: int list, ys: int list): int", [
        assert_eq(dot([], []), 0),
        assert_eq(dot([1,1,1], [1,2,3]), 6),
        assert_eq(dot([1,2,3], [1,2,3]), 14)
    ]);

    (* Vrne transponirano matriko. Matrika je podana z vrstičnimi vektorji
    od zgoraj navzdol: [[1,2,3],[4,5,6],[7,8,9]] predstavlja matriko
    [ 1 2 3 ]
    [ 4 5 6 ]
    [ 7 8 9 ]
    *)
    test("fun transpose (m: 'a list list): 'a list list", [
        assert_eq(transpose [], []),
        assert_eq(transpose [[1, 2, 3]], [[1], [2], [3]]),
        assert_eq(transpose [[1], [2], [3]], [[1, 2, 3]]),
        assert_eq(transpose [[1,2,3],[4,5,6],[7,8,9]], [[1,4,7], [2,5,8], [3,6,9]])
    ]);

    (* Zmnoži dve matriki. Uporabite dot in transpose. *)
    test("fun multiply (a: int list list, b: int list list): int list list", [
        assert_eq(multiply([], []), []),
        assert_eq(multiply([[1,0], [0,1]], [[1,2], [3,4]]), [[1,2], [3,4]]),
        assert_eq(multiply([[1,2], [3,4]], [[1,2], [3,4]]), [[7,10], [15,22]])
    ]);

    (* V podanem seznamu prešteje zaporedne enake elemente in vrne seznam
    parov (vrednost, število ponovitev). Podobno deluje UNIX-ovo orodje
    uniq -c. *)
    test("fun group (xs: ''a list): (''a * int) list", [
        assert_eq(group [], []),
        assert_eq(group [1,2,2,3,4,4,4,4,5,6,7,6,6,2,1,1,4,4], [(1,1), (2,2), (3,1), (4,4), (5,1), (6,1), (7,1), (6,2), (2,1), (1,2), (4,2)])
    ]);

    (* Elemente iz podanega seznama razvrsti v ekvivalenčne razrede.
    Znotraj razredov naj bodo elementi v istem vrstnem redu kot v
    podanem seznamu. Ekvivalentnost elementov definira funkcija f,
    ki za dva elementa vrne true, če sta ekvivalentna. *)
    test("fun equivalenceClasses (f: ''a * ''a -> bool, xs: ''a list): ''a list list", [
        assert_eq(equivalenceClasses((fn (a,b) => a = b), []), []),
        assert_eq(equivalenceClasses((fn (a,b) => a = b), [1, 2, 3, 4, 5, 1, 3, 4, 6, 3, 1]), [[1,1,1], [2], [3,3,3], [4,4], [5], [6]]),
        assert_eq(equivalenceClasses((fn (a,b) => a mod 2 = b mod 2), [1, 2, 3, 4, 5, 1, 3, 4, 6, 3, 1]), [[1,3,5,1,3,3,1], [2,4,4,6]])
    ]);

    OS.Process.exit(OS.Process.success)
);