Identity matrix: Difference between revisions

 

<math>I_n = \begin{bmatrix}

0 & 0 & 0 & \cdots & 1 \\

\end{bmatrix}</math>

 

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

 

For a square matrix of 3:

1 0 0

0 1 0

0 0 1

 

For a function that makes an identity matrix:

ID 5

1 0 0 0 0

0 0 0 1 0

0 0 0 0 1

 

There is a more idomatic way however:

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

 

=={{header|AWK}}==

# syntax: GAWK -f IDENTITY_MATRIX.AWK size

BEGIN {

exit(0)

}

<pre>

1 0 0 0 0

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

 

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

</pre>

 

 

 

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

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

 

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

 

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

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

 

 

=={{header|Erlang}}==

%% Implemented by Arjun Sunel

 

 

identity(Size) ->

 

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

 

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

 

=={{header|Fortran}}==

{{works with|Fortran|95}}

 

program identitymatrix

 

 

end program identitymatrix

 

=={{header|Go}}==

 

import "fmt"

func I(n int) [][]float64 {

m := make([][]float64, n)

for i := 0; i < n; i++ {

a[i] = 1

}

return m

{{out}}

No special formatting method used.

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

</pre>

 

import "fmt"

 

func main() {

}

 

func I(n int) matrix {

m := make(matrix, n*n)

n++

for i := 0; i < len(m); i += n {

}

return m

{{out}}

<pre>

[1 0 0 0 1 0 0 0 1]

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

 

<pre>[1, 0]

[0, 1]

 

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

 

=={{header|J}}==

1 0 0 0

0 1 0 0

0 0 1 0 0

0 0 0 1 0

 

=={{header|Java}}==

 

}

 

 

=={{header|Julia}}==

 

 

<pre>

</pre>

 

=={{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(), "");

}

}

<pre>You: 0

Identity_Matrix: You entered 0.

Identity_Matrix: [0, 0, 0, 1, 0]

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

 

=={{header|Lua}}==

function identity_matrix (size)

local m = {}

end

 

<pre>

1 0 0 0 0

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

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

a 3x3 identity matrix

 

=={{header|OxygenBasic}}==

Class SquareMatrix

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

'...

del M

 

=={{header|Pascal}}==

 

var

writeln;

end;

<pre>

% ./IdentityMatrix

</pre>

 

 

}

 

{{out}}

<pre>4:

0 0 0 1 0 0

0 0 0 0 1 0

 

{{out}}

 

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

<pre> 1 0 0

0 1 0

 

=={{header|Python}}==

 

for i in range(size):

for elements in rows:

print elements,

 

 

A solution using the numpy library

np.mat(np.eye(size))

 

=={{header|R}}==

produces:

[1,] 1 0 0

[2,] 0 1 0

 

=={{header|Racket}}==

#lang racket

(require math)

(identity-matrix 5)

<pre>

(array #[#[1 0 0 0 0]

#[0 0 0 1 0]

#[0 0 0 0 1]])

</pre>

 

=={{header|REXX}}==

===version 1===

 

 

 

 

 

</pre>

 

===version 2===

An alternative?!

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

* show identity matrix of size n

Say ol

End

<pre>

Identity Matrix of size 3 (m.i.j IS the Matrix)

0 0 1

</pre>

m.=0

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

m.4.17.333='Walter'

 

=={{header|Ruby}}==

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

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

</pre>

 

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

for ims = 4 to 6

 

print "]"

next

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

[1, 0, 0, 0]

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

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

 

=={{header|Scala}}==

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

 

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

[0, 1, 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));

 

<pre>

1 0 0 0 0 0

0 0 0 0 1 0

0 0 0 0 0 1

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

0 0 0 0 1</pre>