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}}==

 

 

set xs to enumFromTo(1, n)

script row

on |λ|(x)

on |λ|(i)

if i = x then

end |λ|

end script

end |λ|

end script

map(row, xs)

 

 

on run

end run

 

 

 

-- enumFromTo :: Int -> Int -> [Int]

on enumFromTo(m, n)

else

end if

end enumFromTo

 

-- map :: (a -> b) -> [a] -> [b]

end tell

end map

 

-- Lift 2nd class handler function into 1st class script wrapper

end script

end if

{{Out}}

 

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|Burlesque}}==

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|C}}==

#include <stdlib.h>

#include <stdio.h>

exit(EXIT_FAILURE);

}

if (rowsize < 0) {

printf("Dimensions of matrix cannot be negative\n");

exit(EXIT_FAILURE);

}

if (numElements < rowsize) {

printf("Squaring %d caused result to overflow to %d.\n", rowsize, numElements);

int** matrix = calloc(numElements, sizeof(int*));

if (!matrix) {

abort();

}

matrix[row] = calloc(numElements, sizeof(int));

if (!matrix[row]) {

abort();

}

}

}

 

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

{{libheader|STL}}

class matrix

{

return 0;

}

{{libheader|boost}}

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

 

return 0;

}

{{out}}

<pre>

0 0 0 1 0

0 0 0 0 1

</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|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}}==

{

{ 1 0 0 0 0 0 }

{ 0 0 0 0 1 0 }

{ 0 0 0 0 0 1 }

 

=={{header|FBSL}}==

</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}}

0 0 0 1 0

0 0 0 0 1

</pre>

 

=={{header|FunL}}==

 

 

{{out}}

((1, 0, 0), (0, 1, 0), (0, 0, 1))

</pre>

 

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

 

length: n

}, (_, i) => Array.from({

}, (_, j) => i !== j ? 0 : 1));

 

 

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

 

=={{header|Julia}}==

 

 

=={{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}}

</pre>

 

 

=={{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|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)

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|Pascal}}==

 

var

writeln;

end;

{{out}}

<pre>

</pre>

 

 

}

 

{{out}}

<pre>4:

0 0 0 1 0 0

0 0 0 0 1 0

 

=={{header|Phix}}==

{{out}}

<pre style="float:left">

 

=={{header|PHP}}==

}

}

{{out}}

<pre>

</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>

1

0

</pre>

 

=={{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|R}}==

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>

#[0 0 0 1 0]

#[0 0 0 0 1]])

</pre>

 

 

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

[0 0 1 0]

[0 0 0 1]]</pre>

 

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