Matrix transposition: Difference between revisions

From Rosetta Code
Content added Content deleted
(→‎{{header|Go}}: added transpose in place)
Line 888: Line 888:
[3 6]
[3 6]
</pre>
</pre>
===Transpose in place===
{{trans|C}}
<lang go>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>


=={{header|Groovy}}==
=={{header|Groovy}}==

Revision as of 22:57, 21 January 2012

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.

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

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

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>

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

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

C++

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

C#

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

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

double[,] t = Transpose( m );

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

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

return t; } } }</lang>

Clojure

<lang lisp> (defmulti matrix-transpose 

 "Switch rows with columns."
 class)

(defmethod matrix-transpose clojure.lang.PersistentList 

 [mtx]
 (apply map list mtx))

(defmethod matrix-transpose clojure.lang.PersistentVector 

 [mtx]
 (vec (apply map vector mtx)))

</lang>

Sample output:

<lang lisp> => (matrix-transpose [[1 2 3] [4 5 6]]) [[1 4] [2 5] [3 6]] </lang>

CoffeeScript

<lang coffeescript>transpose = (matrix) -> 

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

> 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

<lang d>import std.stdio, std.algorithm, std.array, std.conv;

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

   auto r = new T[][](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);
   writeln("[", join(map!text(T), "\n "), "]");

}</lang> Output: 

[[10, 14, 18]
 [11, 15, 19]
 [12, 16, 20]
 [13, 17, 21]]

Functional style (same output): <lang d>import std.stdio, std.algorithm, std.conv, std.range;

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

   return map!(i => transversal(m, i))(iota(m[0].length));

}

void main() { 

   enum M = [[10, 11, 12, 13],
             [14, 15, 16, 17],
             [18, 19, 20, 21]];
   /*immutable*/ auto T = transpose(M);
   writeln("[", join(map!text(T), "\n "), "]");

}</lang>

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. 

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

Fortran

In ISO Fortran 90 or later, use the TRANSPOSE intrinsic function: <lang fortran>integer, parameter  :: n = 3, m = 5 real, dimension(n,m) :: a = reshape( (/ (i,i=1,n*m) /), (/ n, m /) ) real, dimension(m,n) :: b

b = transpose(a)

do i = 1, n 

   print *, a(i,:)

end do

do j = 1, m 

   print *, b(j,:)

end do</lang>

In ANSI FORTRAN 77 with MIL-STD-1753 extensions or later, use nested structured DO loops: <lang fortran>REAL A(3,5), B(5,3) DATA ((A(I,J),I=1,3),J=1,5) /1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15/

DO I = 1, 3 

  DO J = 1, 5
     B(J,I) = A(I,J)
  END DO

END DO</lang>

In ANSI FORTRAN 66 or later, use nested labeled DO loops: <lang fortran> REAL A(3,5), B(5,3) 

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

20 CONTINUE 10 CONTINUE</lang>

F#

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

GAP

<lang gap>originalMatrix := [[1, 1, 1, 1], 

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

transposedMatrix := TransposedMat(originalMatrix);</lang>

Go

2D representation

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

import "fmt"

type row []float64 type matrix []row

func main() { 

   m := matrix{
       {1, 2, 3},
       {4, 5, 6},
   }
   printMatrix(m)
   t := transpose(m)
   printMatrix(t)

}

func printMatrix(m matrix) { 

   for _, s := range m {
       fmt.Println(s)
   }

}

func transpose(m matrix) matrix { 

   r := make(matrix, len(m[0]))
   for x, _ := range r {
       r[x] = make(row, len(m))
   }
   for y, s := range m {
       for x, e := range s {
           r[x][y] = e
       }
   }
   return r

}</lang> Output: 

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

Flat representation

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

A flat element representation with a stride is almost always better. <lang go>package main

import "fmt"

type matrix struct { 

   ele    []float64
   stride int

}

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

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

}

func main() { 

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

}

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

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

}

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

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

}</lang> Output: 

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

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

Transpose in place

Translation of: C

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

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

Icon and Unicon

<lang Icon> procedure transpose_matrix (matrix) 

 result := []
 # for each column
 every (i := 1 to *matrix[1]) do {
   col := []
   # extract the number in each row for that column
   every (row := !matrix) do put (col, row[i]) 
   # and push that column as a row in the result matrix
   put (result, col)
 }
 return result

end

procedure print_matrix (matrix) 

 every (row := !matrix) do {
   every writes (!row || " ")
   write ()
 }

end

procedure main () 

 matrix := [[1,2,3],[4,5,6]]
 write ("Start:")
 print_matrix (matrix)
 transposed := transpose_matrix (matrix)
 write ("Transposed:")
 print_matrix (transposed)

end </lang>

Output: 

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

IDL

Standard IDL function transpose()

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

J

Solution:
Transpose is the monadic primary verb |:

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

  |: matrix

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

Java

<lang java>import java.util.Arrays; public class Transpose{ 

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

}</lang>

JavaScript

Works with: SpiderMonkey

for the print() function

<lang javascript>function Matrix(ary) { 

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

}

Matrix.prototype.toString = function() { 

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

}

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

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

}

var m = new Matrix([[1,1,1,1],[2,4,8,16],[3,9,27,81],[4,16,64,256],[5,25,125,625]]); print(m); print(); print(m.transpose());</lang>

produces 

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

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

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>

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>

Liberty BASIC

There is no native matrix capability. A set of functions is available at http://www.diga.me.uk/RCMatrixFuncs.bas implementing matrices of arbitrary dimension in a string format. <lang lb> MatrixC$ ="4, 3, 0, 0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90, 1.00, 1.10"

print "Transpose of matrix" call DisplayMatrix MatrixC$ print " =" MatrixT$ =MatrixTranspose$( MatrixC$) call DisplayMatrix MatrixT$ </lang>

Transpose of matrix
| 0.00000 0.10000 0.20000 0.30000 |
| 0.40000 0.50000 0.60000 0.70000 |
| 0.80000 0.90000 1.00000 1.10000 |

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


Lua

<lang lua>function Transpose( m ) 

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

end

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

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

end</lang>

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(matrix)" 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>

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>

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>

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


PARI/GP

This can also be accessed through mattranspose. <lang parigp>M~</lang>

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

<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 (^10).pick X (^10).pick -> $x, $y { @a[$x][$y] = (^100).pick; }

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

my @b = transpose(@a);

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

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

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

}

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

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

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

Output:

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

PHP

<lang php>function transpose($m) { 

 // 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> Caveat: this will not work correctly for a row matrix (matrix with only 1 row); it should return a column matrix (matrix where each row has length 1), but simply returns the row itself, which is a 1-dimensional array, not a matrix.

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> /* Transpose matrix A, result at B. */ transpose: procedure (a, b); 

  declare (a, b) (*,*) float controlled;
  declare (m, n) fixed binary;

  if allocation(b) > 0 then free b;

  m = hbound(a,1); n = hbound(a,2);

  allocate b(n,m);

  do i = 1 to m;
     b(*,i) = a(i,*);
  end;

end transpose; </lang>

Pop11

<lang pop11>define transpose(m) -> res; 

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

enddefine;</lang>

PostScript

Library: initlib

<lang postscript> /transpose { 

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

}.

</lang>

Prolog

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

<lang Prolog>% transposition of a rectangular matrix % e.g. [[1,2,3,4], [5,6,7,8]] % give [[1,5],[2,6],[3,7],[4,8]]

transpose(In, Out) :- 

   In = [H | T],
   maplist(initdl, H, L),
   work(T, In, Out).

% we use the difference list to make "quick" appends (one inference) initdl(V, [V | X] - X).

work(Lst, [H], Out) :- maplist(my_append_last, Lst, H, Out).

work(Lst, [H | T], Out) :- 

   maplist(my_append, Lst, H, Lst1),
   work(Lst1, T, Out).

my_append(X-Y, C, X1-Y1) :- 

   append_dl(X-Y, [C | U]- U, X1-Y1).

my_append_last(X-Y, C, X1) :- append_dl(X-Y, [C | U]- U, X1-[]).

% "quick" append append_dl(X-Y, Y-Z, X-Z).

</lang>

PureBasic

Matrices represented by integer arrays using rows as the first dimension and columns as the second dimension. <lang PureBasic>Procedure transposeMatrix(Array a(2), Array trans(2)) 

 Protected rows, cols
 
 Protected ar = ArraySize(a(), 1) ;rows in original matrix
 Protected ac = ArraySize(a(), 2) ;cols in original matrix
 
 ;size the matrix receiving the transposition
 Dim trans(ac, ar)
 
 ;copy the values
 For rows = 0 To ar
   For cols = 0 To ac
     trans(cols, rows) = a(rows, cols)
   Next
 Next

EndProcedure

Procedure displayMatrix(Array a(2), text.s = "") 

 Protected i, j 
 Protected cols = ArraySize(a(), 2), rows = ArraySize(a(), 1)
 
 PrintN(text + ": (" + Str(rows + 1) + ", " + Str(cols + 1) + ")")
 For i = 0 To rows
   For j = 0 To cols
     Print(LSet(Str(a(i, j)), 4, " "))
   Next
   PrintN("")
 Next
 PrintN("")

EndProcedure

setup a matrix of arbitrary size

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

Define rows, cols

fill matrix with 'random' data

For rows = 0 To ArraySize(m(),1) ;ArraySize() can take a dimension as its second argument 

 For cols = 0 To ArraySize(m(), 2)
   m(rows, cols) = random(10) - 10 
 Next

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

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>

REXX

<lang rexx> /*REXX program transposes a matrix, shows before and after matrixes. */

x.= x.1='1.02 2.03 3.04 4.05 5.06 6.07 7.07' x.2='111 2222 33333 444444 5555555 66666666 777777777' 

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

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
    end

call showMat 'A',rows,cols call showMat 'B',cols,rows exit


/*─────────────────────────────────────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; say _
    end

return </lang> Output: 

---------------------------------A matrix---------------------------------
      1.02      2.03      3.04      4.05      5.06      6.07      7.07
       111      2222     33333    444444   5555555  66666666 777777777

--------B matrix--------
      1.02       111
      2.03      2222
      3.04     33333
      4.05    444444
      5.06   5555555
      6.07  66666666
      7.07 777777777

RLaB

<lang RLaB> >> m = rand(3,5) 

 0.41844289   0.476591435    0.75054022   0.226388925   0.963880314
 0.91267171   0.941762397   0.464227895   0.693482786   0.203839405
0.261512966   0.157981873    0.26582235    0.11557427  0.0442493069

>> m' 

 0.41844289    0.91267171   0.261512966
0.476591435   0.941762397   0.157981873
 0.75054022   0.464227895    0.26582235
0.226388925   0.693482786    0.11557427
0.963880314   0.203839405  0.0442493069

</lang>

Ruby

<lang ruby>m=[[1, 1, 1, 1], 

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

puts m.transpose</lang> Output: 

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

or using 'matrix' from the standard library <lang ruby>require 'matrix'

m=Matrix[[1, 1, 1, 1], 

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

puts m.transpose</lang> Output: 

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

or using zip: <lang ruby>def transpose(m) 

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

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

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

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: result is matrix.value;
 local
   var integer: i is 0;
   var integer: j is 0;
 begin
   result := 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
       result[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

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

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

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>

  1. 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. 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 "https://rosettacode.org/wiki/Matrix_transposition?oldid=56890"