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>

=={{header|Action!}}==

CARD pos

BYTE i,j

LMARGIN=old ;restore left margin on the screen

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Identity_matrix.png Screenshot from Atari 8-bit computer]

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

----

===Simple alternative===

set digits to {}

set m to n - 1

end indentityMatrix

{{output}}

=={{header|Arturo}}==

result: array.of: @[n n] 0

loop 0..dec n 'i -> result\[i]\[i]: 1

loop identityM sz => print

print ""

{{out}}

=={{header|BASIC}}==

==={{header|Applesoft BASIC}}===

100 INPUT "MATRIX SIZE:"; SIZE%

110 GOSUB 200"IDENTITYMATRIX

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

250 RETURN :IM

==={{header|Commodore BASIC}}===

{{trans|Applesoft BASIC}}

{{works with|Commodore BASIC|2.0}}

110 GOSUB 200: REM IDENTITYMATRIX

120 FOR R = 0 TO SIZE

240 IM(I, I) = 1

250 NEXT I

==={{header|QBasic}}===

{{works with|QuickBasic|4.5}}

{{trans|IS-BASIC}}

FOR i = LBOUND(identity,1) TO UBOUND(identity,1)

FOR j = LBOUND(identity,2) TO UBOUND(identity,2)

CALL inicio(identity())

==={{header|BASIC256}}===

{{trans|FreeBASIC}}

do

input "Enter size of matrix: ", n

else

print "Matrix is too big to display on 80 column console"

{{out}}

<pre>Same as FreeBASIC entry.</pre>

==={{header|Yabasic}}===

{{trans|FreeBASIC}}

input "Enter size of matrix: " n

until n > 0

else

print "Matrix is too big to display on 80 column console"

{{out}}

<pre>Same as FreeBASIC entry.</pre>

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

=={{header|Eiffel}}==

class

APPLICATION

end

{{out}}

=={{header|Elena}}==

ELENA 4.x :

import system'routines;

import system'collections;

identity.forEach:

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

=={{header|Fermat}}==

Func Identity(n)=Array id[n,n];[id]:=[1].

Identity(7)

[id]

{{out}}

<pre>

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

This does not use the Matrix.frink library, which has methods to create an identity matrix, but shows how to build a "raw" identity matrix as a two-dimensional array, and shows how to nicely format it using built-in routines.

{{out}}

=={{header|FunL}}==

{{out}}

=={{header|FutureBasic}}==

include "NSLog.incl"

HandleEvents

{{output}}

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

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