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

with Ada.Numerics.Generic_Real_Arrays;

 

begin

Put (R);

 

{{out}}

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

1.000</pre>

 

Instead of copying a bunch of arrays, I made a class with an indexer that simply accesses the correct items in the original matrix.

using System.Collections.Generic;

using static System.Linq.Enumerable;

}

 

{{out}}

<pre>

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

{{trans|C#}}

#include <iostream>

#include <vector>

double det = matrix.det();

if (det == 0.0) {

}

 

[size](const std::vector<double> &a) { return a.size() != size + 1; }

)) {

}

 

 

return 0;

{{out}}

<pre>[2, -12, -4, 1]</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|D}}==

{{trans|Kotlin}}

import std.range : iota;

import std.stdio : writeln;

auto wxyz = cramer(m, d);

writeln("w = ", wxyz[0], ", x = ", wxyz[1], ", y = ", wxyz[2], ", z = ", wxyz[3]);

{{out}}

<pre>w = 2, x = -12, y = -4, z = 1</pre>

 

=={{header|EchoLisp}}==

(lib 'matrix)

(string-delimiter "")

(writeln "B = " B)

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

{{out}}

<pre>

 

=={{header|Factor}}==

IN: rosetta-code.cramers-rule

 

{ -3 -32 -47 49 } solve . ;

 

{{out}}

<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

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

task a b

{{out}}

<pre>

 

===Version 3===

 

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

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

Supports double data type. A more robust solution would support arbitrary precision integers, arbitrary precision decimals, arbitrary precision rationals, or even arbitrary precision algebraic numbers.

 

import java.util.ArrayList;

import java.util.Arrays;

 

}

{{out}}

<pre>

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

 

=={{header|Lua}}==

 

local function cramer(mat, vec)

local result = cramer(A, b)

print("Result: " .. table.concat(result, ", "))

 

{{out}}

 

=={{header|Maple}}==

cramer:=proc(A,B)

local n,d,X,V,i;

A:=Matrix([[2,-1,5,1],[3,2,2,-6],[1,3,3,-1],[5,-2,-3,3]]):

B:=Vector([-3,-32,-47,49]):

 

{{out}}

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

 

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

 

{1, 3, 3, -1},

{5, -2, -3, 3}

 

{{out}}

 

=={{header|Maxima}}==

(%i1) eqns: [ 2*w-x+5*y+z=-3, 3*w+2*x+2*y-6*z=-32, w+3*x+3*y-z=-47, 5*w-2*x-3*y+3*z=49];

(%o1) [z + 5 y - x + 2 w = - 3, (- 6 z) + 2 y + 2 x + 3 w = - 32,

(%i6) linsolve(eqns, [w,x,y,z]);

(%o6) [w = 2, x = - 12, y = - 4, z = 1]

 

=={{header|Nim}}==

{{trans|Phix}}

 

SquareMatrix[N: static Positive] = array[N, array[N, float]]

Vector[N: static Positive] = array[N, float]

 

for i in 0..A.high:

 

{{out}}

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

(formerly Perl 6)

my $pivot = 1;

my $previous-pivot = $pivot;

$sign = -$sign;

}

}

}

}

 

sub cramers_rule(@A, @terms) {

my @Ai = @A.map: { [|$_] };

}

take det(@Ai);

);

 

{{out}}

<pre>

 

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

 

=={{header|Rust}}==

 

fn main() {

&mut self.elts[m * i..m * (i + 1)]

}

 

Which outputs:

 

=={{header|Sidef}}==

gather {

for i in ^A {

say "x = #{x}"

say "y = #{y}"

{{out}}

<pre>

 

=={{header|Tcl}}==

package require math::linearalgebra

namespace path ::math::linearalgebra

puts [format "%0.4f" $v] ;# format and display result

}

{{out}}

<pre>

 

=={{header|VBA}}==

Sub CramersRule()

OrigM = [{2, -1, 5, 1; 3,2,2,-6;1,3,3,-1;5,-2,-3,3}]

End Sub

 

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Imports System.Linq.Enumerable

 

End Sub

 

{{out}}

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

=={{header|Wren}}==

{{libheader|Wren-matrix}}

 

var cramer = Fn.new { |a, d|

 

var x = cramer.call(a, d)

 

{{out}}

<pre>

Solution is [2, -12, -4, 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>