Matrix transposition

Transpose an arbitrarily sized rectangular Matrix.

ACL2

<lang Lisp>(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)))))</lang>

In ActionScript, multi-dimensional arrays are created by making an "Array of arrays" where each element is an array. <lang ActionScript>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[0].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]);</lang>

Ada

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: <lang ada>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;</lang>

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

<lang agda>module Matrix where

open import Data.Nat open import Data.Vec

Matrix : (A : Set) → ℕ → ℕ → Set Matrix A m n = Vec (Vec A m) n

transpose : ∀ {A m n} → Matrix A m n → Matrix A n m transpose [] = replicate [] transpose (xs ∷ xss) = zipWith _∷_ xs (transpose xss)

a = (1 ∷ 2 ∷ 3 ∷ []) ∷ (4 ∷ 5 ∷ 6 ∷ []) ∷ [] b = transpose a</lang>

b evaluates to the following normal form:

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

<lang algol68>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))

)</lang>

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));

APL

     3 3⍴⍳10

1 2 3 4 5 6 7 8 9

     ⍉ 3 3⍴⍳10

1 4 7 2 5 8 3 6 9 </lang>

AutoHotkey

<lang AutoHotkey>a = a m = 10 n = 10 Loop, 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" . after Return

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

} </lang>

Using Objects

<lang AutoHotkey>Transpose(M){ R := [] for i, row in M for j, col in row R[j,i] := col return R }</lang> Examples:<lang AutoHotkey>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[1].MaxIndex())?"":"`n") return Trim(Res,"`n") }</lang>

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)

} </lang>

input:

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

Output:

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

BBC BASIC

Works with: BBC BASIC for Windows

<lang bbcbasic> 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%</lang>

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

C

Transpose a 2D double array. <lang c>#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[3][5] = {{ 0, 1, 2, 3, 4 }, { 5, 6, 7, 8, 9 }, { 1, 0, 0, 0, 42}}; double b[5][3]; 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; }</lang>

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. <lang c>#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[15]; 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; }</lang>

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

Library: Boost.uBLAS

<lang cpp>#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;

}</lang>

Output:

 [3,3]((0,3,6),(1,4,7),(2,5,8))

Generic solution

main.cpp

<lang cpp>#include <iostream>

include "matrix.h"

if !defined(ARRAY_SIZE)

   #define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0]))

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[2][3] = {
       {1,2,3},
       {4,5,6},
   };

   Matrix<int> a(ARRAY_SIZE(am), ARRAY_SIZE(am[0]), am[0], ARRAY_SIZE(am)*ARRAY_SIZE(am[0]));

   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() */</lang>

matrix.h

<lang cpp>#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 columns

protected:

   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 */</lang>

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

<lang cpp>#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;

}</lang>

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

C#

<lang csharp>using System; using System.Text;

namespace prog { class MainClass { public static void Main (string[] args) { double[,] m = { {1,2,3},{4,5,6},{7,8,9} };

double[,] t = Transpose( m );

for( int i=0; i<t.GetLength(0); i++ ) { for( int j=0; j<t.GetLength(1); j++ ) Console.Write( t[i,j] + " " ); Console.WriteLine(""); } }

public static double[,] Transpose( double[,] m ) { double[,] t = new double[m.GetLength(1),m.GetLength(0)]; for( int i=0; i<m.GetLength(0); i++ ) for( int j=0; j<m.GetLength(1); j++ ) t[j,i] = m[i,j];

return t; } } }</lang>

Clojure

<lang lisp>(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]
 (vec (apply map vector mtx)))</lang>

Output:

=> (matrix-transpose [[1 2 3] [4 5 6]])
[[1 4] [2 5] [3 6]]

CoffeeScript

<lang coffeescript>transpose = (matrix) ->

   (t[i] for t in matrix) for i in [0...matrix[0].length]</lang>

Output:

> transpose [[1,2,3],[4,5,6]]

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

Common Lisp

If the matrix is given as a list: <lang lisp>(defun transpose (m)

 (apply #'mapcar #'list m))</lang>

If the matrix A is given as a 2D array: <lang lisp>;; 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))</lang>

D

Standard Version

<lang d>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);

}</lang>

Output:

Locally Procedural Style

<lang d>T[][] transpose(T)(in T[][] m) pure nothrow {

   auto r = new typeof(return)(m[0].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);

}</lang> Same output.

Functional Style

<lang d>import std.stdio, std.algorithm, std.range, std.functional;

auto transpose(T)(in T[][] m) pure nothrow {

   return m[0].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);

}</lang> Same output.

ELLA

Sample originally from ftp://ftp.dra.hmg.gb/pub/ella (a now dead link) - Public release.

Code for matrix transpose hardware design verification:<lang ella>MAC TRANSPOSE = ([INT n][INT m]TYPE t: matrix) -> [m][n]t:

 [INT i = 1..m] [INT j = 1..n] matrix[j][i].</lang>

Euphoria

<lang euphoria>function transpose(sequence in)

   sequence out
   out = repeat(repeat(0,length(in)),length(in[1]))
   for n = 1 to length(in) do
       for m = 1 to length(in[1]) do
           out[m][n] = in[n][m]
       end for
   end for
   return out

end function

sequence m m = {

 {1,2,3,4},
 {5,6,7,8},
 {9,10,11,12}

}

? transpose(m)</lang>

Output:

 {
   {1,5,9},
   {2,6,10},
   {3,7,11},
   {4,8,12}
 }

Factor

flip can be used. <lang factor>( scratchpad ) { { 1 2 3 } { 4 5 6 } } flip .

{ { 1 4 } { 2 5 } { 3 6 } }</lang>

Fortran

In ISO Fortran 90 or later, use the TRANSPOSE intrinsic function: <lang fortran>integer, parameter :: n = 3, m = 5 real, 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</lang>

In ANSI FORTRAN 77 with MIL-STD-1753 extensions or later, use nested structured DO loops: <lang fortran>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 DO

END DO</lang>

In ANSI FORTRAN 66 or later, use nested labeled DO loops: <lang fortran> 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 CONTINUE 10 CONTINUE</lang>

F#

Very straightforward solution... <lang fsharp>let transpose (mtx : _ [,]) = Array2D.init (mtx.GetLength 1) (mtx.GetLength 0) (fun x y -> mtx.[y,x])</lang>

GAP

<lang 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);</lang>

Go

2D representation

Go arrays and slices are only one-dimensional. The obvious way to represent two-dimensional arrays is with a slice of slices: <lang go>package main

import "fmt"

type row []float64 type 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[0]))
   for x, _ := range r {
       r[x] = make(row, len(m))
   }
   for y, s := range m {
       for x, e := range s {
           r[x][y] = e
       }
   }
   return r

}</lang>

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. <lang go>package main

import "fmt"

type matrix struct {

   ele    []float64
   stride int

}

// construct new matrix from slice of slices func matrixFromRows(rows [][]float64) *matrix {

   if len(rows) == 0 {
       return &matrix{nil, 0}
   }
   m := &matrix{make([]float64, len(rows)*len(rows[0])), len(rows[0])}
   for rx, row := range rows {
       copy(m.ele[rx*m.stride:(rx+1)*m.stride], row)
   }
   return m

}

func main() {

   m := matrixFromRows([][]float64{
       {1, 2, 3},
       {4, 5, 6},
   })
   m.print("original:")
   m.transpose().print("transpose:")

}

func (m *matrix) print(heading string) {

   if heading > "" {
       fmt.Print("\n", heading, "\n")
   }
   for e := 0; e < len(m.ele); e += m.stride {
       fmt.Println(m.ele[e : e+m.stride])
   }

}

func (m *matrix) transpose() *matrix {

   r := &matrix{make([]float64, len(m.ele)), len(m.ele) / m.stride}
   rx := 0
   for _, e := range m.ele {
       r.ele[rx] = e
       rx += r.stride
       if rx >= len(r.ele) {
           rx -= len(r.ele) - 1
       }
   }
   return r

}</lang>

Output:

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. <lang go>package main

import "fmt"

type matrix struct {

   ele    []float64
   stride int

}

// construct new matrix from slice of slices func matrixFromRows(rows [][]float64) *matrix {

   if len(rows) == 0 {
       return &matrix{nil, 0}
   }
   m := &matrix{make([]float64, len(rows)*len(rows[0])), len(rows[0])}
   for rx, row := range rows {
       copy(m.ele[rx*m.stride:(rx+1)*m.stride], row)
   }
   return m

}

func main() {

   m := matrixFromRows([][]float64{
       {1, 2, 3},
       {4, 5, 6},
   })
   m.print("original:")
   m.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

}</lang> Output same as above.

Library

<lang go>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)

}</lang>

Output:

original:
{1, 2, 3,
 4, 5, 6}
transpose:
{1, 4,
 2, 5,
 3, 6}

Groovy

The Groovy extensions to the List class provides a transpose method: <lang groovy>def matrix = [ [ 1, 2, 3, 4 ],

              [ 5, 6, 7, 8 ] ]

matrix.each { println it } println() def transpose = matrix.transpose()

transpose.each { println it }</lang>

Output:

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

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

Haskell

For matrices represented as lists, there's transpose: <lang haskell>*Main> transpose [[1,2],[3,4],[5,6]] [[1,3,5],[2,4,6]]</lang>

For matrices in arrays, one can use ixmap: <lang haskell>import Data.Array

swap (x,y) = (y,x)

transpArray :: (Ix a, Ix b) => Array (a,b) e -> Array (b,a) e transpArray a = ixmap (swap l, swap u) swap a where

 (l,u) = bounds a</lang>

Hope

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

HicEst

<lang hicest>REAL :: mtx(2, 4)

mtx = 1.1 * $ WRITE() mtx

SOLVE(Matrix=mtx, Transpose=mtx) WRITE() mtx</lang>

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

Icon and Unicon

<lang Icon>procedure transpose_matrix (matrix)

 result := []
 # for each column
 every (i := 1 to *matrix[1]) 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 result

end

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</lang>

Output:

Start:
1 2 3 
4 5 6 
Transposed:
1 4 
2 5 
3 6

IDL

Standard IDL function transpose() <lang idl>m=[[1,1,1,1],[2, 4, 8, 16],[3, 9,27, 81],[5, 25,125, 625]] print,transpose(m)</lang>

J

Solution:
Transpose is the monadic primary verb |:

Example: <lang j> ]matrix=: (^/ }:) >:i.5 NB. make and show example matrix 1 1 1 1 2 4 8 16 3 9 27 81 4 16 64 256 5 25 125 625

  |: matrix

1 2 3 4 5 1 4 9 16 25 1 8 27 64 125 1 16 81 256 625</lang>

Java

<lang 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[0].length][m.length];
              for(int rows = 0; rows < m.length; rows++){
                      for(int cols = 0; cols < m[0].length; cols++){
                              ans[cols][rows] = m[rows][cols];
                      }
              }
              for(double[] i:ans){//2D arrays are arrays of arrays
                      System.out.println(Arrays.toString(i));
              }
      }

}</lang>

JavaScript

Works with: SpiderMonkey

for the print() function

<lang javascript>function Matrix(ary) {

   this.mtx = ary
   this.height = ary.length;
   this.width = ary[0].length;

}

Matrix.prototype.toString = function() {

   var s = []
   for (var i = 0; i < this.mtx.length; i++) 
       s.push( this.mtx[i].join(",") );
   return s.join("\n");

}

// returns a new matrix Matrix.prototype.transpose = function() {

   var transposed = [];
   for (var i = 0; i < this.width; i++) {
       transposed[i] = [];
       for (var j = 0; j < this.height; j++) {
           transposed[i][j] = this.mtx[j][i];
       }
   }
   return new Matrix(transposed);

}

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());</lang>

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

Transposition using functional style influence <lang javascript> transpose = function(a) { return a[0].map(function(x,i) { return a.map(function(y,k) { return y[i]; }); }); }

A = [[1,2,3],[4,5,6],[7,8,9],[10,11,12]];

JSON.stringify(transpose(A)); "[[1,4,7,10],[2,5,8,11],[3,6,9,12]]" </lang>

Joy

For matrices represented as lists, there's transpose, defined in seqlib like this: <lang joy>DEFINE transpose == [ [null] [true] [[null] some] ifte ]

                   [ pop [] ]
                   [ [[first] map] [[rest] map] cleave ]
                   [ cons ]
                   linrec .</lang>

jq

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. <lang jq>def transpose:

 if (.[0] | length) == 0 then []
 else [map(.[0])] + (map(.[1:]) | transpose)
 end ;</lang>

Examples

[[], []] | transpose
# => []

[[1], [3]] | transpose
# => 1,3

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

Julia

The transposition is obtained by quoting the matrix. <lang Julia>julia> [1 2 3 ; 4 5 6] # a 2x3 matrix 2x3 Array{Int64,2}:

1  2  3
4  5  6

julia> [1 2 3 ; 4 5 6]' # note the quote 3x2 Array{Int64,2}:

1  4
2  5
3  6</lang>

K

Transpose is the monadic verb + <lang k> {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)</lang>

Lang5

<lang Lang5>12 iota [3 4] reshape 1 + dup . 1 transpose .</lang>

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

<lang lisp> (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)))))))

</lang>

Usage in the LFE REPL:

<lang lisp> > (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)) > </lang>

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. <lang lb>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$</lang>

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

<lang lua>function Transpose( m )

   local res = {}
   
   for i = 1, #m[1] do
       res[i] = {}
       for j = 1, #m do
           res[i][j] = m[j][i]
       end
   end
   
   return res

end

-- a test for Transpose(m) mat = { { 1, 2, 3 }, { 4, 5, 6 } } erg = Transpose( mat ) for i = 1, #erg do

   for j = 1, #erg[1] do
       io.write( erg[i][j] )
       io.write( "  " )
   end
   io.write( "\n" )

end</lang>

Using apply map list <lang lua>function map(f, a)

 local b = {}
 for k,v in ipairs(a) do b[k] = f(v) end
 return b

end

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
 end

end

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"))</lang>

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

<lang Maple> M := <<2,3>|<3,4>|<5,6>>;

M^%T;

with(LinearAlgebra): Transpose(M); </lang>

Output:

                                    [2  3  5]
                               M := [       ]
                                    [3  4  6]

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

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

Mathematica

<lang mathematica>originalMatrix = {{1, 1, 1, 1},

                 {2, 4, 8, 16},
                 {3, 9, 27, 81},
                 {4, 16, 64, 256},
                 {5, 25, 125, 625}}

transposedMatrix = Transpose[originalMatrix]</lang>

MATLAB / Octave

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. <lang Matlab>>> transpose([1 2;3 4])

ans =

    1     3
    2     4

>> [1 2;3 4].'

ans =

    1     3
    2     4</lang>

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: <lang Matlab>

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

</lang>

Transposing nested cells using apply map list <lang Matlab>xy = {{1,2,3,4},{1,2,3,4},{1,2,3,4}} yx = feval(@(x) cellfun(@(varargin)[varargin],x{:},'un',0), xy)</lang>

Maxima

<lang 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);</lang>

MAXScript

Uses the built in transpose() function <lang maxscript>m = bigMatrix 5 4 for i in 1 to 5 do for j in 1 to 4 do m[i][j] = pow i j m = transpose m</lang>

Nial

make an array <lang nial>|a := 2 3 reshape count 6 =1 2 3 =4 5 6</lang> transpose it <lang nial>|transpose a =1 4 =2 5 =3 6</lang>

Nimrod

For statically sized arrays: <lang nimrod>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 ""</lang>

Output:

For dynamically sized seqs: <lang nimrod>proc transpose[T](s: seq[seq[T]]): seq[seq[T]] =

 result = newSeq[seq[T]](s[0].len)
 for i in 0 .. < s[0].len:
   result[i] = newSeq[T](s.len)
   for j in 0 .. < s.len:
     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)</lang>

Output:

@[@[0, 5, 1], @[1, 6, 0], @[2, 7, 0], @[3, 8, 0], @[4, 9, 42]]

Objeck

<lang 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[0],dim[1]];
     for(i := 0; i < dim[0]; i+=1;) {
       for(j := 0; j < dim[1]; j+=1;) {
         output[i,j] := input[i,j];
       };
     };

     Print(output);
   }

   function : Print(matrix : Int[,]) ~ Nil {
     dim := matrix->Size();
     for(i := 0; i < dim[0]; i+=1;) {
       for(j := 0; j < dim[1]; j+=1;) {
         IO.Console->Print(matrix[i,j])->Print('\t');
       };
       '\n'->Print();
     };
   }
 }

} </lang>

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:

<lang ocaml>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) ;;</lang>

Output:

A version for lists: <lang ocaml>let rec transpose m =

 assert (m <> []);
 if List.mem [] m then
   []
 else
   List.map List.hd m :: transpose (List.map List.tl m)</lang>

Example:

# transpose [[1;2;3;4];
             [5;6;7;8]];;
- : int list list = [[1; 5]; [2; 6]; [3; 7]; [4; 8]]

Octave

<lang octave>a = [ 1, 1, 1, 1 ;

     2, 4, 8, 16 ;
     3, 9, 27, 81 ;
     4, 16, 64, 256 ;
     5, 25, 125, 625 ];

tranposed = a.'; % tranpose ctransp = a'; % conjugate transpose</lang>

OxygenBasic

<lang 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
 next

end 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 pr

end function

'==== 'DEMO '====

double A[5*4],B[4*5] 'columns x 'rows y

A <= 'y minor, x major 11,12,13,14,15, 21,22,23,24,25, 31,32,33,34,35, 41,42,43,44,45

print MatrixShow A,5,4 Transpose A,B,5,4 print MatrixShow B,4,5 </lang>

PARI/GP

The GP function for matrix (or vector) transpose is mattranspose, but it is usually invoked with a tilde: <lang parigp>M~</lang>

In PARI the function is <lang C>gtrans(M)</lang> though shallowtrans is also available when deep copying is not desired.

Pascal

<lang 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[1]) to high(A[1]) do
     B[j,i] := A[i,j];

 writeln ('A:');
 for i := low(A) to high(A) do
 begin
   for j := low(A[1]) to high(A[1]) do
     write (A[i,j]:3);
   writeln;
 end;

 writeln ('B:');
 for i := low(B) to high(B) do
 begin
   for j := low(B[1]) to high(B[1]) do
     write (B[i,j]:3);
   writeln;
 end;

end.</lang>

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

Library: Math::Matrix Matrix

<lang 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;</lang>

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: <lang perl>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[0]}) {

 push(@transposed, [map $_->[$j], @m]);

}</lang>

Perl 6

<lang perl6>sub transpose(@m) {

   my @t;
   for ^@m X ^@m[0] -> $x, $y { @t[$y][$x] = @m[$x][$y] }
   return @t;

}

creates a random matrix

my @a; for (^10).pick X (^10).pick -> $x, $y { @a[$x][$y] = (^100).pick; }

say "original: "; .perl.say for @a;

my @b = transpose(@a);

say "transposed: "; .perl.say for @b;</lang>

A more concise solution: <lang perl6>sub transpose (@m) {

   @m[0].keys.map: {[ @m».[$_] ]};

}

my @a = [< a b c d e >],

       [< f g h i j >],
       [< k l m n o >],
       [< p q r s t >];

.say for @a.&transpose;</lang>

Output:

a f k p
b g l q
c h m r
d i n s
e j o t

PHP

<lang php>function transpose($m) {

 if (count($m) == 0) // special case: empty matrix
   return array();
 else if (count($m) == 1) // special case: row matrix
   return array_chunk($m[0], 1);

 // array_map(NULL, m[0], m[1], ..)
 array_unshift($m, NULL); // the original matrix is not modified because it was passed by value
 return call_user_func_array('array_map', $m);

}</lang>

PicoLisp

<lang PicoLisp>(de matTrans (Mat)

  (apply mapcar Mat list) )

(matTrans '((1 2 3) (4 5 6)))</lang>

Output:

-> ((1 4) (2 5) (3 6))

PL/I

<lang 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. */</lang> Traditional method: <lang PL/I>/* 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;</lang>

Pop11

<lang 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;</lang>

PostScript

Library: initlib

<lang postscript>/transpose {

   [ exch {
       { {empty? exch pop} map all?} {pop exit} ift
       [ exch {} {uncons {exch cons} dip exch} fold counttomark 1 roll] uncons
   } loop ] {reverse} map

}.</lang>

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

<lang 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" append append_dl(X-Y, Y-Z, X-Z).</lang>

PureBasic

Matrices represented by integer arrays using rows as the first dimension and columns as the second dimension. <lang PureBasic>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 size

Dim m(random(5), random(5))

Define rows, cols

fill matrix with 'random' data

For 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 
 Next

 displayMatrix(m(), "matrix before transposition")
 transposeMatrix(m(), t())
 displayMatrix(t(), "matrix after transposition")
  
 Print(#CRLF$ + #CRLF$ + "Press ENTER to exit")
 Input()
 CloseConsole()

EndIf</lang>

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

<lang 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)))</lang>

Output:

 [(1, 2, 3, 4, 5),
  (1, 4, 9, 16, 25),
  (1, 8, 27, 64, 125),
  (1, 16, 81, 256, 625)]

R

Racket

lang racket

(require math) (matrix-transpose (matrix [[1 2] [3 4]])) </lang>

Output:

(array #[#[1 3] #[2 4]])

Rascal

<lang Rascal>public rel[real, real, real] matrixTranspose(rel[real x, real y, real v] matrix){

   return {<y, x, v> | <x, y, v> <- matrix};

}

//a matrix public 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> };</lang>

REXX

<lang rexx>/*REXX program transposes a matrix, shows before and after matrixes. */ x. = x.1 = 1.02 2.03 3.04 4.05 5.06 6.07 7.07 x.2 = 111 2222 33333 444444 5555555 66666666 777777777

 do     r=1  while x.r\==     /*build the "A" matric from X. numbers */
     do c=1  while x.r\==
     parse var  x.r  a.r.c  x.r
     end   /*c*/
 end       /*r*/

rows = r-1; cols = c-1 L=0 /*L is the maximum width element value.*/

    do     i=1  for rows
        do j=1  for cols
        b.j.i = a.i.j;          L=max(L,length(b.j.i))
        end   /*j*/
    end       /*i*/

call showMat 'A', rows, cols call showMat 'B', cols, rows exit /*stick a fork in it, we're done.*/ /*─────────────────────────────────────SHOWMAT subroutine───────────────*/ showMat: parse arg mat,rows,cols; say say center(mat 'matrix', cols*(L+1) +4, "─")

        do       r=1  for rows;   _=
              do c=1  for cols;   _ = _ right(value(mat'.'r'.'c), L)
              end   /*c*/
        say _
        end         /*r*/

return</lang>

Output:

─────────────────────────────────A matrix─────────────────────────────────
      1.02      2.03      3.04      4.05      5.06      6.07      7.07
       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.07 777777777

RLaB

<lang 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</lang>

Ruby

<lang 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</lang>

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 <lang ruby>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</lang>

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: <lang ruby>def transpose(m)

 m[0].zip(*m[1..-1])

end p transpose([[1,2,3],[4,5,6]])</lang>

Output:

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

Run BASIC

<lang runbasic>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 i

MatrixTranspose$ =left$(t$, len(t$) -1) end function

sub DisplayMatrix in$ ' Display looking like a matrix!

html "

" w = val(word$(in$, 1, ",")) h = val(word$(in$, 2, ",")) for i =0 to h -1 html "" for j =1 to w term$ = word$(in$, j +2 +i *w, ",") html ""

   next j

html "" next i html "

";val(term$);"

"

end sub</lang>

Output:

Transpose of matrix

0	0.1	0.2	0.3
0.4	0.5	0.6	0.7
0.8	0.9	1.0	1.1

=

0	0.4	0.8
0.1	0.5	0.9
0.2	0.6	1.0
0.3	0.7	1.1

Scala

<lang 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.transpose res13: 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 11

12 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</lang>

Scheme

<lang scheme>(define (transpose m)

 (apply map list m))</lang>

Seed7

<lang 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[1]) times length(aMatrix) times 0.0;
   for i range 1 to length(aMatrix) do
     for j range 1 to length(aMatrix[1]) 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;</lang>

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

<lang ruby>func transpose(matrix) {

   matrix[0].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...);

}</lang>

Output:

    1    2    3    4    5
    1    4    9   16   25
    1    8   27   64  125
    1   16   81  256  625

Sparkling

<lang sparkling>function transpose(A) {

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

}</lang>

Tcl

With core Tcl, representing a matrix as a list of lists: <lang tcl>package require Tcl 8.5 namespace 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"</lang>

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)

<lang tcl>package require struct::matrix struct::matrix M M deserialize {5 4 {{1 1 1 1} {2 4 8 16} {3 9 27 81} {4 16 64 256} {5 25 125 625}}} M format 2string M transpose M format 2string</lang>

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:

A^T → B

Ursala

Matrices are stored as lists of lists, and transposing them is a built in operation. <lang Ursala>#cast %eLL

example =

~&K7 <

  <1.,2.,3.,4.>,
  <5.,6.,7.,8.>,
  <9.,10.,11.,12.>></lang>

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

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. <lang wortel>@zipm [[1 2 3] [4 5 6] [7 8 9]]</lang> Returns:

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

zkl

Translation of: Wortel

The list xplode method pushes list contents on to the call stack. <lang zkl>m:=T(T(1,2,3),T(4,5,6)); m[0].zip(m.xplode(1)) m:=L(L(1,"a"),L(2,"b"),L(3,"c")); m[0].zip(m.xplode(1))</lang>

Output:

L(L(1,4),L(2,5),L(3,6))
L(L(1,2,3),L("a","b","c"))