Matrix transposition: Difference between revisions
Content added Content deleted
(→{{header|Go}}: added version with flat representation) |
|||
Line 779: | Line 779: | ||
transposedMatrix := TransposedMat(originalMatrix);</lang> |
transposedMatrix := TransposedMat(originalMatrix);</lang> |
||
=={{header|Go}}== |
=={{header|Go}}== |
||
===2D representation=== |
|||
Go arrays and slices are only one-dimensional. The obvious way to represent two-dimensional arrays is with a slice of slices: |
|||
<lang go>package main |
<lang go>package main |
||
Line 820: | Line 822: | ||
[2 5] |
[2 5] |
||
[3 6]</pre> |
[3 6]</pre> |
||
===Flat representation=== |
|||
Slices of slices turn out to have disadvantages. It is possible to construct ill-formed matricies with a different number of elements on different rows, for example. They require multiple allocations, and the compiler must generate complex address calculations to index elements. |
|||
A flat element representation with a stride is almost always better. |
|||
<lang go>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 |
|||
} |
|||
func main() { |
|||
m := matrixFromRows([][]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 |
|||
}</lang> |
|||
Output: |
|||
<pre> |
|||
original: |
|||
[1 2 3] |
|||
[4 5 6] |
|||
transpose: |
|||
[1 4] |
|||
[2 5] |
|||
[3 6] |
|||
</pre> |
|||
=={{header|Groovy}}== |
=={{header|Groovy}}== |