I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Matrix transposition

Matrix transposition
You are encouraged to solve this task according to the task description, using any language you may know.

Transpose an arbitrarily sized rectangular Matrix.

## 11l

`F transpose(&matrix)    V toRet = [ * matrix.len] * matrix.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))`
Output:
```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]]
```

## 360 Assembly

`...          KN       EQU    3KM       EQU    5N        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 1LOOPI    BXH    R4,R6,ELOOPI       do i=1 to n         LA     R5,0               j,from 1         LA     R9,KM              to m         LA     R8,1               step 1LOOPJ    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 jELOOPJ   EQU    *                  out of loop j         B      LOOPI              next iELOOPI   EQU    *                  out of loop i...`

## 68000 Assembly

`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`

## ACL2

`(defun cons-each (xs xss)   (if (or (endp xs) (endp xss))       nil       (cons (cons (first xs) (first xss))             (cons-each (rest xs) (rest xss))))) (defun list-each (xs)   (if (endp xs)       nil       (cons (list (first xs))             (list-each (rest xs))))) (defun transpose-list (xss)   (if (endp (rest xss))       (list-each (first xss))       (cons-each (first xss)                  (transpose-list (rest xss)))))`

## 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()  ODRETURN PROC Create(MATRIX POINTER m BYTE w,h BYTE ARRAY a)  m.width=w  m.height=h  m.data=aRETURN 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  ODRETURN 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`
Output:
```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
```

## ActionScript

In ActionScript, multi-dimensional arrays are created by making an "Array of arrays" where each element is an array.

`function transpose( m:Array):Array{	//Assume each element in m is an array. (If this were production code, use typeof to be sure) 	//Each element in m is a row, so this gets the length of a row in m, 	//which is the same as the number of rows in m transpose.	var mTranspose = new Array(m.length);	for(var i:uint = 0; i < mTranspose.length; i++)	{                //create a row		mTranspose[i] = new Array(m.length);                //set the row to the appropriate values		for(var j:uint = 0; j < mTranspose[i].length; j++)			mTranspose[i][j] = m[j][i];	}	return mTranspose;}var m:Array = [[1, 2, 3, 10],	       [4, 5, 6, 11],	       [7, 8, 9, 12]];var M:Array = transpose(m);for(var i:uint = 0; i < M.length; i++)	trace(M[i]);`

Transpose is a function of the standard Ada library provided for matrices built upon any floating-point or complex type. The relevant packages are Ada.Numerics.Generic_Real_Arrays and Ada.Numerics.Generic_Complex_Arrays, correspondingly.

This example illustrates use of Transpose for the matrices built upon the standard type Float:

`with Ada.Numerics.Real_Arrays;  use Ada.Numerics.Real_Arrays;with Ada.Text_IO;               use Ada.Text_IO;  procedure Matrix_Transpose is   procedure Put (X : Real_Matrix) is      type Fixed is delta 0.01 range -500.0..500.0;   begin      for I in X'Range (1) loop         for J in X'Range (2) loop            Put (Fixed'Image (Fixed (X (I, J))));         end loop;         New_Line;      end loop;   end Put;    Matrix : constant Real_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)            );begin   Put_Line ("Before Transposition:");   Put (Matrix);   New_Line;   Put_Line ("After Transposition:");   Put (Transpose (Matrix));end Matrix_Transpose;`
Output:
```Before Transposition:
0.00 0.10 0.20 0.30
0.40 0.50 0.60 0.70
0.80 0.90 1.00 1.10

After Transposition:
0.00 0.40 0.80
0.10 0.50 0.90
0.20 0.60 1.00
0.30 0.70 1.10
```

## Agda

`module Matrix where open import Data.Natopen import Data.Vec Matrix : (A : Set) → ℕ → ℕ → SetMatrix A m n = Vec (Vec A m) n transpose : ∀ {A m n} → Matrix A m n → Matrix A n mtranspose [] = replicate []transpose (xs ∷ xss) = zipWith _∷_ xs (transpose xss) a = (1 ∷ 2 ∷ 3 ∷ []) ∷ (4 ∷ 5 ∷ 6 ∷ []) ∷ []b = transpose a`

b evaluates to the following normal form:

`(1 ∷ 4 ∷ []) ∷ (2 ∷ 5 ∷ []) ∷ (3 ∷ 6 ∷ []) ∷ []`

## ALGOL 68

Works with: ALGOL 68 version Revision 1 - no extensions to language used
Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny
`main:(   [,]REAL m=((1,  1,  1,   1),             (2,  4,  8,  16),             (3,  9, 27,  81),             (4, 16, 64, 256),             (5, 25,125, 625));   OP ZIP = ([,]REAL in)[,]REAL:(    [2 LWB in:2 UPB in,1 LWB in:1UPB in]REAL out;    FOR i FROM LWB in TO UPB in DO       out[,i]:=in[i,]     OD;    out  );   PROC pprint = ([,]REAL m)VOID:(    FORMAT real fmt = \$g(-6,2)\$; # width of 6, with no '+' sign, 2 decimals #     FORMAT vec fmt = \$"("n(2 UPB m-1)(f(real fmt)",")f(real fmt)")"\$;    FORMAT matrix fmt = \$x"("n(UPB m-1)(f(vec fmt)","lxx)f(vec fmt)");"\$;    # finally print the result #    printf((matrix fmt,m))  );   printf((\$x"Transpose:"l\$));  pprint((ZIP m)))`
Output:
```Transpose:
((  1.00,  2.00,  3.00,  4.00,  5.00),
(  1.00,  4.00,  9.00, 16.00, 25.00),
(  1.00,  8.00, 27.00, 64.00,125.00),
(  1.00, 16.00, 81.00,256.00,625.00));
```

## 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) .localsshow 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"}, printlnback `
Output:
```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

```

## APL

If M is a matrix, ⍉M is its transpose. For example,

`       3 3⍴⍳101 2 34 5 67 8 9      ⍉ 3 3⍴⍳101 4 72 5 83 6 9 `

## AppleScript

We can do this iteratively, by manually setting up two nested loops, and initialising iterators and empty lists,

`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 on transpose(xss)    set lstTrans to {}     repeat with iCol from 1 to length of item 1 of xss        set lstCol to {}         repeat with iRow from 1 to length of xss            set end of lstCol to item iCol of item iRow of xss        end repeat         set end of lstTrans to lstCol    end repeat     return lstTransend transpose`

or, if our library contains some generic basics like map(), and we use the AS script mechanism for closures, we can delegate the iterative details and write transpose() a little more declaratively, without having to reach for set, repeat, or return inside its definition.

Translation of: JavaScript
`-- TRANSPOSE ----------------------------------------------------------------- -- transpose :: [[a]] -> [[a]]on transpose(xss)    script column        on |λ|(_, iCol)            script row                on |λ|(xs)                    item iCol of xs                end |λ|            end script             map(row, xss)        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 --------------------------------------------------------- -- map :: (a -> b) -> [a] -> [b]on map(f, xs)    tell mReturn(f)        set lng to length of xs        set lst to {}        repeat with i from 1 to lng            set end of lst to |λ|(item i of xs, i, xs)        end repeat        return lst    end tellend map -- Lift 2nd class handler function into 1st class script wrapper -- mReturn :: Handler -> Scripton mReturn(f)    if class of f is script then        f    else        script            property |λ| : f        end script    end ifend mReturn`
Output:
`{{1, 4, 7, 10}, {2, 5, 8, 11}, {3, 6, 9, 12}}`

## Arturo

`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 rowprint "-------------"loop transpose arr 'row -> print row`
Output:
```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```

## AutoHotkey

`a = am = 10n = 10Loop, 10{  i := A_Index - 1  Loop, 10  {    j := A_Index - 1    %a%%i%%j% := i - j  }}before := matrix_print("a", m, n)transpose("a", m, n)after := matrix_print("a", m, n)  MsgBox % before . "`ntransposed:`n" . afterReturn transpose(a, m, n){  Local i, j, row, matrix  Loop, % m   {    i := A_Index - 1    Loop, % n     {      j := A_Index - 1      temp%i%%j% := %a%%j%%i%    }  }  Loop, % m   {    i := A_Index - 1    Loop, % n     {      j := A_Index - 1      %a%%i%%j% := temp%i%%j%    }  }} matrix_print(a, m, n){  Local i, j, row, matrix  Loop, % m   {    i := A_Index - 1    row := ""    Loop, % n     {      j := A_Index - 1      row .= %a%%i%%j% . ","    }    StringTrimRight, row, row, 1    matrix .= row . "`n"  }  Return matrix} `

### Using Objects

`Transpose(M){	R := []	for i, row in M		for j, col in row			R[j,i] := col	return R}`
Examples:
`Matrix := [[1,2,3],[4,5,6],[7,8,9],[10,11,12]]MsgBox % 	""		. "Original Matrix :`n" 		Print(Matrix) 		. "`nTransposed Matrix :`n" 	Print(Transpose(Matrix)) Print(M){	for i, row in M		for j, col in row			Res .= (A_Index=1?"":"`t") col (Mod(A_Index,M.MaxIndex())?"":"`n")	return Trim(Res,"`n")}`
Output:
```Original Matrix :
1	2	3
4	5	6
7	8	9
10	11	12

Transposed Matrix :
1	4	7	10
2	5	8	11
3	6	9	12
```

## 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)} `

input:

```1 2 3 4
5 6 7 8
9 10 11 12
```
Output:
```1 5 9
2 6 10
3 7 11
4 8 12
```

### Using 2D-Arrays

`# 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, idx] = source[idx, idx]    }}function max(m, n) {    return m > n ? m : n}`

Input:

```1 2 3
4 5 6
```
Output:
```1. 4.
2. 5.
3. 6.
```

## BASIC

Works with: QuickBasic version 4.5
```CLS
DIM m(1 TO 5, 1 TO 4) 'any dimensions you want

'set up the values in the array
FOR rows = LBOUND(m, 1) TO UBOUND(m, 1) 'LBOUND and UBOUND can take a dimension as their second argument
FOR cols = LBOUND(m, 2) TO UBOUND(m, 2)
m(rows, cols) = rows ^ cols 'any formula you want
NEXT cols
NEXT rows

'declare the new matrix
DIM trans(LBOUND(m, 2) TO UBOUND(m, 2), LBOUND(m, 1) TO UBOUND(m, 1))

'copy the values
FOR rows = LBOUND(m, 1) TO UBOUND(m, 1)
FOR cols = LBOUND(m, 2) TO UBOUND(m, 2)
trans(cols, rows) = m(rows, cols)
NEXT cols
NEXT rows

'print the new matrix
FOR rows = LBOUND(trans, 1) TO UBOUND(trans, 1)
FOR cols = LBOUND(trans, 2) TO UBOUND(trans, 2)
PRINT trans(rows, cols);
NEXT cols
PRINT
NEXT rows
```

## BASIC256

`arraybase 1dim 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	printnext filaprint for fila = 1 to mtranspuesta[?,]    for columna = 1 to mtranspuesta[,?]		print mtranspuesta[fila, columna]; " ";    next columna	printnext filaend`

## BBC BASIC

`      INSTALL @lib\$+"ARRAYLIB"       DIM matrix(3,4), transpose(4,3)      matrix() = 78,19,30,12,36,49,10,65,42,50,30,93,24,78,10,39,68,27,64,29       PROC_transpose(matrix(), transpose())       FOR row% = 0 TO DIM(matrix(),1)        FOR col% = 0 TO DIM(matrix(),2)          PRINT ;matrix(row%,col%) " ";        NEXT        PRINT      NEXT row%       PRINT       FOR row% = 0 TO DIM(transpose(),1)        FOR col% = 0 TO DIM(transpose(),2)          PRINT ;transpose(row%,col%) " ";        NEXT        PRINT      NEXT row%`
Output:
```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
```

## Burlesque

` blsq ) {{78 19 30 12 36}{49 10 65 42 50}{30 93 24 78 10}{39 68 27 64 29}}tpsp78 49 30 3919 10 93 6830 65 24 2712 42 78 6436 50 10 29 `

## C

Transpose a 2D double array.

`#include <stdio.h> void transpose(void *dest, void *src, int src_h, int src_w){	int i, j;	double (*d)[src_h] = dest, (*s)[src_w] = src;	for (i = 0; i < src_h; i++)		for (j = 0; j < src_w; j++)			d[j][i] = s[i][j];} int main(){	int i, j;	double a = {{ 0, 1, 2, 3, 4 },			  { 5, 6, 7, 8, 9 },			  { 1, 0, 0, 0, 42}};	double b;	transpose(b, a, 3, 5); 	for (i = 0; i < 5; i++)		for (j = 0; j < 3; j++)			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 Wikipedia article for more information.

`#include <stdio.h> void transpose(double *m, int w, int h){	int start, next, i;	double tmp; 	for (start = 0; start <= w * h - 1; start++) {		next = start;		i = 0;		do {	i++;			next = (next % h) * w + next / h;		} while (next > start);		if (next < start || i == 1) continue; 		tmp = m[next = start];		do {			i = (next % h) * w + next / h;			m[next] = (i == start) ? tmp : m[i];			next = i;		} while (next > start);	}} void show_matrix(double *m, int w, int h){	int i, j;	for (i = 0; i < h; i++) {		for (j = 0; j < w; j++)			printf("%2g ", m[i * w + j]);		putchar('\n');	}} int main(void){	int i;	double m;	for (i = 0; i < 15; i++) m[i] = i + 1; 	puts("before transpose:");	show_matrix(m, 3, 5); 	transpose(m, 3, 5); 	puts("\nafter transpose:");	show_matrix(m, 5, 3); 	return 0;}`
Output:
```before transpose:
1  2  3
4  5  6
7  8  9
10 11 12
13 14 15

after transpose:
1  4  7 10 13
2  5  8 11 14
3  6  9 12 15 ```

## C#

`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;		}	}}`

## C++

C++ does not have a built-in or standard-library Matrix class, so many users have rolled their own. Boost supplies one (boost::numeric::ublas::matrix<element_t> in the example below). Many users have rolled their own matrix class; a (long) code sample below shows such a class.

Library: Boost.uBLAS
`#include <boost/numeric/ublas/matrix.hpp>#include <boost/numeric/ublas/io.hpp> int main(){  using namespace boost::numeric::ublas;   matrix<double> m(3,3);   for(int i=0; i!=m.size1(); ++i)    for(int j=0; j!=m.size2(); ++j)      m(i,j)=3*i+j;   std::cout << trans(m) << std::endl;}`
Output:
``` [3,3]((0,3,6),(1,4,7),(2,5,8))
```

### Generic solution

main.cpp
`#include <iostream>#include "matrix.h" #if !defined(ARRAY_SIZE)    #define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)))#endif template<class T>void printMatrix(const Matrix<T>& m) {    std::cout << "rows = " << m.rowNum() << "   columns = " << m.colNum() << std::endl;    for (unsigned int i = 0; i < m.rowNum(); i++) {        for (unsigned int j = 0; j < m.colNum(); j++) {            std::cout <<  m[i][j] << "  ";        }        std::cout << std::endl;    }} /* printMatrix() */ int main() {    int  am = {        {1,2,3},        {4,5,6},    };     Matrix<int> a(ARRAY_SIZE(am), ARRAY_SIZE(am), am, ARRAY_SIZE(am)*ARRAY_SIZE(am));     try {        std::cout << "Before transposition:" << std::endl;        printMatrix(a);        std::cout << std::endl;        a.transpose();        std::cout << "After transposition:" << std::endl;        printMatrix(a);    } catch (MatrixException& e) {        std::cerr << e.message() << std::endl;        return e.errorCode();    } } /* main() */`
matrix.h
`#ifndef _MATRIX_H#define	_MATRIX_H #include <sstream>#include <string>#include <vector>#include <algorithm> #define MATRIX_ERROR_CODE_COUNT 5#define MATRIX_ERR_UNDEFINED "1 Undefined exception!"#define MATRIX_ERR_WRONG_ROW_INDEX "2 The row index is out of range."#define MATRIX_ERR_MUL_ROW_AND_COL_NOT_EQUAL "3 The row number of second matrix must be equal with the column number of first matrix!"#define MATRIX_ERR_MUL_ROW_AND_COL_BE_GREATER_THAN_ZERO "4 The number of rows and columns must be greater than zero!"#define MATRIX_ERR_TOO_FEW_DATA "5 Too few data in matrix." class MatrixException {private:    std::string message_;    int errorCode_;public:    MatrixException(std::string message = MATRIX_ERR_UNDEFINED);     inline std::string message() {        return message_;    };     inline int errorCode() {        return errorCode_;    };}; MatrixException::MatrixException(std::string message) {    errorCode_ = MATRIX_ERROR_CODE_COUNT + 1;    std::stringstream ss(message);    ss >> errorCode_;    if (errorCode_ < 1) {        errorCode_ = MATRIX_ERROR_CODE_COUNT + 1;    }    std::string::size_type pos = message.find(' ');    if (errorCode_ <= MATRIX_ERROR_CODE_COUNT && pos != std::string::npos) {        message_ = message.substr(pos + 1);    } else {        message_ = message + " (This an unknown and unsupported exception!)";    }} /** * Generic class for matrices. */template <class T>class Matrix {private:    std::vector<T> v; // the data of matrix    unsigned int m;   // the number of rows    unsigned int n;   // the number of columnsprotected:     virtual void clear() {        v.clear();        m = n = 0;    }public:     Matrix() {        clear();    }    Matrix(unsigned int, unsigned int, T* = 0, unsigned int = 0);    Matrix(unsigned int, unsigned int, const std::vector<T>&);     virtual ~Matrix() {        clear();    }    Matrix& operator=(const Matrix&);    std::vector<T> operator[](unsigned int) const;    Matrix operator*(const Matrix&);    void transpose();     inline unsigned int rowNum() const {        return m;    }     inline unsigned int colNum() const {        return n;    }     inline unsigned int size() const {        return v.size();    }     inline void add(const T& t) {        v.push_back(t);    }}; template <class T>Matrix<T>::Matrix(unsigned int row, unsigned int col, T* data, unsigned int dataLength) {    clear();    if (row > 0 && col > 0) {        m = row;        n = col;        unsigned int mxn = m * n;        if (dataLength && data) {            for (unsigned int i = 0; i < dataLength && i < mxn; i++) {                v.push_back(data[i]);            }        }    }} template <class T>Matrix<T>::Matrix(unsigned int row, unsigned int col, const std::vector<T>& data) {    clear();    if (row > 0 && col > 0) {        m = row;        n = col;        unsigned int mxn = m * n;        if (data.size() > 0) {            for (unsigned int i = 0; i < mxn && i < data.size(); i++) {                v.push_back(data[i]);            }        }    }} template<class T>Matrix<T>& Matrix<T>::operator=(const Matrix<T>& other) {    clear();    if (other.m > 0 && other.n > 0) {        m = other.m;        n = other.n;        unsigned int mxn = m * n;        for (unsigned int i = 0; i < mxn && i < other.size(); i++) {            v.push_back(other.v[i]);        }    }    return *this;} template<class T>std::vector<T> Matrix<T>::operator[](unsigned int index) const {    std::vector<T> result;    if (index >= m) {        throw MatrixException(MATRIX_ERR_WRONG_ROW_INDEX);    } else if ((index + 1) * n > size()) {        throw MatrixException(MATRIX_ERR_TOO_FEW_DATA);    } else {        unsigned int begin = index * n;        unsigned int end = begin + n;        for (unsigned int i = begin; i < end; i++) {            result.push_back(v[i]);        }    }    return result;} template<class T>Matrix<T> Matrix<T>::operator*(const Matrix<T>& other) {    Matrix result(m, other.n);    if (n != other.m) {        throw MatrixException(MATRIX_ERR_MUL_ROW_AND_COL_NOT_EQUAL);    } else if (m <= 0 || n <= 0 || other.n <= 0) {        throw MatrixException(MATRIX_ERR_MUL_ROW_AND_COL_BE_GREATER_THAN_ZERO);    } else if (m * n > size() || other.m * other.n > other.size()) {        throw MatrixException(MATRIX_ERR_TOO_FEW_DATA);    } else {        for (unsigned int i = 0; i < m; i++) {            for (unsigned int j = 0; j < other.n; j++) {                T temp = v[i * n] * other.v[j];                for (unsigned int k = 1; k < n; k++) {                    temp += v[i * n + k] * other.v[k * other.n + j];                }                result.v.push_back(temp);            }        }    }    return result;} template<class T>void Matrix<T>::transpose() {    if (m * n > size()) {        throw MatrixException(MATRIX_ERR_TOO_FEW_DATA);    } else {        std::vector<T> v2;        std::swap(v, v2);        for (unsigned int i = 0; i < n; i++) {            for (unsigned int j = 0; j < m; j++) {                v.push_back(v2[j * n + i]);            }        }        std::swap(m, n);    }} #endif	/* _MATRIX_H */`
Output:
```Before transposition:
rows = 2   columns = 3
1  2  3
4  5  6

After transposition:
rows = 3   columns = 2
1  4
2  5
3  6```

### Easy Mode

`#include <iostream> int main(){    const int l = 5;    const int w = 3;    int m1[l][w] = {{1,2,3}, {4,5,6}, {7,8,9}, {10,11,12}, {13,14,15}};    int m2[w][l];     for(int i=0; i<w; i++){        for(int x=0; x<l; x++){            m2[i][x]=m1[x][i];        }    }     // This is just output...     std::cout << "Before:";    for(int i=0; i<l; i++){        std::cout << std::endl;        for(int x=0; x<w; x++){            std::cout << m1[i][x] << " ";        }    }     std::cout << "\n\nAfter:";    for(int i=0; i<w; i++){        std::cout << std::endl;        for(int x=0; x<l; x++){            std::cout << m2[i][x] << " ";        }    }     std::cout << std::endl;     return 0;}`
Output:
```Before:
1 2 3
4 5 6
7 8 9
10 11 12
13 14 15

After:
1 4 7 10 13
2 5 8 11 14
3 6 9 12 15
```

## Clojure

`(defmulti matrix-transpose  "Switch rows with columns."  class) (defmethod matrix-transpose clojure.lang.PersistentList  [mtx]  (apply map list mtx)) (defmethod matrix-transpose clojure.lang.PersistentVector  [mtx]  (apply mapv vector mtx)) `
Output:
```=> (matrix-transpose [[1 2 3] [4 5 6]])
[[1 4] [2 5] [3 6]]```

## CoffeeScript

`transpose = (matrix) ->    (t[i] for t in matrix) for i in [0...matrix.length]`
Output:
```> transpose [[1,2,3],[4,5,6]]

[[1,4],[2,5],[3,6]]
```

## Common Lisp

If the matrix is given as a list:

`(defun transpose (m)  (apply #'mapcar #'list m))`

If the matrix A is given as a 2D array:

`;; Transpose a mxn matrix A to a nxm matrix B=A'.(defun mtp (A)  (let* ((m (array-dimension A 0))         (n (array-dimension A 1))         (B (make-array `(,n ,m) :initial-element 0)))    (loop for i from 0 below m do          (loop for j from 0 below n do                (setf (aref B j i)                      (aref A i j))))    B))`

## D

### Standard Version

`void main() {    import std.stdio, std.range;     /*immutable*/ auto M = [[10, 11, 12, 13],                            [14, 15, 16, 17],                            [18, 19, 20, 21]];    writefln("%(%(%2d %)\n%)", M.transposed);}`
Output:
```10 14 18
11 15 19
12 16 20
13 17 21```

### Locally Procedural Style

`T[][] transpose(T)(in T[][] m) pure nothrow {    auto r = new typeof(return)(m.length, m.length);    foreach (immutable nr, const row; m)        foreach (immutable nc, immutable c; row)            r[nc][nr] = c;    return r;} void main() {    import std.stdio;     immutable M = [[10, 11, 12, 13],                   [14, 15, 16, 17],                   [18, 19, 20, 21]];    writefln("%(%(%2d %)\n%)", M.transpose);}`

Same output.

### Functional Style

`import std.stdio, std.algorithm, std.range, std.functional; auto transpose(T)(in T[][] m) pure nothrow {    return m.length.iota.map!(curry!(transversal, m));} void main() {    immutable M = [[10, 11, 12, 13],                   [14, 15, 16, 17],                   [18, 19, 20, 21]];    writefln("%(%(%2d %)\n%)", M.transpose);}`

Same output.

See #Pascal;

## EchoLisp

` (lib 'matrix) (define M (list->array (iota 6) 3 2))(array-print M)  0   1   2   3   4   5 (array-print (matrix-transpose M))  0   2   4   1   3   5  `

## 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

`   [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  [email protected]         [set up return to caller]             A13F  [email protected]  [email protected]  [initialize T order for storing transpose]             A12F  [email protected]  [email protected]  [initialize A order for loading original]             [email protected]              [also save as A order for top of current column]             S10 F             [negative of width]         [email protected]              [initialize negative counter]             S11 F             [negative of height]         [email protected]              [initialize negative counter]         AF                [maunfactured order; load matrix element]         TF                [maunfactured order; store matrix element]             [email protected]  A2F  [email protected]   [update address in T order]             [email protected]  A10F  [email protected]  [update address in A order]             [email protected]  A2F  [email protected]   [inner loop till finished this column]             [email protected]  A2F  [email protected]  [email protected]  [update address for start of column]             [email protected]  A2F  [email protected]   [outer loop till finished all columns]         ZF  [exit]         AF  [added to an address to make A order for that address]         TF  [added to an address to make T order for that address]         PF  [negative counter for rows]         PF  [negative counter for columns]         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    [email protected]@[email protected]@[email protected]@[email protected]@[email protected]    GN  [call library subroutine P1]    [email protected]@[email protected]@[email protected]@[email protected]@[email protected]&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   [email protected]@[email protected]@[email protected]@[email protected]@EFU3FJFM1F    [Main routine]             PK T300K GK      [Constants]          #F     [figures shift on teleprinter]          @F     [carriage return]          &F     [line feed]          P3F    [number of columns (in address field)]          P5F    [number of rows (in address field)]          P400F  [address of matrix]          P500F  [address of transposed matrix]          P2F    [number of decimals when printing matrix]          TF     [add to address to make T order]          P328F  [0.0100097...., matrix elements are multiples of this]      [Variables]         PF     [matrix element, initialized to 0.00]         PF     [negative counter]            [Enter with acc = 0]         [email protected]     [set figures mode on teleprinter]             [email protected]    [address of matrix]             [email protected]    [make T order to store first elememt]             [email protected]   [plant in code]             [email protected]  [email protected]  L64F  L32F  [acc := negative number of entries]         [email protected]   [initialize negative counter]             [email protected]  [email protected]  [email protected]  [increment matrix element]         TF               [store in matrix]             [email protected]  A2F  [email protected]  [inc store address]             [email protected]  A2F  [email protected]  [inc negative counter, loop till zero]            [Matrix is set up, now print it]             [email protected]  T10F  [10F := width]             [email protected]  T11F  [11F := height]             A5@  T12F  [12F := address of matrix]             [email protected]  T13F  [13F := number of decimals]         [email protected]  GM   [call print subroutine]             [email protected]  [email protected]   [add CR LF]            [Transpose matrix: 10F, 11F, 12F stay the same]             [email protected]  T13F  [13F := address of transpose]         [email protected]  GX   [call transpose routine]            [Print transpose]             A10F  TF  A11F  T10F  AF  T11F  [swap width and height]             A13F  T12F [12F := address of transpose]             [email protected]  T13F  [13F := number of decimals]         [email protected]  GM   [call print subroutine]              [email protected]    [figures mode, dummy to flush teleprinter buffer]             ZF    [stop]             E12Z  [enter at 12 (relative)]             PF    [accumulator = 0 on entry] `
Output:
``` .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
```

### Transpose in place

Translation of: 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.

` [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  [email protected]               [set up return to caller]           H10F  V11F  L32F  L64F  [acc := size of matrix as width*height]           [email protected]  [email protected]              [store size; C variable start := 0]        TF  [email protected]  [email protected]  [email protected]    [set C variables, next := start, i := 0]       TF  [email protected]  A2F  [email protected]     [i++]           [email protected]  [email protected]              [call subroutine to update "next"]           [email protected]  [email protected]  [email protected]        [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  [email protected]               [subtract 1 from acc, skip if still >= 0]           S2F  [email protected]  [email protected]         [acc := -2 + i, skip if < 0]      [The assignment next := start in the C program is unnecessary]           TF  [email protected]  A12F  [email protected]  [email protected]  [make and plant order to load m{next}]       AF  [email protected]                [tmp := m{next}]       TF  [clear acc; also added to an address to make T order for that address]       [email protected]  A12F  [email protected]  [email protected]  [make and plant order to store m{next}]           [email protected]  [email protected]              [call subroutine to update "next"]           [email protected]  [email protected]  [email protected]        [go to 48 if i < start]           S2F   [email protected]              [go to 48 if i > start]           TF  [email protected]  [email protected]          [make order to load tmp, and go to 52]       TF  [email protected]  A12F  [email protected]    [make order to load m{next}]       [email protected]                    [plant order to load tmp or m{next}]       AF  [manufactured order; if i = start loads tmp, else loads m{next}]       TF  [manufactured order; stores m{next}, using old value of "next"]           [email protected]  [email protected]  [email protected]        [acc := start - next, loop back if < 0]       TF  [email protected]  A2F  [email protected]     [start++]           [email protected]  [email protected]               [loop until start = size]       ZF                      [overwritten by return to caller]    [Subroutine to execute next = (next % h) * w + next / h in C program]       A3F  [email protected]               [set up return to caller]           [email protected]  T4F  A11F  T5F    [set up parameters to divide "next" by "h"]           [email protected]  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  [email protected]  [compute RHS and store in "next"]       ZF                      [overwritten by return to caller]    [Constants]       AF    [added to an address to make A order for that address]       [email protected]  [order to load C variable "tmp"]    [Variables; integers are stored in the address field for convenience.]       PF    [C variable "tmp" (holds value of a matrix element)]       PF    [size of matrix, width*height]       PF    [C variable "start"]       PF    [C variable "next"]       PF    [C variable "i"]  [Subroutine to print a matrix of 17-bit real numbers.]     E25K  TM     [email protected]@[email protected]@[email protected]@[email protected]@[email protected]     GN     [email protected]@[email protected]@[email protected]@[email protected]@[email protected]&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    [email protected]@[email protected]@[email protected]@[email protected]@EFU3FJFM1F  [Integer division: number at 4F, divisor at 5F Returns remainder at 4F, quotient at 5F Working location 0D.  37 locations.]    E25K T&    [email protected]@[email protected]@T1FA35[email protected]@[email protected]@    [email protected]@[email protected]@[email protected]@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#[email protected]&[email protected]@[email protected]@[email protected]@L64FL32F  [email protected]@[email protected]@[email protected]@[email protected]@[email protected]@[email protected]@T13F  [email protected]@[email protected]@[email protected]@ZFE11ZPF `
Output:
``` .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
```

## Elixir

`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)`
Output:
```[[1, 2, 3, 4, 5], [1, 4, 9, 16, 25], [1, 8, 27, 64, 125], [1, 16, 81, 256, 625]]
```

## ELLA

Code for matrix transpose hardware design verification:
`MAC TRANSPOSE = ([INT n][INT m]TYPE t: matrix) -> [m][n]t:  [INT i = 1..m] [INT j = 1..n] matrix[j][i].`

## Emacs Lisp

Library: cl-lib
`(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)))`
Output:
```((2 3 9)
(3 5 9)
(4 6 9)
(5 9 9))
```

## Erlang

A nice introduction http://langintro.com/erlang/article2/ which is much more explicit.

` -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([]) -> [].                                                               `
Output:
```

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]]
```

## Euphoria

`function transpose(sequence in)    sequence out    out = repeat(repeat(0,length(in)),length(in))    for n = 1 to length(in) do        for m = 1 to length(in) do            out[m][n] = in[n][m]        end for    end for    return outend function sequence mm = {  {1,2,3,4},  {5,6,7,8},  {9,10,11,12}} ? transpose(m)`
Output:
``` {
{1,5,9},
{2,6,10},
{3,7,11},
{4,8,12}
}```

## Excel

Excel has a built-in TRANSPOSE function:

 =TRANSPOSE(F2#) fx A B C D E F G H I 1 Transposed Source matrix 2 1 5 9 1 2 3 4 3 2 6 10 5 6 7 8 4 3 7 11 9 10 11 12 5 4 8 12

## F#

Very straightforward solution...

`let transpose (mtx : _ [,]) = Array2D.init (mtx.GetLength 1) (mtx.GetLength 0) (fun x y -> mtx.[y,x])`

## Factor

`flip` can be used.

`( scratchpad ) { { 1 2 3 } { 4 5 6 } } flip . { { 1 4 } { 2 5 } { 3 6 } }`

## Fermat

Matrix transpose is built in.

` Array a[3,1][a]:=[(1,2,3)][b]:=Trans([a])[a][b] `
Output:
```[[  1, `
2, `
3   ]]

[[  1,  2,  3  ]]```

## Forth

Works with: gforth version 0.7.9_20170308
`S" fsl-util.fs" REQUIREDS" fsl/dynmem.seq" REQUIRED: F+! ( addr -- ) ( F: r -- )  DUP [email protected] 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{{ }}fputfloat dmatrix b{{ a{{ 5 3 & b{{ transpose3 5 b{{ }}fprint`

## Fortran

In ISO Fortran 90 or later, use the TRANSPOSE intrinsic function:

`integer, parameter   :: n = 3, m = 5real, dimension(n,m) :: a = reshape( (/ (i,i=1,n*m) /), (/ n, m /) )real, dimension(m,n) :: b b = transpose(a) do i = 1, n    print *, a(i,:)end do 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:

`REAL A(3,5), B(5,3)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/ DO I = 1, 3   DO J = 1, 5      B(J,I) = A(I,J)   END DOEND DO`

In ANSI FORTRAN 66 or later, use nested labeled DO loops:

`   REAL A(3,5), B(5,3)   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/    DO 10 I = 1, 3      DO 20 J = 1, 5         B(J,I) = A(I,J)20    CONTINUE10 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 `((A(row,col),row=1,3),col=1,5)` which could therefore be replaced with just `A`, however one could use `((A(row,col),col=1,5),row=1,3)` instead and the DATA values could be arranged so as to appear in the same layout as one expects for a matrix. Consider
`      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`

Output:

``` 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```

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.

## 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    PrintNext filaPrint For fila = Lbound(mtranspuesta,1) To Ubound(mtranspuesta,1)    For columna = Lbound(mtranspuesta,2) To Ubound(mtranspuesta,2)        Print ; mtranspuesta(fila,columna); " ";    Next columna    PrintNext filaSleep`
Output:
``` 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
```

## Frink

The built-in array method `transpose` transposes a 2-dimensional array.

` a = [[1,2,3],     [4,5,6],     [7,8,9]]join["\n",a.transpose[]] `

## Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website, However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.

## GAP

`originalMatrix := [[1, 1, 1, 1],                   [2, 4, 8, 16],                   [3, 9, 27, 81],                   [4, 16, 64, 256],                   [5, 25, 125, 625]];transposedMatrix := TransposedMat(originalMatrix);`

## Go

### Library gonum/mat

`package main import (    "fmt"     "gonum.org/v1/gonum/mat") func main() {    m := mat.NewDense(2, 3, []float64{        1, 2, 3,        4, 5, 6,    })    fmt.Println(mat.Formatted(m))    fmt.Println()    fmt.Println(mat.Formatted(m.T()))}`
Output:
```⎡1  2  3⎤
⎣4  5  6⎦

⎡1  4⎤
⎢2  5⎥
⎣3  6⎦
```

### Library go.matrix

`package main import (    "fmt"     mat "github.com/skelterjohn/go.matrix") func main() {    m := mat.MakeDenseMatrixStacked([][]float64{        {1, 2, 3},        {4, 5, 6},    })    fmt.Println("original:")    fmt.Println(m)    m = m.Transpose()    fmt.Println("transpose:")    fmt.Println(m)}`
Output:
```original:
{1, 2, 3,
4, 5, 6}
transpose:
{1, 4,
2, 5,
3, 6}
```

### 2D representation

Go arrays and slices are only one-dimensional. The obvious way to represent two-dimensional arrays is with a slice of slices:

`package main import "fmt" type row []float64type matrix []row 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))    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}`
Output:
```[1 2 3]
[4 5 6]
[1 4]
[2 5]
[3 6]```

### 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.

`package main import "fmt" type matrix struct {    ele    []float64    stride int} // construct new matrix from slice of slicesfunc matrixFromRows(rows [][]float64) *matrix {    if len(rows) == 0 {        return &matrix{nil, 0}    }    m := &matrix{make([]float64, len(rows)*len(rows)), len(rows)}    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}`
Output:
```original:
[1 2 3]
[4 5 6]

transpose:
[1 4]
[2 5]
[3 6]
```

### Transpose in place

Translation of: C

Note representation is "flat," as above, but without the fluff of constructing from rows.

`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}`

Output same as above.

## Groovy

The Groovy extensions to the List class provides a transpose method:

`def matrix = [ [ 1, 2, 3, 4 ],               [ 5, 6, 7, 8 ] ] matrix.each { println it }println()def transpose = matrix.transpose() transpose.each { println it }`
Output:
```[1, 2, 3, 4]
[5, 6, 7, 8]

[1, 5]
[2, 6]
[3, 7]
[4, 8]```

For matrices represented as lists, there's transpose:

`*Main> transpose [[1,2],[3,4],[5,6]][[1,3,5],[2,4,6]]`

For matrices in arrays, one can use ixmap:

`import Data.Array swap (x,y) = (y,x) transpArray :: (Ix a, Ix b) => Array (a,b) e -> Array (b,a) etranspArray a = ixmap (swap l, swap u) swap a where   (l,u) = bounds a`

Using zipWith assuming a matrix is a list of row lists:

` tpose [ms] = [[m] | m <- ms]tpose (ms:mss) = zipWith (:) ms (tpose mss) `
Output:
```tpose [[1,2,3],[4,5,6],[7,8,9]]
[[1,4,7],[2,5,8],[3,6,9]]
```

### With Numeric.LinearAlgebra

`import Numeric.LinearAlgebra a :: Matrix Ia = (3><2)   [1,2  ,3,4  ,5,6] main = do  print \$ a  print \$ tr a`
Output:
```(3><2)
[ 1, 2
, 3, 4
, 5, 6 ]
(2><3)
[ 1, 3, 5
, 2, 4, 6 ]```

## 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.length)                      [ for (j in 0...m.length) 0 ] ];        for(i in 0...m.length)            for(j in 0...m.length)                t[j][i] = m[i][j];         for(aa in [m, t])            for(a in aa) Sys.println(a);    }}`
Output:
```[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]```

## HicEst

`REAL :: mtx(2, 4) mtx = 1.1 * \$WRITE() mtx SOLVE(Matrix=mtx, Transpose=mtx)WRITE() mtx`
Output:
```1.1 2.2 3.3 4.4
5.5 6.6 7.7 8.8

1.1 5.5
2.2 6.6
3.3 7.7
4.4 8.8 ```

## Hope

`uses lists;dec transpose : list (list alpha) -> list (list alpha);--- transpose ([]::_) <= [];--- transpose n <= map head n :: transpose (map tail n);`

## Icon and Unicon

`procedure transpose_matrix (matrix)  result := []  # for each column  every (i := 1 to *matrix) do {    col := []    # extract the number in each row for that column    every (row := !matrix) do put (col, row[i])     # and push that column as a row in the result matrix    put (result, col)  }  return resultend procedure print_matrix (matrix)  every (row := !matrix) do {    every writes (!row || " ")    write ()  }end procedure main ()  matrix := [[1,2,3],[4,5,6]]  write ("Start:")  print_matrix (matrix)  transposed := transpose_matrix (matrix)  write ("Transposed:")  print_matrix (transposed)end`
Output:
```Start:
1 2 3
4 5 6
Transposed:
1 4
2 5
3 6
```

## IDL

Standard IDL function transpose()

`m=[[1,1,1,1],[2, 4, 8, 16],[3, 9,27, 81],[5, 25,125, 625]]print,transpose(m)`

## Idris

`Idris> transpose [[1,2],[3,4],[5,6]][[1, 3, 5], [2, 4, 6]] : List (List Integer)`

## J

Solution:
Transpose is the monadic primary verb `|:`

Example:

`   ]matrix=: (^/ }:) >:i.5    NB. make and show example matrix1  1   1   12  4   8  163  9  27  814 16  64 2565 25 125 625   |: matrix1  2  3   4   51  4  9  16  251  8 27  64 1251 16 81 256 625`

As an aside, note that `.` and `:` 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 diacritics in many languages. (If you want to use ` :` or `.` as tokens by themselves you must precede them with a space - beware though that wiki rendering software may sometimes elide the preceding space in <code> .</code> contexts.)

## Java

`import java.util.Arrays;public class Transpose{       public static void main(String[] args){               double[][] m = {{1, 1, 1, 1},                               {2, 4, 8, 16},                               {3, 9, 27, 81},                               {4, 16, 64, 256},                               {5, 25, 125, 625}};               double[][] ans = new double[m.length][m.length];               for(int rows = 0; rows < m.length; rows++){                       for(int cols = 0; cols < m.length; cols++){                               ans[cols][rows] = m[rows][cols];                       }               }               for(double[] i:ans){//2D arrays are arrays of arrays                       System.out.println(Arrays.toString(i));               }       }}`

## JavaScript

### ES5

Works with: SpiderMonkey
for the `print()` function
`function Matrix(ary) {    this.mtx = ary    this.height = ary.length;    this.width = ary.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 new matrixMatrix.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);} var m = new Matrix([[1,1,1,1],[2,4,8,16],[3,9,27,81],[4,16,64,256],[5,25,125,625]]);print(m);print();print(m.transpose());`

produces

```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```

Or, as a functional expression (rather than an imperative procedure):

` (function () {    'use strict';     function transpose(lst) {        return lst.map(function (_, iCol) {            return lst.map(function (row) {                return row[iCol];            })        });    }     return transpose(        [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]    ); })(); `
Output:
`[[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]`

### ES6

`(() => {    "use strict";     // transpose :: [[a]] -> [[a]]    const transpose = xs =>        0 < xs.length ? (            xs.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();})();`
Output:
`[[1,4,7],[2,5,8],[3,6,9]]`

## Joy

For matrices represented as lists, there's transpose, defined in seqlib like this:

`DEFINE transpose == [ [null] [true] [[null] some] ifte ]                    [ pop [] ]                    [ [[first] map] [[rest] map] cleave ]                    [ cons ]                    linrec .`

## jq

Works with: jq version 1.4

Recent versions of jq include a more general "transpose" that can be used to transpose jagged matrices.

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.

`def transpose:  if (. | length) == 0 then []  else [map(.)] + (map(.[1:]) | transpose)  end ;`

Examples

```[[], []] | transpose
# => []
```
```[, ] | transpose
# => 1,3
```
```[[1,2], [3,4]] | transpose
# => [[1,3],[2,4]]
```

## Jsish

From the Javascript Matrix entries.

First a module, shared by the Transposition, Multiplication and Exponentiation tasks.

`/* Matrix transposition, multiplication, identity, and exponentiation, in Jsish */function Matrix(ary) {    this.mtx = ary;    this.height = ary.length;    this.width = ary.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 matrixMatrix.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 othersMatrix.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 Matrixfunction 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 functionMatrix.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');`

Then a unitTest of the transposition.

`/* 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!=*/`
Output:
```prompt\$ jsish -u matrixTranspose.jsi
[PASS] matrixTranspose.jsi```

## Julia

The transposition is obtained by quoting the matrix.

`julia> [1 2 3 ; 4 5 6]  # a 2x3 matrix2x3 Array{Int64,2}: 1  2  3 4  5  6 julia> [1 2 3 ; 4 5 6]'  # note the quote3x2 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}.

## K

Transpose is the monadic verb `+`

`  {x^\:-1_ x}1+!:5(1 1 1 1.0 2 4 8 16.0 3 9 27 81.0 4 16 64 256.0 5 25 125 625.0)   +{x^\:-1_ x}1+!:5(1 2 3 4 5.0 1 4 9 16 25.0 1 8 27 64 125.0 1 16 81 256 625.0)`

## Klong

Transpose is the monadic verb `+`

`    [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]]`

## Kotlin

`// version 1.1.3 typealias Vector = DoubleArraytypealias Matrix = Array<Vector> fun Matrix.transpose(): Matrix {    val rows = this.size    val cols = this.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 versiontypealias Matrix<T> = List<List<T>>fun <T> Matrix<T>.transpose(): Matrix<T> {    return (0 until this.size).map { x ->        (this.indices).map { y ->            this[y][x]        }    }}`

## Lang5

`12 iota [3 4] reshape 1 + dup .1 transpose .`
Output:
```[
[    1     2     3     4  ]
[    5     6     7     8  ]
[    9    10    11    12  ]
][
[    1     5     9  ]
[    2     6    10  ]
[    3     7    11  ]
[    4     8    12  ]
]```

## LFE

` (defun transpose (matrix)  (transpose matrix '())) (defun transpose (matrix acc)  (cond    ((lists:any        (lambda (x) (== x '()))        matrix)     acc)    ('true      (let ((heads (lists:map #'car/1 matrix))            (tails (lists:map #'cdr/1 matrix)))        (transpose tails (++ acc `(,heads))))))) `

Usage in the LFE REPL:

` > (transpose '((1  2  3)               (4  5  6)               (7  8  9)               (10 11 12)               (13 14 15)               (16 17 18)))((1 4 7 10 13 16) (2 5 8 11 14 17) (3 6 9 12 15 18))> `

## 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.

`MatrixC\$ ="4, 3,          0, 0.10, 0.20, 0.30,       0.40, 0.50, 0.60, 0.70,      0.80, 0.90, 1.00, 1.10" print "Transpose of matrix"call DisplayMatrix MatrixC\$print "         ="MatrixT\$ =MatrixTranspose\$( MatrixC\$)call DisplayMatrix MatrixT\$`
Output:
```Transpose of matrix
| 0.00000 0.10000 0.20000 0.30000 |
| 0.40000 0.50000 0.60000 0.70000 |
| 0.80000 0.90000 1.00000 1.10000 |

=
| 0.00000 0.40000 0.80000 |
| 0.10000 0.50000 0.90000 |
| 0.20000 0.60000 1.00000 |
| 0.30000 0.70000 1.10000 |```

## Lua

`function Transpose( m )    local res = {}     for i = 1, #m do        res[i] = {}        for j = 1, #m do            res[i][j] = m[j][i]        end    end     return resend -- a test for Transpose(m)mat = { { 1, 2, 3 }, { 4, 5, 6 } }erg = Transpose( mat )for i = 1, #erg do    for j = 1, #erg do        io.write( erg[i][j] )        io.write( "  " )    end    io.write( "\n" )end`

Using apply map list

`function map(f, a)  local b = {}  for k,v in ipairs(a) do b[k] = f(v) end  return bend function mapn(f, ...)  local c = {}  local k = 1  local aarg = {...}  local n = #aarg  while true do    local a = map(function(b) return b[k] end, aarg)    if #a < n then return c end    c[k] = f(unpack(a))    k = k + 1  endend function apply(f1, f2, a) return f1(f2, unpack(a))end xy = {{1,2,3,4},{1,2,3,4},{1,2,3,4}}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

## Maple

The `Transpose` function in Maple's `LinearAlgebra` package computes this. The computation can also be accomplished by raising the Matrix to the `%T` power. Similarly for `HermitianTranspose` and the `%H` power.

` M := <<2,3>|<3,4>|<5,6>>; M^%T; with(LinearAlgebra):Transpose(M); `
Output:
```                                    [2  3  5]
M := [       ]
[3  4  6]

[2  3]
[    ]
[3  4]
[    ]
[5  6]

[2  3]
[    ]
[3  4]
[    ]
[5  6]
```

## Mathematica/Wolfram Language

`originalMatrix = {{1, 1, 1, 1},                  {2, 4, 8, 16},                  {3, 9, 27, 81},                  {4, 16, 64, 256},                  {5, 25, 125, 625}}transposedMatrix = Transpose[originalMatrix]`

## MATLAB

Matlab contains two built-in methods of transposing a matrix: by using the `transpose()` function, or by using the `.'` operator. The `'` operator yields the complex conjugate transpose.

`>> transpose([1 2;3 4]) ans =      1     3     2     4 >> [1 2;3 4].' ans =      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:

`  B=size(A);   %In this code, we assume that a previous matrix "A" has already been inputted.for j=1:B(1)    for i=1:B(2)        C(i,j)=A(j,i);    end      %The transposed A-matrix should be C end  `

Transposing nested cells using apply map list

`xy = {{1,2,3,4},{1,2,3,4},{1,2,3,4}}yx = feval(@(x) cellfun(@(varargin)[varargin],x{:},'un',0), xy)`

## Maxima

`originalMatrix : matrix([1, 1, 1, 1],                        [2, 4, 8, 16],                        [3, 9, 27, 81],                        [4, 16, 64, 256],                        [5, 25, 125, 625]);transposedMatrix : transpose(originalMatrix);`

## MAXScript

Uses the built in transpose() function

`m = bigMatrix 5 4for i in 1 to 5 do for j in 1 to 4 do m[i][j] = pow i jm = transpose m`

## Nial

make an array

`|a := 2 3 reshape count 6=1 2 3=4 5 6`

transpose it

`|transpose a=1 4=2 5=3 6`

## Nim

For statically sized arrays:

`proc transpose[X, Y; T](s: array[Y, array[X, T]]): array[X, array[Y, T]] =  for i in low(X)..high(X):    for j in low(Y)..high(Y):      result[i][j] = s[j][i] let b = [[ 0, 1, 2, 3, 4],         [ 5, 6, 7, 8, 9],         [ 1, 0, 0, 0,42]]let c = transpose(b)for r in c:  for i in r:    stdout.write i, " "  echo ""`
Output:
``` 0  5  1
1  6  0
2  7  0
3  8  0
4  9 42 ```

For dynamically sized seqs:

`proc transpose[T](s: seq[seq[T]]): seq[seq[T]] =  result = newSeq[seq[T]](s.len)  for i in 0 .. s.high:    result[i] = newSeq[T](s.len)    for j in 0 .. s.high:      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)`
Output:
`@[@[0, 5, 1], @[1, 6, 0], @[2, 7, 0], @[3, 8, 0], @[4, 9, 42]]`

## Objeck

` bundle Default {  class Transpose {    function : Main(args : String[]) ~ Nil {      input := [[1, 1, 1, 1]        [2, 4, 8, 16]        [3, 9, 27, 81]        [4, 16, 64, 256]        [5, 25, 125, 625]];      dim := input->Size();       output := Int->New[dim,dim];      for(i := 0; i < dim; i+=1;) {        for(j := 0; j < dim; j+=1;) {          output[i,j] := input[i,j];        };      };       Print(output);    }     function : Print(matrix : Int[,]) ~ Nil {      dim := matrix->Size();      for(i := 0; i < dim; i+=1;) {        for(j := 0; j < dim; j+=1;) {          IO.Console->Print(matrix[i,j])->Print('\t');        };        '\n'->Print();      };    }  }} `
Output:
```1	2	3	4	5
1	4	9	16	25
1	8	27	64	125
1	16	81	256	625
```

## OCaml

Matrices can be represented in OCaml as a type 'a array array, or using the module Bigarray. The implementation below uses a bigarray:

`open Bigarray let transpose b =  let dim1 = Array2.dim1 b  and dim2 = Array2.dim2 b in  let kind = Array2.kind b  and layout = Array2.layout b in  let b' = Array2.create kind layout dim2 dim1 in  for i=0 to pred dim1 do    for j=0 to pred dim2 do      b'.{j,i} <- b.{i,j}    done;  done;  (b');; let array2_display print newline b =  for i=0 to Array2.dim1 b - 1 do    for j=0 to Array2.dim2 b - 1 do      print b.{i,j}    done;    newline();  done;;; let a = Array2.of_array int c_layout [|  [| 1; 2; 3; 4 |];  [| 5; 6; 7; 8 |];|] array2_display (Printf.printf " %d") print_newline (transpose a) ;;`
Output:
``` 1 5
2 6
3 7
4 8
```

A version for lists:

`let rec transpose m =  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];
[5;6;7;8]];;
- : int list list = [[1; 5]; [2; 6]; [3; 7]; [4; 8]]
```

## Octave

`a = [ 1, 1, 1, 1 ;      2, 4, 8, 16 ;      3, 9, 27, 81 ;      4, 16, 64, 256 ;      5, 25, 125, 625 ];tranposed = a.'; % tranposectransp = a'; % conjugate transpose`

## OxygenBasic

` function Transpose(double *A,*B, sys nx,ny)'==========================================  sys x,y  indexbase 0  for x=0 to <nx    for y=0 to <ny      B[y*nx+x]=A[x*ny+y]    next  nextend function function MatrixShow(double*A, sys nx,ny) as string'=================================================  sys x,y  indexbase 0  string pr="",tab=chr(9),cr=chr(13)+chr(10)  for y=0 to <ny    for x=0 to <nx      pr+=tab A[x*ny+y]    next    pr+=cr  next  return prend function '===='DEMO'==== double A[5*4],B[4*5]'columns x'rows    y A <= 'y minor, x major11,12,13,14,15,21,22,23,24,25,31,32,33,34,35,41,42,43,44,45 print MatrixShow A,5,4Transpose        A,B,5,4print MatrixShow B,4,5 `

## PARI/GP

The GP function for matrix (or vector) transpose is `mattranspose`, but it is usually invoked with a tilde:

`M~`

In PARI the function is

`gtrans(M)`

though `shallowtrans` is also available when deep copying is not desired.

## Pascal

`Program Transpose; const  A: array[1..3,1..5] of integer = (( 1,  2,  3,  4,  5),                                     ( 6,  7,  8,  9, 10),				    (11, 12, 13, 14, 15)				   );var  B: array[1..5,1..3] of integer;  i, j: integer; begin  for i := low(A) to high(A) do    for j := low(A) to high(A) do      B[j,i] := A[i,j];   writeln ('A:');  for i := low(A) to high(A) do  begin    for j := low(A) to high(A) do      write (A[i,j]:3);    writeln;  end;   writeln ('B:');  for i := low(B) to high(B) do  begin    for j := low(B) to high(B) do      write (B[i,j]:3);    writeln;  end;end.`
Output:
```% ./Transpose
A:
1  2  3  4  5
6  7  8  9 10
11 12 13 14 15
B:
1  6 11
2  7 12
3  8 13
4  9 14
5 10 15
```

## Perl

`use Math::Matrix; \$m = Math::Matrix->new(  [1, 1, 1, 1],  [2, 4, 8, 16],  [3, 9, 27, 81],  [4, 16, 64, 256],  [5, 25, 125, 625],); \$m->transpose->print;`
Output:
``` 1.00000    2.00000    3.00000    4.00000    5.00000
1.00000    4.00000    9.00000   16.00000   25.00000
1.00000    8.00000   27.00000   64.00000  125.00000
1.00000   16.00000   81.00000  256.00000  625.00000
```

Manually:

`my @m = (  [1, 1, 1, 1],  [2, 4, 8, 16],  [3, 9, 27, 81],  [4, 16, 64, 256],  [5, 25, 125, 625],); my @transposed;foreach my \$j (0..\$#{\$m}) {  push(@transposed, [map \$_->[\$j], @m]);}`

## Phix

```with javascript_semantics
function matrix_transpose(sequence mat)
integer rows = length(mat),
cols = length(mat)
sequence res = repeat(repeat(0,rows),cols)
for r=1 to rows do
for c=1 to cols do
res[c][r] = mat[r][c]
end for
end for
return res
end function
```

## PHP

#### Up to PHP version 5.6

` 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, 1);   // array_map(NULL, m, m, ..)  array_unshift(\$m, NULL); // the original matrix is not modified because it was passed by value  return call_user_func_array('array_map', \$m);}`

#### Starting with PHP 5.6

`  function transpose(\$m) {     return count(\$m) == 0 ? \$m : (count(\$m) == 1 ? array_chunk(\$m, 1) : array_map(null, ...\$m)); } `

## Picat

Picat has a built-in function `transpose/1` (in the `util` module).

`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.`
Output:
```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]```

## PicoLisp

`(de matTrans (Mat)   (apply mapcar Mat list) ) (matTrans '((1 2 3) (4 5 6)))`
Output:
`-> ((1 4) (2 5) (3 6))`

## PL/I

`/* The short method: */declare A(m, n) float, B (n,m) float defined (A(2sub, 1sub));/* Any reference to B gives the transpose of matrix A. */`

`/* Transpose matrix A, result at B. */transpose: procedure (a, b);   declare (a, b) (*,*) float controlled;   declare (m, n) fixed binary;    if allocation(b) > 0 then free b;    m = hbound(a,1); n = hbound(a,2);    allocate b(n,m);    do i = 1 to m;      b(*,i) = a(i,*);   end;end transpose;`

## Pop11

`define transpose(m) -> res;    lvars bl = boundslist(m);    if length(bl) /= 4 then        throw([need_2d_array ^a])    endif;    lvars i, i0 = bl(1), i1 = bl(2);    lvars j, j0 = bl(3), j1 = bl(4);    newarray([^j0 ^j1 ^i0 ^i1], 0) -> res;    for i from i0 to i1 do        for j from j0 to j1 do            m(i, j) -> res(j, i);        endfor;    endfor;enddefine;`

## PostScript

Library: initlib
`/transpose {    [ exch {        { {empty? exch pop} map all?} {pop exit} ift        [ exch {} {uncons {exch cons} dip exch} fold counttomark 1 roll] uncons    } loop ] {reverse} map}.`

## 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.

`#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 LONGLOCAL 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 rEND SUB'----------------------------------------------------------------------SUB TranspositionDemo(BYVAL DimSize1 AS DWORD, BYVAL DimSize2 AS DWORD)LOCAL r, c, cc AS DWORDLOCAL a() AS DWORDLOCAL 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, 7END FUNCTION`
Output:
```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```

## PowerShell

### Any Matrix

` function transpose(\$a) {    \$arr = @()    if(\$a) {         \$n = \$a.count - 1         if(0 -lt \$n) {             \$m = (\$a | foreach {\$_.count} | measure-object -Minimum).Minimum - 1            if( 0 -le \$m) {                if (0 -lt \$m) {                    \$arr [email protected](0)*(\$m+1)                    foreach(\$i in 0..\$m) {                        \$arr[\$i] = foreach(\$j in 0..\$n) {@(\$a[\$j][\$i])}                        }                } else {\$arr = foreach(\$row in \$a) {\$row}}            }        } else {\$arr = \$a}    }    \$arr} function show(\$a) {    if(\$a) {         0..(\$a.Count - 1) | foreach{ if(\$a[\$_]){"\$(\$a[\$_])"}else{""} }    }} \$a = @(@(2, 0, 7, 8),@(3, 5, 9, 1),@(4, 1, 6, 3))"`\$a ="show \$a"""transpose `\$a ="show (transpose \$a)""\$a = @(1)"`\$a ="show \$a"""transpose `\$a ="show (transpose \$a)"""`\$a ="\$a = @(1,2,3)show \$a"""transpose `\$a =""\$(transpose \$a)""""`\$a ="\$a = @(@(4,7,8),@(1),@(2,3))show \$a"""transpose `\$a =""\$(transpose \$a)""""`\$a ="\$a = @(@(4,7,8),@(1,5,9,0),@(2,3))show \$a"""transpose `\$a ="show (transpose \$a) `

Output:

```\$a =
2 0 7 8
3 5 9 1
4 1 6 3

transpose \$a =
2 3 4
0 5 1
7 9 6
8 1 3

\$a =
1

transpose \$a =
1

\$a =
1
2
3

transpose \$a =
1 2 3

\$a =
4 7 8
1
2 3

transpose \$a =
4 1 2

\$a =
4 7 8
1 5 9 0
2 3

transpose \$a =
4 1 2
7 5 3
```

### Square Matrix

` function transpose(\$a) {    if(\$a) {         \$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) {         0..(\$a.Count - 1) | foreach{ if(\$a[\$_]){"\$(\$a[\$_])"}else{""} }    }}\$a = @(@(2, 4, 7),@(3, 5, 9),@(4, 1, 6))show \$a""show (transpose \$a) `

Output:

```
2 4 7
3 5 9
4 1 6

2 3 4
4 5 1
7 9 6
```

## Prolog

Predicate transpose/2 exists in libray clpfd of SWI-Prolog.
In Prolog, a matrix is a list of lists. transpose/2 can be written like that.

Works with: SWI-Prolog
`% transposition of a rectangular matrix% e.g.   [[1,2,3,4], [5,6,7,8]]% give [[1,5],[2,6],[3,7],[4,8]] transpose(In, Out) :-    In = [H | T],    maplist(initdl, H, L),    work(T, In, Out). % we use the difference list to make "quick" appends (one inference)initdl(V, [V | X] - X). work(Lst, [H], Out) :-	maplist(my_append_last, Lst, H, Out). work(Lst, [H | T], Out) :-    maplist(my_append, Lst, H, Lst1),    work(Lst1, T, Out). my_append(X-Y, C, X1-Y1) :-    append_dl(X-Y, [C | U]- U, X1-Y1). my_append_last(X-Y, C, X1) :-	append_dl(X-Y, [C | U]- U, X1-[]). % "quick" appendappend_dl(X-Y, Y-Z, X-Z).`

## PureBasic

Matrices represented by integer arrays using rows as the first dimension and columns as the second dimension.

`Procedure transposeMatrix(Array a(2), Array trans(2))  Protected rows, cols   Protected ar = ArraySize(a(), 1) ;rows in original matrix  Protected ac = ArraySize(a(), 2) ;cols in original matrix   ;size the matrix receiving the transposition  Dim trans(ac, ar)   ;copy the values  For rows = 0 To ar    For cols = 0 To ac      trans(cols, rows) = a(rows, cols)    Next  Next  EndProcedure Procedure displayMatrix(Array a(2), text.s = "")  Protected i, j   Protected cols = ArraySize(a(), 2), rows = ArraySize(a(), 1)   PrintN(text + ": (" + Str(rows + 1) + ", " + Str(cols + 1) + ")")  For i = 0 To rows    For j = 0 To cols      Print(LSet(Str(a(i, j)), 4, " "))    Next    PrintN("")  Next  PrintN("")EndProcedure ;setup a matrix of arbitrary sizeDim m(random(5), random(5)) Define rows, cols;fill matrix with 'random' dataFor rows = 0 To ArraySize(m(),1)      ;ArraySize() can take a dimension as its second argument  For cols = 0 To ArraySize(m(), 2)    m(rows, cols) = random(10) - 10   NextNext Dim t(0,0) ;this will be resized during transpositionIf OpenConsole()  displayMatrix(m(), "matrix before transposition")  transposeMatrix(m(), t())  displayMatrix(t(), "matrix after transposition")   Print(#CRLF\$ + #CRLF\$ + "Press ENTER to exit")  Input()  CloseConsole()EndIf`
Output:
```matrix m, before: (3, 4)
-4  -9  -7  -9
-3  -6  -4  -6
-1  -2  0   -6

matrix m after transposition: (4, 3)
-4  -3  -1
-9  -6  -2
-7  -4  0
-9  -6  -6```

## Python

`m=((1,  1,  1,   1),   (2,  4,  8,  16),   (3,  9, 27,  81),   (4, 16, 64, 256),   (5, 25,125, 625))print(zip(*m))# in Python 3.x, you would do:# print(list(zip(*m)))`
Output:
``` [(1, 2, 3, 4, 5),
(1, 4, 9, 16, 25),
(1, 8, 27, 64, 125),
(1, 16, 81, 256, 625)]
```

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:

`# transpose :: Matrix a -> Matrix adef transpose(m):    if m:        inner = type(m)        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).__name__) if m else ''            ) + ' :: ' + str(m) + ' -> ' + str(tm)        )`
Output:
```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)]```

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:

`# Uneven list of listsuls = [[10, 11], , [], [30, 31, 32]] print (    list(zip(*uls))) #  --> []`

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 version 3.7
`'''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] + [xs 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], , [], [31, 32, 33]]),            ('Single row', [[1, 2, 3]]),            ('Single row, one cell', []),            ('Not rows', [1, 2, 3]),            ('Nothing', [])        ])    )  # TEST RESULT FORMATTING ---------------------------------- # fTable :: String -> (a -> String) ->#                     (b -> String) -> (a -> b) -> [a] -> Stringdef 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 -> bdef 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, f(ab)) if (        2 == len(ab)    ) else None  # show :: a -> Stringdef 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] -> Stringdef showList(xs):    '''Stringification of a list.'''    return '[' + ','.join(show(x) for x in xs) + ']'  # snd :: (a, b) -> bdef snd(tpl):    '''Second member of a pair.'''    return tpl  # typeName :: a -> Stringdef 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()`
Output:
```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],,[],[31,32,33]] -> [[10,20,31],[11,32],]
Single row: [[1,2,3]] -> [,,]
Single row, one cell: [] -> []
Not rows: [1,2,3] -> []
Nothing: [] -> []```

## 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`
Output:
```[ [ 1 2 ] [ 3 4 ] [ 5 6 ] ]

[ [ 1 3 5 ] [ 2 4 6 ] ]

[ [ 1 2 ] [ 3 4 ] [ 5 6 ] ]```

## R

`b <- 1:5m <- matrix(c(b, b^2, b^3, b^4), 5, 4)print(m)tm <- t(m)print(tm)`

## Racket

` #lang racket(require math)(matrix-transpose (matrix [[1 2] [3 4]])) `
Output:
```(array #[#[1 3] #[2 4]])
```

(Another method, without math, and using lists is demonstrated in the Scheme solution.)

## Raku

(formerly Perl 6)

Works with: rakudo version 2018.03
`# 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;`
Output:
```((A E I) (B F J) (C G K) (D H L))
[[A E I] [B F J] [C G K] [D H L]]```

## Rascal

`public rel[real, real, real] matrixTranspose(rel[real x, real y, real v] matrix){    return {<y, x, v> | <x, y, v> <- matrix};} //a matrixpublic rel[real x, real y, real v] matrixA = {<0.0,0.0,12.0>, <0.0,1.0, 6.0>, <0.0,2.0,-4.0>, <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>};`

## REXX

`/*REXX program transposes any sized rectangular matrix, displays before & after matrices*/@.=;     @.1 =   1.02     2.03      3.04       4.05        5.06         6.07          7.08         @.2 = 111     2222     33333     444444     5555555     66666666     777777777w=0                             do    row=1  while @.row\==''                                do col=1  until @.row==''; parse var @.row A.row.col @.row                                w=max(w, length(A.row.col) )    /*max width for elements*/                                end   /*col*/                   /*(used to align ouput).*/                             end      /*row*/    /* [↑]  build matrix A from the @ lists*/row= row-1                                       /*adjust for  DO  loop index increment.*/                             do    j=1  for row  /*process each    row    of the matrix.*/                                do k=1  for col  /*   "      "    column   "  "     "   */                                B.k.j= A.j.k     /*transpose the  A  matrix  (into  B). */                                end   /*k*/                             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: arg mat,rows,cols;     say;       say center( mat  'matrix',  (w+1)*cols +4, "─")                 do      r=1  for rows;    _=                                  /*newLine*/                      do c=1  for cols;    _=_ right( value( mat'.'r"."c), w)  /*append.*/                      end   /*c*/                 say _                                                         /*1 line.*/                 end        /*r*/;         return`
output   when using the default input:
```─────────────────────────────────A matrix─────────────────────────────────
1.02      2.03      3.04      4.05      5.06      6.07      7.08
111      2222     33333    444444   5555555  66666666 777777777

────────B matrix────────
1.02       111
2.03      2222
3.04     33333
4.05    444444
5.06   5555555
6.07  66666666
7.08 777777777
```

## Ring

` load "stdlib.ring"transpose = newlist(5,4)matrix = [[78,19,30,12,36], [49,10,65,42,50], [30,93,24,78,10], [39,68,27,64,29]]for i = 1 to 5    for j = 1 to 4        transpose[i][j] = matrix[j][i]        see "" + transpose[i][j] + " "    next    see nlnext `

Output:

```78 49 30 39
19 10 93 68
30 65 24 27
12 42 78 64
36 50 10 29
```

## RLaB

` >> m = rand(3,5)  0.41844289   0.476591435    0.75054022   0.226388925   0.963880314  0.91267171   0.941762397   0.464227895   0.693482786   0.203839405 0.261512966   0.157981873    0.26582235    0.11557427  0.0442493069>> m'  0.41844289    0.91267171   0.261512966 0.476591435   0.941762397   0.157981873  0.75054022   0.464227895    0.26582235 0.226388925   0.693482786    0.11557427 0.963880314   0.203839405  0.0442493069`

## Ruby

`m=[[1,  1,  1,   1],   [2,  4,  8,  16],   [3,  9, 27,  81],   [4, 16, 64, 256],   [5, 25,125, 625]]puts m.transpose`
Output:
``` [[1, 2, 3, 4, 5], [1, 4, 9, 16, 25], [1, 8, 27, 64, 125], [1, 16, 81, 256, 625]]
```

or using 'matrix' from the standard library

`require 'matrix' m=Matrix[[1,  1,  1,   1],         [2,  4,  8,  16],         [3,  9, 27,  81],         [4, 16, 64, 256],         [5, 25,125, 625]]puts m.transpose`
Output:
``` Matrix[[1, 2, 3, 4, 5], [1, 4, 9, 16, 25], [1, 8, 27, 64, 125], [1, 16, 81, 256, 625]]
```

or using zip:

`def transpose(m)  m.zip(*m[1..-1])endp transpose([[1,2,3],[4,5,6]])`
Output:
```  [[1, 4], [2, 5], [3, 6]]
```

## Run BASIC

`mtrx\$ ="4, 3,   0, 0.10, 0.20, 0.30,   0.40, 0.50, 0.60, 0.70,  0.80, 0.90, 1.00, 1.10" print "Transpose of matrix"call DisplayMatrix mtrx\$print "         ="MatrixT\$ =MatrixTranspose\$(mtrx\$)call DisplayMatrix MatrixT\$ end function MatrixTranspose\$(in\$)  w	= val(word\$(in\$, 1, ","))    '   swap w and h parameters  h	= val(word\$(in\$, 2, ","))  t\$	= str\$(h); ","; str\$(w); ","  for i =1 to w    for j =1 to h      t\$ = t\$ +word\$(in\$, 2 +i +(j -1) *w, ",") +","    next j  next iMatrixTranspose\$ =left\$(t\$, len(t\$) -1)end function sub DisplayMatrix in\$   '   Display looking like a matrix!html "<table border=2>"  w	= val(word\$(in\$, 1, ","))  h	= val(word\$(in\$, 2, ","))  for i =0 to h -1   html "<tr align=right>"   for j =1 to w      term\$	= word\$(in\$, j +2 +i *w, ",")      html "<td>";val(term\$);"</td>"    next jhtml "</tr>"next ihtml "</table>"end sub`
Output:
Transpose of matrix
 0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1 1.1
=
 0 0.4 0.8 0.1 0.5 0.9 0.2 0.6 1 0.3 0.7 1.1

## Rust

### version 1

` 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();} `

### version 2

` 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.len()];    for r in m {        for i in 0..r.len() {            t[i].push(r[i]);        }    }    t} `

Output:

```Matrix:
1	2	3
4	5	6

Transpose:
1	4
2	5
3	6
```

## Scala

`scala> Array.tabulate(4)(i => Array.tabulate(4)(j => i*4 + j))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)) scala> res12.transposeres13: Array[Array[Int]] = Array(Array(0, 4, 8, 12), Array(1, 5, 9, 13), Array(2, 6, 10, 14), Array(3, 7, 11, 15)) scala> res12 map (_ map ("%2d" format _) mkString " ") mkString "\n"res16: String = 0  1  2  3 4  5  6  7 8  9 10 1112 13 14 15 scala> res13 map (_ map ("%2d" format _) mkString " ") mkString "\n"res17: String = 0  4  8 12 1  5  9 13 2  6 10 14 3  7 11 15`

## Scheme

`(define (transpose m)  (apply map list m))`

## Seed7

`\$ include "seed7_05.s7i";  include "float.s7i"; const type: matrix is array array float; const func matrix: transpose (in matrix: aMatrix) is func  result    var matrix: transposedMatrix is matrix.value;  local    var integer: i is 0;    var integer: j is 0;  begin    transposedMatrix := length(aMatrix) times length(aMatrix) times 0.0;    for i range 1 to length(aMatrix) do      for j range 1 to length(aMatrix) do        transposedMatrix[j][i] := aMatrix[i][j];      end for;    end for;  end func; const proc: write (in matrix: aMatrix) is func  local    var integer: line is 0;    var integer: column is 0;  begin    for line range 1 to length(aMatrix) do      for column range 1 to length(aMatrix[line]) do        write(" " <& aMatrix[line][column] digits 2);      end for;      writeln;    end for;  end func; const matrix: testMatrix is [] (    [] (0.0, 0.1, 0.2, 0.3),    [] (0.4, 0.5, 0.6, 0.7),    [] (0.8, 0.9, 1.0, 1.1)); const proc: main is func  begin    writeln("Before Transposition:");    write(testMatrix);    writeln;    writeln("After Transposition:");    write(transpose(testMatrix));  end func;`
Output:
```Before Transposition:
0.00 0.10 0.20 0.30
0.40 0.50 0.60 0.70
0.80 0.90 1.00 1.10

After Transposition:
0.00 0.40 0.80
0.10 0.50 0.90
0.20 0.60 1.00
0.30 0.70 1.10
```

## Sidef

`func transpose(matrix) {    matrix.range.map{|i| matrix.map{_[i]}};}; var m = [  [1,  1,   1,   1],  [2,  4,   8,  16],  [3,  9,  27,  81],  [4, 16,  64, 256],  [5, 25, 125, 625],]; transpose(m).each { |row|    "%5d" * row.len -> printlnf(row...);}`
Output:
```    1    2    3    4    5
1    4    9   16   25
1    8   27   64  125
1   16   81  256  625```

Works with: FriCAS
Works with: OpenAxiom
Works with: Axiom
`(1) -> originalMatrix := matrix [[1, 1, 1, 1],[2, 4, 8, 16], _                                 [3, 9, 27, 81],[4, 16, 64, 256], _                                 [5, 25, 125, 625]]         +1  1    1    1 +        |               |        |2  4    8   16 |        |               |   (1)  |3  9   27   81 |        |               |        |4  16  64   256|        |               |        +5  25  125  625+                                                        Type: Matrix(Integer)(2) -> transposedMatrix := transpose(originalMatrix)         +1  2   3    4    5 +        |                   |        |1  4   9   16   25 |   (2)  |                   |        |1  8   27  64   125|        |                   |        +1  16  81  256  625+                                                        Type: Matrix(Integer)`

Domain:Matrix(R)

## Sparkling

`function transpose(A) {    return map(range(sizeof A), function(k, idx) {        return map(A, function(k, row) {            return row[idx];        });    });}`

## 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 transposeonly() function.

### Stata matrices

`. mat a=1,2,3\4,5,6. mat b=a'. mat list a a[2,3]    c1  c2  c3r1   1   2   3r2   4   5   6 . mat list b b[3,2]    r1  r2c1   1   4c2   2   5c3   3   6`

### Mata

`: a=1,1i : a        1    2    +-----------+  1 |   1   1i  |    +-----------+ : a'         1    +-------+  1 |    1  |  2 |  -1i  |    +-------+ : transposeonly(a)        1    +------+  1 |   1  |  2 |  1i  |    +------+`

## Swift

`@inlinablepublic func matrixTranspose<T>(_ matrix: [[T]]) -> [[T]] {  guard !matrix.isEmpty else {    return []  }   var ret = Array(repeating: [T](), count: matrix.count)   for row in matrix {    for j in 0..<row.count {      ret[j].append(row[j])    }  }   return ret} @inlinablepublic func printMatrix<T>(_ matrix: [[T]]) {  guard !matrix.isEmpty else {    print()     return  }   let rows = matrix.count  let cols = matrix.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)`
Output:
```Input:
1 2 3
4 5 6
Output:
1 4
2 5
3 6```

## Tailspin

` templates transpose  def a: \$;  [1..\$a(1)::length -> \$a(1..last;\$)] !end transpose templates printMatrix&{w:}  templates formatN    @: [];    \$ -> #    '[email protected] -> \$::length~..\$w -> ' ';[email protected](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 `
Output:
```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|
```

## Tcl

With core Tcl, representing a matrix as a list of lists:

`package require Tcl 8.5namespace path ::tcl::mathfunc proc size {m} {    set rows [llength \$m]    set cols [llength [lindex \$m 0]]    return [list \$rows \$cols]}proc transpose {m} {    lassign [size \$m] rows cols     set new [lrepeat \$cols [lrepeat \$rows ""]]    for {set i 0} {\$i < \$rows} {incr i} {        for {set j 0} {\$j < \$cols} {incr j} {            lset new \$j \$i [lindex \$m \$i \$j]        }    }    return \$new}proc print_matrix {m {fmt "%.17g"}} {    set max [widest \$m \$fmt]    lassign [size \$m] rows cols     for {set i 0} {\$i < \$rows} {incr i} {        for {set j 0} {\$j < \$cols} {incr j} {	    set s [format \$fmt [lindex \$m \$i \$j]]            puts -nonewline [format "%*s " [lindex \$max \$j] \$s]        }        puts ""    }}proc widest {m {fmt "%.17g"}} {    lassign [size \$m] rows cols     set max [lrepeat \$cols 0]    for {set i 0} {\$i < \$rows} {incr i} {        for {set j 0} {\$j < \$cols} {incr j} {	    set s [format \$fmt [lindex \$m \$i \$j]]            lset max \$j [max [lindex \$max \$j] [string length \$s]]        }    }    return \$max} 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"`
Output:
```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```
Library: Tcllib (Package: struct::matrix)
`package require struct::matrixstruct::matrix MM 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 2stringM transposeM format 2string`
Output:
```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

```

## TI-83 BASIC, TI-89 BASIC

TI-83: Assuming the original matrix is in [A], place its transpose in [B]:

```[A]T->[B]
```

The T operator can be found in the matrix math menu.

TI-89: The same except that matrix variables do not have special names:

```AT → B
```

## True BASIC

`OPTION BASE 0DIM matriz(3, 4)DATA 78, 19, 30, 12, 36DATA 49, 10, 65, 42, 50DATA 30, 93, 24, 78, 10DATA 39, 68, 27, 64, 29 FOR f = 0 TO 3    FOR c = 0 TO 4        READ matriz(f, c)    NEXT cNEXT 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    PRINTNEXT filaPRINT FOR fila = LBOUND(mtranspuesta,1) TO UBOUND(mtranspuesta,1)    FOR columna = LBOUND(mtranspuesta,2) TO UBOUND(mtranspuesta,2)        PRINT mtranspuesta(fila, columna);    NEXT columna    PRINTNEXT filaEND`

## Ursala

Matrices are stored as lists of lists, and transposing them is a built in operation.

`#cast %eLL example =  ~&K7 <   <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.

Output:
```<
<1.000000e+00,5.000000e+00,9.000000e+00>,
<2.000000e+00,6.000000e+00,1.000000e+01>,
<3.000000e+00,7.000000e+00,1.100000e+01>,
<4.000000e+00,8.000000e+00,1.200000e+01>>
```

## VBA

`Function transpose(m As Variant) As Variant    transpose = WorksheetFunction.transpose(m)End Function`

## VBScript

` 'create and display the initial matrixWScript.StdOut.WriteLine "Initial Matrix:"x = 4 : y = 6 : n = 1Dim 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.WriteLineNext 'display the trasposed matrixWScript.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.WriteLineNext `
Output:
```Initial 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	25
26	27	28	29	30
31	32	33	34	35

Transposed Matrix:
1	6	11	16	21	26	31
2	7	12	17	22	27	32
3	8	13	18	23	28	33
4	9	14	19	24	29	34
5	10	15	20	25	30	35
```

## Visual Basic

Translation of: PowerBASIC
Works with: Visual Basic version 5
Works with: Visual Basic version 6
`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 rEnd Function'----------------------------------------------------------------------Sub PrintMatrix(a() As Long)Dim l1 As Long, l2 As Long, u1 As Long, u2 As Long, r As Long, c As LongDim 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 rEnd Sub'----------------------------------------------------------------------Sub TranspositionDemo(ByVal DimSize1 As Long, ByVal DimSize2 As Long)Dim r, c, cc As LongDim a() As LongDim 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, 7End Sub`
Output:
```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```

## Wortel

The `@zipm` operator zips together an array of arrays, this is the same as transposition if the matrix is represented as an array of arrays.

`@zipm [[1 2 3] [4 5 6] [7 8 9]]`

Returns:

`[[1 4 7] [2 5 8] [3 6 9]]`

## Wren

Library: Wren-matrix
Library: Wren-fmt
`import "/matrix" for Matriximport "/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)`
Output:
```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|
```

## 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.

`proc Transpose(M, R, C, N);     \Transpose matrix M to Nint  M, R, C, N;                \rows and columnsint  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 Mint  M, R, C;                   \rows and columnsint  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);]`
Output:
```   1   2   3   4
5   6   7   8
9  10  11  12

1   5   9
2   6  10
3   7  11
4   8  12
```

## Yabasic

Translation of: FreeBASIC
`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	printnext filaprint for fila = 1 to arraysize(mtranspuesta(), 1)    for columna = 1 to arraysize(mtranspuesta(), 2)		print mtranspuesta(fila, columna);    next columna	printnext filaend data 78,19,30,12,36data 49,10,65,42,50data 30,93,24,78,10data 39,68,27,64,29`

## zkl

Using the GNU Scientific Library:

`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 placeprintln("---");GSL.Matrix(2,2).set(1,2, 3,4).transpose().format(5).println();  // in placeprintln("---");GSL.Matrix(3,1).set(1,2,3).transpose().format(5).println();  // in place`
Output:
``` 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
```

Or, using lists:

Translation of: Wortel
`fcn transpose(M){   if(M.len()==1) M.pump(List,List.create); // 1 row --> n columns   else M.zip(M.xplode(1));}`

The list xplode method pushes list contents on to the call stack.

`m:=T(T(1,2,3),T(4,5,6));          transpose(m).println();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();`
Output:
```L(L(1,4),L(2,5),L(3,6))
L(L(1,2,3),L("a","b","c"))
L(L(1),L(2),L(3))
(L(1,2,3))
L(L(1))
```

## 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. `