Another update from ingydotnet^djgoku

Task/Matrix-transposition/Elixir/matrix-transposition.elixir

@@ -0,0 +1,9 @@
+m = [[1,  1,  1,   1],
+     [2,  4,  8,  16],
+     [3,  9, 27,  81],
+     [4, 16, 64, 256],
+     [5, 25,125, 625]]
+
+transpose = fn(m)-> List.zip(m) |> Enum.map(&Tuple.to_list(&1)) end
+
+IO.inspect transpose.(m)

Task/Matrix-transposition/Go/matrix-transposition-1.go

@@ -1,35 +1,17 @@
 package main
 
-import "fmt"
+import (
+    "fmt"
 
-type row []float64
-type matrix []row
+    "github.com/gonum/matrix/mat64"
+)
 
 func main() {
-    m := matrix{
-        {1, 2, 3},
-        {4, 5, 6},
-    }
-    printMatrix(m)
-    t := transpose(m)
-    printMatrix(t)
-}
-
-func printMatrix(m matrix) {
-    for _, s := range m {
-        fmt.Println(s)
-    }
-}
-
-func transpose(m matrix) matrix {
-    r := make(matrix, len(m[0]))
-    for x, _ := range r {
-        r[x] = make(row, len(m))
-    }
-    for y, s := range m {
-        for x, e := range s {
-            r[x][y] = e
-        }
-    }
-    return r
+    m := mat64.NewDense(2, 3, []float64{
+        1, 2, 3,
+        4, 5, 6,
+    })
+    fmt.Println(mat64.Formatted(m))
+    fmt.Println()
+    fmt.Println(mat64.Formatted(m.T()))
 }

Task/Matrix-transposition/Go/matrix-transposition-2.go

@@ -1,51 +1,19 @@
 package main
 
-import "fmt"
+import (
+    "fmt"
 
-type matrix struct {
-    ele    []float64
-    stride int
-}
-
-// construct new matrix from slice of slices
-func matrixFromRows(rows [][]float64) *matrix {
-    if len(rows) == 0 {
-        return &matrix{nil, 0}
-    }
-    m := &matrix{make([]float64, len(rows)*len(rows[0])), len(rows[0])}
-    for rx, row := range rows {
-        copy(m.ele[rx*m.stride:(rx+1)*m.stride], row)
-    }
-    return m
-}
+    mat "github.com/skelterjohn/go.matrix"
+)
 
 func main() {
-    m := matrixFromRows([][]float64{
+    m := mat.MakeDenseMatrixStacked([][]float64{
         {1, 2, 3},
         {4, 5, 6},
     })
-    m.print("original:")
-    m.transpose().print("transpose:")
-}
-
-func (m *matrix) print(heading string) {
-    if heading > "" {
-        fmt.Print("\n", heading, "\n")
-    }
-    for e := 0; e < len(m.ele); e += m.stride {
-        fmt.Println(m.ele[e : e+m.stride])
-    }
-}
-
-func (m *matrix) transpose() *matrix {
-    r := &matrix{make([]float64, len(m.ele)), len(m.ele) / m.stride}
-    rx := 0
-    for _, e := range m.ele {
-        r.ele[rx] = e
-        rx += r.stride
-        if rx >= len(r.ele) {
-            rx -= len(r.ele) - 1
-        }
-    }
-    return r
+    fmt.Println("original:")
+    fmt.Println(m)
+    m = m.Transpose()
+    fmt.Println("transpose:")
+    fmt.Println(m)
 }

Task/Matrix-transposition/Go/matrix-transposition-3.go

@@ -2,72 +2,34 @@ package main
 
 import "fmt"
 
-type matrix struct {
-    ele    []float64
-    stride int
-}
-
-// construct new matrix from slice of slices
-func matrixFromRows(rows [][]float64) *matrix {
-    if len(rows) == 0 {
-        return &matrix{nil, 0}
-    }
-    m := &matrix{make([]float64, len(rows)*len(rows[0])), len(rows[0])}
-    for rx, row := range rows {
-        copy(m.ele[rx*m.stride:(rx+1)*m.stride], row)
-    }
-    return m
-}
+type row []float64
+type matrix []row
 
 func main() {
-    m := matrixFromRows([][]float64{
+    m := matrix{
         {1, 2, 3},
         {4, 5, 6},
-    })
-    m.print("original:")
-    m.transposeInPlace()
-    m.print("transpose:")
+    }
+    printMatrix(m)
+    t := transpose(m)
+    printMatrix(t)
 }
 
-func (m *matrix) print(heading string) {
-    if heading > "" {
-        fmt.Print("\n", heading, "\n")
-    }
-    for e := 0; e < len(m.ele); e += m.stride {
-        fmt.Println(m.ele[e : e+m.stride])
+func printMatrix(m matrix) {
+    for _, s := range m {
+        fmt.Println(s)
     }
 }
 
-func (m *matrix) transposeInPlace() {
-    h := len(m.ele) / m.stride
-    for start := range m.ele {
-        next := start
-        i := 0
-        for {
-            i++
-            next = (next%h)*m.stride + next/h
-            if next <= start {
-                break
-            }
-        }
-        if next < start || i == 1 {
-            continue
-        }
-
-        next = start
-        tmp := m.ele[next]
-        for {
-            i = (next%h)*m.stride + next/h
-            if i == start {
-                m.ele[next] = tmp
-            } else {
-                m.ele[next] = m.ele[i]
-            }
-            next = i
-            if next <= start {
-                break
-            }
+func transpose(m matrix) matrix {
+    r := make(matrix, len(m[0]))
+    for x, _ := range r {
+        r[x] = make(row, len(m))
+    }
+    for y, s := range m {
+        for x, e := range s {
+            r[x][y] = e
         }
     }
-    m.stride = h
+    return r
 }

Task/Matrix-transposition/Go/matrix-transposition-4.go

@@ -1,19 +1,51 @@
 package main
 
-import (
-    "fmt"
+import "fmt"
 
-    mat "github.com/skelterjohn/go.matrix"
-)
+type matrix struct {
+    ele    []float64
+    stride int
+}
+
+// construct new matrix from slice of slices
+func matrixFromRows(rows [][]float64) *matrix {
+    if len(rows) == 0 {
+        return &matrix{nil, 0}
+    }
+    m := &matrix{make([]float64, len(rows)*len(rows[0])), len(rows[0])}
+    for rx, row := range rows {
+        copy(m.ele[rx*m.stride:(rx+1)*m.stride], row)
+    }
+    return m
+}
 
 func main() {
-    m := mat.MakeDenseMatrixStacked([][]float64{
+    m := matrixFromRows([][]float64{
         {1, 2, 3},
         {4, 5, 6},
     })
-    fmt.Println("original:")
-    fmt.Println(m)
-    m = m.Transpose()
-    fmt.Println("transpose:")
-    fmt.Println(m)
+    m.print("original:")
+    m.transpose().print("transpose:")
+}
+
+func (m *matrix) print(heading string) {
+    if heading > "" {
+        fmt.Print("\n", heading, "\n")
+    }
+    for e := 0; e < len(m.ele); e += m.stride {
+        fmt.Println(m.ele[e : e+m.stride])
+    }
+}
+
+func (m *matrix) transpose() *matrix {
+    r := &matrix{make([]float64, len(m.ele)), len(m.ele) / m.stride}
+    rx := 0
+    for _, e := range m.ele {
+        r.ele[rx] = e
+        rx += r.stride
+        if rx >= len(r.ele) {
+            rx -= len(r.ele) - 1
+        }
+    }
+    return r
 }

Task/Matrix-transposition/Go/matrix-transposition-5.go

@@ -0,0 +1,61 @@
+package main
+
+import "fmt"
+
+type matrix struct {
+    stride int
+    ele    []float64
+}
+
+func main() {
+    m := matrix{3, []float64{
+        1, 2, 3,
+        4, 5, 6,
+    }}
+    m.print("original:")
+    m.transposeInPlace()
+    m.print("transpose:")
+}
+
+func (m *matrix) print(heading string) {
+    if heading > "" {
+        fmt.Print("\n", heading, "\n")
+    }
+    for e := 0; e < len(m.ele); e += m.stride {
+        fmt.Println(m.ele[e : e+m.stride])
+    }
+}
+
+func (m *matrix) transposeInPlace() {
+    h := len(m.ele) / m.stride
+    for start := range m.ele {
+        next := start
+        i := 0
+        for {
+            i++
+            next = (next%h)*m.stride + next/h
+            if next <= start {
+                break
+            }
+        }
+        if next < start || i == 1 {
+            continue
+        }
+
+        next = start
+        tmp := m.ele[next]
+        for {
+            i = (next%h)*m.stride + next/h
+            if i == start {
+                m.ele[next] = tmp
+            } else {
+                m.ele[next] = m.ele[i]
+            }
+            next = i
+            if next <= start {
+                break
+            }
+        }
+    }
+    m.stride = h
+}

Task/Matrix-transposition/Perl-6/matrix-transposition-1.pl6

@@ -1,13 +1,13 @@
 sub transpose(@m)
 {
     my @t;
-    for ^@m X ^@m[0] -> $x, $y { @t[$y][$x] = @m[$x][$y] }
+    for ^@m X ^@m[0] -> ($x, $y) { @t[$y][$x] = @m[$x][$y] }
     return @t;
 }
 
 # creates a random matrix
 my @a;
-for (^10).pick X (^10).pick -> $x, $y { @a[$x][$y] = (^100).pick; }
+for (^10).pick X (^10).pick -> ($x, $y) { @a[$x][$y] = (^100).pick; }
 
 say "original: ";
 .perl.say for @a;

Task/Matrix-transposition/Perl-6/matrix-transposition-2.pl6

@@ -1,10 +1,10 @@
 sub transpose (@m) {
-    @m[0].keys.map: {[ @m».[$_] ]};
+    ([ @m[*;$_] ] for ^@m[0]);
 }
 
-my @a = [< a b c d e >],
-        [< f g h i j >],
-        [< k l m n o >],
-        [< p q r s t >];
+my @a = < a b c d e >,
+        < f g h i j >,
+        < k l m n o >,
+        < p q r s t >;
 
 .say for @a.&transpose;

Task/Matrix-transposition/Perl-6/matrix-transposition-3.pl6

@@ -0,0 +1 @@
+say [Z] (<A B C>,<D E F>,<G H I>)

Task/Matrix-transposition/PowerShell/matrix-transposition.psh

@@ -0,0 +1,23 @@
+function transpose($a) {
+    if($a.Count -gt 0) {
+        $n = $a.Count - 1
+        foreach($i in 0..$n) {
+            $j = 0
+            while($j -lt $i) {
+                $a[$i][$j], $a[$j][$i] = $a[$j][$i], $a[$i][$j]
+                $j++
+            }
+        }
+    }
+    $a
+}
+function show($a) {
+    if($a.Count -gt 0) {
+        $n = $a.Count - 1
+        0..$n | foreach{ "$($a[$_][0..$n])" }
+    }
+}
+$a = @(@(2, 4, 7),@(3, 5, 9),@(4, 1, 6))
+show $a
+""
+show (transpose $a)

Task/Matrix-transposition/VBScript/matrix-transposition.vb

@@ -0,0 +1,31 @@
+'create and display the initial matrix
+WScript.StdOut.WriteLine "Initial Matrix:"
+x = 4 : y = 6 : n = 1
+Dim matrix()
+ReDim matrix(x,y)
+For i = 0 To y
+	For j = 0 To x
+		matrix(j,i) = n
+		If j < x Then
+			WScript.StdOut.Write n & vbTab
+		Else
+			WScript.StdOut.Write n
+		End If
+		n = n + 1
+	Next
+	WScript.StdOut.WriteLine
+Next
+
+'display the trasposed matrix
+WScript.StdOut.WriteBlankLines(1)
+WScript.StdOut.WriteLine "Transposed Matrix:"
+For i = 0 To x
+	For j = 0 To y
+		If j < y Then
+			WScript.StdOut.Write matrix(i,j) & vbTab
+		Else
+			WScript.StdOut.Write matrix(i,j)
+		End If
+	Next
+	WScript.StdOut.WriteLine
+Next