Matrix transposition: Difference between revisions
| Line 1,104: | Line 1,104: | ||
enddefine;</lang> |
enddefine;</lang> |
||
=={{header|Prolog}}== |
=={{header|Prolog}}== |
||
Predicate transpose/2 exists in libray clpfd of SWI-Prolog.<BR> |
|||
In Prolog, a matrix is a list of lists. transpose/2 can be written like that. <BR> |
|||
Works with SWI-Prolog. |
|||
<lang Prolog>% transposition of a rectangular matrix |
<lang Prolog>% transposition of a rectangular matrix |
||
| Line 1,118: | Line 1,120: | ||
initdl(V, [V | X] - X). |
initdl(V, [V | X] - X). |
||
work(Lst, [], Out) :- |
work(Lst, [H], Out) :- |
||
maplist(my_append_last, Lst, H, Out). |
|||
work(Lst, [H | T], Out) :- |
work(Lst, [H | T], Out) :- |
||
| Line 1,127: | Line 1,129: | ||
my_append(X-Y, C, X1-Y1) :- |
my_append(X-Y, C, X1-Y1) :- |
||
append_dl(X-Y, [C | U]- U, 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 |
% "quick" append |
||
append_dl(X-Y, Y-Z, X-Z). |
append_dl(X-Y, Y-Z, X-Z). |
||
% transforms difference list in list |
|||
dl2l(X-[], X). |
|||
</lang> |
</lang> |
||
Revision as of 09:30, 20 October 2010
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
<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
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
Reserving the proper space for the matrix is left to the caller. <lang c>void transpose_matrix(double *m,
double *d,
int rows, int columns)
{
int i,j;
for(i = 0; i < rows; i++)
{
for(j = 0; j < columns; j++)
{
d[j*rows+i] = m[i*columns+j];
}
}
}</lang> Usage example (note that you must specify first the row, then the column): <lang c>int main() {
int i,j;
double a[4][5] = {{ 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}};
double b[5][4];
transpose_matrix(&a[0][0], &b[0][0], 4, 5);
for(j=0;j<4;j++)
{
for(i=0;i<5;i++)
{
printf("%6.2lf ", a[j][i]);
}
printf("\n");
}
printf("--\n");
for(j=0;j<5;j++)
{
for(i=0;i<4;i++)
{
printf("%6.2lf ", b[j][i]);
}
printf("\n");
}
}</lang> Output:
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 -- 1.00 1.00 1.00 1.00 2.00 4.00 8.00 16.00 3.00 9.00 27.00 81.00 4.00 16.00 64.00 256.00 5.00 25.00 125.00 625.00
Playing more to C's strengths, the following implementation transposes a matrix of any type and dimensions in place with only O(1) space. See the Wikipedia article for more information. <lang c>void *transpose_matrix(void *matrix, int rows, int cols, size_t item_size) {
- define ALIGNMENT 16 /* power of 2 >= minimum array boundary alignment; maybe unnecessary but machine dependent */
char *cursor; char carry[ALIGNMENT]; size_t block_size, remaining_size; int nadir, lag, orbit, ents;
if (rows == 1 || cols == 1)
return matrix;
ents = rows * cols;
cursor = (char *) matrix;
remaining_size = item_size;
while ((block_size = ALIGNMENT < remaining_size ? ALIGNMENT : remaining_size))
{
nadir = 1; /* first and last entries are always fixed points so aren't visited */
while (nadir + 1 < ents)
{
memcpy(carry, &cursor[(lag = nadir) * item_size], block_size);
while ((orbit = lag / rows + cols * (lag % rows)) > nadir) /* follow a complete cycle */
{
memcpy(&cursor[lag * item_size], &cursor[orbit * item_size], block_size);
lag = orbit;
}
memcpy(&cursor[lag * item_size], carry, block_size);
orbit = nadir++;
while (orbit < nadir && nadir + 1 < ents) /* find the next unvisited index by an exhaustive search */
{
orbit = nadir;
while ((orbit = orbit / rows + cols * (orbit % rows)) > nadir);
if (orbit < nadir) nadir++;
}
}
cursor += block_size;
remaining_size -= block_size;
}
return matrix;
}</lang> No extra storage allocation is required by the caller. Here are usage examples for an array of doubles and an array of complex numbers. <lang c>a = (double *) transpose_matrix((void *) a, n, m, sizeof(double)); b = (complex *) transpose_matrix((void *) b, n, m, sizeof(complex));</lang> After execution, the memory maps of a and b will be those of m by n arrays instead of n by m.
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
Clojure
<lang lisp>;takes matrix represented as nested lists (defn transpose [m]
(apply map list m))
- takes matrix represented as nested vectors
(defn transpose [m]
(vec (apply map vector m)))</lang>
<lang lisp>; takes both representations (and can be extended) (defmulti transpose class) (defmethod transpose clojure.lang.PersistentList [m]
(apply map list m))
(defmethod transpose clojure.lang.PersistentVector [m]
(vec (apply map vector m)))
</lang>
Common Lisp
<lang lisp>(defun transpose (m)
(apply #'mapcar #'list m))</lang>
D
<lang d>import std.stdio: writefln; import std.string: join, format;
T[][] transpose(T)(T[][] mat) {
static bool isRectangular(T[][] mat) {
foreach (row; mat)
if (row.length != mat[0].length)
return false;
return true;
}
if (!mat.length || !isRectangular(mat))
throw new Exception("Transpose Error");
auto result = new T[][](mat[0].length, mat.length);
for (int i = 0; i < mat.length; i++)
for (int j = 0; j < mat[0].length; j++)
result[j][i] = mat[i][j];
return result;
}
string toString(T)(T[][] mat) { // for pretty print
string[] parts;
foreach (row; mat)
parts ~= format("%8s", row)[1 .. $ - 1];
return "\n<" ~ join(parts, "\n ") ~ ">";
}
void main() {
float[][] m = [[0.5,0,0,1], [0.0,0.5,0,0], [0.0,0,0.5,-1]];
writefln("M:", m.toString());
auto mt = m.transpose();
writefln("M transposed:", mt.toString());
}</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>
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>
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>
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>
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
<lang Matlab>function [transposedMatrix] = transposematrix(originalMatrix)
transposedMatrix = originalMatrix';</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>
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.rand.truncate X ^10.rand.truncate -> $x, $y { @a[$x][$y]=100.rand.truncate; };
say "original: "; .perl.say for @a;
my @b = transpose(@a);
say "transposed: "; .perl.say for @b;</lang>
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>
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>
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))
- 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 <- c(1,2,3,4,5) m <- matrix(c(b, b^2, b^3, b^4), 5, 4) print(m) tm <- t(m) print(tm)</lang>
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
<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]]
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>
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} {
set max [widest $m]
lassign [size $m] rows cols
for {set i 0} {$i < $rows} {incr i} {
for {set j 0} {$j < $cols} {incr j} {
puts -nonewline [format "%*s " [lindex $max $j] [lindex $m $i $j]]
}
puts ""
}
} proc widest {m} {
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} {
lset max $j [max [lindex $max $j] [string length [lindex $m $i $j]]]
}
}
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 print_matrix [transpose $m]</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
Using the struct::matrix package from
<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
- ActionScript
- Ada
- ALGOL 68
- AutoHotkey
- BASIC
- C
- C++
- Boost.uBLAS
- Clojure
- Common Lisp
- D
- ELLA
- Factor
- Fortran
- F Sharp
- GAP
- Groovy
- Haskell
- Hope
- HicEst
- IDL
- J
- Java
- JavaScript
- Joy
- Lua
- Mathematica
- MATLAB
- Maxima
- MAXScript
- Nial
- OCaml
- Octave
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- Pop11
- Prolog
- PureBasic
- Python
- R
- RLaB
- Ruby
- Matrix.rb
- Scala
- Scheme
- Tcl
- Tcllib
- TI-83 BASIC
- TI-89 BASIC
- Ursala