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.
ACL2
<lang Lisp>(defun cons-each (xs xss)
(if (or (endp xs) (endp xss)) nil (cons (cons (first xs) (first xss)) (cons-each (rest xs) (rest xss)))))
(defun list-each (xs)
(if (endp xs) nil (cons (list (first xs)) (list-each (rest xs)))))
(defun transpose-list (xss)
(if (endp (rest xss)) (list-each (first xss)) (cons-each (first xss) (transpose-list (rest xss)))))</lang>
ActionScript
In ActionScript, multi-dimensional arrays are created by making an "Array of arrays" where each element is an array. <lang ActionScript>function transpose( m:Array):Array { //Assume each element in m is an array. (If this were production code, use typeof to be sure)
//Each element in m is a row, so this gets the length of a row in m, //which is the same as the number of rows in m transpose. var mTranspose = new Array(m[0].length); for(var i:uint = 0; i < mTranspose.length; i++) {
//create a row
mTranspose[i] = new Array(m.length);
//set the row to the appropriate values
for(var j:uint = 0; j < mTranspose[i].length; j++) mTranspose[i][j] = m[j][i]; } return mTranspose; } var m:Array = [[1, 2, 3, 10], [4, 5, 6, 11], [7, 8, 9, 12]]; var M:Array = transpose(m); for(var i:uint = 0; i < M.length; i++) trace(M[i]);</lang>
Ada
Transpose is a function of the standard Ada library provided for matrices built upon any floating-point or complex type. The relevant packages are Ada.Numerics.Generic_Real_Arrays and Ada.Numerics.Generic_Complex_Arrays, correspondingly.
This example illustrates use of Transpose for the matrices built upon the standard type Float: <lang ada>with Ada.Numerics.Real_Arrays; use Ada.Numerics.Real_Arrays; with Ada.Text_IO; use Ada.Text_IO;
procedure Matrix_Transpose is
procedure Put (X : Real_Matrix) is type Fixed is delta 0.01 range -500.0..500.0; begin for I in X'Range (1) loop for J in X'Range (2) loop Put (Fixed'Image (Fixed (X (I, J)))); end loop; New_Line; end loop; end Put; Matrix : constant Real_Matrix := ( (0.0, 0.1, 0.2, 0.3), (0.4, 0.5, 0.6, 0.7), (0.8, 0.9, 1.0, 1.1) );
begin
Put_Line ("Before Transposition:"); Put (Matrix); New_Line; Put_Line ("After Transposition:"); Put (Transpose (Matrix));
end Matrix_Transpose;</lang> 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
Agda
<lang agda>module Matrix where
open import Data.Nat open import Data.Vec
Matrix : (A : Set) → ℕ → ℕ → Set Matrix A m n = Vec (Vec A m) n
transpose : ∀ {A m n} → Matrix A m n → Matrix A n m transpose [] = replicate [] transpose (xs ∷ xss) = zipWith _∷_ xs (transpose xss)
a = (1 ∷ 2 ∷ 3 ∷ []) ∷ (4 ∷ 5 ∷ 6 ∷ []) ∷ [] b = transpose a</lang>
b evaluates to the following normal form:
<lang agda>(1 ∷ 4 ∷ []) ∷ (2 ∷ 5 ∷ []) ∷ (3 ∷ 6 ∷ []) ∷ []</lang>
ALGOL 68
<lang algol68>main:(
[,]REAL m=((1, 1, 1, 1), (2, 4, 8, 16), (3, 9, 27, 81), (4, 16, 64, 256), (5, 25,125, 625));
OP ZIP = ([,]REAL in)[,]REAL:( [2 LWB in:2 UPB in,1 LWB in:1UPB in]REAL out; FOR i FROM LWB in TO UPB in DO out[,i]:=in[i,] OD; out );
PROC pprint = ([,]REAL m)VOID:( FORMAT real fmt = $g(-6,2)$; # width of 6, with no '+' sign, 2 decimals # FORMAT vec fmt = $"("n(2 UPB m-1)(f(real fmt)",")f(real fmt)")"$; FORMAT matrix fmt = $x"("n(UPB m-1)(f(vec fmt)","lxx)f(vec fmt)");"$; # finally print the result # printf((matrix fmt,m)) );
printf(($x"Transpose:"l$)); pprint((ZIP m))
)</lang> Output:
Transpose: (( 1.00, 2.00, 3.00, 4.00, 5.00), ( 1.00, 4.00, 9.00, 16.00, 25.00), ( 1.00, 8.00, 27.00, 64.00,125.00), ( 1.00, 16.00, 81.00,256.00,625.00));
APL
<lang apl>
3 3⍴⍳10
1 2 3 4 5 6 7 8 9
⍉ 3 3⍴⍳10
1 4 7 2 5 8 3 6 9 </lang>
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>
AWK
<lang AWK>
- syntax: GAWK -f MATRIX_TRANSPOSITION.AWK filename
{ if (NF > nf) {
nf = NF } for (i=1; i<=nf; i++) { row[i] = row[i] $i " " }
} END {
for (i=1; i<=nf; i++) { printf("%s\n",row[i]) } exit(0)
} </lang>
input:
1 2 3 4 5 6 7 8 9 10 11 12
output:
1 5 9 2 6 10 3 7 11 4 8 12
BASIC
CLS DIM m(1 TO 5, 1 TO 4) 'any dimensions you want 'set up the values in the array FOR rows = LBOUND(m, 1) TO UBOUND(m, 1) 'LBOUND and UBOUND can take a dimension as their second argument FOR cols = LBOUND(m, 2) TO UBOUND(m, 2) m(rows, cols) = rows ^ cols 'any formula you want NEXT cols NEXT rows 'declare the new matrix DIM trans(LBOUND(m, 2) TO UBOUND(m, 2), LBOUND(m, 1) TO UBOUND(m, 1)) 'copy the values FOR rows = LBOUND(m, 1) TO UBOUND(m, 1) FOR cols = LBOUND(m, 2) TO UBOUND(m, 2) trans(cols, rows) = m(rows, cols) NEXT cols NEXT rows 'print the new matrix FOR rows = LBOUND(trans, 1) TO UBOUND(trans, 1) FOR cols = LBOUND(trans, 2) TO UBOUND(trans, 2) PRINT trans(rows, cols); NEXT cols PRINT NEXT rows
BBC BASIC
<lang bbcbasic> INSTALL @lib$+"ARRAYLIB"
DIM matrix(3,4), transpose(4,3) matrix() = 78,19,30,12,36,49,10,65,42,50,30,93,24,78,10,39,68,27,64,29 PROC_transpose(matrix(), transpose()) FOR row% = 0 TO DIM(matrix(),1) FOR col% = 0 TO DIM(matrix(),2) PRINT ;matrix(row%,col%) " "; NEXT PRINT NEXT row% PRINT FOR row% = 0 TO DIM(transpose(),1) FOR col% = 0 TO DIM(transpose(),2) PRINT ;transpose(row%,col%) " "; NEXT PRINT NEXT row%</lang>
Output:
78 19 30 12 36 49 10 65 42 50 30 93 24 78 10 39 68 27 64 29 78 49 30 39 19 10 93 68 30 65 24 27 12 42 78 64 36 50 10 29
Burlesque
<lang burlesque> blsq ) {{78 19 30 12 36}{49 10 65 42 50}{30 93 24 78 10}{39 68 27 64 29}}tpsp 78 49 30 39 19 10 93 68 30 65 24 27 12 42 78 64 36 50 10 29 </lang>
C
Transpose a 2D double array. <lang c>#include <stdio.h>
void transpose(void *dest, void *src, int src_h, int src_w) { int i, j; double (*d)[src_h] = dest, (*s)[src_w] = src; for (i = 0; i < src_h; i++) for (j = 0; j < src_w; j++) d[j][i] = s[i][j]; }
int main() { int i, j; double a[3][5] = {{ 0, 1, 2, 3, 4 }, { 5, 6, 7, 8, 9 }, { 1, 0, 0, 0, 42}}; double b[5][3]; transpose(b, a, 3, 5);
for (i = 0; i < 5; i++) for (j = 0; j < 3; j++) printf("%g%c", b[i][j], j == 2 ? '\n' : ' '); return 0; }</lang>
Transpose a matrix of size w x h in place with only O(1) space and without moving any element more than once. See the Wikipedia article for more information. <lang c>#include <stdio.h>
void transpose(double *m, int w, int h) { int start, next, i; double tmp;
for (start = 0; start <= w * h - 1; start++) { next = start; i = 0; do { i++; next = (next % h) * w + next / h; } while (next > start); if (next < start || i == 1) continue;
tmp = m[next = start]; do { i = (next % h) * w + next / h; m[next] = (i == start) ? tmp : m[i]; next = i; } while (next > start); } }
void show_matrix(double *m, int w, int h) { int i, j; for (i = 0; i < h; i++) { for (j = 0; j < w; j++) printf("%2g ", m[i * w + j]); putchar('\n'); } }
int main(void) { int i; double m[15]; for (i = 0; i < 15; i++) m[i] = i + 1;
puts("before transpose:"); show_matrix(m, 3, 5);
transpose(m, 3, 5);
puts("\nafter transpose:"); show_matrix(m, 5, 3);
return 0; }</lang> output
before transpose: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 after transpose: 1 4 7 10 13 2 5 8 11 14 3 6 9 12 15
C++
<lang cpp>#include <boost/numeric/ublas/matrix.hpp>
- include <boost/numeric/ublas/io.hpp>
int main() {
using namespace boost::numeric::ublas;
matrix<double> m(3,3);
for(int i=0; i!=m.size1(); ++i) for(int j=0; j!=m.size2(); ++j) m(i,j)=3*i+j;
std::cout << trans(m) << std::endl;
}</lang>
Output:
[3,3]((0,3,6),(1,4,7),(2,5,8))
Generic solution
- main.cpp
<lang cpp>#include <iostream>
- include "matrix.h"
- if !defined(ARRAY_SIZE)
#define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0]))
- endif
template<class T> void printMatrix(const Matrix<T>& m) {
std::cout << "rows = " << m.rowNum() << " columns = " << m.colNum() << std::endl; for (unsigned int i = 0; i < m.rowNum(); i++) { for (unsigned int j = 0; j < m.colNum(); j++) { std::cout << m[i][j] << " "; } std::cout << std::endl; }
} /* printMatrix() */
int main() {
int am[2][3] = { {1,2,3}, {4,5,6}, };
Matrix<int> a(ARRAY_SIZE(am), ARRAY_SIZE(am[0]), am[0], ARRAY_SIZE(am)*ARRAY_SIZE(am[0]));
try { std::cout << "Before transposition:" << std::endl; printMatrix(a); std::cout << std::endl; a.transpose(); std::cout << "After transposition:" << std::endl; printMatrix(a); } catch (MatrixException& e) { std::cerr << e.message() << std::endl; return e.errorCode(); }
} /* main() */</lang>
- matrix.h
<lang cpp>#ifndef _MATRIX_H
- define _MATRIX_H
- include <sstream>
- include <string>
- include <vector>
- include <algorithm>
- define MATRIX_ERROR_CODE_COUNT 5
- define MATRIX_ERR_UNDEFINED "1 Undefined exception!"
- define MATRIX_ERR_WRONG_ROW_INDEX "2 The row index is out of range."
- define MATRIX_ERR_MUL_ROW_AND_COL_NOT_EQUAL "3 The row number of second matrix must be equal with the column number of first matrix!"
- define MATRIX_ERR_MUL_ROW_AND_COL_BE_GREATER_THAN_ZERO "4 The number of rows and columns must be greater than zero!"
- define MATRIX_ERR_TOO_FEW_DATA "5 Too few data in matrix."
class MatrixException { private:
std::string message_; int errorCode_;
public:
MatrixException(std::string message = MATRIX_ERR_UNDEFINED);
inline std::string message() { return message_; };
inline int errorCode() { return errorCode_; };
};
MatrixException::MatrixException(std::string message) {
errorCode_ = MATRIX_ERROR_CODE_COUNT + 1; std::stringstream ss(message); ss >> errorCode_; if (errorCode_ < 1) { errorCode_ = MATRIX_ERROR_CODE_COUNT + 1; } std::string::size_type pos = message.find(' '); if (errorCode_ <= MATRIX_ERROR_CODE_COUNT && pos != std::string::npos) { message_ = message.substr(pos + 1); } else { message_ = message + " (This an unknown and unsupported exception!)"; }
}
/**
* Generic class for matrices. */
template <class T> class Matrix { private:
std::vector<T> v; // the data of matrix unsigned int m; // the number of rows unsigned int n; // the number of columns
protected:
virtual void clear() { v.clear(); m = n = 0; }
public:
Matrix() { clear(); } Matrix(unsigned int, unsigned int, T* = 0, unsigned int = 0); Matrix(unsigned int, unsigned int, const std::vector<T>&);
virtual ~Matrix() { clear(); } Matrix& operator=(const Matrix&); std::vector<T> operator[](unsigned int) const; Matrix operator*(const Matrix&); void transpose();
inline unsigned int rowNum() const { return m; }
inline unsigned int colNum() const { return n; }
inline unsigned int size() const { return v.size(); }
inline void add(const T& t) { v.push_back(t); }
};
template <class T> Matrix<T>::Matrix(unsigned int row, unsigned int col, T* data, unsigned int dataLength) {
clear(); if (row > 0 && col > 0) { m = row; n = col; unsigned int mxn = m * n; if (dataLength && data) { for (unsigned int i = 0; i < dataLength && i < mxn; i++) { v.push_back(data[i]); } } }
}
template <class T> Matrix<T>::Matrix(unsigned int row, unsigned int col, const std::vector<T>& data) {
clear(); if (row > 0 && col > 0) { m = row; n = col; unsigned int mxn = m * n; if (data.size() > 0) { for (unsigned int i = 0; i < mxn && i < data.size(); i++) { v.push_back(data[i]); } } }
}
template<class T> Matrix<T>& Matrix<T>::operator=(const Matrix<T>& other) {
clear(); if (other.m > 0 && other.n > 0) { m = other.m; n = other.n; unsigned int mxn = m * n; for (unsigned int i = 0; i < mxn && i < other.size(); i++) { v.push_back(other.v[i]); } } return *this;
}
template<class T> std::vector<T> Matrix<T>::operator[](unsigned int index) const {
std::vector<T> result; if (index >= m) { throw MatrixException(MATRIX_ERR_WRONG_ROW_INDEX); } else if ((index + 1) * n > size()) { throw MatrixException(MATRIX_ERR_TOO_FEW_DATA); } else { unsigned int begin = index * n; unsigned int end = begin + n; for (unsigned int i = begin; i < end; i++) { result.push_back(v[i]); } } return result;
}
template<class T> Matrix<T> Matrix<T>::operator*(const Matrix<T>& other) {
Matrix result(m, other.n); if (n != other.m) { throw MatrixException(MATRIX_ERR_MUL_ROW_AND_COL_NOT_EQUAL); } else if (m <= 0 || n <= 0 || other.n <= 0) { throw MatrixException(MATRIX_ERR_MUL_ROW_AND_COL_BE_GREATER_THAN_ZERO); } else if (m * n > size() || other.m * other.n > other.size()) { throw MatrixException(MATRIX_ERR_TOO_FEW_DATA); } else { for (unsigned int i = 0; i < m; i++) { for (unsigned int j = 0; j < other.n; j++) { T temp = v[i * n] * other.v[j]; for (unsigned int k = 1; k < n; k++) { temp += v[i * n + k] * other.v[k * other.n + j]; } result.v.push_back(temp); } } } return result;
}
template<class T> void Matrix<T>::transpose() {
if (m * n > size()) { throw MatrixException(MATRIX_ERR_TOO_FEW_DATA); } else { std::vector<T> v2; std::swap(v, v2); for (unsigned int i = 0; i < n; i++) { for (unsigned int j = 0; j < m; j++) { v.push_back(v2[j * n + i]); } } std::swap(m, n); }
}
- endif /* _MATRIX_H */</lang>
Output:
Before transposition: rows = 2 columns = 3 1 2 3 4 5 6 After transposition: rows = 3 columns = 2 1 4 2 5 3 6
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
Locally Procedural Style
(Currently the standard version std.range.transposed doesn't work.) <lang d>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);
}</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.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);
}</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.
<lang factor>( scratchpad ) { { 1 2 3 } { 4 5 6 } } flip .
{ { 1 4 } { 2 5 } { 3 6 } }</lang>
Fortran
In ISO Fortran 90 or later, use the TRANSPOSE intrinsic function: <lang fortran>integer, parameter :: n = 3, m = 5 real, dimension(n,m) :: a = reshape( (/ (i,i=1,n*m) /), (/ n, m /) ) real, dimension(m,n) :: b
b = transpose(a)
do i = 1, n
print *, a(i,:)
end do
do j = 1, m
print *, b(j,:)
end do</lang>
In ANSI FORTRAN 77 with MIL-STD-1753 extensions or later, use nested structured DO loops: <lang fortran>REAL A(3,5), B(5,3) DATA ((A(I,J),I=1,3),J=1,5) /1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15/
DO I = 1, 3
DO J = 1, 5 B(J,I) = A(I,J) END DO
END DO</lang>
In ANSI FORTRAN 66 or later, use nested labeled DO loops: <lang fortran> REAL A(3,5), B(5,3)
DATA ((A(I,J),I=1,3),J=1,5) /1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15/ DO 10 I = 1, 3 DO 20 J = 1, 5 B(J,I) = A(I,J)
20 CONTINUE 10 CONTINUE</lang>
F#
Very straightforward solution... <lang fsharp>let transpose (mtx : _ [,]) = Array2D.init (mtx.GetLength 1) (mtx.GetLength 0) (fun x y -> mtx.[y,x])</lang>
GAP
<lang gap>originalMatrix := [[1, 1, 1, 1],
[2, 4, 8, 16], [3, 9, 27, 81], [4, 16, 64, 256], [5, 25, 125, 625]];
transposedMatrix := TransposedMat(originalMatrix);</lang>
Go
2D representation
Go arrays and slices are only one-dimensional. The obvious way to represent two-dimensional arrays is with a slice of slices: <lang go>package main
import "fmt"
type row []float64 type matrix []row
func main() {
m := matrix{ {1, 2, 3}, {4, 5, 6}, } printMatrix(m) t := transpose(m) printMatrix(t)
}
func printMatrix(m matrix) {
for _, s := range m { fmt.Println(s) }
}
func transpose(m matrix) matrix {
r := make(matrix, len(m[0])) for x, _ := range r { r[x] = make(row, len(m)) } for y, s := range m { for x, e := range s { r[x][y] = e } } return r
}</lang>
- Output:
[1 2 3] [4 5 6] [1 4] [2 5] [3 6]
Flat representation
Slices of slices turn out to have disadvantages. It is possible to construct ill-formed matricies with a different number of elements on different rows, for example. They require multiple allocations, and the compiler must generate complex address calculations to index elements.
A flat element representation with a stride is almost always better. <lang go>package main
import "fmt"
type matrix struct {
ele []float64 stride int
}
// construct new matrix from slice of slices func matrixFromRows(rows [][]float64) *matrix {
if len(rows) == 0 { return &matrix{nil, 0} } m := &matrix{make([]float64, len(rows)*len(rows[0])), len(rows[0])} for rx, row := range rows { copy(m.ele[rx*m.stride:(rx+1)*m.stride], row) } return m
}
func main() {
m := matrixFromRows([][]float64{ {1, 2, 3}, {4, 5, 6}, }) m.print("original:") m.transpose().print("transpose:")
}
func (m *matrix) print(heading string) {
if heading > "" { fmt.Print("\n", heading, "\n") } for e := 0; e < len(m.ele); e += m.stride { fmt.Println(m.ele[e : e+m.stride]) }
}
func (m *matrix) transpose() *matrix {
r := &matrix{make([]float64, len(m.ele)), len(m.ele) / m.stride} rx := 0 for _, e := range m.ele { r.ele[rx] = e rx += r.stride if rx >= len(r.ele) { rx -= len(r.ele) - 1 } } return r
}</lang>
- Output:
original: [1 2 3] [4 5 6] transpose: [1 4] [2 5] [3 6]
Transpose in place
Note representation is "flat," as above. <lang go>package main
import "fmt"
type matrix struct {
ele []float64 stride int
}
// construct new matrix from slice of slices func matrixFromRows(rows [][]float64) *matrix {
if len(rows) == 0 { return &matrix{nil, 0} } m := &matrix{make([]float64, len(rows)*len(rows[0])), len(rows[0])} for rx, row := range rows { copy(m.ele[rx*m.stride:(rx+1)*m.stride], row) } return m
}
func main() {
m := matrixFromRows([][]float64{ {1, 2, 3}, {4, 5, 6}, }) m.print("original:") m.transposeInPlace() m.print("transpose:")
}
func (m *matrix) print(heading string) {
if heading > "" { fmt.Print("\n", heading, "\n") } for e := 0; e < len(m.ele); e += m.stride { fmt.Println(m.ele[e : e+m.stride]) }
}
func (m *matrix) transposeInPlace() {
h := len(m.ele) / m.stride for start := range m.ele { next := start i := 0 for { i++ next = (next%h)*m.stride + next/h if next <= start { break } } if next < start || i == 1 { continue }
next = start tmp := m.ele[next] for { i = (next%h)*m.stride + next/h if i == start { m.ele[next] = tmp } else { m.ele[next] = m.ele[i] } next = i if next <= start { break } } } m.stride = h
}</lang> Output same as above.
Library
<lang go>package main
import (
"fmt"
mat "github.com/skelterjohn/go.matrix"
)
func main() {
m := mat.MakeDenseMatrixStacked([][]float64{ {1, 2, 3}, {4, 5, 6}, }) fmt.Println("original:") fmt.Println(m) m = m.Transpose() fmt.Println("transpose:") fmt.Println(m)
}</lang>
- Output:
original: {1, 2, 3, 4, 5, 6} transpose: {1, 4, 2, 5, 3, 6}
Groovy
The Groovy extensions to the List class provides a transpose method: <lang groovy>def matrix = [ [ 1, 2, 3, 4 ],
[ 5, 6, 7, 8 ] ]
matrix.each { println it } println() def transpose = matrix.transpose()
transpose.each { println it }</lang>
Output:
[1, 2, 3, 4] [5, 6, 7, 8] [1, 5] [2, 6] [3, 7] [4, 8]
Haskell
For matrices represented as lists, there's transpose: <lang haskell>*Main> transpose [[1,2],[3,4],[5,6]] [[1,3,5],[2,4,6]]</lang>
For matrices in arrays, one can use ixmap: <lang haskell>import Data.Array
swap (x,y) = (y,x)
transpArray :: (Ix a, Ix b) => Array (a,b) e -> Array (b,a) e transpArray a = ixmap (swap l, swap u) swap a where
(l,u) = bounds a</lang>
Hope
<lang hope>uses lists; dec transpose : list (list alpha) -> list (list alpha); --- transpose ([]::_) <= []; --- transpose n <= map head n :: transpose (map tail n);</lang>
HicEst
<lang hicest>REAL :: mtx(2, 4)
mtx = 1.1 * $ WRITE() mtx
SOLVE(Matrix=mtx, Transpose=mtx) WRITE() mtx</lang> Output: <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
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>
Lang5
<lang Lang5>12 iota [3 4] reshape 1 + dup . 1 transpose .</lang>
- Output:
[ [ 1 2 3 4 ] [ 5 6 7 8 ] [ 9 10 11 12 ] ][ [ 1 5 9 ] [ 2 6 10 ] [ 3 7 11 ] [ 4 8 12 ] ]
Liberty BASIC
There is no native matrix capability. A set of functions is available at http://www.diga.me.uk/RCMatrixFuncs.bas implementing matrices of arbitrary dimension in a string format. <lang lb>MatrixC$ ="4, 3, 0, 0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90, 1.00, 1.10"
print "Transpose of matrix" call DisplayMatrix MatrixC$ print " =" MatrixT$ =MatrixTranspose$( MatrixC$) call DisplayMatrix MatrixT$</lang>
Transpose of matrix
| 0.00000 0.10000 0.20000 0.30000 |
| 0.40000 0.50000 0.60000 0.70000 |
| 0.80000 0.90000 1.00000 1.10000 |
=
| 0.00000 0.40000 0.80000 |
| 0.10000 0.50000 0.90000 |
| 0.20000 0.60000 1.00000 |
| 0.30000 0.70000 1.10000 |
Lua
<lang lua>function Transpose( m )
local res = {} for i = 1, #m[1] do res[i] = {} for j = 1, #m do res[i][j] = m[j][i] end end return res
end
-- a test for Transpose(m) mat = { { 1, 2, 3 }, { 4, 5, 6 } } erg = Transpose( mat ) for i = 1, #erg do
for j = 1, #erg[1] do io.write( erg[i][j] ) io.write( " " ) end io.write( "\n" )
end</lang>
Using apply map list <lang lua>function map(f, a)
local b = {} for k,v in ipairs(a) do b[k] = f(v) end return b
end
function mapn(f, ...)
local c = {} local k = 1 local aarg = {...} local n = table.getn(aarg) while true do local a = map(function(b) return b[k] end, aarg) if table.getn(a) < n then return c end c[k] = f(unpack(a)) k = k + 1 end
end
function apply(f1, f2, a)
return f1(f2, unpack(a))
end
xy = {{1,2,3,4},{1,2,3,4},{1,2,3,4}} yx = apply(mapn, function(...) return {...} end, xy) print(table.concat(map(function(a) return table.concat(a,",") end, xy), "\n"),"\n") print(table.concat(map(function(a) return table.concat(a,",") end, yx), "\n"))</lang>
Mathematica
<lang mathematica>originalMatrix = {{1, 1, 1, 1},
{2, 4, 8, 16}, {3, 9, 27, 81}, {4, 16, 64, 256}, {5, 25, 125, 625}}
transposedMatrix = Transpose[originalMatrix]</lang>
MATLAB / Octave
Matlab contains two built-in methods of transposing a matrix: by using the transpose()
function, or by using the .'
operator. The '
operator yields the complex conjugate transpose.
<lang Matlab>>> transpose([1 2;3 4])
ans =
1 3 2 4
>> [1 2;3 4].'
ans =
1 3 2 4</lang>
But, you can, obviously, do the transposition of a matrix without a built-in method, in this case, the code can be this hereafter code: <lang Matlab>
B=size(A); %In this code, we assume that a previous matrix "A" has already been inputted. for j=1:B(1)
for i=1:B(2) C(i,j)=A(j,i); end %The transposed A-matrix should be C
end
</lang>
Transposing nested cells using apply map list <lang Matlab>xy = {{1,2,3,4},{1,2,3,4},{1,2,3,4}} yx = feval(@(x) cellfun(@(varargin)[varargin],x{:},'un',0), xy)</lang>
Maxima
<lang maxima>originalMatrix : matrix([1, 1, 1, 1],
[2, 4, 8, 16], [3, 9, 27, 81], [4, 16, 64, 256], [5, 25, 125, 625]);
transposedMatrix : transpose(originalMatrix);</lang>
MAXScript
Uses the built in transpose() function <lang maxscript>m = bigMatrix 5 4 for i in 1 to 5 do for j in 1 to 4 do m[i][j] = pow i j m = transpose m</lang>
Nial
make an array <lang nial>|a := 2 3 reshape count 6 =1 2 3 =4 5 6</lang> transpose it <lang nial>|transpose a =1 4 =2 5 =3 6</lang>
Objeck
<lang objeck> bundle Default {
class Transpose { function : Main(args : String[]) ~ Nil { input := [[1, 1, 1, 1] [2, 4, 8, 16] [3, 9, 27, 81] [4, 16, 64, 256] [5, 25, 125, 625]]; dim := input->Size();
output := Int->New[dim[0],dim[1]]; for(i := 0; i < dim[0]; i+=1;) { for(j := 0; j < dim[1]; j+=1;) { output[i,j] := input[i,j]; }; };
Print(output); }
function : Print(matrix : Int[,]) ~ Nil { dim := matrix->Size(); for(i := 0; i < dim[0]; i+=1;) { for(j := 0; j < dim[1]; j+=1;) { IO.Console->Print(matrix[i,j])->Print('\t'); }; '\n'->Print(); }; } }
} </lang>
Output:
1 2 3 4 5 1 4 9 16 25 1 8 27 64 125 1 16 81 256 625
OCaml
Matrices can be represented in OCaml as a type 'a array array, or using the module Bigarray. The implementation below uses a bigarray:
<lang ocaml>open Bigarray
let transpose b =
let dim1 = Array2.dim1 b and dim2 = Array2.dim2 b in let kind = Array2.kind b and layout = Array2.layout b in let b' = Array2.create kind layout dim2 dim1 in for i=0 to pred dim1 do for j=0 to pred dim2 do b'.{j,i} <- b.{i,j} done; done; (b')
let array2_display print newline b =
for i=0 to Array2.dim1 b - 1 do for j=0 to Array2.dim2 b - 1 do print b.{i,j} done; newline(); done;
let a = Array2.of_array int c_layout [|
[| 1; 2; 3; 4 |]; [| 5; 6; 7; 8 |];
|]
array2_display (Printf.printf " %d") print_newline (transpose a) ;;</lang>
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>
OxygenBasic
<lang oxygenbasic> function Transpose(double *A,*B, sys nx,ny) '==========================================
sys x,y indexbase 0 for x=0 to <nx for y=0 to <ny B[y*nx+x]=A[x*ny+y] next next
end function
function MatrixShow(double*A, sys nx,ny) as string '=================================================
sys x,y indexbase 0 string pr="",tab=chr(9),cr=chr(13)+chr(10) for y=0 to <ny for x=0 to <nx pr+=tab A[x*ny+y] next pr+=cr next return pr
end function
'==== 'DEMO '====
double A[5*4],B[4*5] 'columns x 'rows y
A <= 'y minor, x major 11,12,13,14,15, 21,22,23,24,25, 31,32,33,34,35, 41,42,43,44,45
print MatrixShow A,5,4 Transpose A,B,5,4 print MatrixShow B,4,5 </lang>
PARI/GP
The GP function for matrix (or vector) transpose is mattranspose
, but it is usually invoked with a tilde:
<lang parigp>M~</lang>
In PARI the function is
<lang C>gtrans(M)</lang>
though shallowtrans
is also available when deep copying is not desired.
Pascal
<lang pascal>Program Transpose;
const
A: array[1..3,1..5] of integer = (( 1, 2, 3, 4, 5), ( 6, 7, 8, 9, 10),
(11, 12, 13, 14, 15) ); var
B: array[1..5,1..3] of integer; i, j: integer;
begin
for i := low(A) to high(A) do for j := low(A[1]) to high(A[1]) do B[j,i] := A[i,j];
writeln ('A:'); for i := low(A) to high(A) do begin for j := low(A[1]) to high(A[1]) do write (A[i,j]:3); writeln; end;
writeln ('B:'); for i := low(B) to high(B) do begin for j := low(B[1]) to high(B[1]) do write (B[i,j]:3); writeln; end;
end.</lang> Output:
% ./Transpose A: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 B: 1 6 11 2 7 12 3 8 13 4 9 14 5 10 15
Perl
<lang perl>use Math::Matrix;
$m = Math::Matrix->new(
[1, 1, 1, 1], [2, 4, 8, 16], [3, 9, 27, 81], [4, 16, 64, 256], [5, 25, 125, 625],
);
$m->transpose->print;</lang>
Output:
1.00000 2.00000 3.00000 4.00000 5.00000 1.00000 4.00000 9.00000 16.00000 25.00000 1.00000 8.00000 27.00000 64.00000 125.00000 1.00000 16.00000 81.00000 256.00000 625.00000
Manually: <lang perl>my @m = (
[1, 1, 1, 1], [2, 4, 8, 16], [3, 9, 27, 81], [4, 16, 64, 256], [5, 25, 125, 625],
);
my @transposed; foreach my $j (0..$#{$m[0]}) {
push(@transposed, [map $_->[$j], @m]);
}</lang>
Perl 6
<lang perl6>sub transpose(@m) {
my @t; for ^@m X ^@m[0] -> $x, $y { @t[$y][$x] = @m[$x][$y] } return @t;
}
- creates a random matrix
my @a; for (^10).pick X (^10).pick -> $x, $y { @a[$x][$y] = (^100).pick; }
say "original: "; .perl.say for @a;
my @b = transpose(@a);
say "transposed: "; .perl.say for @b;</lang>
A more concise solution: <lang perl6>sub transpose (@m) {
@m[0].keys.map: {[ @m».[$_] ]};
}
my @a = [< a b c d e >],
[< f g h i j >], [< k l m n o >], [< p q r s t >];
.say for @a.&transpose;</lang> Output:
a f k p b g l q c h m r d i n s e j o t
PHP
<lang php>function transpose($m) {
if (count($m) == 0) // special case: empty matrix return array(); else if (count($m) == 1) // special case: row matrix return array_chunk($m[0], 1);
// array_map(NULL, m[0], m[1], ..) array_unshift($m, NULL); // the original matrix is not modified because it was passed by value return call_user_func_array('array_map', $m);
}</lang>
PicoLisp
<lang PicoLisp>(de matTrans (Mat)
(apply mapcar Mat list) )
(matTrans '((1 2 3) (4 5 6)))</lang> Output:
-> ((1 4) (2 5) (3 6))
PL/I
<lang PL/I>/* The short method: */ declare A(m, n) float, B (n,m) float defined (A(2sub, 1sub)); /* Any reference to B gives the transpose of matrix A. */</lang> Traditional method: <lang PL/I>/* Transpose matrix A, result at B. */ transpose: procedure (a, b);
declare (a, b) (*,*) float controlled; declare (m, n) fixed binary;
if allocation(b) > 0 then free b;
m = hbound(a,1); n = hbound(a,2);
allocate b(n,m);
do i = 1 to m; b(*,i) = a(i,*); end;
end transpose;</lang>
Pop11
<lang pop11>define transpose(m) -> res;
lvars bl = boundslist(m); if length(bl) /= 4 then throw([need_2d_array ^a]) endif; lvars i, i0 = bl(1), i1 = bl(2); lvars j, j0 = bl(3), j1 = bl(4); newarray([^j0 ^j1 ^i0 ^i1], 0) -> res; for i from i0 to i1 do for j from j0 to j1 do m(i, j) -> res(j, i); endfor; endfor;
enddefine;</lang>
PostScript
<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.
<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))
- in Python 3.x, you would do:
- print(list(zip(*m)))</lang>
Output:
[(1, 2, 3, 4, 5), (1, 4, 9, 16, 25), (1, 8, 27, 64, 125), (1, 16, 81, 256, 625)]
R
<lang R>b <- 1:5 m <- matrix(c(b, b^2, b^3, b^4), 5, 4) print(m) tm <- t(m) print(tm)</lang>
Racket
<lang racket>
- lang racket
(require math) (matrix-transpose (matrix [[1 2] [3 4]])) </lang> Output:
(array #[#[1 3] #[2 4]])
Rascal
<lang Rascal>public rel[real, real, real] matrixTranspose(rel[real x, real y, real v] matrix){
return {<y, x, v> | <x, y, v> <- matrix};
}
//a matrix public rel[real x, real y, real v] matrixA = { <0.0,0.0,12.0>, <0.0,1.0, 6.0>, <0.0,2.0,-4.0>, <1.0,0.0,-51.0>, <1.0,1.0,167.0>, <1.0,2.0,24.0>, <2.0,0.0,4.0>, <2.0,1.0,-68.0>, <2.0,2.0,-41.0> };</lang>
REXX
<lang rexx>/*REXX program transposes a matrix, shows before and after matrixes. */ x. = x.1 = 1.02 2.03 3.04 4.05 5.06 6.07 7.07 x.2 = 111 2222 33333 444444 5555555 66666666 777777777
do r=1 while x.r\== /*build the "A" matric from X. numbers */ do c=1 while x.r\== parse var x.r a.r.c x.r end /*c*/ end /*r*/
rows = r-1; cols = c-1 L=0 /*L is the maximum width element value.*/
do i=1 for rows do j=1 for cols b.j.i = a.i.j; L=max(L,length(b.j.i)) end /*j*/ end /*i*/
call showMat 'A', rows, cols call showMat 'B', cols, rows exit /*stick a fork in it, we're done.*/ /*─────────────────────────────────────SHOWMAT subroutine───────────────*/ showMat: parse arg mat,rows,cols; say say center(mat 'matrix', cols*(L+1) +4, "─")
do r=1 for rows; _= do c=1 for cols; _ = _ right(value(mat'.'r'.'c), L) end /*c*/ say _ end /*r*/
return</lang> output
─────────────────────────────────A matrix───────────────────────────────── 1.02 2.03 3.04 4.05 5.06 6.07 7.07 111 2222 33333 444444 5555555 66666666 777777777 ────────B matrix──────── 1.02 111 2.03 2222 3.04 33333 4.05 444444 5.06 5555555 6.07 66666666 7.07 777777777
RLaB
<lang RLaB> >> m = rand(3,5)
0.41844289 0.476591435 0.75054022 0.226388925 0.963880314 0.91267171 0.941762397 0.464227895 0.693482786 0.203839405 0.261512966 0.157981873 0.26582235 0.11557427 0.0442493069
>> m'
0.41844289 0.91267171 0.261512966 0.476591435 0.941762397 0.157981873 0.75054022 0.464227895 0.26582235 0.226388925 0.693482786 0.11557427 0.963880314 0.203839405 0.0442493069</lang>
Ruby
<lang ruby>m=[[1, 1, 1, 1],
[2, 4, 8, 16], [3, 9, 27, 81], [4, 16, 64, 256], [5, 25,125, 625]]
puts m.transpose</lang> Output:
[[1, 2, 3, 4, 5], [1, 4, 9, 16, 25], [1, 8, 27, 64, 125], [1, 16, 81, 256, 625]]
or using 'matrix' from the standard library <lang ruby>require 'matrix'
m=Matrix[[1, 1, 1, 1],
[2, 4, 8, 16], [3, 9, 27, 81], [4, 16, 64, 256], [5, 25,125, 625]]
puts m.transpose</lang> Output:
Matrix[[1, 2, 3, 4, 5], [1, 4, 9, 16, 25], [1, 8, 27, 64, 125], [1, 16, 81, 256, 625]]
or using zip: <lang ruby>def transpose(m)
m[0].zip(*m[1..-1])
end p transpose([[1,2,3],[4,5,6]])</lang> Output:
[[1, 4], [2, 5], [3, 6]]
Run BASIC
<lang runbasic>mtrx$ ="4, 3, 0, 0.10, 0.20, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80, 0.90, 1.00, 1.10"
print "Transpose of matrix" call DisplayMatrix mtrx$ print " =" MatrixT$ =MatrixTranspose$(mtrx$) call DisplayMatrix MatrixT$
end
function MatrixTranspose$(in$)
w = val(word$(in$, 1, ",")) ' swap w and h parameters h = val(word$(in$, 2, ",")) t$ = str$(h); ","; str$(w); "," for i =1 to w for j =1 to h t$ = t$ +word$(in$, 2 +i +(j -1) *w, ",") +"," next j next i
MatrixTranspose$ =left$(t$, len(t$) -1) end function
sub DisplayMatrix in$ ' Display looking like a matrix!
html "
" w = val(word$(in$, 1, ",")) h = val(word$(in$, 2, ",")) for i =0 to h -1 html "" for j =1 to w term$ = word$(in$, j +2 +i *w, ",") html ""next jhtml "" next i html "
";val(term$);" |
"
end sub</lang>Output:
Transpose of matrix
0 | 0.1 | 0.2 | 0.3 |
0.4 | 0.5 | 0.6 | 0.7 |
0.8 | 0.9 | 1.0 | 1.1 |
=
0 | 0.4 | 0.8 |
0.1 | 0.5 | 0.9 |
0.2 | 0.6 | 1.0 |
0.3 | 0.7 | 1.1 |
Scala
<lang scala>scala> Array.tabulate(4)(i => Array.tabulate(4)(j => i*4 + j)) res12: Array[Array[Int]] = Array(Array(0, 1, 2, 3), Array(4, 5, 6, 7), Array(8, 9, 10, 11), Array(12, 13, 14, 15))
scala> res12.transpose res13: Array[Array[Int]] = Array(Array(0, 4, 8, 12), Array(1, 5, 9, 13), Array(2, 6, 10, 14), Array(3, 7, 11, 15))
scala> res12 map (_ map ("%2d" format _) mkString " ") mkString "\n" res16: String =
0 1 2 3 4 5 6 7 8 9 10 11
12 13 14 15
scala> res13 map (_ map ("%2d" format _) mkString " ") mkString "\n" res17: String =
0 4 8 12 1 5 9 13 2 6 10 14 3 7 11 15</lang>
Scheme
<lang scheme>(define (transpose m)
(apply map list m))</lang>
Seed7
<lang seed7>$ include "seed7_05.s7i";
include "float.s7i";
const type: matrix is array array float;
const func matrix: transpose (in matrix: aMatrix) is func
result var matrix: transposedMatrix is matrix.value; local var integer: i is 0; var integer: j is 0; begin transposedMatrix := length(aMatrix[1]) times length(aMatrix) times 0.0; for i range 1 to length(aMatrix) do for j range 1 to length(aMatrix[1]) do transposedMatrix[j][i] := aMatrix[i][j]; end for; end for; end func;
const proc: write (in matrix: aMatrix) is func
local var integer: line is 0; var integer: column is 0; begin for line range 1 to length(aMatrix) do for column range 1 to length(aMatrix[line]) do write(" " <& aMatrix[line][column] digits 2); end for; writeln; end for; end func;
const matrix: testMatrix is [] (
[] (0.0, 0.1, 0.2, 0.3), [] (0.4, 0.5, 0.6, 0.7), [] (0.8, 0.9, 1.0, 1.1));
const proc: main is func
begin writeln("Before Transposition:"); write(testMatrix); writeln; writeln("After Transposition:"); write(transpose(testMatrix)); end func;</lang>
Output:
Before Transposition: 0.00 0.10 0.20 0.30 0.40 0.50 0.60 0.70 0.80 0.90 1.00 1.10 After Transposition: 0.00 0.40 0.80 0.10 0.50 0.90 0.20 0.60 1.00 0.30 0.70 1.10
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
<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>#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>>
- Programming Tasks
- Matrices
- ACL2
- ActionScript
- Ada
- Agda
- ALGOL 68
- APL
- AutoHotkey
- AWK
- BASIC
- BBC BASIC
- Burlesque
- C
- C++
- Boost.uBLAS
- C sharp
- Clojure
- CoffeeScript
- Common Lisp
- D
- ELLA
- Euphoria
- Factor
- Fortran
- F Sharp
- GAP
- Go
- Groovy
- Haskell
- Hope
- HicEst
- Icon
- Unicon
- IDL
- J
- Java
- JavaScript
- Joy
- K
- Lang5
- Liberty BASIC
- Lua
- Mathematica
- MATLAB
- Octave
- Maxima
- MAXScript
- Nial
- Objeck
- OCaml
- OxygenBasic
- PARI/GP
- Pascal
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- Pop11
- PostScript
- Initlib
- Prolog
- PureBasic
- Python
- R
- Racket
- Rascal
- REXX
- RLaB
- Ruby
- Run BASIC
- Scala
- Scheme
- Seed7
- Tcl
- Tcllib
- TI-83 BASIC
- TI-89 BASIC
- Ursala