Cramer's rule: Difference between revisions

solve for <big><math>w</math>, <math>x</math>, <math>y</math></big> and <big><math>z</math></big>, using Cramer's rule.

<br><br>

 

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

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Uses the non-standard DET operator available in Algol 68G.

# this is for REAL arrays, could define additional operators #

# for INT, COMPL, etc. #

OD;

print( ( newline ) )

{{out}}

<pre>

=={{header|C}}==

 

#include <stdio.h>

#include <stdlib.h>

deinit_square_matrix(A);

return EXIT_SUCCESS;

 

{{out}}

-4.000

1.000</pre>

 

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

(loop with dim = (1- (array-dimension m 0))

with result = (make-array (list dim dim))

(1 3 3 -1)

(5 -2 -3 3))

{{out}}

<pre>(2 -12 -4 1)</pre>

 

=={{header|EchoLisp}}==

(lib 'matrix)

(string-delimiter "")

(writeln "B = " B)

(writeln "X = " (cramer A B)))

{{out}}

<pre>

B = #( -3 -32 -47 49)

X = #( 2 -12 -4 1)

</pre>

 

With matrices, there is a problem all the way from the start in 1958. Everyone agrees that a matrix should be indexed as A(''row'',''column'') and that when written out, rows should run down the page and columns across. This is unexceptional and the F90 function MATMUL follows this usage. However, Fortran has always stored its array elements in what is called "column major" order, which is to say that element A(1,1) is followed by element A(2,1) in storage, not A(1,2). Thus, if an array is written (or read) by something like <code>WRITE (6,*) A</code>, consecutive elements, written along a line, will be A(1,1), A(2,1), A(3,1), ... So, subroutine SHOWMATRIX is employed to write the matrix out in the desired form, and to read the values into the array, an explicit loop is used to place them where expected rather than just <code>READ(INF,*) A</code>

 

1 3, 2, 2, -6

2 1, 3, 3, -1

 

INTEGER MSG !Might as well be here.

CONTAINS !The details.

Closedown.

100 WRITE (6,*) "That was interesting." !Quite.

 

Oddly, the Compaq Visual Fortran F90/95 compiler is confused by the usage "BAD IDEA" instead of "BADIDEA" - spaces are not normally relevant in Fortran source. Anyway, file Test.dat has been filled with the numbers of the example, as follows:

</pre>

And at this point I suddenly noticed that the habits of Old Fortran are not so easily suppressed: all calculations are done with double precision. Curiously enough, for the specific example data, the same results are obtained if all variables are integer.

 

=={{header|Go}}==

'''Library gonum:'''

 

import (

}

fmt.Println(x)

{{out}}

<pre>

</pre>

'''Library go.matrix:'''

 

import (

}

fmt.Println(x)

{{out}}

<pre>

[2.0000000000000004 -11.999999999999998 -4 0.9999999999999999]

</pre>

 

=={{header|Haskell}}==

===Version 1===

 

solveCramer :: (Ord a, Fractional a) => Matrix a -> Matrix a -> Maybe [a]

,[1, 3, 3,-1]

,[5,-2,-3, 3]]

{{out}}

 

We use Rational numbers for having more precision.

a % b is the rational a / b.

s_permutations = flip zip (cycle [1, -1]) . (foldl aux [[]])

where aux items x = do

insertEv x [] = [[x]]

insertEv x l@(y:ys) = (x:l) : map (y:) (insertEv x ys)

mult:: Num a => [[a]] -> [[a]] -> [[a]]

elemPos::[[a]] -> Int -> Int -> a

ps = s_permutations ls

d = s_determinant elemPos ms ps

task::[[Rational]] -> [[Rational]] -> IO()

let b = [[-3], [-32], [-47], [49]]

task a b

{{out}}

<pre>

True

</pre>

===Version 3===

 

determinant::(Fractional a, Ord a) => [[a]] -> a

matI n = [ [fromIntegral.fromEnum $ i == j | i <- [1..n]] | j <- [1..n]]

 

mult:: Num a => [[a]] -> [[a]] -> [[a]]

 

task::[[Rational]] -> [[Rational]] -> IO()

let b = [[-3], [-32], [-47], [49]]

task a b

{{out}}

<pre>

Implementation:

 

A=. x [ b=. y

det=. -/ .*

A %~&det (i.#A) b"_`[`]}&.|:"0 2 A

 

Task data:

 

2 -1 5 1

3 2 2 -6

)

 

 

Task example:

 

 

=={{header|JavaScript}}==

 

var matrix = [

[2, -1, 5, 1],

}

 

{{out}}

<pre>[ 2, -12, -4, 1 ]</pre>

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

return collect(begin B = copy(A); B[:, i] = b; det(B) end for i in eachindex(b)) ./ det(A)

end

b = [-3, -32, -47, 49]

 

 

{{out}}

Note that it is entirely impractical to use Cramer's rule in this situation. It would be much better to use the built-in operator for solving linear systems. Assuming that the coefficient matrix and constant vector are defined as before, the solution vector is given by:

 

 

=={{header|Kotlin}}==

As in the case of the [[Matrix arithmetic]] task, I've used the Johnson-Trotter permutations generator to assist with the calculation of the determinants for the various matrices:

 

typealias Vector = DoubleArray

val (w, x, y, z) = cramer(m, d)

println("w = $w, x = $x, y = $y, z = $z")

 

{{out}}

w = 2.0, x = -12.0, y = -4.0, z = 1.0

</pre>

 

=={{header|Maple}}==

 

Table[a = m; a[[All, k]] = b; Det[a]/d, {k, Length[m]}]]

 

{1, 3, 3, -1},

{5, -2, -3, 3}

 

{{out}}

<pre>{2,-12,-4,1}</pre>

 

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

 

M = [2,-1,5,1;3,2,2,-6;1,3,3,-1;5,-2,-3,3];

V = Col([-3,-32,-47,49]);

 

matadjoint(M) * V / matdet(M)

 

Output:

 

=={{header|Perl}}==

 

sub cramers_rule {

print "x = $x\n";

print "y = $y\n";

{{out}}

<pre>

=={{header|Phix}}==

{{trans|C}}

{{Out}}

<pre>

=={{header|Prolog}}==

{{works with|GNU Prolog}}

removeElement([Head|Tail], J, [Head|X]) :-

J_2 is J - 1,

],

B = [-3, -32, -47, 49],

 

{{out}}

 

=={{header|Python}}==

 

 

 

 

 

 

 

{{out}}

 

 

=={{header|REXX}}==

Numeric Digits 20

names='w x y z'

 

 

{{out}}

<pre> 2 -1 5 1 -3

z = 1</pre>

 

=={{header|Ruby}}==

def cramers_rule(a, terms)

 

vector = [-3, -32, -47, 49]

{{out}}

<pre>

</pre>

 

 

 

 

}

}

 

gather {

for i in ^A {

Ai[j][i] = terms[j]

}

}

}

 

say "x = #{x}"

say "y = #{y}"

{{out}}

<pre>

y = -4

z = 1

</pre>

 

=={{header|zkl}}==

Using the GNU Scientific Library, we define the values:

A:=GSL.Matrix(4,4).set(2,-1, 5, 1,

3, 2, 2,-6,

1, 3, 3,-1,

5,-2,-3, 3);

First, just let GSL solve:

Actually implement Cramer's rule:

{{Trans|Julia}}

b.len().pump(GSL.Vector(b.len()),'wrap(i){ // put calculations into new Vector

A.copy().setColumn(i,b).det();

}).close()/A.det();

}

{{out}}

<pre>