Gauss-Jordan matrix inversion: Difference between revisions

'''A'''   being an   '''n''' × '''n'''   matrix.

<br><br>

 

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

The COPY file of FORMAT, to format a floating point number, can be found at:

[[360_Assembly_include|Include files 360 Assembly]].

GAUSSJOR CSECT

USING GAUSSJOR,R13 base register

PG DC CL80' ' buffer

REGEQU

{{out}}

<pre>

=={{header|ALGOL 60}}==

{{works with|A60}}

comment Gauss-Jordan matrix inversion - 22/01/2021;

integer n;

show("c",c)

end

{{out}}

<pre>

4 1 2 2

</pre>

 

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

using System;

 

}

}

using System;

 

}

}

{{out}}<pre>

-0.913043478260869 0.246376811594203 0.0942028985507246 0.413043478260869

 

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

#include <cassert>

#include <iomanip>

print(std::cout, inverse(inv));

return 0;

 

{{out}}

0.0000 -1.0000 2.0000

</pre>

 

=={{header|Factor}}==

Normally you would call <code>recip</code> to calculate the inverse of a matrix, but it uses a different method than Gauss-Jordan, so here's Gauss-Jordan.

{{works with|Factor|0.99 2020-01-23}}

prettyprint sequences ;

 

{ 7 -8 9 1 }

{ 1 -2 1 3 }

{{out}}

<pre>

</pre>

 

 

 

 

{{out}}

<pre>

 

</pre>

 

=={{header|Generic}}==

// The Generic Language is a database compiler. This code is compiled into database then executed out of database.

 

 

}

=={{header|Go}}==

{{trans|Kotlin}}

 

import "fmt"

b := matrix{{2, -1, 0}, {-1, 2, -1}, {0, -1, 2}}

b.inverse().print("Inverse of B is:\n")

{{out}}

<pre>

===Alternative===

{{trans|PowerShell}}

import (

b := matrix{{2, -1, 0}, {-1, 2, -1}, {0, -1, 2}}

b.inverse().print("Inverse of B is:\n")

{{out}}

<pre>Same output than above</pre>

 

=={{header|Haskell}}==

 

isSquareMatrix xs = null xs || all ((== (length xs)).length) xs

mapM_ print $ inversion a

putStrLn "\ninversion b ="

{{out}}

<pre>

 

Uses Gauss-Jordan implementation (as described in [[Reduced_row_echelon_form#J]]) to find reduced row echelon form of the matrix after augmenting with an identity matrix.

augmentR_I1=: ,. e.@i.@# NB. augment matrix on the right with its Identity matrix

 

'''Usage:'''

1 2 3

4 1 6

_0.8125 0.125 0.1875

0.125 _0.25 0.125

 

=={{header|Java}}==

 

import java.util.Random;

Matrix.product(m, inv).print();

}

 

 

public class Matrix {

elements[j] = tmp;

}

 

{{out}}

-0.000 0.000 0.000 1.000 -0.000

-0.000 0.000 0.000 -0.000 1.000

</pre>

 

 

'''Built-in''' LAPACK-based linear solver uses partial-pivoted Gauss elimination):

@show I / A

 

'''Native implementation''':

size(A, 1) == size(A, 2) || throw(ArgumentError("A must be squared"))

n = size(A, 1)

 

A = rand(10, 10)

 

{{out}}

=={{header|Kotlin}}==

This follows the description of Gauss-Jordan elimination in Wikipedia whereby the original square matrix is first augmented to the right by its identity matrix, its reduced row echelon form is then found and finally the identity matrix to the left is removed to leave the inverse of the original square matrix.

 

typealias Matrix = Array<DoubleArray>

)

b.inverse().printf("Inverse of B is :\n")

 

{{out}}

 

=={{header|Lambdatalk}}==

{require lib_matrix}

 

[1.4444444444444444,-0.5555555555555556,0.1111111111111111],

[-0.05555555555555555,0.1111111111111111,-0.05555555555555555]]

 

=={{header|MATLAB}}==

original = M;

[n,~] = size(M);

0, -1, 2 ];

 

 

{{out}}

=={{header|Nim}}==

We reuse the algorithm of task https://rosettacode.org/wiki/Reduced_row_echelon_form (version using floats).

 

const Eps = 1e-10

runTest(m1)

runTest(m2)

 

{{out}}

-0.69565 0.36232 0.07971 0.19565

-0.56522 0.23188 -0.02899 0.56522</pre>

 

=={{header|Perl}}==

Included code from [[Reduced_row_echelon_form#Perl|Reduced row echelon form]] task.

our @m; local *m = shift;

@m or return;

my @rt = gauss_jordan_invert( @gj );

print "After round-trip:\n" . display(\@rt) . "\n";} . "\n"

{{out}}

<pre>Original Matrix:

{{trans|Kotlin}}

uses ToReducedRowEchelonForm() from [[Reduced_row_echelon_form#Phix]]

{{out}}

<pre>

===alternate===

{{trans|PowerShell}}

{{out}}

<pre>

 

=={{header|PowerShell}}==

function gauss-jordan-inv([double[][]]$a) {

$n = $a.count

show $invb

 

<b>Output:</b>

<pre>

Use numpy matrix inversion

 

import numpy as np

from numpy.linalg import inv

print(a)

print(ainv)

 

{{out}}

Using the matrix library that comes with default Racket installation

 

 

(require math/matrix

 

(inverse A)

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

Uses bits and pieces from other tasks, [[Reduced_row_echelon_form#Raku|Reduced row echelon form]] primarily.

 

^@m .map: { @m[$_].append: identity(+@m)[$_] };

@m.&rref[*]»[+@m .. *];

sub identity ($n) { [ 1, |(0 xx $n-1) ], *.rotate(-1).Array ... *.tail }

 

sub rref (@m) {

 

for ^$rows -> $r {

}

@m[$i, $r] = @m[$r, $i] if $r != $i;

for ^$rows -> $n {

next if $n == $r;

}

++$lead;

@m

}

sub rat-or-int ($num) {

return $num unless $num ~~ Rat|FatRat;

$num.nude.join: '/';

}

say_it( ' Gauss-Jordan Inverted:', my @invert = gauss-jordan-invert @matrix );

say_it( ' Re-inverted:', gauss-jordan-invert @invert».Array );

 

{{out}}

=={{header|REXX}}==

===version 1===

Parse Arg seed nn

If seed='' Then

Return bs

 

{{out}} Using the defaults for seed and n

<pre>show 1 The given matrix

===version 2===

{{trans|PL/I}}

call build 4 /*assign data elements to the matrix. */

call show '@', 'The matrix of order ' n " is:" /*display the (square) matrix. */

call invert /*invert the matrix, store result in X.*/

call show 'X', "The inverted matrix is:" /*display (inverted) auxiliary matrix. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

aux: x.= 0; do i=1 for n; x.i.i= 1; end; return

@.r.c= word(data, #); w= max(w, length(@.r.c) )

end /*c*/ /*W: max width of a number*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

invert: do k=1 for n; t= @.k.k /*divide each matrix row by T. */

end /*c*/

end /*r*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

show: parse arg ?, title; say; say title; f= 4 /*F: fractional digits precision.*/

else _= _ right(format(x.r.c, w, f), w + f + length(.))

end /*c*/; say _

{{out|output|text=&nbsp; when using the internal default input:}}

<pre>

-0.1833 -0.7009 -0.1425 0.6163

-0.1064 -0.0855 0.0883 0.0779

</pre>

 

Uses the '''rref(M)''' function from [https://rosettacode.org/wiki/Reduced_row_echelon_form#Sidef Reduced row echelon form].

{{trans|Raku}}

 

var I = M.len.of {|i|

say gauss_jordan_invert(A).map {

.map { "%6s" % .as_rat }.join(" ")

{{out}}

<pre>

-13/23 16/69 -2/69 13/23

</pre>

 

=={{header|Wren}}==

{{libheader|Wren-matrix}}

The above module does in fact use the Gauss-Jordan method for matrix inversion.

 

var arrays = [

Fmt.mprint(m.inverse, 9, 6)

System.print()

 

{{out}}

=={{header|zkl}}==

This uses GSL to invert a matrix via LU decomposition, not Gauss-Jordan.

m:=GSL.Matrix(3,3).set(1,2,3, 4,1,6, 7,8,9);

i:=m.invert();

i.format(10,4).println("\n");

{{out}}

<pre>

-0.0000, 0.0000, 1.0000

</pre>

{{out}}

<pre>

0.2500, 0.5000, 0.7500

</pre>