Rosetta Code

Cramer's rule: Difference between revisions

Page Discussion

Cramer's rule (view source)

Revision as of 19:34, 6 April 2024

7,813 bytes added ,  1 month ago
Added Easylang
m (→‎version 2: shrunk a function.)
(Added Easylang)
 
(13 intermediate revisions by 11 users not shown)
Line 36:
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|11l}}==
{{trans|Nim}}
 
<syntaxhighlight lang="11l">F det(mm)
V m = copy(mm)
V result = 1.0
 
L(j) 0 .< m.len
V imax = j
L(i) j + 1 .< m.len
I m[i][j] > m[imax][j]
imax = i
 
I imax != j
swap(&m[imax], &m[j])
result = -result
 
I abs(m[j][j]) < 1e-12
R Float.infinity
 
L(i) j + 1 .< m.len
V mult = -m[i][j] / m[j][j]
L(k) 0 .< m.len
m[i][k] += mult * m[j][k]
 
L(i) 0 .< m.len
result *= m[i][i]
R result
 
F cramerSolve(aa, detA, b, col)
V a = copy(aa)
L(i) 0 .< a.len
a[i][col] = b[i]
R det(a) / detA
 
V A = [[2.0, -1.0, 5.0, 1.0],
[3.0, 2.0, 2.0, -6.0],
[1.0, 3.0, 3.0, -1.0],
[5.0, -2.0, -3.0, 3.0]]
 
V B = [-3.0, -32.0, -47.0, 49.0]
 
V detA = det(A)
 
L(i) 0 .< A.len
print(‘#3.3’.format(cramerSolve(A, detA, B, i)))</syntaxhighlight>
 
{{out}}
<pre>
2.000
-12.000
-4.000
1.000
</pre>
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;
with Ada.Numerics.Generic_Real_Arrays;
 
Line 107 ⟶ 162:
begin
Put (R);
end Cramers_Rules;</langsyntaxhighlight>
 
{{out}}
Line 115 ⟶ 170:
{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}
Uses the non-standard DET operator available in Algol 68G.
<langsyntaxhighlight lang="algol68"># returns the solution of a.x = b via Cramer's rule #
# this is for REAL arrays, could define additional operators #
# for INT, COMPL, etc. #
Line 162 ⟶ 217:
OD;
print( ( newline ) )
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 170 ⟶ 225:
=={{header|C}}==
 
<langsyntaxhighlight Clang="c">#include <math.h>
#include <stdio.h>
#include <stdlib.h>
Line 281 ⟶ 336:
deinit_square_matrix(A);
return EXIT_SUCCESS;
}</langsyntaxhighlight>
 
{{out}}
Line 289 ⟶ 344:
1.000</pre>
 
=={{header|C sharp|C#}}==
Instead of copying a bunch of arrays, I made a class with an indexer that simply accesses the correct items in the original matrix.
<langsyntaxhighlight lang="csharp">using System;
using System.Collections.Generic;
using static System.Linq.Enumerable;
Line 392 ⟶ 447:
}
 
}</langsyntaxhighlight>
{{out}}
<pre>
Line 400 ⟶ 455:
=={{header|C++}}==
{{trans|C#}}
<langsyntaxhighlight lang="cpp">#include <algorithm>
#include <iostream>
#include <vector>
Line 536 ⟶ 591:
 
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>[2, -12, -4, 1]</pre>
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang="lisp">(defun minor (m col)
(loop with dim = (1- (array-dimension m 0))
with result = (make-array (list dim dim))
Line 581 ⟶ 636:
(1 3 3 -1)
(5 -2 -3 3))
#(-3 -32 -47 49))</langsyntaxhighlight>
{{out}}
<pre>(2 -12 -4 1)</pre>
Line 587 ⟶ 642:
=={{header|D}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang="d">import std.array : array, uninitializedArray;
import std.range : iota;
import std.stdio : writeln;
Line 672 ⟶ 727:
auto wxyz = cramer(m, d);
writeln("w = ", wxyz[0], ", x = ", wxyz[1], ", y = ", wxyz[2], ", z = ", wxyz[3]);
}</langsyntaxhighlight>
{{out}}
<pre>w = 2, x = -12, y = -4, z = 1</pre>
 
=={{header|EasyLang}}==
{{trans|Phix}}
<syntaxhighlight>
proc det . a0[][] res .
res = 1
a[][] = a0[][]
n = len a[][]
for j to n
imax = j
for i = j + 1 to n
if a[i][j] > a[imax][j]
imax = i
.
.
if imax <> j
swap a[imax][] a[j][]
res = -res
.
if abs a[j][j] < 1e-12
print "Singular matrix!"
res = 0 / 0
return
.
for i = j + 1 to n
mult = -a[i][j] / a[j][j]
for k to n
a[i][k] += mult * a[j][k]
.
.
.
for i to n
res *= a[i][i]
.
.
proc cramer_solve . a0[][] deta b[] col res .
a[][] = a0[][]
for i to len a[][]
a[i][col] = b[i]
.
det a[][] d
res = d / deta
.
a[][] = [ [ 2 -1 5 1 ] [ 3 2 2 -6 ] [ 1 3 3 -1 ] [ 5 -2 -3 3 ] ]
b[] = [ -3 -32 -47 49 ]
det a[][] deta
for i to len a[][]
cramer_solve a[][] deta b[] i r
print r
.
</syntaxhighlight>
{{out}}
<pre>
2.00
-12
-4
1.00
</pre>
 
=={{header|EchoLisp}}==
<langsyntaxhighlight lang="scheme">
(lib 'matrix)
(string-delimiter "")
Line 694 ⟶ 807:
(writeln "B = " B)
(writeln "X = " (cramer A B)))
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 708 ⟶ 821:
 
=={{header|Factor}}==
<langsyntaxhighlight lang="factor">USING: kernel math math.matrices.laplace prettyprint sequences ;
IN: rosetta-code.cramers-rule
 
Line 727 ⟶ 840:
{ -3 -32 -47 49 } solve . ;
 
MAIN: cramers-rule-demo</langsyntaxhighlight>
{{out}}
<pre>
Line 743 ⟶ 856:
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>
 
Similarly, if instead a DATA statement were used to initialise the array for the example problem, and it looked something like <langsyntaxhighlight Fortranlang="fortran"> DATA A/2, -1, 5, 1
1 3, 2, 2, -6
2 1, 3, 3, -1
3 5, -2, -3, 3/</langsyntaxhighlight> (ignoring integer/floating-point issues) thus corresponding to the layout of the example problem, there would need to be a statement <code>A = TRANSPOSE(A)</code> to obtain the required order.
 
I have never seen an explanation of why this choice was made for Fortran.<langsyntaxhighlight Fortranlang="fortran"> MODULE BAD IDEA !Employ Cramer's rule for solving A.x = b...
INTEGER MSG !Might as well be here.
CONTAINS !The details.
Line 855 ⟶ 968:
Closedown.
100 WRITE (6,*) "That was interesting." !Quite.
END !Open files are closed, allocated memory is released. </langsyntaxhighlight>
 
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:
Line 884 ⟶ 997:
 
 
=={{header|freebasicFreeBASIC}}==
<langsyntaxhighlight lang="freebasic">
 
Function determinant(matrix() As Double) As Double
Dim As long n=Ubound(matrix,1),sign=1
Line 965 ⟶ 1,077:
Next
Sleep
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 976 ⟶ 1,088:
=={{header|Go}}==
'''Library gonum:'''
<langsyntaxhighlight lang="go">package main
 
import (
Line 1,004 ⟶ 1,116:
}
fmt.Println(x)
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,010 ⟶ 1,122:
</pre>
'''Library go.matrix:'''
<langsyntaxhighlight lang="go">package main
 
import (
Line 1,038 ⟶ 1,150:
}
fmt.Println(x)
}</langsyntaxhighlight>
{{out}}
<pre>
Line 1,046 ⟶ 1,158:
=={{header|Groovy}}==
{{trans|Java}}
<langsyntaxhighlight lang="groovy">class CramersRule {
static void main(String[] args) {
Matrix mat = new Matrix(Arrays.asList(2d, -1d, 5d, 1d),
Line 1,139 ⟶ 1,251:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>Solution = [2.0, -12.0, -4.0, 1.0]</pre>
Line 1,145 ⟶ 1,257:
=={{header|Haskell}}==
===Version 1===
<langsyntaxhighlight lang="haskell">import Data.Matrix
 
solveCramer :: (Ord a, Fractional a) => Matrix a -> Matrix a -> Maybe [a]
Line 1,161 ⟶ 1,273:
,[1, 3, 3,-1]
,[5,-2,-3, 3]]
y = fromLists [[-3], [-32], [-47], [49]]</langsyntaxhighlight>
{{out}}
 
Line 1,169 ⟶ 1,281:
We use Rational numbers for having more precision.
a % b is the rational a / b.
<langsyntaxhighlight Haskelllang="haskell">s_permutations :: [a] -> [([a], Int)]
s_permutations = flip zip (cycle [1, -1]) . (foldl aux [[]])
where aux items x = do
Line 1,248 ⟶ 1,360:
let b = [[-3], [-32], [-47], [49]]
task a b
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,305 ⟶ 1,417:
 
===Version 3===
<langsyntaxhighlight Haskelllang="haskell">import Data.List
 
determinant::(Fractional a, Ord a) => [[a]] -> a
Line 1,377 ⟶ 1,489:
let b = [[-3], [-32], [-47], [49]]
task a b
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,436 ⟶ 1,548:
Implementation:
 
<langsyntaxhighlight Jlang="j">cramer=:4 :0
A=. x [ b=. y
det=. -/ .*
A %~&det (i.#A) b"_`[`]}&.|:"0 2 A
)</langsyntaxhighlight>
 
Task data:
 
<langsyntaxhighlight Jlang="j">A=: _&".;._2]t=: 0 :0
2 -1 5 1
3 2 2 -6
Line 1,451 ⟶ 1,563:
)
 
b=: _3 _32 _47 49</langsyntaxhighlight>
 
Task example:
 
<langsyntaxhighlight Jlang="j"> A cramer b
2 _12 _4 1</langsyntaxhighlight>
 
=={{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.
 
<syntaxhighlight lang="java">
<lang Java>
import java.util.ArrayList;
import java.util.Arrays;
Line 1,564 ⟶ 1,676:
 
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,572 ⟶ 1,684:
=={{header|JavaScript}}==
 
<syntaxhighlight lang="javascript">
<lang Javascript>
var matrix = [
[2, -1, 5, 1],
Line 1,664 ⟶ 1,776:
}
 
</syntaxhighlight>
</lang>
{{out}}
<pre>[ 2, -12, -4, 1 ]</pre>
 
=={{header|jq}}==
'''Adapted from [[#Wren|Wren]]''' (*)
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
 
(*) Note that cramer(a;d) as defined here assumes that d is a 1-d vector
in accordance with the task description and common practice.
<syntaxhighlight lang="jq"># The minor of the input matrix after removing the specified row and column.
# Assumptions: the input is square and the indices are hunky dory.
def minor(rowNum; colNum):
. as $in
| (length - 1) as $len
| reduce range(0; $len) as $i (null;
reduce range(0; $len) as $j (.;
if $i < rowNum and $j < colNum
then .[$i][$j] = $in[$i][$j]
elif $i >= rowNum and $j < colNum
then .[$i][$j] = $in[$i+1][$j]
elif $i < rowNum and $j >= colNum
then .[$i][$j] = $in[$i][$j+1]
else .[$i][$j] = $in[$i+1][$j+1]
end) );
 
# The determinant using Laplace expansion.
# Assumption: the matrix is square
def det:
. as $a
| length as $nr
| if $nr == 1 then .[0][0]
elif $nr == 2 then .[1][1] * .[0][0] - .[0][1] * .[1][0]
else reduce range(0; $nr) as $i (
{ sign: 1, sum: 0 };
($a|minor(0; $i)) as $m
| .sum += .sign * $a[0][$i] * ($m|det)
| .sign *= -1 )
| .sum
end ;
 
# Solve A X = D using Cramer's method
# a is assumed to be a JSON array representing the 2-d square matrix A
# d is assumed to be a JSON array representing the 1-d vector D
def cramer(a; d):
(a | length) as $n
| (a | det) as $ad
| if $ad == 0 then "matrix determinant is 0" | error
else reduce range(0; $n) as $c (null;
(reduce range(0; $n) as $r (a; .[$r][$c] = d[$r])) as $aa
| .[$c] = ($aa|det) / $ad )
end ;
def a: [
[2, -1, 5, 1],
[3, 2, 2, -6],
[1, 3, 3, -1],
[5, -2, -3, 3]
];
def d:
[ -3, -32, -47, 49 ] ;
 
"Solution is \(cramer(a; d))"</syntaxhighlight>
{{out}}
<pre>
Solution is [2,-12,-4,1]
</pre>
 
=={{header|Julia}}==
{{works with|Julia|0.6}}
<langsyntaxhighlight lang="julia">function cramersolve(A::Matrix, b::Vector)
return collect(begin B = copy(A); B[:, i] = b; det(B) end for i in eachindex(b)) ./ det(A)
end
Line 1,681 ⟶ 1,859:
b = [-3, -32, -47, 49]
 
@show cramersolve(A, b)</langsyntaxhighlight>
 
{{out}}
Line 1,688 ⟶ 1,866:
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:
 
<syntaxhighlight lang ="julia">@show A \ b</langsyntaxhighlight>
 
=={{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:
<langsyntaxhighlight lang="scala">// version 1.1.3
 
typealias Vector = DoubleArray
Line 1,760 ⟶ 1,938:
val (w, x, y, z) = cramer(m, d)
println("w = $w, x = $x, y = $y, z = $z")
}</langsyntaxhighlight>
 
{{out}}
Line 1,768 ⟶ 1,946:
 
=={{header|Lua}}==
<langsyntaxhighlight Lualang="lua">local matrix = require "matrix" -- https://github.com/davidm/lua-matrix
 
local function cramer(mat, vec)
Line 1,809 ⟶ 1,987:
local result = cramer(A, b)
print("Result: " .. table.concat(result, ", "))
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,815 ⟶ 1,993:
 
=={{header|Maple}}==
<langsyntaxhighlight Maplelang="maple">with(LinearAlgebra):
cramer:=proc(A,B)
local n,d,X,V,i;
Line 1,832 ⟶ 2,010:
A:=Matrix([[2,-1,5,1],[3,2,2,-6],[1,3,3,-1],[5,-2,-3,3]]):
B:=Vector([-3,-32,-47,49]):
printf("%a",cramer(A,B));</langsyntaxhighlight>
 
{{out}}
Line 1,838 ⟶ 2,016:
<pre>Vector(4, [2,-12,-4,1])</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">crule[m_, b_] := Module[{d = Det[m], a},
Table[a = m; a[[All, k]] = b; Det[a]/d, {k, Length[m]}]]
 
Line 1,847 ⟶ 2,025:
{1, 3, 3, -1},
{5, -2, -3, 3}
} , {-3, -32, -47, 49}]</langsyntaxhighlight>
 
{{out}}
Line 1,853 ⟶ 2,031:
 
=={{header|Maxima}}==
<syntaxhighlight lang="maxima">
<lang 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,
Line 1,882 ⟶ 2,060:
(%i6) linsolve(eqns, [w,x,y,z]);
(%o6) [w = 2, x = - 12, y = - 4, z = 1]
</syntaxhighlight>
</lang>
 
=={{header|Nim}}==
{{trans|Phix}}
 
<langsyntaxhighlight Nimlang="nim">type
SquareMatrix[N: static Positive] = array[N, array[N, float]]
Vector[N: static Positive] = array[N, float]
Line 1,965 ⟶ 2,143:
 
for i in 0..A.high:
echo &"{cramerSolve(A, detA, B, i):7.3f}"</langsyntaxhighlight>
 
{{out}}
Line 1,975 ⟶ 2,153:
=={{header|PARI/GP}}==
 
<langsyntaxhighlight lang="parigp">
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)
</syntaxhighlight>
</lang>
 
Output:
Line 1,986 ⟶ 2,164:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">use Math::Matrix;
 
sub cramers_rule {
Line 2,015 ⟶ 2,193:
print "x = $x\n";
print "y = $y\n";
print "z = $z\n";</langsyntaxhighlight>
{{out}}
<pre>
Line 2,028 ⟶ 2,206:
<del>The copy-on-write semantics of Phix really shine here; because there is no explicit return/re-assign, you can treat parameters as a private workspace, confident in the knowledge that the updated version will be quietly discarded; all the copying and freeing of the C version is automatic/unnecessary here.</del><br>
UPDATE: For the next release, "with js" (or "with javascript_semantics") diables said copy-on-write semantics, so this now needs a couple of deep_copy() calls.
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"0.8.4"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">with</span> <span style="color: #000000;">javascript_semantics</span>
Line 2,090 ⟶ 2,268:
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"%7.3f\n"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">cramer_solve</span><span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">det_a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</langsyntaxhighlight>-->
{{Out}}
<pre>
Line 2,101 ⟶ 2,279:
=={{header|Prolog}}==
{{works with|GNU Prolog}}
<langsyntaxhighlight lang="prolog">removeElement([_|Tail], 0, Tail).
removeElement([Head|Tail], J, [Head|X]) :-
J_2 is J - 1,
Line 2,164 ⟶ 2,342:
],
B = [-3, -32, -47, 49],
cramer(A, B, X).</langsyntaxhighlight>
 
{{out}}
Line 2,174 ⟶ 2,352:
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">
def det(m,n):
if n==1: return m[0][0]
Line 2,188 ⟶ 2,366:
else:r=[det([r[0:i]+[s]+r[i+1:]for r,s in zip(h,t)],w)/d for i in range(w)]
print(r)
</syntaxhighlight>
</lang>
 
=={{header|Racket}}==
<syntaxhighlight lang="racket">
#lang racket
(require math/matrix)
 
(define sys
{{incorrect|Racket|Doesn't really use Cramer's rule}}
(matrix [[2 -1 5 1]
[3 2 2 -6]
[1 3 3 -1]
[5 -2 -3 3]]))
 
(define soln
<lang racket>#lang typed/racket
(require math/ (col-matrix [-3 -32 -47 49]))
 
(define (matrix-set-column M new-col idx)
(matrix-augment (list-set (matrix-cols M) idx new-col)))
 
(define A (matrix [[2 cramers-1 5rule M 1]soln)
(let ([denom (matrix-determinant M)]
[3 2 2 -6]
[1nvars (matrix-num-cols 3 3 -1M)])
(letrec ([roots (λ (position)
[5 -2 -3 3]]))
(if (>= position nvars)
'()
(cons (/ (matrix-determinant
(matrix-set-column M soln position))
denom)
(roots (add1 position)))))])
(map cons '(w x y z) (roots 0)))))
 
(cramers-rule sys soln)
(define B (col-matrix [ -3
</syntaxhighlight>
-32
-47
49]))
 
(matrix->vector (matrix-solve A B))</lang>
{{out}}
 
<pre>'#((w . 2) (x . -12) (y . -4) (z . 1))</pre>
 
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" perl6line>sub det(@matrix) {
my @a = @matrix.map: { [|$_] };
my $sign = +1;
my $pivot = 1;
for ^@a -> $\k {
my @r = ($k+1 ..^ @a.end);
my $previous-pivot = $pivot;
if 0 == ($pivot = @a[$k][$;k]) {
(my $\s = @r.first: { @a[$_][$;k] != 0 }) // return 0;
(@a[$s], @a[$k]) = (@a[$k], @a[$s]);
my $pivot = @a[$k][$;k];
$sign = -$sign;
}
for @r X @r -> ($\i, $\j) {
((@a[$i][$;j] *×= $pivot) -= @a[$i][$;k]*×@a[$k][$;j]) /= $previous-pivot;
}
}
$sign *× $pivot
}
 
sub cramers_rule(@A, @terms) {
gather for ^@A -> $\i {
my @Ai = @A.map: { [|$_] };
for ^@terms -> $\j {
@Ai[$j][$;i] = @terms[$j];
}
take det(@Ai);
Line 2,251 ⟶ 2,443:
);
 
my @free_terms = (<-3, -32, -47, 49)>;
my ($w, $x, $y, $z) = |cramers_rule(@matrix, @free_terms);
("w = $w", "x = $x", "y = $y", "z = $z").join("\n").say;</syntaxhighlight>
 
say "w = $w";
say "x = $x";
say "y = $y";
say "z = $z";</lang>
{{out}}
<pre>
Line 2,268 ⟶ 2,456:
=={{header|REXX}}==
=== version 1 ===
<langsyntaxhighlight lang="rexx">/* REXX Use Cramer's rule to compute solutions of given linear equations */
Numeric Digits 20
names='w x y z'
Line 2,405 ⟶ 2,593:
 
 
dbg: Return</langsyntaxhighlight>
{{out}}
<pre> 2 -1 5 1 -3
Line 2,433 ⟶ 2,621:
* &nbsp; eschewed the deprecated use of: &nbsp; &nbsp; ''call func(args)'' &nbsp; &nbsp; syntax
* &nbsp; automatically used the minimum width when showing the matrix elements and equation values
<langsyntaxhighlight lang="rexx">/*REXX program uses Cramer's rule to find and display solution of given linear equations*/
values= '-3 -32 -47 49' /*values of each matrix row of numbers.*/
variables= substr('abcdefghijklmnopqrstuvwxyz', 27 - words(values) ) /*variable names.*/
call makeM ' 2 -1 5 1 3 2 2 -6 1 3 3 -1 5 -2 -3 3'
do y=1 for sz; $= /*display the matrix (linear equations)*/
do x=1 for sz; $= $ right(psign(@.x.y), w)'*'substr(variables, x, 1)
end /*y*/ /* [↑] right─justify matrix elements.*/
say pad= left('', length($) - 2); say $ ' = ' right( word(values, y), wewv)
end /*x*/ /* [↑] obtain value of the equation. */
say; say
Line 2,449 ⟶ 2,637:
end /*i*/
end /*j*/
say left('', 10)pad substr(variables,k,1) ' = ' right(det(makeL())/det(mat),we digits()+2)
end /*k*/
exit 0 /*stick a fork in it, we're all done. */
Line 2,455 ⟶ 2,643:
makeL: $=; do x=1 for sz; do y=1 for sz; $= $ !.x.y; end; end; return $ /*matrix─►list*/
mSize: arg _; do sz=0 for 1e3; if sz*sz==_ then return; end; say 'error,bad matrix';exit 9
psign: parse arg num; if left(num, 1)\=='-' & x>1 then return "+"num; return num
/*──────────────────────────────────────────────────────────────────────────────────────*/
det: procedure; parse arg a b c d 1 nums; call mSize words(nums); _= 0
if sz==2 then return a*d - b*c
do j=1 for sz
Line 2,469 ⟶ 2,658:
end /*j*/
aa= aa - (-1 ** odd) * @.i.1 * det($)
end; /*i*/; return aa
/*──────────────────────────────────────────────────────────────────────────────────────*/
makeM: procedure expose @. values mat sz w wewv; parse arg mat; call mSize words(mat)
#= 0; wewv= digits()0; + 2; w= 0
do j=1 for sz; wv= max(wv, length( word( values, j) ) )
do k=1 for sz; #= #+1; @.k.j= word(mat, #); w= max(w, length(@.k.j) )
end /*k*/
end; /*j*/; w= w + 1; return</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the internal default inputs:}}
<pre>
2*w -1*x +5*y +1*z = -3
3*w +2*x +2*y -6*z = -32
1*w +3*x +3*y -1*z = -47
5*w -2*x -3*y +3*z = 49
 
 
w = 2
x = -12
y = -4
z = 1
</pre>
 
=={{header|RPL}}==
{{works with|Halcyon Calc|4.2.7}}
===Explicit Cramer's rule===
≪ '''IF''' OVER DET
'''THEN'''
LAST ROT DUP SIZE 1 GET → vect det mtx dim
≪ 1 dim '''FOR''' c
mtx
1 dim '''FOR''' r
r c 2 →LIST vect r GET PUT
'''NEXT'''
DET det /
'''NEXT'''
dim →ARRY
≫
'''END'''
≫
‘CRAMR’ STO
 
[[ 2 -1 5 1 ][ 3 2 2 -6 ][ 1 3 3 -1 ][ 5 -2 -3 3 ]]
[ -3 -32 -47 49 ] CRAMR
{{out}}
<pre>
1: [ 2 -12 -4 1 ]
</pre>
 
===Implicit Cramer's rule===
RPL use Cramer's rule for its built-in equation system resolution feature, performed by the <code>/</code> instruction.
[ -3 -32 -47 49 ]
[[ 2 -1 5 1 ][ 3 2 2 -6 ][ 1 3 3 -1 ][ 5 -2 -3 3 ]]
/
{{out}}
<pre>
1: [ 2 -12 -4 1 ]
</pre>
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">require 'matrix'
def cramers_rule(a, terms)
Line 2,512 ⟶ 2,736:
 
vector = [-3, -32, -47, 49]
puts cramers_rule(matrix, vector)</langsyntaxhighlight>
{{out}}
<pre>
Line 2,522 ⟶ 2,746:
 
=={{header|Rust}}==
<langsyntaxhighlight Rustlang="rust">use std::ops::{Index, IndexMut};
 
fn main() {
Line 2,609 ⟶ 2,833:
&mut self.elts[m * i..m * (i + 1)]
}
}</langsyntaxhighlight>
 
Which outputs:
Line 2,615 ⟶ 2,839:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func cramers_rule(A, terms) {
gather {
for i in ^A {
Line 2,640 ⟶ 2,864:
say "x = #{x}"
say "y = #{y}"
say "z = #{z}"</langsyntaxhighlight>
{{out}}
<pre>
Line 2,650 ⟶ 2,874:
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">
package require math::linearalgebra
namespace path ::math::linearalgebra
Line 2,671 ⟶ 2,895:
puts [format "%0.4f" $v] ;# format and display result
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 2,681 ⟶ 2,905:
 
=={{header|VBA}}==
<syntaxhighlight lang="vba">
<lang VBA>
Sub CramersRule()
OrigM = [{2, -1, 5, 1; 3,2,2,-6;1,3,3,-1;5,-2,-3,3}]
Line 2,701 ⟶ 2,925:
End Sub
 
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 2,712 ⟶ 2,936:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<langsyntaxhighlight lang="vbnet">Imports System.Runtime.CompilerServices
Imports System.Linq.Enumerable
 
Line 2,816 ⟶ 3,040:
End Sub
 
End Module</langsyntaxhighlight>
{{out}}
<pre>2, -12, -4, 1</pre>
Line 2,822 ⟶ 3,046:
=={{header|Wren}}==
{{libheader|Wren-matrix}}
<langsyntaxhighlight ecmascriptlang="wren">import "./matrix" for Matrix
 
var cramer = Fn.new { |a, d|
Line 2,851 ⟶ 3,075:
 
var x = cramer.call(a, d)
System.print("Solution is %(x)")</langsyntaxhighlight>
 
{{out}}
<pre>
Solution is [2, -12, -4, 1]
</pre>
 
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">
func Det(A, N); \Return value of determinate A, order N
int A, N;
int B, Sum, I, K, L, Term;
[if N = 1 then return A(0, 0);
B:= Reserve((N-1)*4\IntSize\);
Sum:= 0;
for I:= 0 to N-1 do
[L:= 0;
for K:= 0 to N-1 do
if K # I then
[B(L):= @A(K, 1); L:= L+1];
Term:= A(I, 0) * Det(B, N-1);
if I & 1 then Term:= -Term;
Sum:= Sum + Term;
];
return Sum;
];
 
real D;
[D:= float(Det([[2,-1,5,1], [3,2,2,-6], [1,3,3,-1], [5,-2,-3,3]], 4));
RlOut(0, float(Det([[-3,-1,5,1], [-32,2,2,-6], [-47,3,3,-1], [49,-2,-3,3]], 4)) / D);
RlOut(0, float(Det([[2,-3,5,1], [3,-32,2,-6], [1,-47,3,-1], [5,49,-3,3]], 4)) / D);
RlOut(0, float(Det([[2,-1,-3,1], [3,2,-32,-6], [1,3,-47,-1], [5,-2,49,3]], 4)) / D);
RlOut(0, float(Det([[2,-1,5,-3], [3,2,2,-32], [1,3,3,-47], [5,-2,-3,49]], 4)) / D);
]</syntaxhighlight>
 
{{out}}
<pre>
2.00000 -12.00000 -4.00000 1.00000
</pre>
 
=={{header|zkl}}==
Using the GNU Scientific Library, we define the values:
<langsyntaxhighlight lang="zkl">var [const] GSL=Import("zklGSL"); // libGSL (GNU Scientific Library)
A:=GSL.Matrix(4,4).set(2,-1, 5, 1,
3, 2, 2,-6,
1, 3, 3,-1,
5,-2,-3, 3);
b:=GSL.Vector(4).set(-3,-32,-47,49);</langsyntaxhighlight>
First, just let GSL solve:
<langsyntaxhighlight lang="zkl">A.AxEQb(b).format().println();</langsyntaxhighlight>
Actually implement Cramer's rule:
{{Trans|Julia}}
<langsyntaxhighlight lang="zkl">fcn cramersRule(A,b){
b.len().pump(GSL.Vector(b.len()),'wrap(i){ // put calculations into new Vector
A.copy().setColumn(i,b).det();
}).close()/A.det();
}
cramersRule(A,b).format().println();</langsyntaxhighlight>
{{out}}
<pre>
Chkas
2,022

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/263567...363338"