Identity matrix: Difference between revisions
Walterpachl (talk | contribs) m (move again) |
No edit summary |
||
| Line 602: | Line 602: | ||
0 0 0 0 0 0 0 0 1 |
0 0 0 0 0 0 0 0 1 |
||
</lang> |
</lang> |
||
=={{header|Icon}} and {{header|Unicon}}== |
|||
The following works in both languages: |
|||
<lang unicon>procedure main(A) |
|||
n := integer(A[1]) | 10 |
|||
m := list(n) |
|||
every !m := list(n,0) |
|||
every m[i := 1 to n][i] := 1 |
|||
every row := !m do { |
|||
every writes(right(!row,3)," ") |
|||
write() |
|||
} |
|||
end</lang> |
|||
Sample run: |
|||
<pre> |
|||
->im 6 |
|||
1 0 0 0 0 0 |
|||
0 1 0 0 0 0 |
|||
0 0 1 0 0 0 |
|||
0 0 0 1 0 0 |
|||
0 0 0 0 1 0 |
|||
0 0 0 0 0 1 |
|||
-> |
|||
</pre> |
|||
=={{header|J}}== |
=={{header|J}}== |
||
Revision as of 14:32, 9 July 2013
You are encouraged to solve this task according to the task description, using any language you may know.
Build an identity matrix of a size known at runtime. An identity matrix is a square matrix, of size n × n, where the diagonal elements are all 1s, and the other elements are all 0s.
Ada
When using floating point matrices in Ada 2005+ the function is defined as "Unit_Matrix" in Ada.Numerics.Generic_Real_Arrays. As a generic package it can work with user defined floating point types, or the predefined Short_Real_Arrays, Real_Arrays, and Long_Real_Arrays initializations. As seen below, the first indices of both dimensions can also be set since Ada array indices do not arbitrarily begin with a particular number. <lang Ada>-- As prototyped in the Generic_Real_Arrays specification: -- function Unit_Matrix (Order : Positive; First_1, First_2 : Integer := 1) return Real_Matrix; -- For the task: mat : Real_Matrix := Unit_Matrix(5);</lang> For prior versions of Ada, or non floating point types its back to basics: <lang Ada>type Matrix is array(Positive Range <>, Positive Range <>) of Integer; mat : Matrix(1..5,1..5) := (others => (others => 0)); -- then after the declarative section: for i in mat'Range(1) loop mat(i,i) := 1; end loop;</lang>
APL
Making an identity matrix in APL involves the outer product of the inequality function.
For a square matrix of 3: <lang apl>
∘.=/⍳¨3 3
1 0 0 0 1 0 0 0 1 </lang>
For a function that makes an identity matrix: <lang apl>
ID←{∘.=/⍳¨ ⍵ ⍵}
ID 5
1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 </lang>
There is a more idomatic way however:
<lang apl>
ID←{⍵ ⍵ ρ 1, ⍵ρ0}
</lang>
AWK
<lang AWK>
- syntax: GAWK -f IDENTITY_MATRIX.AWK size
BEGIN {
size = ARGV[1]
if (size !~ /^[0-9]+$/) {
print("size invalid or missing from command line")
exit(1)
}
for (i=1; i<=size; i++) {
for (j=1; j<=size; j++) {
x = (i == j) ? 1 : 0
printf("%2d",x) # print
arr[i,j] = x # build
}
printf("\n")
}
exit(0)
} </lang>
command: GAWK -f IDENTITY_MATRIX.AWK 5
output:
1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1
BBC BASIC
<lang bbcbasic> INPUT "Enter size of matrix: " size%
PROCidentitymatrix(size%, im())
FOR r% = 0 TO size%-1
FOR c% = 0 TO size%-1
PRINT im(r%, c%),;
NEXT
PRINT
NEXT r%
END
DEF PROCidentitymatrix(s%, RETURN m())
LOCAL i%
DIM m(s%-1, s%-1)
FOR i% = 0 TO s%-1
m(i%,i%) = 1
NEXT
ENDPROC</lang>
Burlesque
Neither very elegant nor short but it'll do
<lang burlesque> blsq ) 6 -.^^0\/r@\/'0\/.*'1+]\/{\/{rt}\/E!XX}x/+]m[sp 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 </lang>
The example above uses strings to generate the identity matrix. If you need a matrix with real numbers (Integers) then use:
<lang burlesque> 6hd0bx#a.*\[#a.*0#a?dr@{(D!)\/1\/^^bx\/[+}m[e! </lang>
C
<lang C>
- include <stdlib.h>
- include <stdio.h>
int main(int argc, char** argv) {
if (argc < 2) {
printf("usage: identitymatrix <number of rows>\n");
exit(EXIT_FAILURE);
}
signed int rowsize = atoi(argv[1]);
if (rowsize < 0) {
printf("Dimensions of matrix cannot be negative\n");
exit(EXIT_FAILURE);
}
volatile int numElements = rowsize * rowsize;
if (numElements < rowsize) {
printf("Squaring %d caused result to overflow to %d.\n", rowsize, numElements);
abort();
}
int** matrix = calloc(numElements, sizeof(int*));
if (!matrix) {
printf("Failed to allocate %d elements of %d bytes each\n", numElements, sizeof(int*));
abort();
}
for (unsigned int row = 0;row < rowsize;row++) {
matrix[row] = calloc(numElements, sizeof(int));
if (!matrix[row]) {
printf("Failed to allocate %d elements of %d bytes each\n", numElements, sizeof(int));
abort();
}
matrix[row][row] = 1;
}
printf("Matrix is: \n");
for (unsigned int row = 0;row < rowsize;row++) {
for (unsigned int column = 0;column < rowsize;column++) {
printf("%d ", matrix[row][column]);
}
printf("\n");
}
} </lang>
C++
<lang cpp>template<class T> class matrix { public:
matrix( unsigned int nSize ) :
m_oData(nSize * nSize, 0), m_nSize(nSize) {}
inline T& operator()(unsigned int x, unsigned int y)
{
return m_oData[x+m_nSize*y];
}
void identity()
{
int nCount = 0;
int nStride = m_nSize + 1;
std::generate( m_oData.begin(), m_oData.end(),
[&]() { return !(nCount++%nStride); } );
}
inline unsigned int size() { return m_nSize; }
private:
std::vector<T> m_oData; unsigned int m_nSize;
};
int main() {
int nSize; std::cout << "Enter matrix size (N): "; std::cin >> nSize;
matrix<int> oMatrix( nSize );
oMatrix.identity();
for ( unsigned int y = 0; y < oMatrix.size(); y++ )
{
for ( unsigned int x = 0; x < oMatrix.size(); x++ )
{
std::cout << oMatrix(x,y) << " ";
}
std::cout << std::endl;
}
return 0;
} </lang>
<lang cpp>
- include <boost/numeric/ublas/matrix.hpp>
int main() {
using namespace boost::numeric::ublas; int nSize; std::cout << "Enter matrix size (N): "; std::cin >> nSize;
identity_matrix<int> oMatrix( nSize );
for ( unsigned int y = 0; y < oMatrix.size2(); y++ )
{
for ( unsigned int x = 0; x < oMatrix.size1(); x++ )
{
std::cout << oMatrix(x,y) << " ";
}
std::cout << std::endl;
}
return 0;
} </lang>
- Output:
Enter matrix size (N): 5 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1
C#
<lang csharp> using System; using System.Linq;
namespace IdentityMatrix {
class Program
{
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Requires exactly one argument");
return;
}
int n;
if (!int.TryParse(args[0], out n))
{
Console.WriteLine("Requires integer parameter");
return;
}
var identity =
Enumerable.Range(0, n).Select(i => Enumerable.Repeat(0, n).Select((z,j) => j == i ? 1 : 0).ToList()).ToList();
foreach (var row in identity)
{
foreach (var elem in row)
{
Console.Write(" " + elem);
}
Console.WriteLine();
}
Console.ReadKey();
}
}
} </lang>
- Output:
1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1
Clojure
The (vec ) function in the following solution is with respect to vector matrices. If dealing with normal lists matrices (e.g. <lang clojure> '( (0 1) (2 3) ) </lang> , then care to remove the vec function. <lang clojure>(defn identity-matrix [n]
(let [row (conj (repeat (dec n) 0) 1)]
(vec
(for [i (range 1 (inc n))]
(vec
(reduce conj (drop i row ) (take i row)))))))
</lang> Sample output: <lang clojure>=> (identity-matrix 5) [[1 0 0 0 0] [0 1 0 0 0] [0 0 1 0 0] [0 0 0 1 0] [0 0 0 0 1]] </lang>
The following is a more idomatic definition that utilizes infinite lists and cycling. <lang clojure> (defn identity-matrix [n]
(take n
(partition n (dec n)
(cycle (conj (repeat (dec n) 0) 1)))))
</lang>
Common Lisp
Common Lisp provides multi-dimensional arrays.
<lang lisp>(defun make-identity-matrix (n)
(let ((array (make-array (list n n) :initial-element 0))) (loop for i below n do (setf (aref array i i) 1)) array))
</lang>
Output:
* (make-identity-matrix 5) #2A((1 0 0 0 0) (0 1 0 0 0) (0 0 1 0 0) (0 0 0 1 0) (0 0 0 0 1))
D
<lang d>import std.traits;
T[][] matId(T)(in size_t n) pure nothrow if (isAssignable!(T, T)) {
auto Id = new T[][](n, n);
foreach (r, row; Id) {
static if (__traits(compiles, {row[] = 0;})) {
row[] = 0; // vector op doesn't work with T = BigInt
row[r] = 1;
} else {
foreach (c; 0 .. n)
row[c] = (c == r) ? 1 : 0;
}
}
return Id;
}
void main() {
import std.stdio, std.bigint; enum form = "[%([%(%s, %)],\n %)]]";
immutable id1 = matId!real(5); writefln(form ~ "\n", id1);
immutable id2 = matId!BigInt(3); writefln(form ~ "\n", id2);
// auto id3 = matId!(const int)(2); // cant't compile
}</lang>
- Output:
[[1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1]] [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
Erlang
<lang erlang>%% Identity Matrix in Erlang for the Rosetta Code Wiki. %% Implemented by Arjun Sunel
-module(identity_matrix). -export([square_matrix/2 , identity/1]).
square_matrix(Size, Elements) ->
[[Elements(Column, Row) || Column <- lists:seq(1, Size)] || Row <- lists:seq(1, Size)].
identity(Size) ->
square_matrix(Size, fun(Column, Row) -> case Column of Row -> 1; _ -> 0 end end).</lang>
Euler Math Toolbox
<lang Euler Math Toolbox> function IdentityMatrix(n)
$ X:=zeros(n,n); $ for i=1 to n $ X[i,i]:=1; $ end; $ return X; $endfunction
</lang>
<lang Euler Math Toobox> >function IdentityMatrix (n:index) $ return setdiag(zeros(n,n),0,1); $endfunction </lang>
<lang> >id(5) </lang>
F#
Builds a 2D matrix with the given square size. <lang FSharp> let ident n = Array2D.init n n (fun i j -> if i = j then 1 else 0) </lang>
Example output: <lang FSharp> ident 10;; val it : int [,] = [[1; 0; 0; 0; 0; 0; 0; 0; 0; 0]
[0; 1; 0; 0; 0; 0; 0; 0; 0; 0]
[0; 0; 1; 0; 0; 0; 0; 0; 0; 0]
[0; 0; 0; 1; 0; 0; 0; 0; 0; 0]
[0; 0; 0; 0; 1; 0; 0; 0; 0; 0]
[0; 0; 0; 0; 0; 1; 0; 0; 0; 0]
[0; 0; 0; 0; 0; 0; 1; 0; 0; 0]
[0; 0; 0; 0; 0; 0; 0; 1; 0; 0]
[0; 0; 0; 0; 0; 0; 0; 0; 1; 0]
[0; 0; 0; 0; 0; 0; 0; 0; 0; 1]]
</lang>
Factor
USE: math.matrices
IN: scratchpad 6 identity-matrix .
{
{ 1 0 0 0 0 0 }
{ 0 1 0 0 0 0 }
{ 0 0 1 0 0 0 }
{ 0 0 0 1 0 0 }
{ 0 0 0 0 1 0 }
{ 0 0 0 0 0 1 }
}
Fortran
<lang fortran> program identitymatrix
real, dimension(:, :), allocatable :: I character(len=8) :: fmt integer :: ms, j
ms = 10 ! the desired size
allocate(I(ms,ms)) I = 0 ! Initialize the array. forall(j = 1:ms) I(j,j) = 1 ! Set the diagonal.
! I is the identity matrix, let's show it:
write (fmt, '(A,I2,A)') '(', ms, 'F6.2)'
! if you consider to have used the (row, col) convention,
! the following will print the transposed matrix (col, row)
! but I' = I, so it's not important here
write (*, fmt) I(:,:)
deallocate(I)
end program identitymatrix </lang>
Go
2D. Representation as a slice of slices, but based on a single allocated array to maintain locality. <lang go>package main
import "fmt"
func main() {
fmt.Println(I(3))
}
func I(n int) [][]float64 {
m := make([][]float64, n)
a := make([]float64, n*n)
for i := 0; i < n; i++ {
a[i] = 1
m[i] = a[:n]
a = a[n:]
}
return m
}</lang>
- Output:
No special formatting method used.
[[1 0 0] [0 1 0] [0 0 1]]
Flat. Representation as a single flat slice. You just have to know to handle it as a square matrix. In many cases that's not a problem and the code is simpler this way. If you want to add a little bit of type checking, you can define a matrix type as shown here. <lang go>package main
import "fmt"
type matrix []float64
func main() {
fmt.Println(I(3))
}
func I(n int) matrix {
m := make(matrix, n*n)
n++
for i := 0; i < len(m); i += n {
m[i] = 1
}
return m
}</lang>
- Output:
[1 0 0 0 1 0 0 0 1]
Library. <lang go>package main
import (
"fmt"
mat "github.com/skelterjohn/go.matrix"
)
func main() {
fmt.Println(mat.Eye(3))
}</lang>
- Output:
A nice library includes formatted output.
{1, 0, 0,
0, 1, 0,
0, 0, 1}
Groovy
Solution: <lang groovy>def makeIdentityMatrix = { n ->
(0..<n).collect { i -> (0..<n).collect { j -> (i == j) ? 1 : 0 } }
}</lang>
Test: <lang groovy>(2..6).each { order ->
def iMatrix = makeIdentityMatrix(order)
iMatrix.each { println it }
println()
}</lang>
Output:
[1, 0] [0, 1] [1, 0, 0] [0, 1, 0] [0, 0, 1] [1, 0, 0, 0] [0, 1, 0, 0] [0, 0, 1, 0] [0, 0, 0, 1] [1, 0, 0, 0, 0] [0, 1, 0, 0, 0] [0, 0, 1, 0, 0] [0, 0, 0, 1, 0] [0, 0, 0, 0, 1] [1, 0, 0, 0, 0, 0] [0, 1, 0, 0, 0, 0] [0, 0, 1, 0, 0, 0] [0, 0, 0, 1, 0, 0] [0, 0, 0, 0, 1, 0] [0, 0, 0, 0, 0, 1]
Haskell
<lang haskell>matI n = [ [fromEnum $ i == j | i <- [1..n]] | j <- [1..n]]</lang> And a function to show matrix pretty: <lang haskell>showMat :: Int -> String showMat = unlines . map (unwords . map show)</lang>
<lang haskell>*Main> putStr $ showMat $ matId 9
1 0 0 0 0 0 0 0 0
0 1 0 0 0 0 0 0 0
0 0 1 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0
0 0 0 0 1 0 0 0 0
0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 1 0 0
0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 1
</lang>
Icon and Unicon
The following works in both languages:
<lang unicon>procedure main(A)
n := integer(A[1]) | 10
m := list(n)
every !m := list(n,0)
every m[i := 1 to n][i] := 1
every row := !m do {
every writes(right(!row,3)," ")
write()
}
end</lang>
Sample run:
->im 6 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 ->
J
<lang j> = i. 4 NB. create an Identity matrix of size 4 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1
makeI=: =@i. NB. define as a verb with a user-defined name makeI 5 NB. create an Identity matrix of size 5
1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1</lang>
Java
<lang Java> public class IdentityMatrix {
public static int[][] matrix(int n){ int[][] array = new int[n][n];
for(int row=0; row<n; row++){ for(int col=0; col<n; col++){ if(row == col){ array[row][col] = 1; } else{ array[row][col] = 0; } } } return array; } public static void printMatrix(int[][] array){ for(int row=0; row<array.length; row++){ for(int col=0; col<array[row].length; col++){ System.out.print(array[row][col] + "\t"); } System.out.println(); } } public static void main (String []args){ printMatrix(matrix(5)); } } By Sani Yusuf @saniyusuf. </lang>
Output:
1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1
Julia
The eye function takes an integer argument and returns a square identity matrix of that size. <lang Julia> eye(3) </lang> This returns:
3x3 Float64 Array: 1.0 0.0 0.0 0.0 1.0 0.0 0.0 0.0 1.0
If you want to take the size from the commandline: <lang Julia> eye(int(readline(STDIN))) </lang>
You can also can also call eye(m,n) to create an M-by-N identity matrix. For example: <lang Julia> eye(2,3) </lang> results in:
2x3 Float64 Array: 1.0 0.0 0.0 0.0 1.0 0.0
LSL
To test it yourself; rez a box on the ground, and add the following as a New Script. <lang LSL>default { state_entry() { llListen(PUBLIC_CHANNEL, "", llGetOwner(), ""); llOwnerSay("Please Enter a Dimension for an Identity Matrix."); } listen(integer iChannel, string sName, key kId, string sMessage) { llOwnerSay("You entered "+sMessage+"."); list lMatrix = []; integer x = 0; integer n = (integer)sMessage; for(x=0 ; x<n*n ; x++) { lMatrix += [(integer)(((x+1)%(n+1))==1)]; } //llOwnerSay("["+llList2CSV(lMatrix)+"]"); for(x=0 ; x<n ; x++) { llOwnerSay("["+llList2CSV(llList2ListStrided(lMatrix, x*n, (x+1)*n-1, 1))+"]"); } } }</lang> Output:
You: 0 Identity_Matrix: You entered 0. You: 1 Identity_Matrix: You entered 1. Identity_Matrix: [1] You: 3 Identity_Matrix: You entered 3. Identity_Matrix: [1, 0, 0] Identity_Matrix: [0, 1, 0] Identity_Matrix: [0, 0, 1] You: 5 Identity_Matrix: You entered 5. Identity_Matrix: [1, 0, 0, 0, 0] Identity_Matrix: [0, 1, 0, 0, 0] Identity_Matrix: [0, 0, 1, 0, 0] Identity_Matrix: [0, 0, 0, 1, 0] Identity_Matrix: [0, 0, 0, 0, 1]
Lang5
<lang lang5>: identity-matrix
dup iota 'A set
: i.(*) A in ; [1] swap append reverse A swap reshape 'i. apply ;
5 identity-matrix .</lang>
- Output:
[ [ 1 0 0 0 0 ] [ 0 1 0 0 0 ] [ 0 0 1 0 0 ] [ 0 0 0 1 0 ] [ 0 0 0 0 1 ] ]
Lua
<lang lua> function identity_matrix (size)
local m = {}
for i = 1, size do
m[i] = {}
for j = 1, size do
m[i][j] = i == j and 1 or 0
end
end
return m
end
function print_matrix (m)
for i = 1, #m do
print(table.concat(m[i], " "))
end
end
print_matrix(identity_matrix(5))</lang> Output:
1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1
Maple
One of a number of ways to do this: <lang Maple> > LinearAlgebra:-IdentityMatrix( 4 );
[1 0 0 0]
[ ]
[0 1 0 0]
[ ]
[0 0 1 0]
[ ]
[0 0 0 1]
</lang> Here, for instance, is another, in which the entries are (4-byte) floats. <lang Maple> > Matrix( 4, shape = scalar[1], datatype = float[4] );
[1. 0. 0. 0.]
[ ]
[0. 1. 0. 0.]
[ ]
[0. 0. 1. 0.]
[ ]
[0. 0. 0. 1.]
</lang> Yet another, with 2-byte integer entries: <lang Maple> > Matrix( 4, shape = identity, datatype = integer[ 2 ] );
[1 0 0 0]
[ ]
[0 1 0 0]
[ ]
[0 0 1 0]
[ ]
[0 0 0 1]
</lang>
Mathematica
<lang Mathematica>IdentityMatrix[4]</lang>
MATLAB / Octave
The eye function create the identity (I) matrix, e.g.:
<lang MATLAB>I = eye(10)</lang>
Maxima
<lang maxima>ident(4); /* matrix([1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1]) */</lang>
NetRexx
<lang NetRexx>/* NetRexx ************************************************************
- show identity matrix of size n
- I consider m[i,j] to represent the matrix
- 09.07.2013 Walter Pachl (translated from REXX Version 2)
- /
Parse Arg n Say 'Identity Matrix of size' n '(m[i,j] IS the Matrix)' m=int[100,100] Loop i=1 To n
ol= Loop j=1 To n m[i,j]=(i=j) ol=ol m[i,j] End Say ol End
</lang>
Objeck
<lang objeck>class IdentityMatrix {
function : Matrix(n : Int) ~ Int[,] {
array := Int->New[n,n];
for(row:=0; row<n; row+=1;){
for(col:=0; col<n; col+=1;){
if(row = col){
array[row, col] := 1;
}
else{
array[row,col] := 0;
};
};
};
return array;
}
function : PrintMatrix(array : Int[,]) ~ Nil {
sizes := array->Size();
for(row:=0; row<sizes[0]; row+=1;){
for(col:=0; col<sizes[1]; col+=1;){
value := array[row,col];
"{$value} \t"->Print();
};
'\n'->PrintLine();
};
}
function : Main(args : String[]) ~ Nil {
PrintMatrix(Matrix(5));
}
} </lang>
OCaml
From the interactive loop (that we call the "toplevel"):
<lang ocaml>$ ocaml
- let make_id_matrix n =
let m = Array.make_matrix n n 0.0 in
for i = 0 to pred n do
m.(i).(i) <- 1.0
done;
(m)
;;
val make_id_matrix : int -> float array array = <fun>
- make_id_matrix 4 ;;
- : float array array = [| [|1.; 0.; 0.; 0.|];
[|0.; 1.; 0.; 0.|]; [|0.; 0.; 1.; 0.|]; [|0.; 0.; 0.; 1.|] |]</lang>
another way:
<lang ocaml># let make_id_matrix n =
Array.init n (fun i ->
Array.init n (fun j ->
if i = j then 1.0 else 0.0))
;;
val make_id_matrix : int -> float array array = <fun>
- make_id_matrix 4 ;;
- : float array array = [| [|1.; 0.; 0.; 0.|];
[|0.; 1.; 0.; 0.|]; [|0.; 0.; 1.; 0.|]; [|0.; 0.; 0.; 1.|] |]</lang>
When we write a function in the toplevel, it returns us its signature (the prototype), and when we write a variable (or a function call), it returns its type and its value.
Octave
The eye function create the identity (I) matrix, e.g.:
<lang octave>I = eye(10)</lang>
ooRexx
ooRexx doesn't have a proper matrix class, but it does have multidimensional arrays. <lang ooRexx> say "a 3x3 identity matrix" say call printMatrix createIdentityMatrix(3) say say "a 5x5 identity matrix" say call printMatrix createIdentityMatrix(5)
- routine createIdentityMatrix
use arg size
matrix = .array~new(size, size)
loop i = 1 to size
loop j = 1 to size
if i == j then matrix[i, j] = 1
else matrix[i, j] = 0
end j
end i
return matrix
- routine printMatrix
use arg matrix
loop i = 1 to matrix~dimension(1)
line = ""
loop j = 1 to matrix~dimension(2)
line = line matrix[i, j]
end j
say line
end i
</lang> Output:
a 3x3 identity matrix 1 0 0 0 1 0 0 0 1 a 5x5 identity matrix 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1
OxygenBasic
<lang oxygenbasic> Class SquareMatrix '=================
double *Cell sys size
method SetIdentity() indexbase 0 sys e,i,j e=size*size for i=0 to <size cell(i*size+j)=1 : j++ next end method
method constructor(sys n) @cell=getmemory n*n*sizeof double size=n end method
method destructor() freememory @cell end method
end class
new SquareMatrix M(8) M.SetIdentity '... del M </lang>
Pascal
<lang pascal>program IdentityMatrix(input, output);
var
matrix: array of array of integer; n, i, j: integer;
begin
write('Size of matrix: ');
readln(n);
setlength(matrix, n, n);
for i := 0 to n - 1 do
matrix[i,i] := 1;
for i := 0 to n - 1 do
begin
for j := 0 to n - 1 do
write (matrix[i,j], ' ');
writeln;
end;
end.</lang> Output:
% ./IdentityMatrix Size of matrix: 5 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1
PARI/GP
Built-in: <lang parigp>matid(9)</lang>
Custom: <lang parigp>matrix(9,9,i,j,i==j)</lang>
Perl
<lang perl>sub identity_matrix {
my $n = shift;
map {
my $i = $_;
[ map { ($_ == $i) - 0 } 1 .. $n ]
} 1 .. $n;
}
@ARGV = (4, 5, 6) unless @ARGV;
for (@ARGV) {
my @id = identity_matrix $_;
print "$_:\n";
for (my $i=0; $i<@id; ++$i) {
print join ' ', @{$id[$i]}, "\n";
}
print "\n";
} </lang>
- Output:
4: 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 5: 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 6: 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1
Perl 6
<lang perl6>sub identity-matrix($n) {
my @id;
for ^$n X ^$n -> $i, $j {
@id[$i][$j] = +($i == $j);
}
@id;
}
.say for identity-matrix(5);</lang>
- Output:
1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1
On the other hand, this may be clearer and/or faster: <lang perl6>sub identity-matrix($n) {
my @id = [0 xx $n] xx $n; @id[$_][$_] = 1 for ^$n; @id;
}</lang>
PHP
<lang php> function createMatrix($size) {
$result = array();
for ($i = 0; $i < $size; $i++) {
$row = array_fill(0, $size, 0);
$row[$i] = 1;
$result[] = $row;
}
return $result;
}
function printMatrix(array $matrix) {
foreach ($matrix as $row) {
foreach ($row as $column) {
echo $column . " ";
}
echo PHP_EOL;
}
echo PHP_EOL;
}
printMatrix(createMatrix(5)); </lang>
- Output:
1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1
PicoLisp
<lang PicoLisp>(de identity (Size)
(let L (need Size (1) 0)
(make
(do Size
(link (copy (rot L))) ) ) ) )</lang>
Test: <lang PicoLisp>: (identity 3) -> ((1 0 0) (0 1 0) (0 0 1))
- (mapc println (identity 5))
(1 0 0 0 0) (0 1 0 0 0) (0 0 1 0 0) (0 0 0 1 0) (0 0 0 0 1)</lang>
PL/I
<lang PL/I> identity: procedure (A, n);
declare A(n,n) fixed controlled; declare (i,n) fixed binary; allocate A; A = 0; do i = 1 to n; A(i,i) = 1; end;
end identity; </lang>
PostScript
<lang PostScript> % n ident [identity-matrix] % create an identity matrix of dimension n*n. % Uses a local dictionary for its one parameter, perhaps overkill. % Constructs arrays of arrays of integers using [], for loops, and stack manipulation. /ident { 1 dict begin /n exch def
[
1 1 n { % [ i
[ exch % [ [ i
1 1 n { % [ [ i j
1 index eq { 1 }{ 0 } ifelse % [ [ i b
exch % [ [ b i
} for % [ [ b+ i
pop ] % [ [ b+ ]
} for % [ [b+]+ ]
]
end } def </lang>
PureBasic
<lang purebasic>>Procedure identityMatrix(Array i(2), size) ;valid only for size >= 0
;formats array i() as an identity matrix of size x size Dim i(size - 1, size - 1)
Protected j For j = 0 To size - 1 i(j, j) = 1 Next
EndProcedure
Procedure displayMatrix(Array a(2))
Protected rows = ArraySize(a(), 2), columns = ArraySize(a(), 1)
Protected i, j
For i = 0 To rows
For j = 0 To columns
Print(RSet(Str(a(i, j)), 3, " "))
Next
PrintN("")
Next
EndProcedure
If OpenConsole()
Dim i3(0, 0)
Dim i4(0, 0)
identityMatrix(i3(), 3)
identityMatrix(i4(), 4)
displayMatrix(i3())
PrintN("")
displayMatrix(i4())
Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()
EndIf</lang> Sample output:
1 0 0 0 1 0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1
Python
A simple solution, using nested lists. <lang python>def identity(size):
matrix = [[0] * size] * size
for i in range(size):
matrix[i][i] = 1
for rows in matrix:
for elements in rows:
print elements,
print ""</lang>
A solution using the numpy library
<lang python>
np.mat(np.eye(size))
</lang>
R
When passed a single scalar argument, "diag" produces an identity matrix of size given by the scalar. For example: <lang R> diag(3) </lang> produces: <lang R>
[,1] [,2] [,3]
[1,] 1 0 0 [2,] 0 1 0 [3,] 0 0 1 </lang>
Racket
<lang racket>
- lang racket
(require math) (identity-matrix 5) </lang> Output:
(array #[#[1 0 0 0 0]
#[0 1 0 0 0]
#[0 0 1 0 0]
#[0 0 0 1 0]
#[0 0 0 0 1]])
REXX
version 1
The REXX language doesn't have matrixes as such, so the problem is largely how to display the "matrix". <lang rexx>/*REXX program to create and display an identity matrix. */ call identity_matrix 4 /*build and display a 4x4 matrix.*/ call identity_matrix 5 /*build and display a 5x5 matrix.*/ exit /*stick a fork in it, we're done.*/ /*─────────────────────────────────────IDENTITY_MATRIX subroutine───────*/ identity_matrix: procedure; parse arg n; $=
do r=1 for n /*build indentity matrix, by row,*/
do c=1 for n /* and by cow.*/
$=$ (r==c) /*append zero or one (if on diag)*/
end /*c*/
end /*r*/
call showMatrix 'identity matrix of size' n,$,n return /*─────────────────────────────────────TELL subroutine───&find the order*/ showMatrix: procedure; parse arg hdr,x,order,sep; if sep== then sep='═'
width=2 /*width of field to be used to display the elements*/
decPlaces=1 /*# decimal places to the right of decimal point. */ say; say center(hdr,max(length(hdr)+6,(width+1)*words(x)%order),sep); say
- =0
do row=1 for order; aLine=
do col=1 for order; #=#+1
aLine=aLine right(format(word(x,#),,decPlaces)/1, width)
end /*col*/ /*dividing by 1 normalizes the #.*/
say aLine
end /*row*/
return</lang> output (using 4 and 5 for generating):
═══identity matrix of size 4═══ 1 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 ═══identity matrix of size 5═══ 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1
version 2
An alternative?! <lang rexx> /* REXX ***************************************************************
- show identity matrix of size n
- I consider m.i.j to represent the matrix (not needed for showing)
- 06.07.2012 Walter Pachl
- /
Parse Arg n Say 'Identity Matrix of size' n '(m.i.j IS the Matrix)' m.=0 Do i=1 To n
ol= Do j=1 To n m.i.j=(i=j) ol=olformat(m.i.j,2) /* or ol=ol (i=j) */ End Say ol End
</lang>
Output
Identity Matrix of size 3 (m.i.j IS the Matrix) 1 0 0 0 1 0 0 0 1
This could be a 3-dimensional sparse matrix with one element set:
<lang rexx> m.=0 m.0=1000 /* the matrix' size */ m.4.17.333='Walter' </lang>
Ruby
<lang ruby>def identity(size)
Array.new(size){|i| Array.new(size){|j| i==j ? 1 : 0}}
end
[4,5,6].each do |size|
puts size, identity(size).map {|r| r.to_s}, ""
end</lang>
- Output:
4 [1, 0, 0, 0] [0, 1, 0, 0] [0, 0, 1, 0] [0, 0, 0, 1] 5 [1, 0, 0, 0, 0] [0, 1, 0, 0, 0] [0, 0, 1, 0, 0] [0, 0, 0, 1, 0] [0, 0, 0, 0, 1] 6 [1, 0, 0, 0, 0, 0] [0, 1, 0, 0, 0, 0] [0, 0, 1, 0, 0, 0] [0, 0, 0, 1, 0, 0] [0, 0, 0, 0, 1, 0] [0, 0, 0, 0, 0, 1]
Run BASIC
<lang runbasic>' formats array im() of size ims for ims = 4 to 6
print :print "--- Size: ";ims;" ---"
Dim im(ims,ims)
For i = 1 To ims im(i,i) = 1 next
For row = 1 To ims
print "[";
cma$ = ""
For col = 1 To ims
print cma$;im(row, col);
cma$ = ", "
next
print "]"
next
next ims</lang>Output:
--- Size: 4 --- [1, 0, 0, 0] [0, 1, 0, 0] [0, 0, 1, 0] [0, 0, 0, 1] --- Size: 5 --- [1, 0, 0, 0, 0] [0, 1, 0, 0, 0] [0, 0, 1, 0, 0] [0, 0, 0, 1, 0] [0, 0, 0, 0, 1] --- Size: 6 --- [1, 0, 0, 0, 0, 0] [0, 1, 0, 0, 0, 0] [0, 0, 1, 0, 0, 0] [0, 0, 0, 1, 0, 0] [0, 0, 0, 0, 1, 0] [0, 0, 0, 0, 0, 1]
Scala
<lang scala>def identityMatrix(n:Int)=Array.tabulate(n,n)((x,y) => if(x==y) 1 else 0) def printMatrix[T](m:Array[Array[T]])=m map (_.mkString("[", ", ", "]")) mkString "\n"
printMatrix(identityMatrix(5))</lang> Output:
[1, 0, 0, 0, 0] [0, 1, 0, 0, 0] [0, 0, 1, 0, 0] [0, 0, 0, 1, 0] [0, 0, 0, 0, 1]
Scheme
When representing a matrix as a collection of nested lists: <lang scheme> (define (identity n)
(letrec
((uvec
(lambda (m i acc) (if (= i n) acc (uvec m (+ i 1) (cons (if (= i m) 1 0) acc)))))
(idgen
(lambda (i acc) (if (= i n) acc (idgen (+ i 1) (cons (uvec i 0 '()) acc))))))
(idgen 0 '())))
</lang> Test program: <lang scheme> (display (identity 4)) </lang>
- Output:
((1 0 0 0) (0 1 0 0) (0 0 1 0) (0 0 0 1))
Seed7
<lang seed7>$ include "seed7_05.s7i";
const type: matrix is array array integer;
const func matrix: identity (in integer: size) is func
result
var matrix: identity is matrix.value;
local
var integer: index is 0;
begin
identity := size times size times 0;
for index range 1 to size do
identity[index][index] := 1;
end for;
end func;
const proc: writeMat (in matrix: a) is func
local
var integer: i is 0;
var integer: num is 0;
begin
for key i range a do
for num range a[i] do
write(num lpad 2);
end for;
writeln;
end for;
end func;
const proc: main is func
begin writeMat(identity(6)); end func;</lang>
Output:
1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1
Tcl
When representing a matrix as a collection of nested lists: <lang tcl>proc I {rank {zero 0.0} {one 1.0}} {
set m [lrepeat $rank [lrepeat $rank $zero]]
for {set i 0} {$i < $rank} {incr i} {
lset m $i $i $one
} return $m
}</lang> Or alternatively with the help of the tcllib package for rectangular data structures:
<lang tcl>package require struct::matrix
proc I {rank {zero 0.0} {one 1.0}} {
set m [struct::matrix]
$m add columns $rank
$m add rows $rank
for {set i 0} {$i < $rank} {incr i} {
for {set j 0} {$j < $rank} {incr j} { $m set cell $i $j [expr {$i==$j ? $one : $zero}] }
} return $m
}</lang> Demonstrating the latter: <lang tcl>set m [I 5 0 1] ;# Integer 0/1 for clarity of presentation puts [$m format 2string]</lang>
- Output:
1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1
Unicon
This code works for Icon and Unicon. <lang unicon>link matrix procedure main(argv)
if not (integer(argv[1]) > 0) then stop("Argument must be a positive integer.")
matrix1 := identity_matrix(argv[1], argv[1])
write_matrix(&output,matrix1)
end </lang>
XPL0
<lang XPL0>include c:\cxpl\codes; def IntSize = 4; \number of bytes in an integer int Matrix, Size, I, J;
[Text(0, "Size: "); Size:= IntIn(0); Matrix:= Reserve(Size*IntSize); \reserve memory for 2D integer array for I:= 0 to Size-1 do
Matrix(I):= Reserve(Size*IntSize);
for J:= 0 to Size-1 do \make array an identity matrix
for I:= 0 to Size-1 do
Matrix(I,J):= if I=J then 1 else 0;
for J:= 0 to Size-1 do \display the result
[for I:= 0 to Size-1 do
[IntOut(0, Matrix(I,J)); ChOut(0, ^ )];
CrLf(0);
];
]</lang>
Example output:
Size: 5 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1
- Programming Tasks
- Solutions by Programming Task
- Matrices
- Ada
- APL
- AWK
- BBC BASIC
- Burlesque
- C
- C++
- STL
- Boost
- C sharp
- Clojure
- Common Lisp
- D
- Erlang
- Euler Math Toolbox
- F Sharp
- Factor
- Fortran
- Go
- Groovy
- Haskell
- Icon
- Unicon
- J
- Java
- Julia
- LSL
- Lang5
- Lua
- Maple
- Mathematica
- MATLAB
- Octave
- Maxima
- NetRexx
- Objeck
- OCaml
- OoRexx
- OxygenBasic
- Pascal
- PARI/GP
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- PostScript
- PureBasic
- Python
- R
- Racket
- REXX
- Ruby
- Run BASIC
- Scala
- Scheme
- Seed7
- Tcl
- Tcllib
- XPL0