Identity matrix
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>
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>
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]]
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>
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>
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
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]
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>
Maxima
<lang maxima>ident(4); /* matrix([1, 0, 0, 0],
[0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]) */</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>
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)
size.times.map { |i| size.times.map { |j| i == j ? 1 : 0 } }
end
[4,5,6].each do |size|
puts size, identity(size.to_i).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))
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
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
- C
- Clojure
- Common Lisp
- D
- Euler Math Toolbox
- Factor
- Fortran
- Go
- Groovy
- Haskell
- J
- Java
- LSL
- Lua
- Maple
- Mathematica
- Maxima
- OCaml
- Octave
- OoRexx
- OxygenBasic
- Pascal
- PARI/GP
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- PostScript
- PureBasic
- Python
- R
- REXX
- Ruby
- Run BASIC
- Scala
- Scheme
- Tcl
- Tcllib
- XPL0