Reduced row echelon form: Difference between revisions

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

''lead'' := 0

 

For testing purposes, the RREF of this matrix:

is:

 

=={{header|ActionScript}}==

 

var lead:uint, i:uint, j:uint, r:uint = 0;

 

}

return this;

 

=={{header|Ada}}==

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

 

=={{header|Aime}}==

{

list u, v;

 

i = r;

i += 1;

if (i == rows) {

}

 

 

if (e) {

}

}

 

if (i != r) {

}

}

}

 

}

 

{

o_byte('\n');

}

}

 

main(void)

{

list l;

 

rref(l, 3, 4);

 

 

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

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

Global $ivMatrix[3][4] = [[1, 2, -1, -4],[2, 3, -1, -11],[-2, 0, -3, 22]]

ToReducedRowEchelonForm($ivMatrix)

Return $matrix

EndFunc ;==>ToReducedRowEchelonForm

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

[-0,1,0,1]

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

 

{{works with|BBC BASIC for Windows}}

matrix() = 1, 2, -1, -4, \

\ 2, 3, -1, -11, \

lead% += 1

NEXT r%

<pre>

1 0 0 -8

 

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

 

void toReducedRowEchelonForm(T)(T[][] M) pure nothrow @nogc {

A.toReducedRowEchelonForm;

writefln("%(%(%2d %)\n%)", A);

{{out}}

<pre> 1 0 0 -8

0 1 0 1

0 0 1 -2</pre>

 

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

===2D representation===

From WP pseudocode:

 

import "fmt"

lead++

}

<pre>

[1 2 -1 -4]

[-0 -0 1 -2]

</pre>

===Flat representation===

 

import "fmt"

m.rref()

m.print("Reduced:")

<pre>

Input:

 

=={{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|Icon}} and {{header|Unicon}}==

 

Works in both languages:

tM := [[ 1, 2, -1, -4],

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

procedure showMat(M)

every r := !M do every writes(right(!r,5)||" " | "\n")

 

<pre>

->rref

 

=={{header|J}}==

1 2 _1 _4

2 3 _1 _11

_2 0 _3 22

 

1 0 0 _8

0 1 0 1

 

Additional examples, recommended on talk page:

 

gauss_jordan 2 0 _1 0 0,1 0 0 _1 0,3 0 0 _2 _1,0 1 0 0 _2,:0 1 _1 0 0

1 0 0 0 _1

1 0

0 1

 

=={{header|Java}}==

''This requires Apache Commons 2.2+''

import java.lang.Math;

import org.apache.commons.math.fraction.Fraction;

System.out.println("after\n" + a.toString() + "\n");

}

 

=={{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,0,1,1</pre>

 

 

=={{header|Julia}}==

<pre>

julia> matrix = [1 2 -1 -4 ; 2 3 -1 -11 ; -2 0 -3 22]

0.0 0.0 1.0 -2.0

 

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

 

with(LinearAlgebra):

 

ReducedRowEchelonForm(<<1,2,-2>|<2,3,0>|<-1,-1,-3>|<-4,-11,22>>);

<pre>

[1 0 0 -8]

</pre>

 

 

=={{header|MATLAB}}==

 

=={{header|Maxima}}==

k:min(p,q),

for i thru min(p,q) do (if a[i,i]=0 then (k:i-1,return())),

 

rref(a);

 

=={{header|Objeck}}==

class RowEchelon {

function : Main(args : String[]) ~ Nil {

}

}

 

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

 

 

 

);

 

 

</pre>

 

=={{header|PHP}}==

{{works with|PHP|5.x}}

{{trans|Java}}

 

function rref($matrix)

return $matrix;

}

 

=={{header|PicoLisp}}==

(let (Lead 1 Cols (length (car Mat)))

(for (X Mat X (cdr X))

(car X) ) ) ) )

(T (> (inc 'Lead) Cols)) ) )

<pre>(reducedRowEchelonForm

'(( 1 2 -1 -4) ( 2 3 -1 -11) (-2 0 -3 22)) )

=={{header|Python}}==

 

if not M: return

lead = 0

 

for rw in mtx:

 

=={{header|R}}==

{{trans|Fortran}}

pivot <- 1

norow <- nrow(m)

-2, 0, -3, 22), 3, 4, byrow=TRUE)

print(m)

 

=={{header|Racket}}==

#lang racket

(require math)

[2 3 -1 -11]

[-2 0 -3 22]]))

<pre>

(mutable-array

</pre>

 

 

 

 

 

 

 

do c=1 for cols

end

end /*c*/

<pre>

────original matrix────

0 1 0 1

0 0 1 -2

</pre>

 

=={{header|Ruby}}==

{{works with|Ruby|1.9.3}}

def reduced_row_echelon_form(ary)

lead = 0

reduced = reduced_row_echelon_form(mtx)

print_matrix reduced

 

{{out}}

0.0 1.0 0.0 1.6666666666666667

0.0 0.0 1.0 1.0

</pre>

 

=={{header|Sage}}==

{{works with|Sage|4.6.2}}

sage: m.rref()

[ 1 0 0 -8]

[ 0 1 0 1]

 

=={{header|Scheme}}==

{{Works with|Scheme|R<math>^5</math>RS}}

(define (clean-down matrix from-row column)

(cons (car matrix)

indices)

indices)

Example:

(list (list 1 2 -1 -4) (list 2 3 -1 -11) (list -2 0 -3 22)))

 

(display (reduced-row-echelon-form matrix))

 

=={{header|Seed7}}==

 

const proc: toReducedRowEchelonForm (inout matrix: mat) is func

end for;

end for;

 

Original source: [http://seed7.sourceforge.net/algorith/math.htm#toReducedRowEchelonForm]

 

=={{header|Tcl}}==

Using utility procs defined at [[Matrix Transpose#Tcl]]

namespace path {::tcl::mathop ::tcl::mathfunc}

 

set m {{1 2 -1 -4} {2 3 -1 -11} {-2 0 -3 22}}

print_matrix $m

<pre> 1 2 -1 -4

2 3 -1 -11

-0.0 1.0 0.0 1.0

-0.0 -0.0 1.0 -2.0 </pre>

 

=={{header|TI-89 BASIC}}==

 

Output (in prettyprint mode): <math>\begin{bmatrix} 1&0&0&-8 \\ 0&1&0&1 \\ 0&0&1&-2 \end{bmatrix}</math>

 

 

=={{header|Ursala}}==

The most convenient representation for a matrix in Ursala is as a list of lists.

Several auxiliary functions are defined to make this task more manageable.

The descending function is a second order function abstracting the pattern

 

#import flo

 

<1.,2.,-1.,-4.>,

<2.,3.,-1.,-11.>,

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