Identity matrix: Difference between revisions

{{trans|Python}}

 

V matrix = [[0] * size] * size

L(i) 0 .< size

 

L(row) identity_matrix(3)

 

{{out}}

 

=={{header|360 Assembly}}==

INDENMAT CSECT

USING INDENMAT,R13 base register

A DS F a(n,n)

YREGS

{{out}}

<pre>

0000000010

0000000001

</pre>

 

=={{header|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.

-- function Unit_Matrix (Order : Positive; First_1, First_2 : Integer := 1) return Real_Matrix;

-- For the task:

For prior versions of Ada, or non floating point types its back to basics:

mat : Matrix(1..5,1..5) := (others => (others => 0));

-- then after the declarative section:

 

=={{header|ALGOL 68}}==

'''Note:''' The generic vector and matrix code should be moved to a more generic page.

 

# -*- coding: utf-8 -*- #

 

);

 

 

# Define some generic matrix initialisation and printing operations #

);

 

 

PRIO IDENT = 9; # The same as I for COMPLex #

1 IDENT upb;

 

# -*- coding: utf-8 -*- #

 

PR READ "prelude/matrix_ident.a68" PR;

 

# -*- coding: utf-8 -*- #

 

PR READ "prelude/matrix.a68" PR;

 

{{out}}

<pre>

 

=={{header|ALGOL W}}==

% set m to an identity matrix of size s %

procedure makeIdentity( real array m ( *, * )

end text

 

 

=={{header|APL}}==

 

For a square matrix of 3:

∘.=⍨⍳3

1 0 0

0 1 0

0 0 1

 

For a function that makes an identity matrix:

ID←{∘.=⍨⍳⍵}

ID 5

0 0 0 1 0

0 0 0 0 1

An tacit function can be defined with one of the following equivalent lines:

ID←∘.=⍨⍳

ID←⍳∘.=⍳

 

There is a more idomatic way however:

ID←{⍵ ⍵ ρ 1, ⍵ρ0}

 

=={{header|AppleScript}}==

 

 

-- identityMatrix :: Int -> [(0|1)]

set my text item delimiters to dlm

s

{{Out}}

<pre>[1, 0, 0, 0, 0]

[0, 0, 0, 1, 0]

[0, 0, 0, 0, 1]</pre>

 

100 INPUT "MATRIX SIZE:"; SIZE%

110 GOSUB 200"IDENTITYMATRIX

240 LET IM(I, I) = 1 : NEXT I

250 RETURN :IM

 

=={{header|ATS}}==

(* ****** ****** *)

//

//

} (* end of [main0] *)

 

=={{header|AutoHotkey}}==

return

 

s .= " "

return Rtrim(r,"`n") "`n" s "--"

 

{{out}}

 

=={{header|AWK}}==

# syntax: GAWK -f IDENTITY_MATRIX.AWK size

BEGIN {

exit(0)

}

{{out}} for command: GAWK -f IDENTITY_MATRIX.AWK 5

<pre>

 

=={{header|Bash}}==

for i in `seq $1`;do printf '%*s\n' $1|tr ' ' '0'|sed "s/0/1/$i";done

{{out}} for command: ./scriptname 5

<pre>

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

PROCidentitymatrix(size%, im())

FOR r% = 0 TO size%-1

m(i%,i%) = 1

NEXT

 

=={{header|Beads}}==

 

var

loop from:1 to:n index:i

loop from:1 to:n index:j

 

{{out}}

Neither very elegant nor short but it'll do

 

blsq ) 6 -.^^0\/r@\/'0\/.*'1+]\/{\/{rt}\/E!XX}x/+]m[sp

1 0 0 0 0 0

0 0 0 0 1 0

0 0 0 0 0 1

 

The example above uses strings to generate the identity matrix. If you need a matrix with real numbers (Integers) then use:

 

6hd0bx#a.*\[#a.*0#a?dr@{(D!)\/1\/^^bx\/[+}m[e!

 

Shorter alternative:

 

blsq ) 6 ^^^^10\/**XXcy\/co.+sp

 

=={{header|BQN}}==

Eye ← =⌜˜∘↕

•Show Eye 3

⍝ Using reshape

Eye1 ← {𝕩‿𝕩⥊1∾𝕩⥊0}

╵ 1 0 0

0 1 0

0 0 0 0 1

┘

 

<code>Eye</code> generates an identity matrix using a table of equality for [0,n).

 

=={{header|C}}==

#include <stdlib.h>

#include <stdio.h>

}

}

 

=={{header|C sharp}}==

using System;

using System.Linq;

}

}

{{out}}

<pre>

=={{header|C++}}==

{{libheader|STL}}

class matrix

{

return 0;

}

{{libheader|boost}}

#include <boost/numeric/ublas/matrix.hpp>

 

return 0;

}

{{out}}

<pre>

 

=={{header|Clio}}==

[0:n] -> * fn i:

[0:n] -> * if = i: 1

else: 0

 

 

=={{header|Clojure}}==

 

The (vec ) function in the following solution is with respect to vector matrices. If dealing with normal lists matrices (e.g.

, then care to remove the vec function.

(let [row (conj (repeat (dec n) 0) 1)]

(vec

(vec

(reduce conj (drop i row ) (take i row)))))))

{{out}}

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

 

The following is a more idomatic definition that utilizes infinite lists and cycling.

(defn identity-matrix [n]

(take n

(partition n (dec n)

(cycle (conj (repeat (dec n) 0) 1)))))

 

=={{header|Common Lisp}}==

Common Lisp provides multi-dimensional arrays.

 

(let ((array (make-array (list n n) :initial-element 0)))

(loop for i below n do (setf (aref array i i) 1))

array))

 

{{out}}

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

 

(loop for a from 1 to n

collect (loop for e from 1 to n

if (= a e) collect 1

else collect 0)))

 

{{out}}

=={{header|Component Pascal}}==

BlackBox Component Builder

MODULE Algebras;

IMPORT StdLog,Strings;

END Do;

END Algebras.

Execute: ^Q Algebras.Do<br/>

{{out}}

 

=={{header|D}}==

 

T[][] matId(T)(in size_t n) pure nothrow if (isAssignable!(T, T)) {

 

// auto id3 = matId!(const int)(2); // cant't compile

{{out}}

<pre>[[1, 0, 0, 0, 0],

 

=={{header|Delphi}}==

 

// Modified from the Pascal version

writeln;

end;

{{out}}

<pre>

0 0 0 0 1

</pre>

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

 

{{out}}

 

=={{header|Elena}}==

import system'routines;

import system'collections;

public program()

{

.summarize(new ArrayList());

(row) { console.printLine(row.asEnumerable()) }

{{out}}

<pre>

 

=={{header|Elixir}}==

def identity(n) do

Enum.map(0..n-1, fn i ->

end

 

 

{{out}}

 

=={{header|Erlang}}==

%% Implemented by Arjun Sunel

 

 

identity(Size) ->

 

=={{header|ERRE}}==

PROGRAM IDENTITY

 

END FOR

END PROGRAM

 

=={{header|Euler Math Toolbox}}==

 

function IdentityMatrix(n)

$ X:=zeros(n,n);

$ return X;

$endfunction

 

>function IdentityMatrix (n:index)

$ return setdiag(zeros(n,n),0,1);

$endfunction

 

>id(5)

 

=={{header|Excel}}==

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(n,

LET(

)

)

 

{{Out}}

=={{header|F Sharp|F#}}==

Builds a 2D matrix with the given square size.

let ident n = Array2D.init n n (fun i j -> if i = j then 1 else 0)

 

{{out}}

ident 10;;

val it : int [,] = [[1; 0; 0; 0; 0; 0; 0; 0; 0; 0]

[0; 0; 0; 0; 0; 0; 0; 0; 1; 0]

[0; 0; 0; 0; 0; 0; 0; 0; 0; 1]]

 

=={{header|Factor}}==

{{works with|Factor|0.99 2020-07-03}}

 

{{out}}

<pre>

Press any key to continue...</span>

</code></b></div>

 

=={{header|Forth}}==

{{libheader|Forth Scientific Library}}

{{works with|gforth|0.7.9_20170308}}

 

: build-identity ( 'p n -- 'p ) \ make an NxN identity matrix

6 6 float matrix a{{

a{{ 6 build-identity

 

=={{header|Fortran}}==

{{works with|Fortran|95}}

 

program identitymatrix

 

 

end program identitymatrix

 

===Notorious trick===

The objective is to do the assignment in one fell swoop, rather than separately setting the 0 values and the 1 values. It works because, with integer arithmetic, the only way that both i/j and j/i are one is when they are equal - thus one on the diagonal elements, and zero elsewhere because either i < j so that i/j = 0, or i > j so that j/i = 0. While this means two divides and a multiply per element instead of simply transferring a constant, the constraint on speed is likely to be the limited bandwidth from cpu to memory. The expression's code would surely fit in the cpu's internal memory, and registers would be used for the variables.

Integer N

Parameter (N = 666)

ForAll(i = 1:N, j = 1:N) A(i,j) = (i/j)*(j/i)

 

The <code>ForAll</code> statement is a feature of F90, and carries the implication that the assignments may be done in any order, even "simultaneously" (as with multiple cpus), plus that all RHS values are calculated before any LHS part receives a value - not relevant here since the RHS makes no reference to items altered in the LHS. Earlier Fortran compilers lack this statement and so one must use explicit DO-loops:

DO 1 J = 1,N

Array assignment statements are also a feature of F90 and later.

 

 

=={{header|FreeBASIC}}==

 

Dim As Integer n

Print

Print "Press any key to quit"

Sample input/output

{{out}}

 

=={{header|Frink}}==

 

 

{{out}}

<pre>

Enter matrix dimension as an integer: 3

</pre>

 

=={{header|FunL}}==

 

 

{{out}}

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|GAP}}==

IdentityMat(3);

 

# One can also specify the base ring

 

=={{header|Go}}==

===Library gonum/mat===

 

import (

func main() {

fmt.Println(mat.Formatted(eye(3)))

{{out}}

<pre>

===Library go.matrix===

A somewhat earlier matrix library for Go.

 

import (

func main() {

fmt.Println(mat.Eye(3))

{{out}}

<pre>

===From scratch===

'''Simplest: ''' A matrix as a slice of slices, allocated separately.

 

import "fmt"

}

return m

{{out}}

No special formatting method used.

 

'''2D, resliced: ''' Representation as a slice of slices still, but with all elements based on single underlying slice. Might save a little memory management, might have a little better locality.

 

import "fmt"

}

return m

 

{{out}}

 

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

 

import "fmt"

}

return m

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

(0..<n).collect { i -> (0..<n).collect { j -> (i == j) ? 1 : 0 } }

 

Test:

def iMatrix = makeIdentityMatrix(order)

iMatrix.each { println it }

println()

 

{{out}}

 

=={{header|Haskell}}==

And a function to show matrix pretty:

 

 

1 0 0 0 0 0 0 0 0

0 1 0 0 0 0 0 0 0

0 0 0 0 0 0 0 1 0

0 0 0 0 0 0 0 0 1

 

We could alternatively bypassing the syntactic sugaring of list comprehension notation, and use a bind function directly:

 

idMatrix n =

let xs = [1 .. n]

 

or reduce the number of terms a little to:

idMatrix n =

let xs = [1 .. n]

 

main :: IO ()

{{Out}}

<pre>1 0 0 0 0

 

This code works for Icon and Unicon.

procedure main(argv)

if not (integer(argv[1]) > 0) then stop("Argument must be a positive integer.")

write_matrix(&output,matrix1)

end

 

{{out}}

 

=={{header|IS-BASIC}}==

110 INPUT PROMPT "Enter size of matrix: ":N

120 NUMERIC A(1 TO N,1 TO N)

280 PRINT

290 NEXT

 

=={{header|J}}==

1 0 0 0

0 1 0 0

0 0 1 0 0

0 0 0 1 0

 

=={{header|Java}}==

 

public static void main(String[] args) {

.forEach(System.out::println);

}

 

{{out}}

===ES5===

 

return Array.apply(null, new Array(n))

.map(function (x, i, xs) {

})

});

 

===ES6===

 

// identityMatrix :: Int -> [[Int]]

.map(JSON.stringify)

.join('\n');

{{Out}}

<pre>[1,0,0,0,0]

=={{header|jq}}==

===Construction===

[range(0;n) | 0] as $row

Example:

[[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]

 

===Using matrix/2===

Using the definition of matrix/2 at [[Create_a_two-dimensional_array_at_runtime#jq]]:

reduce range(0;n) as $i

(0 | matrix(n;n); .[$i][$i] = 1);

 

=={{header|Jsish}}==

function identityMatrix(n) {

var mat = new Array(n).fill(0);

[ 0, 0, 0, 1 ]

=!EXPECTEND!=

 

{{out}}

representing an identity matrix of any size,

boolean by default, that can be multiplied by a scalar

 

UniformScaling object can be used as a function to construct a Diagonal

matrix of given size, that can be converted to a full matrix using <tt>collect</tt>

diagI3 = 1.0I(3)

 

The function I(3) is not defined in Julia-1.0.5. Other ways to construct a full matrix of given size are

 

fullI3 = Matrix{Float64}(I, 3, 3)

fullI3 = Array{Float64}(I, 3, 3)

fullI3 = Array{Float64,2}(I, 3, 3)

 

=={{header|K}}==

 

(1 0 0 0

0 1 0 0

0 0 0 1 0

0 0 0 0 1)

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

else

println("Matrix is too big to display on 80 column console")

Sample input/output

{{out}}

 

=={{header|Lambdatalk}}==

{def identity

{lambda {:n}

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

 

 

=={{header|Lang5}}==

dup iota 'A set

 

;

 

{{out}}

<pre>[

=={{header|LFE}}==

 

(defun identity

((`(,m ,n))

(defun identity (m n)

(lists:duplicate m (lists:duplicate n 1)))

 

From the LFE REPL; note that the last two usage examples demonstrate how identify could be used when composed with functions that get the dimension of a matrix:

 

> (identity 3)

((1 1 1) (1 1 1) (1 1 1))

((1 1 1) (1 1 1) (1 1 1))

 

 

=={{header|LSL}}==

To test it yourself; rez a box on the ground, and add the following as a New Script.

state_entry() {

llListen(PUBLIC_CHANNEL, "", llGetOwner(), "");

}

}

{{out}}

<pre>You: 0

 

=={{header|Lua}}==

function identity_matrix (size)

local m = {}

end

 

{{out}}

<pre>

=={{header|Maple}}==

One of a number of ways to do this:

> LinearAlgebra:-IdentityMatrix( 4 );

[1 0 0 0]

[ ]

[0 0 0 1]

Here, for instance, is another, in which the entries are (4-byte) floats.

> Matrix( 4, shape = scalar[1], datatype = float[4] );

[1. 0. 0. 0.]

[ ]

[0. 0. 0. 1.]

Yet another, with 2-byte integer entries:

> Matrix( 4, shape = identity, datatype = integer[ 2 ] );

[1 0 0 0]

[ ]

[0 0 0 1]

 

=={{header|MathCortex}}==

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

=={{header|MATLAB}} / {{header|Octave}}==

The '''eye''' function create the identity (I) matrix, e.g.:

 

 

=={{header|Maxima}}==

/* matrix([1, 0, 0, 0],

[0, 1, 0, 0],

[0, 0, 1, 0],

 

=={{header|NetRexx}}==

===Using int Array===

{{trans|REXX}}

* show identity matrix of size n

* I consider m[i,j] to represent the matrix

Say ol

End

 

===Using Indexed String===

options replace format comments java crossref symbols nobinary

 

displayIdMatrix(createIdMatrix(n))

return

 

=={{header|Nim}}==

result = newSeq[seq[int]](n)

for i in 0 ..< result.len:

result[i] = newSeq[int](n)

 

=={{header|Objeck}}==

function : Matrix(n : Int) ~ Int[,] {

array := Int->New[n,n];

}

}

 

=={{header|OCaml}}==

From the interactive loop (that we call the "toplevel"):

 

 

# let make_id_matrix n =

[|0.; 1.; 0.; 0.|];

[|0.; 0.; 1.; 0.|];

 

another way:

 

Array.init n (fun i ->

Array.init n (fun j ->

[|0.; 1.; 0.; 0.|];

[|0.; 0.; 1.; 0.|];

 

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.

The '''eye''' function create the identity (I) matrix, e.g.:

 

 

=={{header|Ol}}==

(define (make-identity-matrix n)

(map (lambda (i)

 

(for-each print (make-identity-matrix 3))

{{out}}

<pre>

=={{header|ooRexx}}==

ooRexx doesn't have a proper matrix class, but it does have multidimensional arrays.

say "a 3x3 identity matrix"

say

say line

end i

{{out}}

<pre style="height:20ex;overflow:scroll">

 

=={{header|OxygenBasic}}==

Class SquareMatrix

'=================

'...

del M

 

=={{header|PARI/GP}}==

Built-in:

 

Custom:

 

=={{header|Pascal}}==

 

var

writeln;

end;

{{out}}

<pre>

 

=={{header|Perl}}==

}

 

{{out}}

<pre>4:

0 0 0 1 0 0

0 0 0 0 1 0

 

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">identity</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">),</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">identity</span><span style="color: #0000FF;">(</span><span style="color: #000000;">7</span><span style="color: #0000FF;">))</span>

<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">identity</span><span style="color: #0000FF;">(</span><span style="color: #000000;">9</span><span style="color: #0000FF;">))</span>

{{out}}

<pre style="float:left">

 

=={{header|PHP}}==

function identity($length) {

return array_map(function($key, $value) {$value[$key] = 1; return $value;}, range(0, $length-1),

}

print_identity(identity(10));

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(let L (need Size (1) 0)

(make

(do Size

Test:

-> ((1 0 0) (0 1 0) (0 0 1))

 

(0 0 1 0 0)

(0 0 0 1 0)

 

=={{header|PL/I}}==

identity: procedure (A, n);

declare A(n,n) fixed controlled;

do i = 1 to n; A(i,i) = 1; end;

end identity;

 

=={{header|PostScript}}==

% n ident [identity-matrix]

% create an identity matrix of dimension n*n.

]

end } def

 

=={{header|PowerShell}}==

function identity($n) {

0..($n-1) | foreach{$row = @(0) * $n; $row[$_] = 1; ,$row}

$array = identity 4

show $array

<b>Output:</b>

<pre>

0 0 0 1

</pre>

$array[0][0]

$array[0][1]

<b>Output:</b>

<pre>

=={{header|Prolog}}==

{{Works with|SWi-Prolog}}

rotate(Int,List,Rotated) :-

integer(Int),

idmatrix(5,I),

maplist(writeln,I).

 

{{out}}

 

=={{header|PureBasic}}==

;formats array i() as an identity matrix of size x size

Dim i(size - 1, size - 1)

Print(#CRLF$ + #CRLF$ + "Press ENTER to exit"): Input()

CloseConsole()

{{out}}

<pre> 1 0 0

===Nested lists===

A simple solution, using nested lists to represent the matrix.

matrix = [[0]*size for i in range(size)]

#matrix = [[0] * size] * size #Has a flaw. See http://stackoverflow.com/questions/240178/unexpected-feature-in-a-python-list-of-lists

for elements in rows:

print elements,

 

===Nested maps and comprehensions===

{{Works with|Python|3.7}}

 

import operator

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>idMatrix:

===Dict of points===

A dict of tuples of two ints (x, y) are used to represent the matrix.

... return {(x, y):int(x == y) for x in range(size) for y in range(size)}

...

0 0 1 0

0 0 0 1

 

===Numpy===

A solution using the numpy library

np.mat(np.eye(size))

 

=={{header|Quackery}}==

[ 0 i^ of 1 join 0 i of

join nested join ] ] is identity ( n --> [ )

 

{{out}}

<pre>

When passed a single scalar argument, <code>diag</code> produces an identity matrix of size given by the scalar. For example:

 

 

produces:

[3,] 0 0 1</pre>

Or you can also use the method that is shown below

x=matrix(0,size,size)

for (i in 1:size) {

}

return(x)

 

=={{header|Racket}}==

#lang racket

(require math)

(identity-matrix 5)

{{out}}

<pre>

(formerly Perl 6)

{{works with|rakudo|2015-09-15}}

my @id;

for flat ^$n X ^$n -> $i, $j {

}

 

{{out}}

<pre>[1 0 0 0 0]

[0 0 0 0 1]</pre>

On the other hand, this may be clearer and/or faster:

my @id = [0 xx $n] xx $n;

@id[$_][$_] = 1 for ^$n;

@id;

 

Here is yet an other way to do it:

[1, |(0 xx $n-1)], *.rotate(-1) ... *[*-1]

 

=={{header|REXX}}==

 

It also tries to display a centered (and easier to read) matrix, &nbsp; along with a title.

do k=3 to 6 /* [↓] build and display a sq. matrix.*/

call ident_mat k /*build & display a KxK square matrix. */

say _ /*display a single line of the matrix. */

end /*row*/

{{out|output|text=&nbsp; when using the default sizes &nbsp; (3 ──► 6) &nbsp; for generating four matrices:}}

<pre>

===version 2===

An alternative?!

/* REXX ***************************************************************

* show identity matrix of size n

Say ol

End

{{out}}

<pre>

</pre>

This could be a 3-dimensional sparse matrix with one element set:

m.=0

m.0=1000 /* the matrix' size */

m.4.17.333='Walter'

 

=={{header|Ring}}==

size = 5

im = newlist(size, size)

next

return alist

Output:

<pre>

00010

00001

</pre>

 

=={{header|Ruby}}==

===Using Array===

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}, ""

 

{{out}}

</pre>

===Using Matrix===

 

=={{header|Run BASIC}}==

for ims = 4 to 6

 

print "]"

next

{{out}}

<pre>--- Size: 4 ---

Run with command-line containing the matrix size.

 

extern crate num;

struct Matrix<T> {

}

}

 

=={{header|Scala}}==

def printMatrix[T](m:Array[Array[T]])=m map (_.mkString("[", ", ", "]")) mkString "\n"

 

{{out}}

<pre>[1, 0, 0, 0, 0]

=={{header|Scheme}}==

When representing a matrix as a collection of nested lists:

(define (identity n)

(letrec

(cons (uvec i 0 '()) acc))))))

(idgen 0 '())))

Test program:

(display (identity 4))

{{out}}

<pre>

 

=={{header|Seed7}}==

 

const type: matrix is array array integer;

begin

writeMat(identity(6));

 

{{out}}

 

=={{header|SenseTalk}}==

set matrix to buildIdentityMatrix(3)

 

return matrixList

end buildIdentityMatrix

Output for n 3

<pre>(1,0,0)

 

=={{header|Sidef}}==

n.of { |i|

n.of { |j|

say row.join(' ')

}

 

{{out}}

=={{header|Sinclair ZX81 BASIC}}==

Works with 1k of RAM, but for a larger matrix you'll want at least 2k.

20 DIM M(S,S)

30 FOR I=1 TO S

100 NEXT J

110 PRINT

{{in}}

<pre>10</pre>

=={{header|Smalltalk}}==

{{works with|Pharo Smalltalk}}

{{Out}}

<pre>

 

=={{header|Sparkling}}==

return map(range(n), function(k1, v1) {

return map(range(n), function(k2, v2) {

});

});

 

=={{header|Standard ML}}==

=={{header|Stata}}==

=== Stata matrix ===

. mat list a

 

r1 1

r2 0 1

 

=== Mata ===

[symmetric]

1 2 3

2 | 0 1 |

3 | 0 0 1 |

 

=={{header|Swift}}==

{{trans|Elixir}}

 

return (0..<size).map({i in

return (0..<size).map({ $0 == i ? 1 : 0})

}

 

 

{{out}}

 

=={{header|Tailspin}}==

templates identityMatrix

def n: $;

end identityMatrix

 

$identity... -> '|$(1);$(2..last)... -> ', $;';|

' -> !OUT::write

{{out}}

<pre>

=={{header|Tcl}}==

When representing a matrix as a collection of nested lists:

set m [lrepeat $rank [lrepeat $rank $zero]]

for {set i 0} {$i < $rank} {incr i} {

}

return $m

Or alternatively with the help of the tcllib package for rectangular data structures:

{{tcllib|struct::matrix}}

 

proc I {rank {zero 0.0} {one 1.0}} {

}

return $m

Demonstrating the latter:

{{out}}

<pre>1 0 0 0 0

 

=={{header|TypeScript}}==

function identity(n) {

if (n < 1) return "Not defined";

}

}

 

=={{header|Vala}}==

if (args.length < 2) {

print ("Please, input an integer > 0.\n");

}

return 0;

 

=={{header|VBA}}==

Dim I() As Integer

ReDim I(n - 1, n - 1)

Next j

Identity = I

 

=={{header|VBScript}}==

build_matrix(7)

 

Next

End Sub

 

{{Out}}

'''Alternate version'''

 

n = 8

 

Identity = a

End Function

{{Out}}

<pre>

=={{header|Visual Basic}}==

{{works with|Visual Basic|6}}

'------------

Public Function BuildIdentityMatrix(ByVal Size As Long) As Byte()

 

End Sub

{{out}}

<pre>10000

 

=={{header|Wortel}}==

im ^(%^\@table ^(@+ =) @to)

 

!im 4

Returns:

<pre>[[1 0 0 0]

{{libheader|Wren-matrix}}

{{libheader|Wren-fmt}}

 

var numRows = 10 // say

 

{{out}}

 

=={{header|XPL0}}==

def IntSize = 4; \number of bytes in an integer

int Matrix, Size, I, J;

CrLf(0);

];

 

{{out}}

=={{header|zkl}}==

Using lists of lists:

m:=(0).pump(n,List.createLong(n).write,0)*n;

m.apply2(fcn(row,rc){ row[rc.inc()]=1 },Ref(0));

}

idMatrix(5).println();

{{out}}

<pre>

=={{header|ZX Spectrum Basic}}==

{{trans|Applesoft_BASIC}}

20 GO SUB 200: REM Identity matrix

30 FOR r=1 TO size

240 LET i(i,i)=1

250 NEXT i