Matrix transposition: Difference between revisions

From Rosetta Code
Content added Content deleted
(→‎{{header|JavaScript}}: ES6 transpose function)
(→‎JS ES6: added example)
Line 1,616: Line 1,616:
===ES6===
===ES6===


<lang JavaScript>// transpose :: [[a]] -> [[a]]
<lang JavaScript>(() => {
'use strict';
⚫
let transpose = xs =>

⚫
xs[0].map((_, iCol) => xs.map((row) => row[iCol]));</lang>
// transpose :: [[a]] -> [[a]]
⚫
let transpose = xs =>
⚫
xs[0].map((_, iCol) => xs.map((row) => row[iCol]));



// TEST
return transpose([
[1, 2],
[3, 4],
[5, 6]
]);
})();</lang>

{{Out}}
<lang JavaScript>[[1, 3, 5], [2, 4, 6]]</lang>


=={{header|Joy}}==
=={{header|Joy}}==

Revision as of 00:28, 13 November 2016

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

360 Assembly

<lang 360asm>... KN EQU 3 KM EQU 5 N DC AL2(KN) M DC AL2(KM) A DS (KN*KM)F matrix a(n,m) B DS (KM*KN)F matrix b(m,n) ...

  • b(j,i)=a(i,j)
  • transposition using Horner's formula
        LA     R4,0               i,from 1
        LA     R7,KN              to n
        LA     R6,1               step 1

LOOPI BXH R4,R6,ELOOPI do i=1 to n 

        LA     R5,0               j,from 1
        LA     R9,KM              to m
        LA     R8,1               step 1

LOOPJ BXH R5,R8,ELOOPJ do j=1 to m 

        LR     R1,R4              i
        BCTR   R1,0               i-1
        MH     R1,M               (i-1)*m
        LR     R2,R5              j
        BCTR   R2,0               j-1
        AR     R1,R2              r1=(i-1)*m+(j-1)
        SLA    R1,2               r1=((i-1)*m+(j-1))*itemlen
        L      R0,A(R1)           r0=a(i,j)
        LR     R1,R5              j
        BCTR   R1,0               j-1
        MH     R1,N               (j-1)*n
        LR     R2,R4              i
        BCTR   R2,0               i-1
        AR     R1,R2              r1=(j-1)*n+(i-1)
        SLA    R1,2               r1=((j-1)*n+(i-1))*itemlen
        ST     R0,B(R1)           b(j,i)=r0
        B      LOOPJ              next j

ELOOPJ EQU * out of loop j 

        B      LOOPI              next i

ELOOPI EQU * out of loop i ...</lang>

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>

ActionScript

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:

<lang agda>(1 ∷ 4 ∷ []) ∷ (2 ∷ 5 ∷ []) ∷ (3 ∷ 6 ∷ []) ∷ []</lang>

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

If M is a matrix, ⍉M is its transpose. For example, <lang 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>

AppleScript

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

<lang applescript>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 lstTrans

end transpose</lang>


or, if our library contains some generic basics like map(), and we have a 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

<lang applescript>-- transpose :: a -> a on transpose(xss) 

   script column
       on lambda(_, iCol)
           script row
               on lambda(xs)
                   item iCol of xs
               end lambda
           end script
           
           map(row, xss)
       end lambda
   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 LIBRARY 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 lambda(item i of xs, i, xs)
       end repeat
       return lst
   end tell

end map

-- Lift 2nd class handler function into 1st class script wrapper -- mReturn :: Handler -> Script on mReturn(f) 

   if class of f is script then
       f
   else
       script
           property lambda : f
       end script
   end if

end mReturn</lang>

Output:

<lang AppleScript>{{1, 4, 7, 10}, {2, 5, 8, 11}, {3, 6, 9, 12}}</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

<lang AWK>

  1. 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:
1 5 9
2 6 10
3 7 11
4 8 12

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

<lang burlesque> blsq ) {{78 19 30 12 36}{49 10 65 42 50}{30 93 24 78 10}{39 68 27 64 29}}tpsp 78 49 30 39 19 10 93 68 30 65 24 27 12 42 78 64 36 50 10 29 </lang>

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

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

<lang cpp>#include <boost/numeric/ublas/matrix.hpp>

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

  1. include "matrix.h"
  1. if !defined(ARRAY_SIZE)
   #define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0]))
  1. 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

  1. define _MATRIX_H
  1. include <sstream>
  2. include <string>
  3. include <vector>
  4. include <algorithm>
  1. define MATRIX_ERROR_CODE_COUNT 5
  2. define MATRIX_ERR_UNDEFINED "1 Undefined exception!"
  3. define MATRIX_ERR_WRONG_ROW_INDEX "2 The row index is out of range."
  4. 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!"
  5. define MATRIX_ERR_MUL_ROW_AND_COL_BE_GREATER_THAN_ZERO "4 The number of rows and columns must be greater than zero!"
  6. 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);
   }

}

  1. 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]
 (apply mapv 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:
10 14 18
11 15 19
12 16 20
13 17 21

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.

EchoLisp

<lang scheme> (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

</lang>

Elixir

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

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

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

Library gonum/matrix

<lang go>package main

import ( 

   "fmt"

   "github.com/gonum/matrix/mat64"

)

func main() { 

   m := mat64.NewDense(2, 3, []float64{
       1, 2, 3,
       4, 5, 6,
   })
   fmt.Println(mat64.Formatted(m))
   fmt.Println()
   fmt.Println(mat64.Formatted(m.T()))

}</lang>

Output:
⎡1  2  3⎤
⎣4  5  6⎦

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

Library go.matrix

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

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, but without the fluff of constructing from rows. <lang go>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

}</lang> Output same as above.

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>

Idris

<lang idris>Idris> transpose [[1,2],[3,4],[5,6]] [[1, 3, 5], [2, 4, 6]] : List (List Integer)</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>

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

<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

ES5

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


Or, as a functional expression (rather than an imperative procedure): <lang javascript> (function () { 

   'use strict';

   function transpose(lst) {
       return lst[0].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]]
   );

})(); </lang>

Output:
[[1, 4, 7, 10], [2, 5, 8, 11], [3, 6, 9, 12]]

ES6

<lang JavaScript>(() => { 

   'use strict';

   // transpose :: a -> a
   let transpose = xs =>
       xs[0].map((_, iCol) => xs.map((row) => row[iCol]));



   // TEST
   return transpose([
       [1, 2],
       [3, 4],
       [5, 6]
   ]);

})();</lang>

Output:

<lang JavaScript>[[1, 3, 5], [2, 4, 6]]</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

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

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

<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

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>

Nim

For statically sized arrays: <lang nim>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:
0 5 1 
1 6 0 
2 7 0 
3 8 0 
4 9 42

For dynamically sized seqs: <lang nim>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:
 1 5
 2 6
 3 7
 4 8

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

<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

Works with: rakudo version 2015.10-46

<lang perl6>sub transpose(@m) { 

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

}

  1. creates a random matrix

my @a; for ^5 X ^5 -> ($x, $y) { @a[$x][$y] = ('a'..'z').pick; } say "original:"; .gist.say for @a;

my @b = transpose(@a); say "transposed:"; .gist.say for @b;</lang>

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

   ([ @m[*;$_] ] for ^@m[0]);

}

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

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

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

Using the [Z] meta-operator.

<lang perl6>say [Z] (<A B C>,<D E F>,<G H I>)</lang>

Output:
((A D G) (B E H) (C F I))

Phix

Copy of Euphoria <lang Phix>function transpose(sequence in) sequence 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</lang>

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>

PowerShell

Any Matrix

<lang PowerShell> 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 =@(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[0]}}
           }
       } 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) </lang> 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

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

<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

Next

Dim t(0,0) ;this will be resized during transposition If OpenConsole() 

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

  1. in Python 3.x, you would do:
  2. 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

<lang R>b <- 1:5 m <- matrix(c(b, b^2, b^3, b^4), 5, 4) print(m) tm <- t(m) print(tm)</lang>

Racket

<lang racket>

  1. lang racket

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

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

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

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, and displays the before and after matrices. */ 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 matrix A  from matrix  X.*/
                        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 /*adjust for DO loop indices. */ L=0 /*L is max 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 all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ 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

Ring

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

next </lang> Output: 

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

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

00.10.20.3
0.40.50.60.7
0.80.91.01.1

=

00.40.8
0.10.50.9
0.20.61.0
0.30.71.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

SPAD

Works with: FriCAS
Works with: OpenAxiom
Works with: Axiom

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

Domain:Matrix(R)

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: 

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

VBScript

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

'display the trasposed matrix WScript.StdOut.WriteBlankLines(1) WScript.StdOut.WriteLine "Transposed Matrix:" For i = 0 To x For j = 0 To y If j < y Then WScript.StdOut.Write matrix(i,j) & vbTab Else WScript.StdOut.Write matrix(i,j) End If Next WScript.StdOut.WriteLine Next </lang>

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

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

Using the GNU Scientific Library: <lang zkl>var [const] GSL=Import("zklGSL"); // libGSL (GNU Scientific Library) GSL.Matrix(2,3).set(1,2,3, 4,5,6).transpose().format(5).println(); // in place println("---"); GSL.Matrix(2,2).set(1,2, 3,4).transpose().format(5).println(); // in place println("---"); GSL.Matrix(3,1).set(1,2,3).transpose().format(5).println(); // in place</lang>

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

<lang zkl>fcn transpose(M){ 

  if(M.len()==1) M[0].pump(List,List.create); // 1 row --> n columns
  else M[0].zip(M.xplode(1));

}</lang> The list xplode method pushes list contents on to the call stack. <lang zkl>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();</lang>

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))
Retrieved from "https://rosettacode.org/wiki/Matrix_transposition?oldid=57039"