Initial data commit

Task/Matrix-multiplication/D/matrix-multiplication-1.d

@@ -0,0 +1,34 @@
+import std.stdio, std.string, std.conv, std.numeric,
+       std.array, std.algorithm;
+
+bool isRectangular(T)(in T[][] M) pure nothrow {
+    return M.all!(row => row.length == M[0].length);
+}
+
+T[][] matrixMul(T)(in T[][] A, in T[][] B) pure nothrow
+in {
+    assert(A.isRectangular && B.isRectangular &&
+           !A.empty && !B.empty && A[0].length == B.length);
+} body {
+    auto result = new T[][](A.length, B[0].length);
+    auto aux = new T[B.length];
+
+    foreach (immutable j; 0 .. B[0].length) {
+        foreach (immutable k, const row; B)
+            aux[k] = row[j];
+        foreach (immutable i, const ai; A)
+            result[i][j] = dotProduct(ai, aux);
+    }
+
+    return result;
+}
+
+void main() {
+    immutable a = [[1, 2], [3, 4], [3, 6]];
+    immutable b = [[-3, -8, 3,], [-2, 1, 4]];
+
+    immutable form = "[%([%(%d, %)],\n %)]]";
+    writefln("A = \n" ~ form ~ "\n", a);
+    writefln("B = \n" ~ form ~ "\n", b);
+    writefln("A * B = \n" ~ form, matrixMul(a, b));
+}

Task/Matrix-multiplication/D/matrix-multiplication-2.d

@@ -0,0 +1,16 @@
+import std.stdio, std.range, std.array, std.numeric, std.algorithm;
+
+T[][] matMul(T)(in T[][] A, in T[][] B) pure nothrow /*@safe*/ {
+    const Bt = B[0].length.iota.map!(i=> B.transversal(i).array).array;
+    return A.map!(a => Bt.map!(b => a.dotProduct(b)).array).array;
+}
+
+void main() {
+    immutable a = [[1, 2], [3, 4], [3, 6]];
+    immutable b = [[-3, -8, 3,], [-2, 1, 4]];
+
+    immutable form = "[%([%(%d, %)],\n %)]]";
+    writefln("A = \n" ~ form ~ "\n", a);
+    writefln("B = \n" ~ form ~ "\n", b);
+    writefln("A * B = \n" ~ form, matMul(a, b));
+}

Task/Matrix-multiplication/D/matrix-multiplication-3.d

@@ -0,0 +1,17 @@
+import std.stdio, std.range, std.numeric, std.algorithm;
+
+T[][] matMul(T)(immutable T[][] A, immutable T[][] B) pure nothrow {
+    immutable Bt = B[0].length.iota.map!(i=> B.transversal(i).array)
+                   .array;
+    return A.map!((in a) => Bt.map!(b => a.dotProduct(b)).array).array;
+}
+
+void main() {
+    immutable a = [[1, 2], [3, 4], [3, 6]];
+    immutable b = [[-3, -8, 3,], [-2, 1, 4]];
+
+    immutable form = "[%([%(%d, %)],\n %)]]";
+    writefln("A = \n" ~ form ~ "\n", a);
+    writefln("B = \n" ~ form ~ "\n", b);
+    writefln("A * B = \n" ~ form, matMul(a, b));
+}

Task/Matrix-multiplication/D/matrix-multiplication-4.d

@@ -0,0 +1,33 @@
+import std.stdio, std.string, std.numeric, std.algorithm, std.traits;
+
+alias TMMul_helper(M1, M2) = Unqual!(ForeachType!(ForeachType!M1))
+                             [M2.init[0].length][M1.length];
+
+void matrixMul(T, T2, size_t k, size_t m, size_t n)
+              (in ref T[m][k] A, in ref T[n][m] B,
+               /*out*/ ref T2[n][k] result) pure nothrow /*@safe*/ @nogc
+if (is(T2 == Unqual!T)) {
+    static if (hasIndirections!T)
+        T2[m] aux;
+    else
+        T2[m] aux = void;
+
+    foreach (immutable j; 0 .. n) {
+        foreach (immutable i, const ref bi; B)
+            aux[i] = bi[j];
+        foreach (immutable i, const ref ai; A)
+            result[i][j] = dotProduct(ai, aux);
+    }
+}
+
+void main() {
+    immutable int[2][3] a = [[1, 2], [3, 4], [3, 6]];
+    immutable int[3][2] b = [[-3, -8, 3,], [-2, 1, 4]];
+
+    enum form = "[%([%(%d, %)],\n %)]]";
+    writefln("A = \n" ~ form ~ "\n", a);
+    writefln("B = \n" ~ form ~ "\n", b);
+    TMMul_helper!(typeof(a), typeof(b)) result = void;
+    matrixMul(a, b, result);
+    writefln("A * B = \n" ~ form, result);
+}