Matrix transposition: Difference between revisions
→{{header|Wren}}: Minor tidy
m (added whitespace before the TOC (table of contents).) |
(→{{header|Wren}}: Minor tidy) |
||
| (141 intermediate revisions by 57 users not shown) | |||
Line 2:
[[wp:Transpose|Transpose]] an arbitrarily sized rectangular [[wp:Matrix (mathematics)|Matrix]].
<br><br>
=={{header|11l}}==
<syntaxhighlight lang="11l">F transpose(&matrix)
V toRet = [[0] * matrix.len] * matrix[0].len
L(row) (0 .< matrix.len)
L(col) (0 .< matrix[row].len)
toRet[col][row] = matrix[row][col]
R toRet
V m = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
print("Original")
print(m)
print("After Transposition")
print(transpose(&m))</syntaxhighlight>
{{out}}
<pre>
Original
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
After Transposition
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
</pre>
=={{header|360 Assembly}}==
<syntaxhighlight lang="360asm">...
KN EQU 3
KM EQU 5
N DC AL2(KN)
M DC AL2(KM)
A DS (KN*KM)F matrix a(n,m)
B DS (KM*KN)F matrix b(m,n)
...
* b(j,i)=a(i,j)
* transposition using Horner's formula
LA R4,0 i,from 1
LA R7,KN to n
LA R6,1 step 1
LOOPI BXH R4,R6,ELOOPI do i=1 to n
LA R5,0 j,from 1
LA R9,KM to m
LA R8,1 step 1
LOOPJ BXH R5,R8,ELOOPJ do j=1 to m
LR R1,R4 i
BCTR R1,0 i-1
MH R1,M (i-1)*m
LR R2,R5 j
BCTR R2,0 j-1
AR R1,R2 r1=(i-1)*m+(j-1)
SLA R1,2 r1=((i-1)*m+(j-1))*itemlen
L R0,A(R1) r0=a(i,j)
LR R1,R5 j
BCTR R1,0 j-1
MH R1,N (j-1)*n
LR R2,R4 i
BCTR R2,0 i-1
AR R1,R2 r1=(j-1)*n+(i-1)
SLA R1,2 r1=((j-1)*n+(i-1))*itemlen
ST R0,B(R1) b(j,i)=r0
B LOOPJ next j
ELOOPJ EQU * out of loop j
B LOOPI next i
ELOOPI EQU * out of loop i
...</syntaxhighlight>
=={{header|68000 Assembly}}==
<syntaxhighlight lang="68000devpac">Transpose2DArray_B:
;INPUT:
;A0 = POINTER TO SOURCE ARRAY
;A1 = POINTER TO BACKUP AREA
; (YOU NEED THE SAME AMOUNT OF FREE SPACE AS THE SOURCE ARRAY.)
; (IT'S YOUR RESPONSIBILITY TO KNOW WHERE THAT IS.)
;D0.W = ARRAY ROW LENGTH-1
;D1.W = ARRAY COLUMN HEIGHT-1
MOVEM.L D2-D7,-(SP)
MOVE.W D0,D4 ;width - this copy is our loop counter
.outerloop:
MOVE.W D1,D7 ;height
MOVEQ.L #0,D3
MOVE.W D0,D6 ;width - this copy is used to offset the array
ADDQ.L #1,D6
.innerloop:
MOVE.B (A0,D3),(A1)+
ADD.W D6,D3
DBRA D7,.innerloop
ADDA.L #1,A0
DBRA D4,.outerloop
MOVEM.L (SP)+,D2-D7
RTS</syntaxhighlight>
=={{header|ACL2}}==
<
(if (or (endp xs) (endp xss))
nil
Line 20 ⟶ 111:
(list-each (first xss))
(cons-each (first xss)
(transpose-list (rest xss)))))</
=={{header|Action!}}==
<syntaxhighlight lang="action!">DEFINE PTR="CARD"
TYPE Matrix=[
BYTE width,height
PTR data] ;BYTE ARRAY
PROC PrintB2(BYTE b)
IF b<10 THEN Put(32) FI
PrintB(b)
RETURN
PROC PrintMatrix(Matrix POINTER m)
BYTE i,j
BYTE ARRAY d
d=m.data
FOR j=0 TO m.height-1
DO
FOR i=0 TO m.width-1
DO
PrintB2(d(j*m.width+i)) Put(32)
OD
PutE()
OD
RETURN
PROC Create(MATRIX POINTER m BYTE w,h BYTE ARRAY a)
m.width=w
m.height=h
m.data=a
RETURN
PROC Transpose(Matrix POINTER in,out)
BYTE i,j
BYTE ARRAY din,dout
din=in.data
dout=out.data
out.width=in.height
out.height=in.width
FOR j=0 TO in.height-1
DO
FOR i=0 TO in.width-1
DO
dout(i*out.width+j)=din(j*in.width+i)
OD
OD
RETURN
PROC Main()
MATRIX in,out
BYTE ARRAY din(35),dout(35)
BYTE i
FOR i=0 TO 34
DO
din(i)=i
OD
Create(in,7,5,din)
Create(out,0,0,dout)
Transpose(in,out)
PrintE("Input:")
PrintMatrix(in)
PutE() PrintE("Transpose:")
PrintMatrix(out)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Matrix_transposition.png Screenshot from Atari 8-bit computer]
<pre>
Input:
0 1 2 3 4 5 6
7 8 9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30 31 32 33 34
Transpose:
0 7 14 21 28
1 8 15 22 29
2 9 16 23 30
3 10 17 24 31
4 11 18 25 32
5 12 19 26 33
6 13 20 27 34
</pre>
=={{header|ActionScript}}==
In ActionScript, multi-dimensional arrays are created by making an "Array of arrays" where each element is an array.
<
{
//Assume each element in m is an array. (If this were production code, use typeof to be sure)
Line 46 ⟶ 225:
var M:Array = transpose(m);
for(var i:uint = 0; i < M.length; i++)
trace(M[i]);</
=={{header|Ada}}==
Line 52 ⟶ 231:
This example illustrates use of Transpose for the matrices built upon the standard type Float:
<
with Ada.Text_IO; use Ada.Text_IO;
Line 78 ⟶ 257:
Put_Line ("After Transposition:");
Put (Transpose (Matrix));
end Matrix_Transpose;</
{{out}}
<pre>
Line 94 ⟶ 273:
=={{header|Agda}}==
<
open import Data.Nat
Line 107 ⟶ 286:
a = (1 ∷ 2 ∷ 3 ∷ []) ∷ (4 ∷ 5 ∷ 6 ∷ []) ∷ []
b = transpose a</
'''b''' evaluates to the following normal form:
<
=={{header|ALGOL 68}}==
Line 118 ⟶ 297:
{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}
{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of FORMATted transput}}
<
[,]REAL m=((1, 1, 1, 1),
Line 144 ⟶ 323:
printf(($x"Transpose:"l$));
pprint((ZIP m))
)</
{{out}}
<pre>
Transpose:
(( 1.00, 2.00, 3.00, 4.00, 5.00),
Line 152 ⟶ 332:
( 1.00, 8.00, 27.00, 64.00,125.00),
( 1.00, 16.00, 81.00,256.00,625.00));
</pre>
=={{header|Amazing Hopper}}==
<syntaxhighlight lang="amazing hopper">
#include<hopper.h>
#proto showarraydata(_X_)
main:
.stack 12
nCols=0, nRows=0,nDims=0
A=-1,{5,11} rand array(A),mulby(10),ceil,mov(A)
{"ORIGINAL ARRAY :\n",A}
_show array data(A)
/* transpose */
TA=0,{nCols,nRows} nan array(TA)
Limit = nRows
{nRows}gthan(nCols) do{ Limit = nCols }
for (i=1, {i} lethan (Limit), ++i)
[i,i:end]get(A), [i:end,i]put(TA)
[i:end,i]get(A), [i,i:end]put(TA)
next
clear mark
{"ARRAY TRANSPOSE:\n",TA}println
_show array data(TA)
exit(0)
.locals
show array data(A)
{"\nSIZE ARRAY : "},size=0,size(A),cpy(size),
dims(size,nDims)
rows(size,nRows)
cols(size,nCols)
{"\nDIMENSION = ",nDims,"; ROWS = ",nRows,"; COLS = ",nCols,"\n"}, println
back
</syntaxhighlight>
{{out}}
<pre>
ORIGINAL ARRAY :
6 6 8 3 2 6 9 3 5 3 10
6 7 10 3 9 6 5 8 8 1 10
2 3 7 10 7 9 3 7 3 8 2
10 1 3 6 9 6 1 1 5 7 7
5 9 6 1 4 3 8 4 2 10 7
SIZE ARRAY : 2 5 11
DIMENSION = 2; ROWS = 5; COLS = 11
ARRAY TRANSPOSE:
6 6 2 10 5
6 7 3 1 9
8 10 7 3 6
3 3 10 6 1
2 9 7 9 4
6 6 9 6 3
9 5 3 1 8
3 8 7 1 4
5 8 3 5 2
3 1 8 7 10
10 10 2 7 7
SIZE ARRAY : 2 11 5
DIMENSION = 2; ROWS = 11; COLS = 5
</pre>
=={{header|APL}}==
If M is a matrix, ⍉M is its transpose. For example,
<syntaxhighlight lang="apl">
3 3⍴⍳10
1 2 3
Line 164 ⟶ 409:
2 5 8
3 6 9
</syntaxhighlight>
=={{header|AppleScript}}==
Line 171 ⟶ 415:
We can do this iteratively, by manually setting up two nested loops, and initialising iterators and empty lists,
<
transpose([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
Line 191 ⟶ 435:
return lstTrans
end transpose</
or, if our library contains some generic basics like '''map()''', and we
{{trans|JavaScript}}
<syntaxhighlight lang="applescript">------------------------ TRANSPOSE -----------------------
-- transpose :: [[a]] -> [[a]]
on transpose(xss)
script
on
end |λ|
end |λ|
end script
map(column, item 1 of xss
end transpose
--------------------------- TEST -------------------------
on run
transpose([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
--> {{1, 4, 7, 10}, {2, 5, 8, 11}, {3, 6, 9, 12}}
end run
-------------------- GENERIC FUNCTIONS -------------------
--
on
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, i, xs)
end repeat
return lst
end tell
end map
--
--
on mReturn(f)
if class of f is script then
else
property |λ| : f
end script
end if
end mReturn</syntaxhighlight>
{{Out}}
<syntaxhighlight lang="applescript">{{1, 4, 7, 10}, {2, 5, 8, 11}, {3, 6, 9, 12}}</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">transpose: function [a][
X: size a
Y: size first a
result: array.of: @[Y X] 0
loop 0..X-1 'i [
loop 0..Y-1 'j [
result\[j]\[i]: a\[i]\[j]
]
]
return result
]
arr: [
[ 0 1 2 3 4 ]
[ 5 6 7 8 9 ]
[ 1 0 0 0 42 ]
]
loop arr 'row -> print row
print "-------------"
loop transpose arr 'row -> print row</syntaxhighlight>
{{out}}
<pre>0 1 2 3 4
5 6 7 8 9
1 0 0 0 42
-------------
0 5 1
1 6 0
2 7 0
3 8 0
4 9 42</pre>
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">a = a
m = 10
n = 10
Line 317 ⟶ 595:
Return matrix
}
</syntaxhighlight>
===Using Objects===
<
R := []
for i, row in M
Line 325 ⟶ 603:
R[j,i] := col
return R
}</
Examples:<
MsgBox % ""
. "Original Matrix :`n" Print(Matrix)
Line 336 ⟶ 614:
Res .= (A_Index=1?"":"`t") col (Mod(A_Index,M[1].MaxIndex())?"":"`n")
return Trim(Res,"`n")
}</
{{out}}
<pre>Original Matrix :
Line 351 ⟶ 629:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f MATRIX_TRANSPOSITION.AWK filename
{ if (NF > nf) {
nf = NF
}
for (i=1; i<=nf; i++) {
row[i] = row[i] $i " "
}
}
END {
for (i=1; i<=nf; i++) {
printf("%s\n",row[i])
}
exit(0)
}
</syntaxhighlight>
<p>input:</p>
<pre>
Line 379 ⟶ 657:
3 7 11
4 8 12
</pre>
===Using 2D-Arrays===
<syntaxhighlight lang="awk"># Usage: GAWK -f MATRIX_TRANSPOSITION.AWK filename
{
i = NR
for (j = 1; j <= NF; j++) {
a[i,j] = $j
}
ranka1 = i
ranka2 = max(ranka2, NF)
}
END {
rankb1 = ranka2
rankb2 = ranka1
b[rankb1, rankb2] = 0
transpose_matrix(b, a)
for (i = 1; i <= rankb1; i++) {
for (j = 1; j <= rankb2; j++) {
printf("%g%c", b[i,j], j < rankb2 ? " " : "\n");
}
}
}
function transpose_matrix(target, source, key, idx) {
for (key in source) {
split(key, idx, SUBSEP)
target[idx[2], idx[1]] = source[idx[1], idx[2]]
}
}
function max(m, n) {
return m > n ? m : n
}</syntaxhighlight>
<p><b>Input:</b></p>
<pre>
1 2 3
4 5 6
</pre>
{{out}}
<pre>
1. 4.
2. 5.
3. 6.
</pre>
Line 410 ⟶ 729:
PRINT
NEXT rows
=={{header|BASIC256}}==
<syntaxhighlight lang="basic256">arraybase 1
dim matriz= {{78,19,30,12,36}, {49,10,65,42,50}, {30,93,24,78,10}, {39,68,27,64,29}}
dim mtranspuesta(matriz[,?], matriz[?,])
for fila = 1 to matriz[?,]
for columna = 1 to matriz[,?]
print matriz[fila, columna]; " ";
mtranspuesta[columna, fila] = matriz[fila, columna]
next columna
print
next fila
print
for fila = 1 to mtranspuesta[?,]
for columna = 1 to mtranspuesta[,?]
print mtranspuesta[fila, columna]; " ";
next columna
print
next fila
end</syntaxhighlight>
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<
DIM matrix(3,4), transpose(4,3)
Line 434 ⟶ 777:
NEXT
PRINT
NEXT row%</
{{out}}
<pre>
Line 448 ⟶ 791:
36 50 10 29
</pre>
=={{header|BQN}}==
{{trans|APL}}
If M is a matrix, ⍉M is its transpose. For example,
<syntaxhighlight lang="bqn">
3‿3⥊↕9
┌─
╵ 0 1 2
3 4 5
6 7 8
┘
⍉3‿3⥊↕9
┌─
╵ 0 3 6
1 4 7
2 5 8
┘
</syntaxhighlight>
=={{header|Burlesque}}==
<
blsq ) {{78 19 30 12 36}{49 10 65 42 50}{30 93 24 78 10}{39 68 27 64 29}}tpsp
78 49 30 39
Line 458 ⟶ 820:
12 42 78 64
36 50 10 29
</syntaxhighlight>
=={{header|C}}==
Transpose a 2D double array.
<
void transpose(void *dest, void *src, int src_h, int src_w)
Line 486 ⟶ 848:
printf("%g%c", b[i][j], j == 2 ? '\n' : ' ');
return 0;
}</
Transpose a matrix of size w x h in place with only O(1) space and without moving any element more than once. See the [[wp:In-place_matrix_transposition|Wikipedia article]] for more information.
<
void transpose(double *m, int w, int h)
Line 538 ⟶ 900:
return 0;
}</
{{out}}
<pre>
Line 552 ⟶ 914:
2 5 8 11 14
3 6 9 12 15 </pre>
=={{header|C sharp|C#}}==
<syntaxhighlight lang="csharp">using System;
using System.Text;
namespace prog
{
class MainClass
{
public static void Main (string[] args)
{
double[,] m = { {1,2,3},{4,5,6},{7,8,9} };
double[,] t = Transpose( m );
for( int i=0; i<t.GetLength(0); i++ )
{
for( int j=0; j<t.GetLength(1); j++ )
Console.Write( t[i,j] + " " );
Console.WriteLine("");
}
}
public static double[,] Transpose( double[,] m )
{
double[,] t = new double[m.GetLength(1),m.GetLength(0)];
for( int i=0; i<m.GetLength(0); i++ )
for( int j=0; j<m.GetLength(1); j++ )
t[j,i] = m[i,j];
return t;
}
}
}</syntaxhighlight>
=={{header|C++}}==
Line 557 ⟶ 953:
{{libheader|Boost.uBLAS}}
<
#include <boost/numeric/ublas/io.hpp>
Line 571 ⟶ 967:
std::cout << trans(m) << std::endl;
}</
{{out}}
Line 580 ⟶ 976:
===Generic solution===
;main.cpp
<
#include "matrix.h"
Line 618 ⟶ 1,014:
}
} /* main() */</
;matrix.h
<
#define _MATRIX_H
Line 814 ⟶ 1,210:
}
#endif /* _MATRIX_H */</
{{out}}
Line 829 ⟶ 1,225:
===Easy Mode===
<
int main(){
Line 864 ⟶ 1,260:
return 0;
}</
{{out}}
<pre>
Line 879 ⟶ 1,275:
3 6 9 12 15
</pre>
=={{header|Clojure}}==
<
"Switch rows with columns."
class)
Line 926 ⟶ 1,288:
[mtx]
(apply mapv vector mtx))
</syntaxhighlight>
{{out}}
<pre>=> (matrix-transpose [[1 2 3] [4 5 6]])
Line 932 ⟶ 1,294:
=={{header|CoffeeScript}}==
<
(t[i] for t in matrix) for i in [0...matrix[0].length]</
{{out}}
<pre>
Line 943 ⟶ 1,305:
=={{header|Common Lisp}}==
If the matrix is given as a list:
<
(apply #'mapcar #'list m))</
If the matrix A is given as a 2D array:
<
(defun mtp (A)
(let* ((m (array-dimension A 0))
Line 956 ⟶ 1,318:
(setf (aref B j i)
(aref A i j))))
B))</
=={{header|D}}==
===Standard Version===
<
import std.stdio, std.range;
Line 967 ⟶ 1,329:
[18, 19, 20, 21]];
writefln("%(%(%2d %)\n%)", M.transposed);
}</
{{out}}
<pre>10 14 18
Line 975 ⟶ 1,337:
===Locally Procedural Style===
<
auto r = new typeof(return)(m[0].length, m.length);
foreach (immutable nr, const row; m)
Line 990 ⟶ 1,352:
[18, 19, 20, 21]];
writefln("%(%(%2d %)\n%)", M.transpose);
}</
Same output.
===Functional Style===
<
auto transpose(T)(in T[][] m) pure nothrow {
Line 1,005 ⟶ 1,367:
[18, 19, 20, 21]];
writefln("%(%(%2d %)\n%)", M.transpose);
}</
Same output.
=={{header|Delphi}}==
See [[#Pascal]];
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
proc transpose . m[][] .
len n[][] len m[1][]
for i to len n[][]
for j to len m[][]
n[i][] &= m[j][i]
.
.
swap n[][] m[][]
.
m[][] = [ [ 1 2 3 4 ] [ 5 6 7 8 ] [ 9 10 11 12 ] ]
print m[][]
print ""
transpose m[][]
print m[][]
</syntaxhighlight>
{{out}}
<pre>
[
[ 1 2 3 4 ]
[ 5 6 7 8 ]
[ 9 10 11 12 ]
]
[
[ 1 5 9 ]
[ 2 6 10 ]
[ 3 7 11 ]
[ 4 8 12 ]
]
</pre>
=={{header|EchoLisp}}==
<
(lib 'matrix)
Line 1,020 ⟶ 1,416:
0 2 4
1 3 5
</syntaxhighlight>
=={{header|EDSAC order code}}==
In these two programs the matrix elements are stored in consecutive memory locations, in row-major order (that is, the 1st row from left to right, then the 2nd row, etc). For simplicity, matrix elements are short values, each occupying one memory location. The programs could be modified so that each element occupies two memory locations, as in the EDSAC library subroutines for vectors and matrices.
===Create a new matrix===
<syntaxhighlight lang="edsac">
[Demo of matrix transposition. Not in place, creates a new matrix.
EDSAC, Initial Orders 2.]
..PZ [blank tape and terminator]
T 50 K [to call matrix transpose subroutine with 'G X']
P 200 F [address of matrix transpose subroutine]
T 47 K [to call matrix print subroutine with 'G M']
P 100 F [address of matrix print subroutine]
T 46 K [to call print subroutine with 'G N']
P 56 F [address of print subroutine (EDSAC library P1)]
[Subroutine to transpose a matrix of 17-bit real numbers, not in place.
Caller must ensure original and transpose don't overlap.
Parameters, all in the address field (i.e. denote n by P n F)
10F = width (number of columns)
11F = height (number of rows)
12F = start address of input matrix
13F = start address of output matrix]
E25K TX GK
[The subroutine loads elements by working down each column in turn.
Elements are stored at consecutive locations in the transposed matrix.]
A3F T31@ [set up return to caller]
A13F A33@ T14@ [initialize T order for storing transpose]
A12F A32@ U13@ [initialize A order for loading original]
T36@ [also save as A order for top of current column]
S10 F [negative of width]
[10] T35@ [initialize negative counter]
S11 F [negative of height]
[12] T34@ [initialize negative counter]
[13] AF [maunfactured order; load matrix element]
[14] TF [maunfactured order; store matrix element]
A14@ A2F T14@ [update address in T order]
A13@ A10F T13@ [update address in A order]
A34@ A2F G12@ [inner loop till finished this column]
A36@ A2F U36@ T13@ [update address for start of column]
A35@ A2F G10@ [outer loop till finished all columns]
[31] ZF [exit]
[32] AF [added to an address to make A order for that address]
[33] TF [added to an address to make T order for that address]
[34] PF [negative counter for rows]
[35] PF [negative counter for columns]
[36] AF [load order for first element in current column]
[Subroutine to print a matrix of 17-bit real numbers.
Straightforward, so given in condensed form.
Parameters (in the address field, i.e. pass n as PnF):
10F = width (number of columns)
11F = height (number of rows)
12F = start address of matrix
13F = number of decimals]
E25K TM
GKA3FT30@A13FT18@A12FA31@T14@S11FT36@S10FT37@O34@O35@TDAFT1FA16@
GN [call library subroutine P1]
PFA14@A2FT14@A37@A2FG10@O32@O33@A36@A2FG8@ZFAF@F&F!FMFPFPF
[Library subroutine P1.
Prints number in 0D to n places of decimals, where
n is specified by 'P n F' pseudo-order after subroutine call.]
E25K TN
GKA18@U17@S20@T5@H19@PFT5@VDUFOFFFSFL4FTDA5@A2FG6@EFU3FJFM1F
[Main routine]
PK T300K GK
[Constants]
[0] #F [figures shift on teleprinter]
[1] @F [carriage return]
[2] &F [line feed]
[3] P3F [number of columns (in address field)]
[4] P5F [number of rows (in address field)]
[5] P400F [address of matrix]
[6] P500F [address of transposed matrix]
[7] P2F [number of decimals when printing matrix]
[8] TF [add to address to make T order]
[9] P328F [0.0100097...., matrix elements are multiples of this]
[Variables]
[10] PF [matrix element, initialized to 0.00]
[11] PF [negative counter]
[Enter with acc = 0]
[12] O@ [set figures mode on teleprinter]
A5@ [address of matrix]
A8@ [make T order to store first elememt]
T24@ [plant in code]
H4@ N3@ L64F L32F [acc := negative number of entries]
[20] T11@ [initialize negative counter]
A10@ A9@ U10@ [increment matrix element]
[24] TF [store in matrix]
A24@ A2F T24@ [inc store address]
A11@ A2F G20@ [inc negative counter, loop till zero]
[Matrix is set up, now print it]
A3@ T10F [10F := width]
A4@ T11F [11F := height]
A5@ T12F [12F := address of matrix]
A7@ T13F [13F := number of decimals]
[39] A39@ GM [call print subroutine]
O1@ O2@ [add CR LF]
[Transpose matrix: 10F, 11F, 12F stay the same]
A6@ T13F [13F := address of transpose]
[45] A45@ GX [call transpose routine]
[Print transpose]
A10F TF A11F T10F AF T11F [swap width and height]
A13F T12F [12F := address of transpose]
A7@ T13F [13F := number of decimals]
[57] A57@ GM [call print subroutine]
O@ [figures mode, dummy to flush teleprinter buffer]
ZF [stop]
E12Z [enter at 12 (relative)]
PF [accumulator = 0 on entry]
</syntaxhighlight>
{{out}}
<pre>
.01 .02 .03
.04 .05 .06
.07 .08 .09
.10 .11 .12
.13 .14 .15
.01 .04 .07 .10 .13
.02 .05 .08 .11 .14
.03 .06 .09 .12 .15
</pre>
===Transpose in place===
{{trans|C}}
That's a neat C program after the complications on Wikipedia. The way EDSAC handles arrays makes it convenient to modify the second half of the program. In C, the updated value of "next" has to be parked in another variable until m[next] (old "next") has been assigned to. In EDSAC, the instruction that assigns to m[next] can be planted before "next" is updated, and won't be affected by that update. Once the EDSAC program has been modified in this way, the code to update "next" is the same in both halves of the program and can be taken out as a subroutine.
<syntaxhighlight lang="edsac">
[Transpose a matrix in place. EDSAC, Initial Orders 2.]
..PZ [blank tape and terminator]
T50K [to call matrix transpose with 'G X']
P160F [address of matrix transpose subroutine]
T47K [to call matrix print subroutine with 'G M']
P120F [address of matrix print subroutine]
T46K [to call print subroutine with 'G N']
P56F [address of print subroutine (P1 in EDSAC library)]
T48K [to call division subroutine with 'G &']
P77F [address of division subroutine]
[Subroutine to transpose a matrix of 17-bit values in place.
Translated and slightly modified from C version on Rosetta Code website.
Parameters, all in the address field (i.e. n is stored as P n F):
10F = width (number of columns, "w" in C program)
11F = height (number of rows, "h" in C program)
12F = start address of matrix]
E25K TX GK
A3F T64@ [set up return to caller]
H10F V11F L32F L64F [acc := size of matrix as width*height]
T84@ T85@ [store size; C variable start := 0]
[8] TF A85@ T86@ T87@ [set C variables, next := start, i := 0]
[12] TF A87@ A2F T87@ [i++]
A16@ G65@ [call subroutine to update "next"]
A85@ S86@ G12@ [acc := start - next, loop back if < 0]
[Skip to location 58 if acc > 0 or i = 1.
We already know that acc >= 0 and i > 0.]
S2F E58@ [subtract 1 from acc, skip if still >= 0]
S2F A87@ G58@ [acc := -2 + i, skip if < 0]
[The assignment next := start in the C program is unnecessary]
TF A86@ A12F A81@ T31@ [make and plant order to load m{next}]
[31] AF T83@ [tmp := m{next}]
[33] TF [clear acc; also added to an address to make T order for that address]
[34] A86@ A12F A33@ T54@ [make and plant order to store m{next}]
A38@ G65@ [call subroutine to update "next"]
A86@ S85@ G48@ [go to 48 if i < start]
S2F E48@ [go to 48 if i > start]
TF A82@ G52@ [make order to load tmp, and go to 52]
[48] TF A86@ A12F A81@ [make order to load m{next}]
[52] T53@ [plant order to load tmp or m{next}]
[53] AF [manufactured order; if i = start loads tmp, else loads m{next}]
[54] TF [manufactured order; stores m{next}, using old value of "next"]
A85@ S86@ G33@ [acc := start - next, loop back if < 0]
[58] TF A85@ A2F U85@ [start++]
S84@ G8@ [loop until start = size]
[64] ZF [overwritten by return to caller]
[Subroutine to execute next = (next % h) * w + next / h in C program]
[65] A3F T80@ [set up return to caller]
A86@ T4F A11F T5F [set up parameters to divide "next" by "h"]
A71@ G& [call division subroutine]
[In case anybody is following this in detail, note that "next" and "h" are
stored in the address field, so we need to shift the quotient 1 left]
H4F V10F L64F L16F A5F LD T86@ [compute RHS and store in "next"]
[80] ZF [overwritten by return to caller]
[Constants]
[81] AF [added to an address to make A order for that address]
[82] A83@ [order to load C variable "tmp"]
[Variables; integers are stored in the address field for convenience.]
[83] PF [C variable "tmp" (holds value of a matrix element)]
[84] PF [size of matrix, width*height]
[85] PF [C variable "start"]
[86] PF [C variable "next"]
[87] PF [C variable "i"]
[Subroutine to print a matrix of 17-bit real numbers.]
E25K TM
GKA3FT30@A13FT18@A12FA31@T14@S11FT36@S10FT37@O34@O35@TDAFT1FA16@
GN
PFA14@A2FT14@A37@A2FG10@O32@O33@A36@A2FG8@ZFAF@F&F!FMFPFPF
[Library subroutine P1.
Prints positive number in 0D to n places of decimals, where
n is specified by 'P n F' pseudo-order after subroutine call.]
E25K TN
GKA18@U17@S20@T5@H19@PFT5@VDUFOFFFSFL4FTDA5@A2FG6@EFU3FJFM1F
[Integer division: number at 4F, divisor at 5F
Returns remainder at 4F, quotient at 5F
Working location 0D. 37 locations.]
E25K T&
GKA3FT34@A5FUFT35@A4FRDS35@G13@T1FA35@LDE4@T1FT5FA4FS35@G22@
T4FA5FA36@T5FT1FAFS35@E34@T1FA35@RDT35@A5FLDT5FE15@EFPFPD
[Main routine]
[Given in condensed form, since it's the same as in part 1, except
that the address of the transposed matrix is not required.]
PKT250KGK#F@F&FP7FP4FP320FP2FTFP328FPFPFO@A5@A7@T23@H4@N3@L64FL32F
T10@A9@A8@U9@TFA23@A2FT23@A10@A2FG19@A3@T10FA4@T11FA5@T12FA6@T13F
A38@GMO1@O2@A42@GXA10FTFA11FT10FAFT11FA50@GMO@ZFE11ZPF
</syntaxhighlight>
{{out}}
<pre>
.01 .02 .03 .04 .05 .06 .07
.08 .09 .10 .11 .12 .13 .14
.15 .16 .17 .18 .19 .20 .21
.22 .23 .24 .25 .26 .27 .28
.01 .08 .15 .22
.02 .09 .16 .23
.03 .10 .17 .24
.04 .11 .18 .25
.05 .12 .19 .26
.06 .13 .20 .27
.07 .14 .21 .28
</pre>
=={{header|Elixir}}==
<
[2, 4, 8, 16],
[3, 9, 27, 81],
Line 1,031 ⟶ 1,666:
transpose = fn(m)-> List.zip(m) |> Enum.map(&Tuple.to_list(&1)) end
IO.inspect transpose.(m)</
{{out}}
Line 1,041 ⟶ 1,676:
Sample originally from ftp://ftp.dra.hmg.gb/pub/ella (a now dead link) - Public release.
Code for matrix transpose hardware design verification:<
[INT i = 1..m] [INT j = 1..n] matrix[j][i].</
=={{header|Emacs Lisp}}==
{{libheader|cl-lib}}
<syntaxhighlight lang="lisp">(require 'cl-lib)
(defun transpose (m)
(apply #'cl-mapcar #'list m))
;;test for transposition function
(transpose '((2 3 4 5) (3 5 6 9) (9 9 9 9)))</syntaxhighlight>
{{out}}
<pre>
((2 3 9)
(3 5 9)
(4 6 9)
(5 9 9))
</pre>
Implementation using seq library:
<syntaxhighlight lang="lisp">
(defun matrix-transposition (m)
(apply #'seq-mapn (append (list #'list) m)) )
(let ((m '(( 2 0 -5 -1)
(-3 -2 -4 7)
(-1 -3 0 -6))))
(message "%s" (matrix-transposition m)) )
</syntaxhighlight>
{{out}}
<pre>
((2 -3 -1) (0 -2 -3) (-5 -4 0) (-1 7 -6))
</pre>
=={{header|Erlang}}==
A nice introduction http://langintro.com/erlang/article2/ which is much more explicit.
<syntaxhighlight lang="erlang">
-module(transmatrix).
-export([trans/1,transL/1]).
% using built-ins hd = head, tl = tail
trans([[]|_]) -> [];
trans(M) ->
[ lists:map(fun hd/1, M) | transpose( lists:map(fun tl/1, M) ) ].
% Purist version
transL( [ [Elem | Rest] | List] ) ->
[ [Elem | [H || [H | _] <- List] ] |
transL( [Rest |
[ T || [_ | T] <- List ] ]
) ];
transL([ [] | List] ) -> transL(List);
transL([]) -> [].
</syntaxhighlight>
{{out}}
<pre>
2> transmatrix:transL( [ [1,2,3],[4,5,6],[7,8,9] ] ).
[[1,4,7],[2,5,8],[3,6,9]]
3> transmatrix:trans( [ [1,2,3],[4,5,6],[7,8,9] ] ).
[[1,4,7],[2,5,8],[3,6,9]]
</pre>
=={{header|Euphoria}}==
<
sequence out
out = repeat(repeat(0,length(in)),length(in[1]))
Line 1,063 ⟶ 1,771:
}
? transpose(m)</
{{out}}
Line 1,072 ⟶ 1,780:
{4,8,12}
}</pre>
=={{header|Excel}}==
Excel has a built-in TRANSPOSE function:
{| class="wikitable"
|-
|||style="text-align:right; font-family:serif; font-style:italic; font-size:120%;"|fx
! colspan="9" style="text-align:left; vertical-align: bottom; font-family:Arial, Helvetica, sans-serif !important;"|=TRANSPOSE(F2#)
|- style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff;"
|
| A
| B
| C
| D
| E
| F
| G
| H
| I
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 1
|
| colspan="3" style="text-align:left; font-weight:bold" | Transposed
|
| colspan="4" style="text-align:left; font-weight:bold" | Source matrix
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 2
|
| style="text-align:center; background-color:#cbcefb" | 1
| style="text-align:center" | 5
| style="text-align:center" | 9
|
| style="text-align:center" | 1
| style="text-align:center" | 2
| style="text-align:center" | 3
| style="text-align:center" | 4
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 3
|
| style="text-align:center" | 2
| style="text-align:center" | 6
| style="text-align:center" | 10
|
| style="text-align:center" | 5
| style="text-align:center" | 6
| style="text-align:center" | 7
| style="text-align:center" | 8
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 4
|
| style="text-align:center" | 3
| style="text-align:center" | 7
| style="text-align:center" | 11
|
| style="text-align:center" | 9
| style="text-align:center" | 10
| style="text-align:center" | 11
| style="text-align:center" | 12
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 5
|
| style="text-align:center" | 4
| style="text-align:center" | 8
| style="text-align:center" | 12
|
|
|
|
|
|}
=={{header|F_Sharp|F#}}==
Very straightforward solution...
<syntaxhighlight lang="fsharp">let transpose (mtx : _ [,]) = Array2D.init (mtx.GetLength 1) (mtx.GetLength 0) (fun x y -> mtx.[y,x])</syntaxhighlight>
=={{header|Factor}}==
<code>flip</code> can be used.
<
{ { 1 4 } { 2 5 } { 3 6 } }</
=={{header|Fermat}}==
Matrix transpose is built in.
<syntaxhighlight lang="fermat">
Array a[3,1]
[a]:=[(1,2,3)]
[b]:=Trans([a])
[a]
[b]
</syntaxhighlight>
{{out}}
<pre>
[[ 1, `
2, `
3 ]]
[[ 1, 2, 3 ]]</pre>
=={{header|Forth}}==
{{libheader|Forth Scientific Library}}
{{works with|gforth|0.7.9_20170308}}
<syntaxhighlight lang="forth">S" fsl-util.fs" REQUIRED
S" fsl/dynmem.seq" REQUIRED
: F+! ( addr -- ) ( F: r -- ) DUP F@ F+ F! ;
: FSQR ( F: r1 -- r2 ) FDUP F* ;
S" fsl/gaussj.seq" REQUIRED
5 3 float matrix a{{
1e 2e 3e 4e 5e 6e 7e 8e 9e 10e 11e 12e 13e 14e 15e 5 3 a{{ }}fput
float dmatrix b{{
a{{ 5 3 & b{{ transpose
3 5 b{{ }}fprint</syntaxhighlight>
=={{header|Fortran}}==
In ISO Fortran 90 or later, use the TRANSPOSE intrinsic function:
<
real, dimension(n,m) :: a = reshape( (/ (i,i=1,n*m) /), (/ n, m /) )
real, dimension(m,n) :: b
Line 1,092 ⟶ 1,908:
do j = 1, m
print *, b(j,:)
end do</
In ANSI FORTRAN 77 with MIL-STD-1753 extensions or later, use nested structured DO loops:
<
DATA ((A(I,J),I=1,3),J=1,5) /1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15/
Line 1,102 ⟶ 1,918:
B(J,I) = A(I,J)
END DO
END DO</
In ANSI FORTRAN 66 or later, use nested labeled DO loops:
<
DATA ((A(I,J),I=1,3),J=1,5) /1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15/
Line 1,112 ⟶ 1,928:
B(J,I) = A(I,J)
20 CONTINUE
10 CONTINUE</
Explicit transposition via DO-loops was available from the start. Less obvious is that Fortran uses what is called "column major" order rather than "row major", which is to say that consecutive elements of the array are stored in memory with indices counting down the columns first, not along the rows. The above examples acknowledge this in the DATA statement with the <code>((A(row,col),row=1,3),col=1,5)</code> which could therefore be replaced with just <code>A</code>, however one could use <code>((A(row,col),col=1,5),row=1,3)</code> instead and the DATA values could be arranged so as to appear in the same layout as one expects for a matrix. Consider <syntaxhighlight lang="fortran"> DIMENSION A(3,5),B(5,3),C(5,3)
EQUIVALENCE (A,C) !Occupy the same storage.
DATA A/
1 1, 2, 3, 4, 5,
2 6, 7, 8, 9,10,
3 11,12,13,14,15/ !Supplies values in storage order.
WRITE (6,*) "Three rows of five values:"
WRITE (6,1) A !This shows values in storage order.
WRITE (6,*) "...written as C(row,column):"
WRITE (6,2) ((C(I,J),J = 1,3),I = 1,5)
WRITE (6,*) "... written as A(row,column):"
WRITE (6,1) ((A(I,J),J = 1,5),I = 1,3)
WRITE (6,*)
WRITE (6,*) "B = Transpose(A)"
DO 10 I = 1,3
DO 10 J = 1,5
10 B(J,I) = A(I,J)
WRITE (6,*) "Five rows of three values:"
WRITE (6,2) B
WRITE (6,*) "... written as B(row,column):"
WRITE (6,2) ((B(I,J),J = 1,3),I = 1,5)
1 FORMAT (5F6.1) !Five values per line.
2 FORMAT (3F6.1) !Three values per line.
END</syntaxhighlight>
Output:
<pre>
Three rows of five values:
1.0 2.0 3.0 4.0 5.0
6.0 7.0 8.0 9.0 10.0
11.0 12.0 13.0 14.0 15.0
...written as C(row,column):
1.0 6.0 11.0
2.0 7.0 12.0
3.0 8.0 13.0
4.0 9.0 14.0
5.0 10.0 15.0
... written as A(row,column):
1.0 4.0 7.0 10.0 13.0
2.0 5.0 8.0 11.0 14.0
3.0 6.0 9.0 12.0 15.0
B = Transpose(A)
Five rows of three values:
1.0 4.0 7.0
10.0 13.0 2.0
5.0 8.0 11.0
14.0 3.0 6.0
9.0 12.0 15.0
... written as B(row,column):
1.0 2.0 3.0
4.0 5.0 6.0
7.0 8.0 9.0
10.0 11.0 12.0
13.0 14.0 15.0</pre>
Thus, the first output of A replicates the layout of the DATA statement, and the output of matrix C gives its transpose. ''But'', the values in matrix A do ''not'' appear where they would be expected to appear in terms of (row,column) as applied to the layout of the DATA statement. Only ''after'' the transposition is this so. Put another way, the ordering of array values for statements just naming the matrix (the DATA statement, and the simple write statements of A and B) is the transpose of the (row,column) expectation for a matrix. All input and output statements for matrices should thus explicitly specify the index order, even for temporary debugging, lest confusion ensue.
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">Dim matriz(0 To 3, 0 To 4) As Integer = {{78,19,30,12,36},_
{49,10,65,42,50},_
{30,93,24,78,10},_
{39,68,27,64,29}}
Dim As Integer mtranspuesta(Lbound(matriz, 2) To Ubound(matriz, 2), Lbound(matriz, 1) To Ubound(matriz, 1))
Dim As Integer fila, columna
For fila = Lbound(matriz,1) To Ubound(matriz,1)
For columna = Lbound(matriz,2) To Ubound(matriz,2)
mtranspuesta(columna, fila) = matriz(fila, columna)
Print ; matriz(fila,columna); " ";
Next columna
Print
Next fila
Print
For fila = Lbound(mtranspuesta,1) To Ubound(mtranspuesta,1)
For columna = Lbound(mtranspuesta,2) To Ubound(mtranspuesta,2)
Print ; mtranspuesta(fila,columna); " ";
Next columna
Print
Next fila
Sleep</syntaxhighlight>
{{out}}
<pre>
78 19 30 12 36
49 10 65 42 50
30 93 24 78 10
39 68 27 64 29
78 49 30 39
19 10 93 68
30 65 24 27
12 42 78 64
36 50 10 29
</pre>
=={{header|Frink}}==
The built-in array method <CODE>transpose</CODE> transposes a 2-dimensional array.
<syntaxhighlight lang="frink">
a = [[1,2,3],
[4,5,6],
[7,8,9]]
joinln[a.transpose[]]
</syntaxhighlight>
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Matrix_transposition}}
'''Solution'''
Matrix transposition is an intrsinec operation in Fōrmulæ, through the Transpose expression:
[[File:Fōrmulæ - Matrix transposition 01.png]]
[[File:Fōrmulæ - Matrix transposition 02.png]]
However, a matrix transposition can be coded:
[[File:Fōrmulæ - Matrix transposition 03.png]]
[[File:Fōrmulæ - Matrix transposition 04.png]]
[[File:Fōrmulæ - Matrix transposition 02.png]]
=={{header|GAP}}==
<
[2, 4, 8, 16],
[3, 9, 27, 81],
[4, 16, 64, 256],
[5, 25, 125, 625]];
transposedMatrix := TransposedMat(originalMatrix);</
=={{header|Go}}==
===Library gonum/
<
import (
"fmt"
"
)
func main() {
m :=
1, 2, 3,
4, 5, 6,
})
fmt.Println(
fmt.Println()
fmt.Println(
}</
{{out}}
<pre>
Line 1,156 ⟶ 2,098:
===Library go.matrix===
<
import (
Line 1,174 ⟶ 2,116:
fmt.Println("transpose:")
fmt.Println(m)
}</
{{out}}
<pre>
Line 1,188 ⟶ 2,130:
===2D representation===
Go arrays and slices are only one-dimensional. The obvious way to represent two-dimensional arrays is with a slice of slices:
<
import "fmt"
Line 1,222 ⟶ 2,164:
}
return r
}</
{{out}}
<pre>[1 2 3]
Line 1,233 ⟶ 2,175:
A flat element representation with a stride is almost always better.
<
import "fmt"
Line 1,283 ⟶ 2,225:
}
return r
}</
{{out}}
<pre>
Line 1,298 ⟶ 2,240:
{{trans|C}}
Note representation is "flat," as above, but without the fluff of constructing from rows.
<
import "fmt"
Line 1,358 ⟶ 2,300:
}
m.stride = h
}</
Output same as above.
=={{header|Groovy}}==
The Groovy extensions to the List class provides a transpose method:
<
[ 5, 6, 7, 8 ] ]
Line 1,370 ⟶ 2,312:
def transpose = matrix.transpose()
transpose.each { println it }</
{{out}}
Line 1,383 ⟶ 2,325:
=={{header|Haskell}}==
For matrices represented as lists, there's ''transpose'':
<
[[1,3,5],[2,4,6]]</
For matrices in arrays, one can use ''ixmap'':
<
swap (x,y) = (y,x)
Line 1,393 ⟶ 2,335:
transpArray :: (Ix a, Ix b) => Array (a,b) e -> Array (b,a) e
transpArray a = ixmap (swap l, swap u) swap a where
(l,u) = bounds a</
Using ''zipWith'' assuming a matrix is a list of row lists:
<syntaxhighlight lang="haskell">
tpose [ms] = [[m] | m <- ms]
tpose (ms:mss) = zipWith (:) ms (tpose mss)
</syntaxhighlight>
{{out}}
<pre>
tpose [[1,2,3],[4,5,6],[7,8,9]]
[[1,4,7],[2,5,8],[3,6,9]]
</pre>
or, in terms of Data.Matrix:
<syntaxhighlight lang="haskell">import Data.Matrix
main :: IO ()
main = print matrix >> print (transpose matrix)
where
matrix = fromList 3 4 [1 ..]</syntaxhighlight>
{{Out}}
<pre>┌ ┐
│ 1 2 3 4 │
│ 5 6 7 8 │
│ 9 10 11 12 │
└ ┘
┌ ┐
│ 1 5 9 │
│ 2 6 10 │
│ 3 7 11 │
│ 4 8 12 │
└ ┘</pre>
===With Numeric.LinearAlgebra===
<syntaxhighlight lang="haskell">import Numeric.LinearAlgebra
a :: Matrix I
a = (3><2)
[1,2
,3,4
,5,6]
main = do
print $ a
print $ tr a</syntaxhighlight>
{{out}}
<pre>(3><2)
[ 1, 2
, 3, 4
, 5, 6 ]
(2><3)
[ 1, 3, 5
, 2, 4, 6 ]</pre>
=={{header|Haxe}}==
<syntaxhighlight lang="haxe">class Matrix {
static function main() {
var m = [ [1, 1, 1, 1],
[2, 4, 8, 16],
[3, 9, 27, 81],
[4, 16, 64, 256],
[5, 25, 125, 625] ];
var t = [ for (i in 0...m[0].length)
[ for (j in 0...m.length) 0 ] ];
for(i in 0...m.length)
for(j in 0...m[0].length)
t[j][i] = m[i][j];
for(aa in [m, t])
for(a in aa) Sys.println(a);
}
}</syntaxhighlight>
{{Out}}
<pre>[1,1,1,1]
[2,4,8,16]
[3,9,27,81]
[4,16,64,256]
[5,25,125,625]
[1,2,3,4,5]
[1,4,9,16,25]
[1,8,27,64,125]
[1,16,81,256,625]</pre>
=={{header|HicEst}}==
<
mtx = 1.1 * $
Line 1,408 ⟶ 2,426:
SOLVE(Matrix=mtx, Transpose=mtx)
WRITE() mtx</
{{out}}
<pre>1.1 2.2 3.3 4.4
Line 1,417 ⟶ 2,435:
3.3 7.7
4.4 8.8 </pre>
=={{header|Hope}}==
<syntaxhighlight lang="hope">uses lists;
dec transpose : list (list alpha) -> list (list alpha);
--- transpose ([]::_) <= [];
--- transpose n <= map head n :: transpose (map tail n);</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
<
result := []
# for each column
Line 1,446 ⟶ 2,470:
write ("Transposed:")
print_matrix (transposed)
end</
{{out}}
<pre>
Line 1,460 ⟶ 2,484:
=={{header|IDL}}==
Standard IDL function <tt>transpose()</tt>
<
print,transpose(m)</
=={{header|Idris}}==
<
[[1, 3, 5], [2, 4, 6]] : List (List Integer)</
=={{Header|Insitux}}==
<syntaxhighlight lang="insitux">
(var transpose2d @(... map vec))
(transpose2d [[1 1 1 1] [2 4 8 16] [3 9 27 81] [4 16 64 256] [5 25 125 625]])
</syntaxhighlight>
{{out}}
<pre>
[[1 2 3 4 5] [1 4 9 16 25] [1 8 27 64 125] [1 16 81 256 625]]
</pre>
=={{header|J}}==
Line 1,472 ⟶ 2,510:
'''Example:'''
<
1 1 1 1
2 4 8 16
Line 1,482 ⟶ 2,520:
1 4 9 16 25
1 8 27 64 125
1 16 81 256 625</
As an aside, note that <code>.</code> and <code>:</code> are token forming suffixes (if they immediately follow a token forming character, they are a part of the token). This usage is in analogy to the use of [[wp:Diacritic|diacritics]] in many languages. (If you want to use <code> :</code> or <code>.</code> as tokens by themselves you must precede them with a space - beware though that wiki rendering software may sometimes elide the preceding space in <nowiki><code> .</code></nowiki> contexts.)
=={{header|Java}}==
<
public class Transpose{
public static void main(String[] args){
Line 1,505 ⟶ 2,543:
}
}
}</
=={{header|JavaScript}}==
===ES5===
{{works with|SpiderMonkey}} for the <code>print()</code> function
<
this.mtx = ary
this.height = ary.length;
Line 1,537 ⟶ 2,576:
print(m);
print();
print(m.transpose());</
produces
Line 1,553 ⟶ 2,592:
Or, as a functional expression (rather than an imperative procedure):
<
(function () {
'use strict';
Line 1,570 ⟶ 2,609:
})();
</syntaxhighlight>
{{Out}}
<pre>[[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]</pre>
===ES6===
<syntaxhighlight lang="javascript">(() => {
"use strict";
// transpose :: [[a]] -> [[a]]
const transpose = xs =>
0 < xs.length ? (
xs[0].map(
(_, iCol) => xs.map(
row => row[iCol]
)
)
) : [];
// ---------------------- TEST -----------------------
const main = () =>
JSON.stringify(
transpose([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
])
);
// MAIN ---
return main();
})();</syntaxhighlight>
{{Out}}
<syntaxhighlight lang="javascript">[[1,4,7],[2,5,8],[3,6,9]]</syntaxhighlight>
=={{header|Joy}}==
For matrices represented as lists, there's ''transpose'', defined in seqlib like this:
<
=={{header|jq}}==
{{works with|jq|1.4}}
Line 1,588 ⟶ 2,661:
The following definition of transpose/0 expects its input to be a non-empty array, each element of which should be an array of the same size. The result is an array that represents the transposition of the input.
<
if (.[0] | length) == 0 then []
else [map(.[0])] + (map(.[1:]) | transpose)
end ;</
'''Examples'''
[[], []] | transpose
Line 1,601 ⟶ 2,674:
[[1,2], [3,4]] | transpose
# => [[1,3],[2,4]]
=={{header|Jsish}}==
From the Javascript Matrix entries.
First a module, shared by the Transposition, Multiplication and Exponentiation tasks.
<syntaxhighlight lang="javascript">/* Matrix transposition, multiplication, identity, and exponentiation, in Jsish */
function Matrix(ary) {
this.mtx = ary;
this.height = ary.length;
this.width = ary[0].length;
}
Matrix.prototype.toString = function() {
var s = [];
for (var i = 0; i < this.mtx.length; i++) s.push(this.mtx[i].join(","));
return s.join("\n");
};
// returns a transposed matrix
Matrix.prototype.transpose = function() {
var transposed = [];
for (var i = 0; i < this.width; i++) {
transposed[i] = [];
for (var j = 0; j < this.height; j++) transposed[i][j] = this.mtx[j][i];
}
return new Matrix(transposed);
};
// returns a matrix as the product of two others
Matrix.prototype.mult = function(other) {
if (this.width != other.height) throw "error: incompatible sizes";
var result = [];
for (var i = 0; i < this.height; i++) {
result[i] = [];
for (var j = 0; j < other.width; j++) {
var sum = 0;
for (var k = 0; k < this.width; k++) sum += this.mtx[i][k] * other.mtx[k][j];
result[i][j] = sum;
}
}
return new Matrix(result);
};
// IdentityMatrix is a "subclass" of Matrix
function IdentityMatrix(n) {
this.height = n;
this.width = n;
this.mtx = [];
for (var i = 0; i < n; i++) {
this.mtx[i] = [];
for (var j = 0; j < n; j++) this.mtx[i][j] = (i == j ? 1 : 0);
}
}
IdentityMatrix.prototype = Matrix.prototype;
// the Matrix exponentiation function
Matrix.prototype.exp = function(n) {
var result = new IdentityMatrix(this.height);
for (var i = 1; i <= n; i++) result = result.mult(this);
return result;
};
provide('Matrix', '0.60');</syntaxhighlight>
Then a unitTest of the transposition.
<syntaxhighlight lang="javascript">/* Matrix transposition, in Jsish */
require('Matrix');
if (Interp.conf('unitTest')) {
var m = new Matrix([[1,1,1,1],[2,4,8,16],[3,9,27,81],[4,16,64,256],[5,25,125,625]]);
; m;
; m.transpose();
}
/*
=!EXPECTSTART!=
m ==> { height:5, mtx:[ [ 1, 1, 1, 1 ], [ 2, 4, 8, 16 ], [ 3, 9, 27, 81 ], [ 4, 16, 64, 256 ], [ 5, 25, 125, 625 ] ], width:4 }
m.transpose() ==> { height:4, mtx:[ [ 1, 2, 3, 4, 5 ], [ 1, 4, 9, 16, 25 ], [ 1, 8, 27, 64, 125 ], [ 1, 16, 81, 256, 625 ] ], width:5 }
=!EXPECTEND!=
*/</syntaxhighlight>
{{out}}
<pre>prompt$ jsish -u matrixTranspose.jsi
[PASS] matrixTranspose.jsi</pre>
=={{header|Julia}}==
The transposition is obtained by quoting the matrix.
<
2x3 Array{Int64,2}:
1 2 3
Line 1,610 ⟶ 2,770:
julia> [1 2 3 ; 4 5 6]' # note the quote
3x2 LinearAlgebra.Adjoint{Int64,Array{Int64,2}}:
1 4
2 5
3 6</
If you do not want change the type, convert the result back to Array{Int64,2}.
=={{header|K}}==
Transpose is the monadic verb <code>+</code>
<
(1 1 1 1.0
2 4 8 16.0
Line 1,628 ⟶ 2,790:
1 4 9 16 25.0
1 8 27 64 125.0
1 16 81 256 625.0)</
=={{header|Klong}}==
Transpose is the monadic verb <code>+</code>
<syntaxhighlight lang="k"> [5 5]:^!25
[[0 1 2 3 4]
[5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]
[20 21 22 23 24]]
+[5 5]:^!25
[[0 5 10 15 20]
[1 6 11 16 21]
[2 7 12 17 22]
[3 8 13 18 23]
[4 9 14 19 24]]</syntaxhighlight>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.1.3
typealias Vector = DoubleArray
typealias Matrix = Array<Vector>
fun Matrix.transpose(): Matrix {
val rows = this.size
val cols = this[0].size
val trans = Matrix(cols) { Vector(rows) }
for (i in 0 until cols) {
for (j in 0 until rows) trans[i][j] = this[j][i]
}
return trans
}
// Alternate version
typealias Matrix<T> = List<List<T>>
fun <T> Matrix<T>.transpose(): Matrix<T> {
return (0 until this[0].size).map { x ->
(this.indices).map { y ->
this[y][x]
}
}
}</syntaxhighlight>
=={{header|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{require lib_matrix}
{M.disp
{M.transp
[[1, 1, 1, 1],
[2, 4, 8, 16],
[3, 9, 27, 81],
[4, 16, 64, 256],
[5, 25,125, 625]]
}}
->
[[1,2,3,4,5],
[1,4,9,16,25],
[1,8,27,64,125],
[1,16,81,256,625]]
</syntaxhighlight>
=={{header|Lang5}}==
<
1 transpose .</
{{out}}
<pre>[
Line 1,647 ⟶ 2,873:
=={{header|LFE}}==
<
(defun transpose (matrix)
(transpose matrix '()))
Line 1,661 ⟶ 2,887:
(tails (lists:map #'cdr/1 matrix)))
(transpose tails (++ acc `(,heads)))))))
</syntaxhighlight>
Usage in the LFE REPL:
<
> (transpose '((1 2 3)
(4 5 6)
Line 1,674 ⟶ 2,900:
((1 4 7 10 13 16) (2 5 8 11 14 17) (3 6 9 12 15 18))
>
</syntaxhighlight>
=={{header|Liberty BASIC}}==
There is no native matrix capability. A set of functions is available at http://www.diga.me.uk/RCMatrixFuncs.bas implementing matrices of arbitrary dimension in a string format.
<
print "Transpose of matrix"
Line 1,684 ⟶ 2,910:
print " ="
MatrixT$ =MatrixTranspose$( MatrixC$)
call DisplayMatrix MatrixT$</
{{out}}
Line 1,699 ⟶ 2,925:
=={{header|Lua}}==
<
local res = {}
Line 1,721 ⟶ 2,947:
end
io.write( "\n" )
end</
Using apply map list
<
local b = {}
for k,v in ipairs(a) do b[k] = f(v) end
Line 1,750 ⟶ 2,976:
yx = apply(mapn, function(...) return {...} end, xy)
print(table.concat(map(function(a) return table.concat(a,",") end, xy), "\n"),"\n")
print(table.concat(map(function(a) return table.concat(a,",") end, yx), "\n"))</
--Edit: table.getn() deprecated, using # instead
Line 1,758 ⟶ 2,984:
The <code>Transpose</code> function in Maple's <code>LinearAlgebra</code> package computes this. The computation can also be accomplished by raising the Matrix to the <code>%T</code> power. Similarly for <code>HermitianTranspose</code> and the <code>%H</code> power.
<syntaxhighlight lang="maple">
M := <<2,3>|<3,4>|<5,6>>;
Line 1,765 ⟶ 2,991:
with(LinearAlgebra):
Transpose(M);
</syntaxhighlight>
{{out}}
<pre>
Line 1,785 ⟶ 3,011:
</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
{2, 4, 8, 16},
{3, 9, 27, 81},
{4, 16, 64, 256},
{5, 25, 125, 625}}
transposedMatrix = Transpose[originalMatrix]</
=={{header|MATLAB}}==
Matlab contains two built-in methods of transposing a matrix: by using the <code>transpose()</code> function, or by using the <code>.'</code> operator. The <code>'</code> operator yields the [[conjugate transpose|complex conjugate transpose]].
<
ans =
Line 1,807 ⟶ 3,033:
1 3
2 4</
But, you can, obviously, do the transposition of a matrix without a built-in method, in this case, the code can be this hereafter code:
<syntaxhighlight lang="matlab">
B=size(A); %In this code, we assume that a previous matrix "A" has already been inputted.
Line 1,819 ⟶ 3,045:
end
</syntaxhighlight>
Transposing nested cells using apply map list
<
yx = feval(@(x) cellfun(@(varargin)[varargin],x{:},'un',0), xy)</
=={{header|Maxima}}==
<
[2, 4, 8, 16],
[3, 9, 27, 81],
[4, 16, 64, 256],
[5, 25, 125, 625]);
transposedMatrix : transpose(originalMatrix);</
=={{header|MAXScript}}==
Uses the built in transpose() function
<
for i in 1 to 5 do for j in 1 to 4 do m[i][j] = pow i j
m = transpose m</
=={{header|Nial}}==
make an array
<
=1 2 3
=4 5 6</
transpose it
<
=1 4
=2 5
=3 6</
=={{header|Nim}}==
For statically sized arrays:
<
for i in low(X)..high(X):
for j in low(Y)..high(Y):
Line 1,864 ⟶ 3,090:
for i in r:
stdout.write i, " "
echo ""</
{{out}}
<pre> 0 5 1
1 6 0
2 7 0
3 8 0
4 9 42 </pre>
For dynamically sized seqs:
<
result = newSeq[seq[T]](s[0].len)
for i in 0 ..
result[i] = newSeq[T](s.len)
for j in 0 ..
result[i][j] = s[j][i]
let a = @[@[ 0, 1, 2, 3, 4],
@[ 5, 6, 7, 8, 9],
@[ 1, 0, 0, 0, 42]]
echo transpose(a)</
{{out}}
<pre>@[@[0, 5, 1], @[1, 6, 0], @[2, 7, 0], @[3, 8, 0], @[4, 9, 42]]</pre>
=={{header|Objeck}}==
<
bundle Default {
class Transpose {
Line 1,919 ⟶ 3,145:
}
}
</syntaxhighlight>
{{out}}
Line 1,933 ⟶ 3,159:
The implementation below uses a bigarray:
<
let transpose b =
Line 1,962 ⟶ 3,188:
[| 5; 6; 7; 8 |];
|]
;;
array2_display (Printf.printf " %d") print_newline (transpose a) ;;</
{{out}}
Line 1,973 ⟶ 3,200:
</pre>
A version for lists:
<
assert (m <> []);
if List.mem [] m then
[]
else
List.map List.hd m :: transpose (List.map List.tl m)</
Example:
# transpose [[1;2;3;4];
Line 1,985 ⟶ 3,212:
=={{header|Octave}}==
<
2, 4, 8, 16 ;
3, 9, 27, 81 ;
Line 1,991 ⟶ 3,218:
5, 25, 125, 625 ];
tranposed = a.'; % tranpose
ctransp = a'; % conjugate transpose</
=={{header|OxygenBasic}}==
<
function Transpose(double *A,*B, sys nx,ny)
'==========================================
Line 2,037 ⟶ 3,264:
Transpose A,B,5,4
print MatrixShow B,4,5
</syntaxhighlight>
=={{header|PARI/GP}}==
The GP function for matrix (or vector) transpose is <code>mattranspose</code>, but it is usually invoked with a tilde:
<syntaxhighlight lang
In PARI the function is
<syntaxhighlight lang
though <code>shallowtrans</code> is also available when deep copying is not desired.
=={{header|Pascal}}==
<
const
Line 2,079 ⟶ 3,306:
writeln;
end;
end.</
{{out}}
<pre>% ./Transpose
Line 2,096 ⟶ 3,323:
=={{header|Perl}}==
{{libheader|Math::Matrix}}
<
$m = Math::Matrix->new(
Line 2,106 ⟶ 3,333:
);
$m->transpose->print;</
{{out}}
Line 2,116 ⟶ 3,343:
</pre>
Manually:
<
[1, 1, 1, 1],
[2, 4, 8, 16],
Line 2,127 ⟶ 3,354:
foreach my $j (0..$#{$m[0]}) {
push(@transposed, [map $_->[$j], @m]);
}</
=={{header|
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">matrix_transpose</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">mat</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">rows</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">mat</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">cols</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">mat</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">])</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rows</span><span style="color: #0000FF;">),</span><span style="color: #000000;">cols</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">rows</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">cols</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">res</span><span style="color: #0000FF;">[</span><span style="color: #000000;">c</span><span style="color: #0000FF;">][</span><span style="color: #000000;">r</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">mat</span><span style="color: #0000FF;">[</span><span style="color: #000000;">r</span><span style="color: #0000FF;">][</span><span style="color: #000000;">c</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<!--</syntaxhighlight>-->
=={{header|PHP}}==
====Up to PHP version 5.6====
<syntaxhighlight lang="php">
function transpose($m) {
if (count($m) == 0) // special case: empty matrix
return array();
else if (count($m) == 1) // special case: row matrix
return array_chunk($m[0], 1);
// array_map(NULL, m[0], m[1], ..)
array_unshift($m, NULL); // the original matrix is not modified because it was passed by value
return call_user_func_array('array_map', $m);
}</syntaxhighlight>
====Starting with PHP 5.6====
<syntaxhighlight lang="php">
function transpose($m) {
return count($m) == 0 ? $m : (count($m) == 1 ? array_chunk($m[0], 1) : array_map(null, ...$m));
}
</syntaxhighlight>
=={{header|Picat}}==
Picat has a built-in function <code>transpose/1</code> (in the <code>util</code> module).
<syntaxhighlight lang="picat">import util.
go =>
M = [[0.0, 0.1, 0.2, 0.3],
[0.4, 0.5, 0.6, 0.7],
[0.8, 0.9, 1.0, 1.1]],
print_matrix(M),
M2 = [[a,b,c,d,e],
[f,g,h,i,j],
[k,l,m,n,o],
[p,q,r,s,t],
[u,v,w,z,y]],
print_matrix(M2),
M3 = make_matrix(1..24,8),
print_matrix(M3),
nl.
%
% Print original matrix and its transpose
%
print_matrix(M) =>
println("Matrix:"),
foreach(Row in M) println(Row) end,
println("\nTransposed:"),
foreach(Row in M.transpose()) println(Row) end,
nl.
%
% Make a matrix of list L with Rows rows
% (and L.length div Rows columns)
%
make_matrix(L,Rows) = M =>
M = [],
Cols = L.length div Rows,
foreach(I in 1..Rows)
NewRow = new_list(Cols),
foreach(J in 1..Cols)
NewRow[J] := L[ (I-1)*Cols + J]
end,
M := M ++ [NewRow]
end.</syntaxhighlight>
<pre>Matrix:
[0.0,0.1,0.2,0.3]
[0.4,0.5,0.6,0.7]
[0.8,0.9,1.0,1.1]
Transposed:
[0.0,0.4,0.8]
[0.1,0.5,0.9]
[0.2,0.6,1.0]
[0.3,0.7,1.1]
Matrix:
abcde
fghij
klmno
pqrst
uvwzy
Transposed:
afkpu
bglqv
chmrw
dinsz
ejoty
Matrix:
[1,2,3]
[4,5,6]
[7,8,9]
[10,11,12]
[13,14,15]
[16,17,18]
[19,20,21]
[22,23,24]
Transposed:
[1,4,7,10,13,16,19,22]
[2,5,8,11,14,17,20,23]
[3,6,9,12,15,18,21,24]</pre>
=={{header|PicoLisp}}==
<
(apply mapcar Mat list) )
(matTrans '((1 2 3) (4 5 6)))</
{{out}}
<pre>-> ((1 4) (2 5) (3 6))</pre>
=={{header|PL/I}}==
<
declare A(m, n) float, B (n,m) float defined (A(2sub, 1sub));
/* Any reference to B gives the transpose of matrix A. */</
Traditional method:
<
transpose: procedure (a, b);
declare (a, b) (*,*) float controlled;
Line 2,225 ⟶ 3,510:
b(*,i) = a(i,*);
end;
end transpose;</
=={{header|Pop11}}==
<
lvars bl = boundslist(m);
if length(bl) /= 4 then
Line 2,241 ⟶ 3,526:
endfor;
endfor;
enddefine;</
=={{header|PostScript}}==
{{libheader|initlib}}
<
[ exch {
{ {empty? exch pop} map all?} {pop exit} ift
[ exch {} {uncons {exch cons} dip exch} fold counttomark 1 roll] uncons
} loop ] {reverse} map
}.</
=={{header|PowerBASIC}}==
PowerBASIC has the MAT statement to simplify Matrix Algebra calculations; in conjunction with the TRN operation the actual transposition is just a one-liner.
<syntaxhighlight lang="powerbasic">#COMPILE EXE
#DIM ALL
#COMPILER PBCC 6
'----------------------------------------------------------------------
SUB TransposeMatrix(InitMatrix() AS DWORD, TransposedMatrix() AS DWORD)
LOCAL l1, l2, u1, u2 AS LONG
l1 = LBOUND(InitMatrix, 1)
l2 = LBOUND(InitMatrix, 2)
u1 = UBOUND(InitMatrix, 1)
u2 = UBOUND(InitMatrix, 2)
REDIM TransposedMatrix(l2 TO u2, l1 TO u1)
MAT TransposedMatrix() = TRN(InitMatrix())
END SUB
'----------------------------------------------------------------------
SUB PrintMatrix(a() AS DWORD)
LOCAL l1, l2, u1, u2, r, c AS LONG
LOCAL s AS STRING * 8
l1 = LBOUND(a(), 1)
l2 = LBOUND(a(), 2)
u1 = UBOUND(a(), 1)
u2 = UBOUND(a(), 2)
FOR r = l1 TO u1
FOR c = l2 TO u2
RSET s = STR$(a(r, c))
CON.PRINT s;
NEXT c
CON.PRINT
NEXT r
END SUB
'----------------------------------------------------------------------
SUB TranspositionDemo(BYVAL DimSize1 AS DWORD, BYVAL DimSize2 AS DWORD)
LOCAL r, c, cc AS DWORD
LOCAL a() AS DWORD
LOCAL b() AS DWORD
cc = DimSize2
DECR DimSize1
DECR DimSize2
REDIM a(0 TO DimSize1, 0 TO DimSize2)
FOR r = 0 TO DimSize1
FOR c = 0 TO DimSize2
a(r, c)= (cc * r) + c + 1
NEXT c
NEXT r
CON.PRINT "initial matrix:"
PrintMatrix a()
TransposeMatrix a(), b()
CON.PRINT "transposed matrix:"
PrintMatrix b()
END SUB
'----------------------------------------------------------------------
FUNCTION PBMAIN () AS LONG
TranspositionDemo 3, 3
TranspositionDemo 3, 7
END FUNCTION</syntaxhighlight>
{{out}}
<pre>initial matrix:
1 2 3
4 5 6
7 8 9
transposed matrix:
1 4 7
2 5 8
3 6 9
initial matrix:
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
transposed matrix:
1 8 15
2 9 16
3 10 17
4 11 18
5 12 19
6 13 20
7 14 21</pre>
=={{header|PowerShell}}==
===Any Matrix===
<syntaxhighlight lang="powershell">
function transpose($a) {
$arr = @()
Line 2,313 ⟶ 3,676:
"transpose `$a ="
show (transpose $a)
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 2,360 ⟶ 3,723:
===Square Matrix===
<syntaxhighlight lang="powershell">
function transpose($a) {
if($a) {
Line 2,383 ⟶ 3,746:
""
show (transpose $a)
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 2,399 ⟶ 3,762:
In Prolog, a matrix is a list of lists. transpose/2 can be written like that.
{{works with|SWI-Prolog}}
<
% e.g. [[1,2,3,4], [5,6,7,8]]
% give [[1,5],[2,6],[3,7],[4,8]]
Line 2,425 ⟶ 3,788:
% "quick" append
append_dl(X-Y, Y-Z, X-Z).</
=={{header|PureBasic}}==
Matrices represented by integer arrays using rows as the first dimension and columns as the second dimension.
<
Protected rows, cols
Line 2,480 ⟶ 3,843:
Input()
CloseConsole()
EndIf</
{{out}}
<pre>matrix m, before: (3, 4)
Line 2,494 ⟶ 3,857:
=={{header|Python}}==
<
(2, 4, 8, 16),
(3, 9, 27, 81),
Line 2,501 ⟶ 3,864:
print(zip(*m))
# in Python 3.x, you would do:
# print(list(zip(*m)))</
{{out}}
<pre>
Line 2,509 ⟶ 3,872:
(1, 16, 81, 256, 625)]
</pre>
Note, however, that '''zip''', while very useful, doesn't give us a simple type-safe transposition – it is actually a ''''transpose + coerce'''' function rather than a pure '''transpose''' function; polymorphic in its inputs, but not in its outputs.
zip accepts matrices in any of the 4 permutations of (outer lists or tuples) * (inner lists or tuples), but it always and only returns a '''zip''' of '''tuples''', losing any information about what the input type was.
For type-specific transpositions '''without''' coercion (and for a richer set of matrix types, and higher level of efficiency – transpositions are an inherently expensive operation) we can turn to '''numpy'''.
Meanwhile, for the four basic types of Python matrices (the cartesian product of (inner type, container type) * (tuple, list), the simplest (though not necessarily most efficient) approach (in the absence of numpy) may be to write a type-sensitive wrapper, which retains and restores the type information that zip discards.
Perhaps, for example, something like:
<syntaxhighlight lang="python"># transpose :: Matrix a -> Matrix a
def transpose(m):
if m:
inner = type(m[0])
z = zip(*m)
return (type(m))(
map(inner, z) if tuple != inner else z
)
else:
return m
if __name__ == '__main__':
# TRANSPOSING FOUR BASIC TYPES OF PYTHON MATRIX
# Cartesian product of (Outer, Inner) with (List, Tuple)
# Matrix any = Tuple of Tuples of any type
tts = ((1, 2, 3), (4, 5, 6), (7, 8, 9))
# Matrix any = Tuple of Lists of any type
tls = ([1, 2, 3], [4, 5, 6], [7, 8, 9])
emptyTuple = ()
# Matrix any = List of Lists of any type
lls = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# Matrix any = List of Tuples of any type
lts = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
emptyList = []
print('transpose function :: (Transposition without type change):\n')
for m in [emptyTuple, tts, tls, emptyList, lls, lts]:
tm = transpose(m)
print (
type(tm).__name__ + (
(' of ' + type(tm[0]).__name__) if m else ''
) + ' :: ' + str(m) + ' -> ' + str(tm)
)</syntaxhighlight>
{{Out}}
<pre>transpose function :: (Transposition without type change):
tuple :: () -> ()
tuple of tuple :: ((1, 2, 3), (4, 5, 6), (7, 8, 9)) -> ((1, 4, 7), (2, 5, 8), (3, 6, 9))
tuple of list :: ([1, 2, 3], [4, 5, 6], [7, 8, 9]) -> ([1, 4, 7], [2, 5, 8], [3, 6, 9])
list :: [] -> []
list of list :: [[1, 2, 3], [4, 5, 6], [7, 8, 9]] -> [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
list of tuple :: [(1, 2, 3), (4, 5, 6), (7, 8, 9)] -> [(1, 4, 7), (2, 5, 8), (3, 6, 9)]</pre>
Even with its type amnesia fixed, '''zip''' may still not be the instrument to reach for when it's possible that our matrices may contain gaps.
If any of the rows in a '''list of lists''' matrix are not wide enough for a full set of data for one or more of the columns, then '''zip(*xs)''' will drop all the data entirely, without warning or error message, returning no more than an empty list:
<syntaxhighlight lang="python"># Uneven list of lists
uls = [[10, 11], [20], [], [30, 31, 32]]
print (
list(zip(*uls))
)
# --> []</syntaxhighlight>
At this point, short of turning to '''numpy''', we might need to write a custom function.
An obvious approach is to return the full number of potential columns, each containing such data as the rows do have.
For example:
{{Works with|Python|3.7}}
<syntaxhighlight lang="python">'''Transposition of row sets with possible gaps'''
from collections import defaultdict
# listTranspose :: [[a]] -> [[a]]
def listTranspose(xss):
'''Transposition of a matrix which may
contain gaps.
'''
def go(xss):
if xss:
h, *t = xss
return (
[[h[0]] + [xs[0] for xs in t if xs]] + (
go([h[1:]] + [xs[1:] for xs in t])
)
) if h and isinstance(h, list) else go(t)
else:
return []
return go(xss)
# TEST ----------------------------------------------------
# main :: IO ()
def main():
'''Tests with various lists of rows or non-row data.'''
def labelledList(kxs):
k, xs = kxs
return k + ': ' + showList(xs)
print(
fTable(
__doc__ + ':\n'
)(labelledList)(fmapFn(showList)(snd))(
fmapTuple(listTranspose)
)([
('Square', [[1, 2, 3], [4, 5, 6], [7, 8, 9]]),
('Rectangle', [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]),
('Rows with gaps', [[10, 11], [20], [], [31, 32, 33]]),
('Single row', [[1, 2, 3]]),
('Single row, one cell', [[1]]),
('Not rows', [1, 2, 3]),
('Nothing', [])
])
)
# TEST RESULT FORMATTING ----------------------------------
# fTable :: String -> (a -> String) ->
# (b -> String) -> (a -> b) -> [a] -> String
def fTable(s):
'''Heading -> x display function -> fx display function ->
f -> xs -> tabular string.
'''
def go(xShow, fxShow, f, xs):
ys = [xShow(x) for x in xs]
w = max(map(len, ys))
return s + '\n' + '\n'.join(map(
lambda x, y: y.rjust(w, ' ') + ' -> ' + fxShow(f(x)),
xs, ys
))
return lambda xShow: lambda fxShow: lambda f: lambda xs: go(
xShow, fxShow, f, xs
)
# fmapFn :: (a -> b) -> (r -> a) -> r -> b
def fmapFn(f):
'''The application of f to the result of g.
fmap over a function is composition.
'''
return lambda g: lambda x: f(g(x))
# fmapTuple :: (a -> b) -> (c, a) -> (c, b)
def fmapTuple(f):
'''A pair in which f has been
applied to the second item.
'''
return lambda ab: (ab[0], f(ab[1])) if (
2 == len(ab)
) else None
# show :: a -> String
def show(x):
'''Stringification of a value.'''
def go(v):
return defaultdict(lambda: repr, [
('list', showList)
# ('Either', showLR),
# ('Maybe', showMaybe),
# ('Tree', drawTree)
])[
typeName(v)
](v)
return go(x)
# showList :: [a] -> String
def showList(xs):
'''Stringification of a list.'''
return '[' + ','.join(show(x) for x in xs) + ']'
# snd :: (a, b) -> b
def snd(tpl):
'''Second member of a pair.'''
return tpl[1]
# typeName :: a -> String
def typeName(x):
'''Name string for a built-in or user-defined type.
Selector for type-specific instances
of polymorphic functions.
'''
if isinstance(x, dict):
return x.get('type') if 'type' in x else 'dict'
else:
return 'iter' if hasattr(x, '__next__') else (
type(x).__name__
)
# MAIN ---
if __name__ == '__main__':
main()</syntaxhighlight>
{{Out}}
<pre>Transposition of row sets with possible gaps:
Square: [[1,2,3],[4,5,6],[7,8,9]] -> [[1,4,7],[2,5,8],[3,6,9]]
Rectangle: [[1,2,3],[4,5,6],[7,8,9],[10,11,12]] -> [[1,4,7,10],[2,5,8,11],[3,6,9,12]]
Rows with gaps: [[10,11],[20],[],[31,32,33]] -> [[10,20,31],[11,32],[33]]
Single row: [[1,2,3]] -> [[1],[2],[3]]
Single row, one cell: [[1]] -> [[1]]
Not rows: [1,2,3] -> []
Nothing: [] -> []</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ ' [ [ ] ]
over 0 peek size of
[] rot
witheach join
witheach
[ dip behead
nested join
nested join ] ] is transpose ( [ --> [ )
' [ [ 1 2 ] [ 3 4 ] [ 5 6 ] ]
dup echo cr cr
transpose dup echo cr cr
transpose echo cr</syntaxhighlight>
{{out}}
<pre>[ [ 1 2 ] [ 3 4 ] [ 5 6 ] ]
[ [ 1 3 5 ] [ 2 4 6 ] ]
[ [ 1 2 ] [ 3 4 ] [ 5 6 ] ]</pre>
=={{header|R}}==
<
m <- matrix(c(b, b^2, b^3, b^4), 5, 4)
print(m)
tm <- t(m)
print(tm)</
=={{header|Racket}}==
<
#lang racket
(require math)
(matrix-transpose (matrix [[1 2] [3 4]]))
</syntaxhighlight>
{{out}}
<pre>
(array #[#[1 3] #[2 4]])
</pre>
(Another method, without math, and using lists is demonstrated in the Scheme solution.)
=={{header|Raku}}==
(formerly Perl 6)
{{Works with|rakudo|2018.03}}
<syntaxhighlight lang="raku" line># Transposition can be done with the reduced zip meta-operator
# on list-of-lists data structures
say [Z] (<A B C D>, <E F G H>, <I J K L>);
# For native shaped arrays, a more traditional procedure of copying item-by-item
# Here the resulting matrix is also a native shaped array
my @a[3;4] =
[
[<A B C D>],
[<E F G H>],
[<I J K L>],
];
(my $n, my $m) = @a.shape;
my @b[$m;$n];
for ^$m X ^$n -> (\i, \j) {
@b[i;j] = @a[j;i];
}
say @b;</syntaxhighlight>
{{output}}
<pre>((A E I) (B F J) (C G K) (D H L))
[[A E I] [B F J] [C G K] [D H L]]</pre>
=={{header|Rascal}}==
<
return {<y, x, v> | <x, y, v> <- matrix};
}
Line 2,545 ⟶ 4,178:
<1.0,0.0,-51.0>, <1.0,1.0,167.0>, <1.0,2.0,24.0>,
<2.0,0.0,4.0>, <2.0,1.0,-68.0>, <2.0,2.0,-41.0>
};</
=={{header|REXX}}==
<
w=0
do
do
end /*
end /*
B.k.j= A.j.k /*transpose the A matrix (into B). */
end /*j*/
call showMat 'A', row, col /*display the A matrix to terminal.*/
call showMat 'B', col, row /* " " B " " " */
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
showMat:
{{out|output|text= when using the default input:}}
<pre>
─────────────────────────────────A matrix─────────────────────────────────
1.02 2.03 3.04 4.05 5.06 6.07 7.
111 2222 33333 444444 5555555 66666666 777777777
Line 2,589 ⟶ 4,219:
5.06 5555555
6.07 66666666
7.
</pre>
=={{header|Ring}}==
<
load "stdlib.ring"
transpose = newlist(5,4)
Line 2,604 ⟶ 4,234:
see nl
next
</syntaxhighlight>
Output:
<pre>
Line 2,615 ⟶ 4,245:
=={{header|RLaB}}==
<
0.41844289 0.476591435 0.75054022 0.226388925 0.963880314
0.91267171 0.941762397 0.464227895 0.693482786 0.203839405
Line 2,624 ⟶ 4,254:
0.75054022 0.464227895 0.26582235
0.226388925 0.693482786 0.11557427
0.963880314 0.203839405 0.0442493069</
=={{header|RPL}}==
[[1 2 3 4][5 6 7 8][9 10 11 12]] TRN
{{out}}
<pre>
[[1 5 9] [2 6 10] [3 7 11] [4 8 12]]
</pre>
=={{header|Ruby}}==
<
[2, 4, 8, 16],
[3, 9, 27, 81],
[4, 16, 64, 256],
[5, 25,125, 625]]
puts m.transpose</
{{out}}
<pre>
Line 2,638 ⟶ 4,275:
</pre>
or using 'matrix' from the standard library
<
m=Matrix[[1, 1, 1, 1],
Line 2,645 ⟶ 4,282:
[4, 16, 64, 256],
[5, 25,125, 625]]
puts m.transpose</
{{out}}
<pre>
Line 2,651 ⟶ 4,288:
</pre>
or using zip:
<
m[0].zip(*m[1..-1])
end
p transpose([[1,2,3],[4,5,6]])</
{{out}}
<pre>
Line 2,661 ⟶ 4,298:
=={{header|Run BASIC}}==
<
print "Transpose of matrix"
Line 2,696 ⟶ 4,333:
next i
html "</table>"
end sub</
{{out}}
Transpose of matrix<br><table border=2><tr align=right><td>0</td><td>0.1</td><td>0.2</td><td>0.3</td></tr><tr align=right><td>0.4</td><td>0.5</td><td>0.6</td><td>0.7</td></tr><tr align=right><td>0.8</td><td>0.9</td><td>1.0</td><td>1.1</td></tr></table> =<br />
<table border=2><tr align=right><td>0</td><td>0.4</td><td>0.8</td></tr><tr align=right><td>0.1</td><td>0.5</td><td>0.9</td></tr><tr align=right><td>0.2</td><td>0.6</td><td>1.0</td></tr><tr align=right><td>0.3</td><td>0.7</td><td>1.1</td></tr></table>
=={{header|Rust}}==
===version 1===
<syntaxhighlight lang="rust">
struct Matrix {
dat: [[i32; 3]; 3]
}
impl Matrix {
pub fn transpose_m(a: Matrix) -> Matrix
{
let mut out = Matrix {
dat: [[0, 0, 0],
[0, 0, 0],
[0, 0, 0]
]
};
for i in 0..3{
for j in 0..3{
out.dat[i][j] = a.dat[j][i];
}
}
out
}
pub fn print(self)
{
for i in 0..3 {
for j in 0..3 {
print!("{} ", self.dat[i][j]);
}
print!("\n");
}
}
}
fn main()
{
let a = Matrix {
dat: [[1, 2, 3],
[4, 5, 6],
[7, 8, 9] ]
};
let c = Matrix::transpose_m(a);
c.print();
}
</syntaxhighlight>
===version 2===
<syntaxhighlight lang="rust">
fn main() {
let m = vec![vec![1, 2, 3], vec![4, 5, 6]];
println!("Matrix:\n{}", matrix_to_string(&m));
let t = matrix_transpose(m);
println!("Transpose:\n{}", matrix_to_string(&t));
}
fn matrix_to_string(m: &Vec<Vec<i32>>) -> String {
m.iter().fold("".to_string(), |a, r| {
a + &r
.iter()
.fold("".to_string(), |b, e| b + "\t" + &e.to_string())
+ "\n"
})
}
fn matrix_transpose(m: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
let mut t = vec![Vec::with_capacity(m.len()); m[0].len()];
for r in m {
for i in 0..r.len() {
t[i].push(r[i]);
}
}
t
}
</syntaxhighlight>
<b>Output:</b>
<pre>
Matrix:
1 2 3
4 5 6
Transpose:
1 4
2 5
3 6
</pre>
=={{header|Scala}}==
<
res12: Array[Array[Int]] = Array(Array(0, 1, 2, 3), Array(4, 5, 6, 7), Array(8, 9, 10, 11), Array(12, 13, 14, 15))
Line 2,720 ⟶ 4,451:
1 5 9 13
2 6 10 14
3 7 11 15</
=={{header|Scheme}}==
<
(apply map list m))</
=={{header|Seed7}}==
<
include "float.s7i";
Line 2,772 ⟶ 4,503:
writeln("After Transposition:");
write(transpose(testMatrix));
end func;</
{{out}}
Line 2,789 ⟶ 4,520:
=={{header|Sidef}}==
<
matrix[0].range.map{|i| matrix.map{_[i]}};
};
Line 2,803 ⟶ 4,534:
transpose(m).each { |row|
"%5d" * row.len -> printlnf(row...);
}</
{{out}}
<pre> 1 2 3 4 5
Line 2,814 ⟶ 4,545:
{{works with|OpenAxiom}}
{{works with|Axiom}}
<
[3, 9, 27, 81],[4, 16, 64, 256], _
[5, 25, 125, 625]]
Line 2,837 ⟶ 4,568:
| |
+1 16 81 256 625+
Type: Matrix(Integer)</
Domain:[http://fricas.github.io/api/Matrix.html?highlight=matrix Matrix(R)]
=={{header|Sparkling}}==
<
return map(range(sizeof A), function(k, idx) {
return map(A, function(k, row) {
Line 2,848 ⟶ 4,579:
});
});
}</
=={{header|Stata}}==
Stata matrices are always real, so there is no ambiguity about the transpose operator. Mata matrices, however, may be real or complex. The transpose operator is actually a conjugate transpose, but there is also a '''[https://www.stata.com/help.cgi?mf_transposeonly transposeonly()]''' function.
=== Stata matrices ===
<syntaxhighlight lang="stata">. mat a=1,2,3\4,5,6
. mat b=a'
. mat list a
a[2,3]
c1 c2 c3
r1 1 2 3
r2 4 5 6
. mat list b
b[3,2]
r1 r2
c1 1 4
c2 2 5
c3 3 6</syntaxhighlight>
=== Mata ===
<syntaxhighlight lang="stata">: a=1,1i
: a
1 2
+-----------+
1 | 1 1i |
+-----------+
: a'
1
+-------+
1 | 1 |
2 | -1i |
+-------+
: transposeonly(a)
1
+------+
1 | 1 |
2 | 1i |
+------+</syntaxhighlight>
=={{header|Swift}}==
<syntaxhighlight lang="swift">@inlinable
public func matrixTranspose<T>(_ matrix: [[T]]) -> [[T]] {
guard !matrix.isEmpty else {
return []
}
var ret = Array(repeating: [T](), count: matrix[0].count)
for row in matrix {
for j in 0..<row.count {
ret[j].append(row[j])
}
}
return ret
}
@inlinable
public func printMatrix<T>(_ matrix: [[T]]) {
guard !matrix.isEmpty else {
print()
return
}
let rows = matrix.count
let cols = matrix[0].count
for i in 0..<rows {
for j in 0..<cols {
print(matrix[i][j], terminator: " ")
}
print()
}
}
let m1 = [
[1, 2, 3],
[4, 5, 6]
]
print("Input:")
printMatrix(m1)
let m2 = matrixTranspose(m1)
print("Output:")
printMatrix(m2)</syntaxhighlight>
{{out}}
<pre>Input:
1 2 3
4 5 6
Output:
1 4
2 5
3 6</pre>
=={{header|Tailspin}}==
<syntaxhighlight lang="tailspin">
templates transpose
def a: $;
[1..$a(1)::length -> $a(1..last;$)] !
end transpose
templates printMatrix&{w:}
templates formatN
@: [];
$ -> #
'$@ -> $::length~..$w -> ' ';$@(last..1:-1)...;' !
when <1..> do ..|@: $ mod 10; $ ~/ 10 -> #
end formatN
$... -> '|$(1) -> formatN;$(2..last)... -> ', $ -> formatN;';|
' !
end printMatrix
def m: [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]];
'before:
' -> !OUT::write
$m -> printMatrix&{w:2} -> !OUT::write
def mT: $m -> transpose;
'
transposed:
' -> !OUT::write
$mT -> printMatrix&{w:2} -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
before:
| 1, 2, 3, 4|
| 5, 6, 7, 8|
| 9, 10, 11, 12|
transposed:
| 1, 5, 9|
| 2, 6, 10|
| 3, 7, 11|
| 4, 8, 12|
</pre>
=={{header|Tcl}}==
With core Tcl, representing a matrix as a list of lists:
<
namespace path ::tcl::mathfunc
Line 2,895 ⟶ 4,776:
set m {{1 1 1 1} {2 4 8 16} {3 9 27 81} {4 16 64 256} {5 25 125 625}}
print_matrix $m "%d"
print_matrix [transpose $m] "%d"</
{{out}}
<pre>1 1 1 1
Line 2,907 ⟶ 4,788:
1 16 81 256 625</pre>
{{tcllib|struct::matrix}}
<
struct::matrix M
M deserialize {5 4 {{1 1 1 1} {2 4 8 16} {3 9 27 81} {4 16 64 256} {5 25 125 625}}}
M format 2string
M transpose
M format 2string</
{{out}}
<pre>1 1 1 1
Line 2,937 ⟶ 4,818:
A<sup>T</sup> → B
=={{header|True BASIC}}==
<syntaxhighlight lang="qbasic">OPTION BASE 0
DIM matriz(3, 4)
DATA 78, 19, 30, 12, 36
DATA 49, 10, 65, 42, 50
DATA 30, 93, 24, 78, 10
DATA 39, 68, 27, 64, 29
FOR f = 0 TO 3
FOR c = 0 TO 4
READ matriz(f, c)
NEXT c
NEXT f
DIM mtranspuesta(0 TO 4, 0 TO 3)
FOR fila = LBOUND(matriz,1) TO UBOUND(matriz,1)
FOR columna = LBOUND(matriz,2) TO UBOUND(matriz,2)
LET mtranspuesta(columna, fila) = matriz(fila, columna)
PRINT matriz(fila, columna);
NEXT columna
PRINT
NEXT fila
PRINT
FOR fila = LBOUND(mtranspuesta,1) TO UBOUND(mtranspuesta,1)
FOR columna = LBOUND(mtranspuesta,2) TO UBOUND(mtranspuesta,2)
PRINT mtranspuesta(fila, columna);
NEXT columna
PRINT
NEXT fila
END</syntaxhighlight>
=={{header|Ursala}}==
Matrices are stored as lists of lists, and transposing them is a built in operation.
<
example =
Line 2,947 ⟶ 4,863:
<1.,2.,3.,4.>,
<5.,6.,7.,8.>,
<9.,10.,11.,12.>></
For a more verbose version, replace the ~&K7 operator with the standard library function
named transpose.
Line 2,958 ⟶ 4,874:
<4.000000e+00,8.000000e+00,1.200000e+01>>
</pre>
=={{header|VBA}}==
<syntaxhighlight lang="vb">Function transpose(m As Variant) As Variant
transpose = WorksheetFunction.transpose(m)
End Function</syntaxhighlight>
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
'create and display the initial matrix
WScript.StdOut.WriteLine "Initial Matrix:"
Line 2,992 ⟶ 4,913:
WScript.StdOut.WriteLine
Next
</syntaxhighlight>
{{Out}}
Line 3,012 ⟶ 4,933:
5 10 15 20 25 30 35
</pre>
=={{header|Visual Basic}}==
{{trans|PowerBASIC}}
{{works with|Visual Basic|5}}
{{works with|Visual Basic|6}}
<syntaxhighlight lang="vb">Option Explicit
'----------------------------------------------------------------------
Function TransposeMatrix(InitMatrix() As Long, TransposedMatrix() As Long)
Dim l1 As Long, l2 As Long, u1 As Long, u2 As Long, r As Long, c As Long
l1 = LBound(InitMatrix, 1)
l2 = LBound(InitMatrix, 2)
u1 = UBound(InitMatrix, 1)
u2 = UBound(InitMatrix, 2)
ReDim TransposedMatrix(l2 To u2, l1 To u1)
For r = l1 To u1
For c = l2 To u2
TransposedMatrix(c, r) = InitMatrix(r, c)
Next c
Next r
End Function
'----------------------------------------------------------------------
Sub PrintMatrix(a() As Long)
Dim l1 As Long, l2 As Long, u1 As Long, u2 As Long, r As Long, c As Long
Dim s As String * 8
l1 = LBound(a(), 1)
l2 = LBound(a(), 2)
u1 = UBound(a(), 1)
u2 = UBound(a(), 2)
For r = l1 To u1
For c = l2 To u2
RSet s = Str$(a(r, c))
Debug.Print s;
Next c
Debug.Print
Next r
End Sub
'----------------------------------------------------------------------
Sub TranspositionDemo(ByVal DimSize1 As Long, ByVal DimSize2 As Long)
Dim r, c, cc As Long
Dim a() As Long
Dim b() As Long
cc = DimSize2
DimSize1 = DimSize1 - 1
DimSize2 = DimSize2 - 1
ReDim a(0 To DimSize1, 0 To DimSize2)
For r = 0 To DimSize1
For c = 0 To DimSize2
a(r, c) = (cc * r) + c + 1
Next c
Next r
Debug.Print "initial matrix:"
PrintMatrix a()
TransposeMatrix a(), b()
Debug.Print "transposed matrix:"
PrintMatrix b()
End Sub
'----------------------------------------------------------------------
Sub Main()
TranspositionDemo 3, 3
TranspositionDemo 3, 7
End Sub</syntaxhighlight>
{{out}}
<pre>initial matrix:
1 2 3
4 5 6
7 8 9
transposed matrix:
1 4 7
2 5 8
3 6 9
initial matrix:
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
transposed matrix:
1 8 15
2 9 16
3 10 17
4 11 18
5 12 19
6 13 20
7 14 21</pre>
=={{header|Wortel}}==
The <code>@zipm</code> operator zips together an array of arrays, this is the same as transposition if the matrix is represented as an array of arrays.
<
Returns:
<pre>[[1 4 7] [2 5 8] [3 6 9]]</pre>
=={{header|Wren}}==
{{libheader|Wren-matrix}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./matrix" for Matrix
import "./fmt" for Fmt
var m = Matrix.new([
[ 1, 2, 3],
[ 4, 5, 6],
[ 7, 8, 9],
[10, 11, 12]
])
System.print("Original:\n")
Fmt.mprint(m, 2, 0)
System.print("\nTransposed:\n")
Fmt.mprint(m.transpose, 2, 0)</syntaxhighlight>
{{out}}
<pre>
Original:
| 1 2 3|
| 4 5 6|
| 7 8 9|
|10 11 12|
Transposed:
| 1 4 7 10|
| 2 5 8 11|
| 3 6 9 12|
</pre>
=={{header|XPL0}}==
Separate memory for the transposed matrix must be used because of XPL0's
unusual array configuration. It can't simply reorder the elements stored
in the original array's memory.
<syntaxhighlight lang="xpl0">proc Transpose(M, R, C, N); \Transpose matrix M to N
int M, R, C, N; \rows and columns
int I, J;
[for I:= 0 to R-1 do
for J:= 0 to C-1 do
N(J,I):= M(I,J);
];
proc ShowMat(M, R, C); \Display matrix M
int M, R, C; \rows and columns
int I, J;
[for I:= 0 to R-1 do
[for J:= 0 to C-1 do
RlOut(0, float(M(I,J)));
CrLf(0);
];
];
int M, N(4,3);
[M:= [[1, 2, 3, 4], \3 rows by 4 columns
[5, 6, 7, 8],
[9,10,11,12]];
Format(4, 0);
ShowMat(M, 3, 4);
CrLf(0);
Transpose(M, 3, 4, N);
ShowMat(N, 4, 3);
]</syntaxhighlight>
{{out}}
<pre>
1 2 3 4
5 6 7 8
9 10 11 12
1 5 9
2 6 10
3 7 11
4 8 12
</pre>
=={{header|Yabasic}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang="yabasic">dim matriz(4,5)
dim mtranspuesta(5,4)
for fila = 1 to arraysize(matriz(), 1)
for columna = 1 to arraysize(matriz(), 2)
read matriz(fila, columna)
print matriz(fila, columna);
mtranspuesta(columna, fila) = matriz(fila, columna)
next columna
print
next fila
print
for fila = 1 to arraysize(mtranspuesta(), 1)
for columna = 1 to arraysize(mtranspuesta(), 2)
print mtranspuesta(fila, columna);
next columna
print
next fila
end
data 78,19,30,12,36
data 49,10,65,42,50
data 30,93,24,78,10
data 39,68,27,64,29</syntaxhighlight>
=={{header|zkl}}==
Using the GNU Scientific Library:
<syntaxhighlight lang="zkl">var [const] GSL=Import("zklGSL"); // libGSL (GNU Scientific Library)
GSL.Matrix(2,3).set(1,2,3, 4,5,6).transpose().format(5).println(); // in place
println("---");
GSL.Matrix(2,2).set(1,2, 3,4).transpose().format(5).println(); // in place
println("---");
GSL.Matrix(3,1).set(1,2,3).transpose().format(5).println(); // in place</syntaxhighlight>
{{out}}
<pre>
1.00, 4.00
2.00, 5.00
3.00, 6.00
---
1.00, 3.00
2.00, 4.00
---
1.00, 2.00, 3.00
</pre>
Or, using lists:
{{trans|Wortel}}
<
if(M.len()==1) M[0].pump(List,List.create); // 1 row --> n columns
else
}</
The list xplode method pushes list contents on to the call stack.
<
m:=L(L(1,"a"),L(2,"b"),L(3,"c")); transpose(m).println();
transpose(L(L(1,2,3))).println();
transpose(L(L(1),L(2),L(3))).println();
transpose(L(L(1))).println();</
{{out}}
<pre>
Line 3,039 ⟶ 5,169:
L(L(1))
</pre>
=={{header|zonnon}}==
<syntaxhighlight lang="zonnon">
module MatrixOps;
type
Matrix = array {math} *,* of integer;
procedure WriteMatrix(x: array {math} *,* of integer);
var
i,j: integer;
begin
for i := 0 to len(x,0) - 1 do
for j := 0 to len(x,1) - 1 do
write(x[i,j]);
end;
writeln;
end
end WriteMatrix;
procedure Transposition;
var
m,x: Matrix;
begin
m := [[1,2,3],[3,4,5]]; (* matrix initialization *)
x := !m; (* matrix trasposition *)
WriteMatrix(x);
end Transposition;
begin
Transposition;
end MatrixOps.
</syntaxhighlight>
| |||