Reduced row echelon form: Difference between revisions

'''function''' ToReducedRowEchelonForm(Matrix M) '''is'''

''lead'' := 0

'''end while'''

Swap rows ''i'' and ''r''

'''for''' 0 &le; ''i'' < ''rowCount'' '''do'''

'''if''' ''i'' ≠ ''r'' '''do'''

 

For testing purposes, the RREF of this matrix:

is:

 

 

matrices.ads:

type Element_Type is private;

Zero : Element_Type;

array (Positive range <>, Positive range <>) of Element_Type;

function Reduced_Row_Echelon_form (Source : Matrix) return Matrix;

 

matrices.adb:

procedure Swap_Rows (From : in out Matrix; First, Second : in Positive) is

Temporary : Element_Type;

return Result;

end Reduced_Row_Echelon_form;

 

Example use: main.adb:

with Ada.Text_IO;

procedure Main is

Ada.Text_IO.Put_Line ("reduced to:");

Print_Matrix (Reduced);

 

<pre>1.0 2.0 -1.0 -4.0

2.0 3.0 -1.0 -11.0

-0.0 1.0 0.0 1.0

-0.0 -0.0 1.0 -2.0</pre>

 

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

{{trans|Python}}

{{works with|ALGOL 68|Standard - no extensions to language used}}

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

<!-- {{does not work with|ELLA ALGOL 68|Any (with appropriate job cards AND formatted transput statements removed) - tested with release 1.8.8d.fc9.i386 - ELLA has not FORMATted transput, also it generates a call to undefined C external }} -->

MODE VEC = [0]FIELD;

MODE MAT = [0,0]FIELD;

mat repr = $"("n(1 UPB mat-1)(f(vec repr)", "lx)f(vec repr)")"$;

 

<pre>

(( 1.0000, 0.0000, 0.0000, -8.0000),

( 0.0000, 1.0000, 0.0000, 1.0000),

( 0.0000, 0.0000, 1.0000, -2.0000))

</pre>

 

=={{header|C}}==

#define TALLOC(n,typ) malloc(n*sizeof(typ))

 

MtxDisplay(m1);

return 0;

 

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

 

{{works with|g++|4.1.2 20061115 (prerelease) (Debian 4.1.1-21)}}

#include <cstddef>

#include <cassert>

// externalizing this information into a traits class, the same code

// can be used both with native arrays and matrix classes. To use the

// provide the following definitions as members:

//

{

typedef typename MatrixType::index_type index_type;

static index_type min_row(MatrixType const& A)

{ return A.min_row(); }

 

return EXIT_SUCCESS;

<pre>

1 0 0 -8

-0 -0 1 -2

</pre>

 

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

Direct implementation of the pseudo-code given.

(let* ((dimensions (array-dimensions matrix))

(row-count (first dimensions))

(* scale (aref matrix r c))))))

(incf lead))

 

=={{header|D}}==

 

}

M[r][] /= M[r][lead];

if (j != r)

lead++;

}

[ 2, 3, -1, -11],

[-2, 0, -3, 22]];

 

=={{header|Euphoria}}==

integer lead,rowCount,columnCount,i

sequence temp

{ { 1, 2, -1, -4 },

{ 2, 3, -1, -11 },

 

<pre>{

{1,0,0,-8},

{0,0,1,-2}

}</pre>

 

=={{header|Fortran}}==

implicit none

contains

deallocate(trow)

end subroutine to_rref

 

use rref

implicit none

end do

 

 

=={{header|Go}}==

From WP pseudocode:

 

import "fmt"

lead++

}

<pre>

[1 2 -1 -4]

[-0 1 0 1]

[-0 -0 1 -2]

</pre>

 

=={{header|Groovy}}==

NONE({ i, it -> 1 }),

PARTIAL({ i, it -> - (it[i].abs()) }),

}

matrix

 

This test first demonstrates the test case provided, and then demonstrates another test case designed to show the dangers of not using pivoting on an otherwise solvable matrix. Both test cases exercise all three pivoting options.

 

println "Tests for matrix A:"

println "pivoting == Pivoting.SCALED"

reducedRowEchelonForm(matrixCopy(b), Pivoting.SCALED).each { println it }

 

<pre>Tests for matrix A:

[1, 2, -1, -4]

This program was produced by translating from the Python and gradually refactoring the result into a more functional style.

 

 

rref :: Fractional a => [[a]] -> [[a]]

{- Replaces the element at the given index. -}

replace n e l = a ++ e : b

 

=={{header|J}}==

1 2 _1 _4

2 3 _1 _11

_2 0 _3 22

 

1 0 0 _8

0 1 0 1

 

=={{header|Java}}==

 

 

 

 

 

 

 

 

 

 

=={{header|JavaScript}}==

{{works with|SpiderMonkey}} for the <code>print()</code> function.

Extends the Matrix class defined at [[Matrix Transpose#JavaScript]]

Matrix.prototype.toReducedRowEchelonForm = function() {

var lead = 0;

[ 3, 3, 0, 7]

]);

<pre>1,0,0,-8

0,1,0,1

0,1,0,1.666666666666667

0,0,1,1</pre>

=={{header|Lua}}==

local lead = 1

local n_rows, n_cols = #M, #M[1]

end

io.write( "\n" )

<pre>1 0 0 -8

0 1 0 1

0 0 1 -2 </pre>

 

 

=={{header|MATLAB}}==

 

=={{header|Maxima}}==

 

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|OCaml}}==

let tmp = m.(i) in

m.(i) <- m.(j);

) row;

print_newline()

 

Another implementation:

let nr, nc = Array.length m, Array.length m.(0) in

let add r s k =

print_newline();

rref mat;

 

=={{header|Octave}}==

refA = rref(A);

 

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

my(d=matsize(M));

if(d[1]+1 != d[2], error("Bad size in rref"), d=d[1]);

concat(matid(d), matsolve(matrix(d,d,x,y,M[x,y]), M[,d+1]))

Example:

<pre>%1 =

[1 0 0 -8]

=={{header|Perl}}==

{{trans|Python}}

{our @m; local *m = shift;

@m or return;

$_ -= $lv * $mr[++$n] foreach @{ $m[$i] };}

 

 

 

 

$i = $r;

}

 

 

 

for ^$rows -> $n {

next if $n == $r;

}

++$lead;

}

}

 

return $num unless $num ~~ Rat;

}

sub say_it ($message, @array) {

say "\n$message";

}

 

say_it( 'Reduced Row Echelon Form Matrix', rref(@matrix) );

say "\n";

 

 

Original Matrix

1 2 -1 -4

0 1 0 1

0 0 1 -2

 

Original Matrix

0 1 0 -217/6

0 0 1 -125/6

 

Original Matrix

0 0 0 0 0 0

0 0 0 0 0 0

 

Original Matrix

</pre>

 

and

 

 

my @M = (

);

 

}

 

 

 

}

}

}

 

[< 1 2 -1 -4 >],

[< 2 3 -1 -11 >],

);