QR decomposition: Difference between revisions

-4 & 24 & -41 \end{pmatrix}</math>

 

 

'''Method'''

=={{header|Ada}}==

Output matches that of Matlab solution, not tested with other matrices.

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Numerics.Real_Arrays; use Ada.Numerics.Real_Arrays;

Put_Line ("Q:"); Show (Q);

Put_Line ("R:"); Show (R);

{{out}}

<pre>Q:

-0.0000 175.0000 -70.0000

-0.0000 0.0000 35.0000</pre>

 

=={{header|Axiom}}==

The following provides a generic QR decomposition for arbitrary precision floats, double floats and exact calculations:

TestPackage(R:Join(Field,RadicalCategory)): with

unitVector: NonNegativeInteger -> Vector(R)

for j in 0..n repeat

setColumn!(a,j+1,x^j)

This can be called using:

qr m

x := vector [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

y := vector [1, 6, 17, 34, 57, 86, 121, 162, 209, 262, 321];

With output in exact form:

 

+ 6 69 58 +

 

[1,2,3]

The calculations are comparable to those from the default QR decomposition in R.

 

{{works with|BBC BASIC for Windows}}

Makes heavy use of BBC BASIC's matrix arithmetic.

@% = &2040A

INSTALL @lib$+"ARRAYLIB"

REM Create the Householder matrix H() = I - 2/vt()v() v()vt():

vvt() *= 2 / d(0) : H() = I() - vvt()

'''Output:'''

<pre>

 

=={{header|C}}==

#include <stdlib.h>

#include <math.h>

matrix_delete(m);

return 0;

{{out}}

<pre>

2.000 -0.000 3.000

</pre>

 

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

* g++ -O3 -Wall --std=c++11 qr_standalone.cpp -o qr_standalone

*/

return EXIT_SUCCESS;

}

{{out}}

<pre>

</pre>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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

 

Helper functions:

(if (zerop x)

x

 

C))

 

Main routines:

(defun make-householder (a)

(let* ((m (car (array-dimensions a)))

;; Return Q and R.

(values Q A)))

 

Example 1:

 

 

#2A((-0.85 0.39 0.33)

#2A((-14.0 -21.0 14.0)

( 0.0 -175.0 70.0)

 

Example 2, [[Polynomial regression]]:

 

(let* ((m (cadr (array-dimensions x)))

(A (make-array `(,m ,(+ n 1)) :initial-element 0)))

(aref x j 0))))

(aref R k k))))

 

(let ((x #2A((0 1 2 3 4 5 6 7 8 9 10)))

(y #2A((1 6 17 34 57 86 121 162 209 262 321))))

(polyfit x y 2))

 

 

=={{header|D}}==

{{trans|Common Lisp}}

Uses the functions copied from [[Element-wise_operations]], [[Matrix multiplication]], and [[Matrix transposition]].

std.typecons, std.numeric, std.range, std.conv;

 

immutable y = [[1.0, 6, 17, 34, 57, 86, 121, 162, 209, 262, 321]];

polyFit(x, y, 2).writeln;

{{out}}

<pre>[[-0.857, 0.394, 0.331],

 

[[1], [2], [3]]</pre>

 

=={{header|Go}}==

{{trans|Common Lisp}}

A fairly close port of the Common Lisp solution, this solution uses the [http://github.com/skelterjohn/go.matrix go.matrix library] for supporting functions. Note though, that go.matrix has QR decomposition, as shown in the [[Polynomial_regression#Go|Go solution]] to Polynomial regression. The solution there is coded more directly than by following the CL example here. Similarly, examination of the go.matrix QR source shows that it computes the decomposition more directly.

 

import (

}

return x

Output:

<pre>

 

===Library QR, gonum/matrix===

 

import (

}

return x

{{out}}

<pre>

⎢2.000⎥

⎣3.000⎦

</pre>

 

=={{header|J}}==

 

h =: +@|: NB. conjugate transpose

 

(Q0,.Q1);(R0,.T),(-n){."1 R1

end.

 

+-----------------------------+----------+

| 0.857143 _0.394286 _0.331429|14 21 _14|

| 0.428571 0.902857 0.0342857| 0 175 _70|

|_0.285714 0.171429 _0.942857| 0 0 35|

 

'Q R'=: QR X ^/ i.3

R %.~(|:Q)+/ .* Y

'''Notes''':J offers a built-in QR decomposition function, <tt>128!:0</tt>. If J did not offer this function as a built-in, it could be written in J along the lines of the second version, which is covered in [[j:Essays/QR Decomposition|an essay on the J wiki]].

 

=={{header|Java}}==

 

import Jama.QRDecomposition;

 

 

public class Decompose {

public static void main(String[] args) {

});

 

}

 

}

 

{{out}}

<pre>

 

 

 

</pre>

 

=={{header|Julia}}==

Built-in function

{{out}}

<pre>

=={{header|Maple}}==

 

 

 

 

 

q//MatrixForm

 

-> 14 21 -14

0 175 -70

 

=={{header|MATLAB}} / {{header|Octave}}==

6 167 -68

-4 24 -41];

Output:

<pre>Q =

 

=={{header|Maxima}}==

 

a: matrix([12, -51, 4],

4.2632564145606011E-14

 

load("eigen")$

unitVector(n) := ematrix(n,1,1,1,1);

a : genmatrix(lambda([i,j], if j=1 then 1.0b0 else bfloat(x[i,1]^(j-1))),

length(x),n+1),

 

[ 6 69 58 ]

(%o) [ 2.00000000000000000000000000002b0 ]

[ ]

 

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

{{works with|PARI/GP|2.6.0 and above}}

 

{{Works with|rakudo|2018.06}}

 

use v6;

"\n",

@coef.fmt("%12.6f");

 

output:

 

</pre>

 

=={{header|Rascal}}==

This function applies the Gram Schmidt algorithm. Q is printed in the console, R can be printed or visualized.

 

import Prelude;

import vis::Figure;

<1.0,0.0,-51.0>, <1.0,1.0,167.0>, <1.0,2.0,24.0>,

<2.0,0.0,4.0>, <2.0,1.0,-68.0>, <2.0,2.0,-41.0>

 

Example using visualization

 

=={{header|SAS}}==

 

proc iml;

0 -175 70

0 0 35

=={{header|Scala}}==

{{Out}}Best seen running in your browser [https://scastie.scala-lang.org/NMueO16uQl6oivliBKZHew Scastie (remote JVM)].

 

import Jama.{Matrix, QRDecomposition}

print(toString(d.getR))

 

 

=={{header|SequenceL}}==

{{trans|Go}}

import <Utilities/Sequence.sl>;

import <Utilities/Conversion.sl>;

j within 1 ... n;

 

{{out}}

 

=={{header|Standard ML}}==

type real

val zero : real

val * : real * real -> real

val / : real * real -> real

val sign : real -> real

val sqrt : real -> real

fun updateSubMatrix(h,i,j,s) =

tabulate RowMajor (nRows s, nCols s, fn (a,b) => update(h,Int.+(i,a),Int.+(j,b),sub(s,a,b)))

end

end

fun householder a =

let open Array

lsqr(a,y)

end

open Real

val one = 1.0

val sqrt = Real.Math.sqrt

end

structure Q = QR(RealRadicalCategoryField);

 

(* output *)

 

=={{header|Stata}}==

See [http://www.stata.com/help.cgi?mf_qrd QR decomposition] in Stata help.

 

: qrd(a=(12,-51,4\6,167,-68\-4,24,-41),q=.,r=.)

 

2 | 0 -175 70 |

3 | 0 0 -35 |

 

=={{header|Tcl}}==

Assuming the presence of the Tcl solutions to these tasks: [[Element-wise operations]], [[Matrix multiplication]], [[Matrix transposition]]

{{trans|Common Lisp}}

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

proc sign x {expr {$x == 0 ? 0 : $x < 0 ? -1 : 1}}

}

return [list $Q $A]

Demonstrating:

puts "==Q=="

print_matrix [lindex $demo 0] "%f"

puts "==R=="

Output:

<pre>

0.0 -175.0 70.0

0.0 0.0 -35.0

</pre>

 

=={{header|zkl}}==

A:=GSL.Matrix(3,3).set(12.0, -51.0, 4.0,

6.0, 167.0, -68.0,

println("Q:\n",Q.format());

println("R:\n",R.format());

{{out}}

<pre>