|
| 1 | +//############################################################################ |
| 2 | +// Programmation IV - 2002 - Week 04 |
| 3 | +//############################################################################ |
| 4 | + |
| 5 | +object M0 { |
| 6 | + |
| 7 | + def quicksort[a] (less : (a,a) => Boolean) (xs : List[a]) : List[a] = { |
| 8 | + if (xs.isEmpty) |
| 9 | + xs |
| 10 | + else { |
| 11 | + val pivot : a = xs.head; |
| 12 | + val smaller : List[a] = |
| 13 | + quicksort(less)(xs.tail.filter(elem => less(elem, pivot))); |
| 14 | + val greaterOrEqual : List[a] = |
| 15 | + quicksort(less)(xs.tail.filter(elem => !less(elem, pivot))); |
| 16 | + smaller ::: List(pivot) ::: greaterOrEqual |
| 17 | + } |
| 18 | + } |
| 19 | + |
| 20 | + def test = { |
| 21 | + val isort: List[Int] => List[Int] = quicksort[Int]((x,y) => x < y); |
| 22 | + val list0 = List(6,3,1,8,7,1,2,5,8,4,3,4,8); |
| 23 | + val list1 = quicksort[Int]((x,y) => x < y)(list0); |
| 24 | + val list2 = quicksort[Int]((x,y) => x < y)(list1); |
| 25 | + val list3 = isort(list0); |
| 26 | + val list4 = isort(list1); |
| 27 | + val list5 = quicksort[Int]((x,y) => x >= y)(list0); |
| 28 | + val list6 = quicksort[Int]((x,y) => x >= y)(list1); |
| 29 | + |
| 30 | + Console.println("list0 = " + list0); |
| 31 | + Console.println("list1 = " + list1); |
| 32 | + Console.println("list2 = " + list2); |
| 33 | + Console.println("list3 = " + list3); |
| 34 | + Console.println("list4 = " + list4); |
| 35 | + Console.println("list5 = " + list5); |
| 36 | + Console.println("list6 = " + list6); |
| 37 | + Console.println; |
| 38 | + } |
| 39 | +} |
| 40 | + |
| 41 | +//############################################################################ |
| 42 | + |
| 43 | +object M1 { |
| 44 | + |
| 45 | + def mergesort[a] (less : (a,a) => Boolean) (xs: Array[a]): Unit = { |
| 46 | + |
| 47 | + def While(c: => Boolean)(b: => Unit): Unit = |
| 48 | + if (c) { b ; While(c)(b) } else (); |
| 49 | + |
| 50 | + def swap(i: Int, j: Int): Unit = { |
| 51 | + val t = xs(i); |
| 52 | + val u = xs(j); |
| 53 | + xs(i) = u; |
| 54 | + xs(j) = t; |
| 55 | + } |
| 56 | + |
| 57 | + def sort1(l: Int, r: Int): Unit = { |
| 58 | + val pivot = xs((l + r) / 2); |
| 59 | + var i = l; |
| 60 | + var j = r; |
| 61 | + While (i <= j) { |
| 62 | + While (less(xs(i), pivot)) { i = i + 1 } |
| 63 | + While (less(pivot, xs(j))) { j = j - 1 } |
| 64 | + if (i <= j) { |
| 65 | + swap(i, j); |
| 66 | + i = i + 1; |
| 67 | + j = j - 1; |
| 68 | + } |
| 69 | + } |
| 70 | + if (l < j) sort1(l, j); |
| 71 | + if (j < r) sort1(i, r); |
| 72 | + } |
| 73 | + |
| 74 | + if (xs.length > 0) sort1(0, xs.length - 1); |
| 75 | + } |
| 76 | + |
| 77 | + def list2array(list: List[Int]): Array[Int] = { |
| 78 | + val array = new Array[Int](list.length); |
| 79 | + list.copyToArray(array, 0); |
| 80 | + array; |
| 81 | + } |
| 82 | + |
| 83 | + def array2list(array: Array[Int]): List[Int] = { |
| 84 | + var list = List[Int](); |
| 85 | + List.range(0, array.length).map(i => list = array(i) :: list); |
| 86 | + list.reverse; |
| 87 | + } |
| 88 | + |
| 89 | + def isort(list: List[Int]): List[Int] = { |
| 90 | + val array = list2array(list); |
| 91 | + mergesort[Int]((x,y) => x < y)(array); |
| 92 | + array2list(array); |
| 93 | + } |
| 94 | + |
| 95 | + def test = { |
| 96 | + val list0 = List(); |
| 97 | + val list1 = List(0); |
| 98 | + val list2 = List(0,1); |
| 99 | + val list3 = List(1,0); |
| 100 | + val list4 = List(0,1,2); |
| 101 | + val list5 = List(1,0,2); |
| 102 | + val list6 = List(0,1,2); |
| 103 | + val list7 = List(1,0,2); |
| 104 | + val list8 = List(2,0,1); |
| 105 | + val list9 = List(2,1,0); |
| 106 | + val listA = List(6,3,1,8,7,1,2,5,8,4); |
| 107 | + |
| 108 | + Console.println("list0: " + list0 + " -> " + isort(list0)); |
| 109 | + Console.println("list1: " + list1 + " -> " + isort(list1)); |
| 110 | + Console.println("list2: " + list2 + " -> " + isort(list2)); |
| 111 | + Console.println("list3: " + list3 + " -> " + isort(list3)); |
| 112 | + Console.println("list4: " + list4 + " -> " + isort(list4)); |
| 113 | + Console.println("list5: " + list5 + " -> " + isort(list5)); |
| 114 | + Console.println("list6: " + list6 + " -> " + isort(list6)); |
| 115 | + Console.println("list7: " + list7 + " -> " + isort(list7)); |
| 116 | + Console.println("list8: " + list8 + " -> " + isort(list8)); |
| 117 | + Console.println("list9: " + list9 + " -> " + isort(list9)); |
| 118 | + Console.println("listA: " + listA + " -> " + isort(listA)); |
| 119 | + Console.println; |
| 120 | + } |
| 121 | + |
| 122 | +} |
| 123 | + |
| 124 | +//############################################################################ |
| 125 | + |
| 126 | +object M2 { |
| 127 | + |
| 128 | + def horner (x : Double, coefs : List[Double]) : Double = { |
| 129 | + if (coefs.isEmpty) |
| 130 | + 0 |
| 131 | + else |
| 132 | + horner(x, coefs.tail) * x + coefs.head |
| 133 | + } |
| 134 | + |
| 135 | + def test = { |
| 136 | + val poly = List(9.0,5.0,7.0,5.0); |
| 137 | + Console.println("f(x) = 5x^3+7x^2+5x+9"); |
| 138 | + Console.println("f(0) = " + horner(0, poly)); |
| 139 | + Console.println("f(1) = " + horner(1, poly)); |
| 140 | + Console.println("f(2) = " + horner(2, poly)); |
| 141 | + Console.println("f(3) = " + horner(3, poly)); |
| 142 | + Console.println; |
| 143 | + } |
| 144 | +} |
| 145 | + |
| 146 | +//############################################################################ |
| 147 | + |
| 148 | +object M3 { |
| 149 | + |
| 150 | + def dotproduct (v : List[Double], w : List[Double]) : Double = { |
| 151 | + if (v.isEmpty) |
| 152 | + 0 |
| 153 | + else |
| 154 | + (v.head * w.head) + dotproduct(v.tail, w.tail) |
| 155 | + } |
| 156 | + |
| 157 | + def matrixTimesVector (m : List[List[Double]], v : List[Double]) |
| 158 | + : List[Double] = { |
| 159 | + m.map(row => dotproduct(row, v)) |
| 160 | + } |
| 161 | + |
| 162 | + def transpose(m : List[List[Double]]) : List[List[Double]] = { |
| 163 | + if (m.isEmpty || m.head.isEmpty) |
| 164 | + List() |
| 165 | + else |
| 166 | + m.map(row => row.head) :: transpose (m.map (row => row.tail)) |
| 167 | + } |
| 168 | + |
| 169 | + def matrixTimesMatrix(m1 : List[List[Double]], m2 : List[List[Double]]) |
| 170 | + : List[List[Double]] = { |
| 171 | + val columns = transpose(m2); |
| 172 | + m1.map(row => matrixTimesVector(columns, row)) |
| 173 | + } |
| 174 | + |
| 175 | + def test = { |
| 176 | + val v1 = List(2.0,3.0,4.0); |
| 177 | + val v2 = List(6.0,7.0,8.0); |
| 178 | + def id = List(List(1.0,0.0,0.0),List(0.0,1.0,0.0),List(0.0,0.0,1.0)); |
| 179 | + def m1 = List(List(2.0,0.0,0.0),List(0.0,2.0,0.0),List(0.0,0.0,2.0)); |
| 180 | + def m2 = List(List(1.0,2.0,3.0),List(4.0,5.0,6.0),List(7.0,8.0,9.0)); |
| 181 | + |
| 182 | + def v = List(2.0,3.0,4.0); |
| 183 | + |
| 184 | + Console.println("v1 = " + v1); |
| 185 | + Console.println("v2 = " + v2); |
| 186 | + Console.println; |
| 187 | + |
| 188 | + Console.println("id = " + id); |
| 189 | + Console.println("m1 = " + m1); |
| 190 | + Console.println("m2 = " + m2); |
| 191 | + Console.println; |
| 192 | + |
| 193 | + Console.println("v1 * v1 = " + dotproduct(v1,v1)); |
| 194 | + Console.println("v1 * v2 = " + dotproduct(v1,v2)); |
| 195 | + Console.println("v2 * v1 = " + dotproduct(v2,v1)); |
| 196 | + Console.println("v1 * v2 = " + dotproduct(v1,v2)); |
| 197 | + Console.println; |
| 198 | + |
| 199 | + Console.println("id * v1 = " + matrixTimesVector(id,v1)); |
| 200 | + Console.println("m1 * v1 = " + matrixTimesVector(m1,v1)); |
| 201 | + Console.println("m2 * v1 = " + matrixTimesVector(m2,v1)); |
| 202 | + Console.println; |
| 203 | + |
| 204 | + Console.println("trn(id) = " + transpose(id)); |
| 205 | + Console.println("trn(m1) = " + transpose(m1)); |
| 206 | + Console.println("trn(m2) = " + transpose(m2)); |
| 207 | + Console.println; |
| 208 | + |
| 209 | + Console.println("List(v1) * id = " + matrixTimesMatrix(List(v1),id)); |
| 210 | + Console.println("List(v1) * m1 = " + matrixTimesMatrix(List(v1),m1)); |
| 211 | + Console.println("List(v1) * m2 = " + matrixTimesMatrix(List(v1),m2)); |
| 212 | + Console.println; |
| 213 | + |
| 214 | + Console.println("id * List(v1) = " + matrixTimesMatrix(id,List(v1))); |
| 215 | + Console.println("m1 * List(v1) = " + matrixTimesMatrix(m1,List(v1))); |
| 216 | + Console.println("m2 * List(v1) = " + matrixTimesMatrix(m2,List(v1))); |
| 217 | + Console.println; |
| 218 | + |
| 219 | + Console.println("id * id = " + matrixTimesMatrix(id,id)); |
| 220 | + Console.println("id * m1 = " + matrixTimesMatrix(id,m1)); |
| 221 | + Console.println("m1 * id = " + matrixTimesMatrix(m1,id)); |
| 222 | + Console.println("m1 * m1 = " + matrixTimesMatrix(m1,m1)); |
| 223 | + Console.println("id * m2 = " + matrixTimesMatrix(id,m2)); |
| 224 | + Console.println("m2 * id = " + matrixTimesMatrix(m2,id)); |
| 225 | + Console.println("m1 * m2 = " + matrixTimesMatrix(m1,m2)); |
| 226 | + Console.println("m2 * m1 = " + matrixTimesMatrix(m2,m1)); |
| 227 | + Console.println("m2 * m2 = " + matrixTimesMatrix(m2,m2)); |
| 228 | + Console.println; |
| 229 | + } |
| 230 | +} |
| 231 | + |
| 232 | +//############################################################################ |
| 233 | + |
| 234 | +object Test { |
| 235 | + def main(args: Array[String]): Unit = { |
| 236 | + M0.test; |
| 237 | + M1.test; |
| 238 | + M2.test; |
| 239 | + M3.test; |
| 240 | + () |
| 241 | + } |
| 242 | +} |
| 243 | + |
| 244 | +//############################################################################ |
0 commit comments