Matrix transposition

From Rosetta Code
Jump to: navigation, search
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.

Contents

[edit] ACL2

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

[edit] ActionScript

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

function transpose( m:Array):Array
{
	//Assume each element in m is an array. (If this were production code, use typeof to be sure)
 
	//Each element in m is a row, so this gets the length of a row in m, 
	//which is the same as the number of rows in m transpose.
	var mTranspose = new Array(m[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]);

[edit] 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: 

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;

Sample 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

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

b evaluates to the following normal form: 

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

[edit] ALGOL 68

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

Output: 

Transpose:
((  1.00,  2.00,  3.00,  4.00,  5.00),
 (  1.00,  4.00,  9.00, 16.00, 25.00),
 (  1.00,  8.00, 27.00, 64.00,125.00),
 (  1.00, 16.00, 81.00,256.00,625.00));

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


[edit] 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
}

[edit] AWK

 
# syntax: GAWK -f MATRIX_TRANSPOSITION.AWK filename
{   if (NF > nf) {
      nf = NF
    }
    for (i=1; i<=nf; i++) {
      row[i] = row[i] $i " "
    }
}
END {
    for (i=1; i<=nf; i++) {
      printf("%s\n",row[i])
    }
    exit(0)
}
 

input:

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

output:

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

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

[edit] BBC BASIC

Works with: BBC BASIC for Windows
      INSTALL @lib$+"ARRAYLIB"
 
      DIM matrix(3,4), transpose(4,3)
      matrix() = 78,19,30,12,36,49,10,65,42,50,30,93,24,78,10,39,68,27,64,29
 
      PROC_transpose(matrix(), transpose())
 
      FOR row% = 0 TO DIM(matrix(),1)
        FOR col% = 0 TO DIM(matrix(),2)
          PRINT ;matrix(row%,col%) " ";
        NEXT
        PRINT
      NEXT row%
 
      PRINT
 
      FOR row% = 0 TO DIM(transpose(),1)
        FOR col% = 0 TO DIM(transpose(),2)
          PRINT ;transpose(row%,col%) " ";
        NEXT
        PRINT
      NEXT row%

Output: 

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

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

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

[edit] C

Transpose a 2D double array. 

#include <stdio.h>
 
void transpose(void *dest, void *src, int src_h, int src_w)
{
	int i, j;
	double (*d)[src_h] = dest, (*s)[src_w] = src;
	for (i = 0; i < src_h; i++)
		for (j = 0; j < src_w; j++)
			d[j][i] = s[i][j];
}
 
int main()
{
	int i, j;
	double a[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;
}

Transpose a matrix of size w x h in place with only O(1) space and without moving any element more than once. See the Wikipedia article for more information. 

#include <stdio.h>
 
void transpose(double *m, int w, int h)
{
	int start, next, i;
	double tmp;
 
	for (start = 0; start <= w * h - 1; start++) {
		next = start;
		i = 0;
		do {	i++;
			next = (next % h) * w + next / h;
		} while (next > start);
		if (next < start || i == 1) continue;
 
		tmp = m[next = start];
		do {
			i = (next % h) * w + next / h;
			m[next] = (i == start) ? tmp : m[i];
			next = i;
		} while (next > start);
	}
}
 
void show_matrix(double *m, int w, int h)
{
	int i, j;
	for (i = 0; i < h; i++) {
		for (j = 0; j < w; j++)
			printf("%2g ", m[i * w + j]);
		putchar('\n');
	}
}
 
int main(void)
{
	int i;
	double m[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;
}

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

[edit] C++

Library: Boost.uBLAS
#include <boost/numeric/ublas/matrix.hpp>
#include <boost/numeric/ublas/io.hpp>
 
int main()
{
  using namespace boost::numeric::ublas;
 
  matrix<double> m(3,3);
 
  for(int i=0; i!=m.size1(); ++i)
    for(int j=0; j!=m.size2(); ++j)
      m(i,j)=3*i+j;
 
  std::cout << trans(m) << std::endl;
}

Output: 

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

[edit] Generic solution

main.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() */
matrix.h 
#ifndef _MATRIX_H
#define	_MATRIX_H
 
#include <sstream>
#include <string>
#include <vector>
#include <algorithm>
 
#define MATRIX_ERROR_CODE_COUNT 5
#define MATRIX_ERR_UNDEFINED "1 Undefined exception!"
#define MATRIX_ERR_WRONG_ROW_INDEX "2 The row index is out of range."
#define MATRIX_ERR_MUL_ROW_AND_COL_NOT_EQUAL "3 The row number of second matrix must be equal with the column number of first matrix!"
#define MATRIX_ERR_MUL_ROW_AND_COL_BE_GREATER_THAN_ZERO "4 The number of rows and columns must be greater than zero!"
#define MATRIX_ERR_TOO_FEW_DATA "5 Too few data in matrix."
 
class MatrixException {
private:
    std::string message_;
    int errorCode_;
public:
    MatrixException(std::string message = MATRIX_ERR_UNDEFINED);
 
    inline std::string message() {
        return message_;
    };
 
    inline int errorCode() {
        return errorCode_;
    };
};
 
MatrixException::MatrixException(std::string message) {
    errorCode_ = MATRIX_ERROR_CODE_COUNT + 1;
    std::stringstream ss(message);
    ss >> errorCode_;
    if (errorCode_ < 1) {
        errorCode_ = MATRIX_ERROR_CODE_COUNT + 1;
    }
    std::string::size_type pos = message.find(' ');
    if (errorCode_ <= MATRIX_ERROR_CODE_COUNT && pos != std::string::npos) {
        message_ = message.substr(pos + 1);
    } else {
        message_ = message + " (This an unknown and unsupported exception!)";
    }
}
 
/**
 * Generic class for matrices.
 */
template <class T>
class Matrix {
private:
    std::vector<T> v; // the data of matrix
    unsigned int m;   // the number of rows
    unsigned int n;   // the number of 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 */

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

[edit] C#

using System;
using System.Text;
 
namespace prog
{
	class MainClass
	{						
		public static void Main (string[] args)
		{
			double[,] m = { {1,2,3},{4,5,6},{7,8,9} };
 
			double[,] t = Transpose( m );	
 
			for( int i=0; i<t.GetLength(0); i++ )
			{
				for( int j=0; j<t.GetLength(1); j++ )		
					Console.Write( t[i,j] + "  " );
				Console.WriteLine("");
			}
		}
 
		public static double[,] Transpose( double[,] m )
		{
			double[,] t = new double[m.GetLength(1),m.GetLength(0)];
			for( int i=0; i<m.GetLength(0); i++ )
				for( int j=0; j<m.GetLength(1); j++ )
					t[j,i] = m[i,j];			
 
			return t;
		}
	}
}

[edit] Clojure

(defmulti matrix-transpose
  "Switch rows with columns."
  class)
 
(defmethod matrix-transpose clojure.lang.PersistentList
  [mtx]
  (apply map list mtx))
 
(defmethod matrix-transpose clojure.lang.PersistentVector
  [mtx]
  (vec (apply map vector mtx)))

Sample output: 

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

[edit] CoffeeScript

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

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

[edit] Common Lisp

If the matrix is given as a list: 

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

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

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

[edit] D

[edit] Locally Procedural Style

(Currently the standard version std.range.transposed doesn't work.) 

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

[edit] Functional Style

Same output. 

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

[edit] ELLA

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

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

[edit] 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)

Output: 

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

[edit] Factor

flip can be used. 

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

[edit] Fortran

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

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

In ANSI FORTRAN 77 with MIL-STD-1753 extensions or later, use nested structured DO loops: 

REAL A(3,5), B(5,3)
DATA ((A(I,J),I=1,3),J=1,5) /1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15/
 
DO I = 1, 3
   DO J = 1, 5
      B(J,I) = A(I,J)
   END DO
END DO

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

   REAL A(3,5), B(5,3)
   DATA ((A(I,J),I=1,3),J=1,5) /1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15/
 
   DO 10 I = 1, 3
      DO 20 J = 1, 5
         B(J,I) = A(I,J)
20    CONTINUE
10 CONTINUE

[edit] F#

Very straightforward solution... 

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

[edit] 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);

[edit] Go

[edit] 2D representation

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

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

[edit] Flat representation

Slices of slices turn out to have disadvantages. It is possible to construct ill-formed matricies with a different number of elements on different rows, for example. They require multiple allocations, and the compiler must generate complex address calculations to index elements.

A flat element representation with a stride is almost always better. 

package main
 
import "fmt"
 
type matrix struct {
    ele    []float64
    stride int
}
 
// construct new matrix from slice of 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
}
Output:
original:
[1 2 3]
[4 5 6]

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

[edit] Transpose in place

Translation of: C

Note representation is "flat," as above. 

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
}

Output same as above.

[edit] Library

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

[edit] Groovy

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

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

Output: 

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

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

[edit] Haskell

For matrices represented as lists, there's transpose: 

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

For matrices in arrays, one can use ixmap: 

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

[edit] Hope

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

[edit] HicEst

REAL :: mtx(2, 4)
 
mtx = 1.1 * $
WRITE() mtx
 
SOLVE(Matrix=mtx, Transpose=mtx)
WRITE() mtx

Output: 

1.1 2.2 3.3 4.4 
5.5 6.6 7.7 8.8 
 
1.1 5.5 
2.2 6.6 
3.3 7.7 
4.4 8.8

[edit] Icon and Unicon

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

Output: 

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

[edit] IDL

Standard IDL function transpose() 

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

[edit] J

Solution:
Transpose is the monadic primary verb |:

Example: 

   ]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

[edit] 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));
               }
       }
}

[edit] JavaScript

Works with: SpiderMonkey
for the print() function 
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());

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

[edit] Joy

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

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

[edit] K

Transpose is the monadic verb + 

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

[edit] Lang5

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

[edit] Liberty BASIC

There is no native matrix capability. A set of functions is available at http://www.diga.me.uk/RCMatrixFuncs.bas implementing matrices of arbitrary dimension in a string format. 

MatrixC$ ="4, 3,          0, 0.10, 0.20, 0.30,       0.40, 0.50, 0.60, 0.70,      0.80, 0.90, 1.00, 1.10"
 
print "Transpose of matrix"
call DisplayMatrix MatrixC$
print "         ="
MatrixT$ =MatrixTranspose$( MatrixC$)
call DisplayMatrix MatrixT$

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 |

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

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

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

>> transpose([1 2;3 4])
 
ans =
 
     1     3
     2     4
 
>> [1 2;3 4].'
 
ans =
 
     1     3
     2     4

[edit] 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);

[edit] MAXScript

Uses the built in transpose() function 

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

[edit] Nial

make an array 

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

transpose it 

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

[edit] 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();
      };
    }
  }
}
 

Output: 

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

[edit] OCaml

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

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

This will output: 

1 5
2 6
3 7
4 8

A version for lists: 

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

Example: 

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

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

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

[edit] PARI/GP

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

M~

In PARI the function is 

gtrans(M)

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

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

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

[edit] Perl

Library: Math::MatrixMatrix
use Math::Matrix;
 
$m = Math::Matrix->new(
  [1, 1, 1, 1],
  [2, 4, 8, 16],
  [3, 9, 27, 81],
  [4, 16, 64, 256],
  [5, 25, 125, 625],
);
 
$m->transpose->print;

Output: 

1.00000    2.00000    3.00000    4.00000    5.00000 
1.00000    4.00000    9.00000   16.00000   25.00000 
1.00000    8.00000   27.00000   64.00000  125.00000 
1.00000   16.00000   81.00000  256.00000  625.00000

Manually: 

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

[edit] Perl 6

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;

A more concise solution: 

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;

Output: 

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

[edit] 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);
}

[edit] PicoLisp

(de matTrans (Mat)
   (apply mapcar Mat list) )
 
(matTrans '((1 2 3) (4 5 6)))

Output: 

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

[edit] 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. */

Traditional method: 

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

[edit] 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;

[edit] PostScript

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

[edit] Prolog

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

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

[edit] PureBasic

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

Procedure transposeMatrix(Array a(2), Array trans(2))
  Protected rows, cols
 
  Protected ar = ArraySize(a(), 1) ;rows in original matrix
  Protected ac = ArraySize(a(), 2) ;cols in original matrix
 
  ;size the matrix receiving the transposition
  Dim trans(ac, ar)
 
  ;copy the values
  For rows = 0 To ar
    For cols = 0 To ac
      trans(cols, rows) = a(rows, cols)
    Next
  Next  
EndProcedure
 
Procedure displayMatrix(Array a(2), text.s = "")
  Protected i, j 
  Protected cols = ArraySize(a(), 2), rows = ArraySize(a(), 1)
 
  PrintN(text + ": (" + Str(rows + 1) + ", " + Str(cols + 1) + ")")
  For i = 0 To rows
    For j = 0 To cols
      Print(LSet(Str(a(i, j)), 4, " "))
    Next
    PrintN("")
  Next
  PrintN("")
EndProcedure
 
;setup a matrix of arbitrary 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

Sample 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

[edit] Python

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

Output: 

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

[edit] R

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

[edit] Racket

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

Output: 

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

[edit] 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>
};

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

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

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

[edit] Ruby

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

Output: 

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

or using 'matrix' from the standard library 

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

Output: 

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

or using zip: 

def transpose(m)
  m[0].zip(*m[1..-1])
end
p transpose([[1,2,3],[4,5,6]])

Output: 

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

[edit] Run BASIC

mtrx$ ="4, 3,   0, 0.10, 0.20, 0.30,   0.40, 0.50, 0.60, 0.70,  0.80, 0.90, 1.00, 1.10"
 
print "Transpose of matrix"
call DisplayMatrix mtrx$
print "         ="
MatrixT$ =MatrixTranspose$(mtrx$)
call DisplayMatrix MatrixT$
 
end
 
function MatrixTranspose$(in$)
  w	= val(word$(in$, 1, ","))    '   swap w and h parameters
  h	= val(word$(in$, 2, ","))
  t$	= str$(h); ","; str$(w); ","
  for i =1 to w
    for j =1 to h
      t$ = t$ +word$(in$, 2 +i +(j -1) *w, ",") +","
    next j
  next i
MatrixTranspose$ =left$(t$, len(t$) -1)
end function
 
sub DisplayMatrix in$   '   Display looking like a matrix!
html "<table border=2>"
  w	= val(word$(in$, 1, ","))
  h	= val(word$(in$, 2, ","))
  for i =0 to h -1
   html "<tr align=right>"
   for j =1 to w
      term$	= word$(in$, j +2 +i *w, ",")
      html "<td>";val(term$);"</td>"
    next j
html "</tr>"
next i
html "</table>"
end sub
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

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

[edit] Scheme

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

[edit] 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;

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

[edit] Tcl

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

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"

outputs 

1  1   1   1 
2  4   8  16 
3  9  27  81 
4 16  64 256 
5 25 125 625 
1  2  3   4   5 
1  4  9  16  25 
1  8 27  64 125 
1 16 81 256 625
Library: Tcllib (Package: struct::matrix)
package require struct::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

outputs 

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

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

[edit] Ursala

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

#cast %eLL
 
example = 
 
~&K7 <
   <1.,2.,3.,4.>,
   <5.,6.,7.,8.>,
   <9.,10.,11.,12.>>

For a more verbose version, replace the ~&K7 operator with the standard library function named transpose. Here is the 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>>
Retrieved from "http://rosettacode.org/mw/index.php?title=Matrix_transposition&oldid=155225"
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox