Solve equations with substitution method

Solve equations with substitution method is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Task

Let given equations:
3x + y = -1 and 2x - 3y = -19
Solve it with substitution method.

See related

• Reduced row echelon form
• Gaussian elimination

BASIC

BASIC256

Translation of: FreeBASIC

<lang BASIC256>arraybase 1 dim firstEquation(3) firstEquation[1] = 3 firstEquation[2] = 1 firstEquation[3] = -1 dim secondEquation(3) secondEquation[1] = 2 secondEquation[2] = -3 secondEquation[3] = -19

subroutine getCrossingPoint(firstEquation, secondEquation) x1 = firstEquation[1] y1 = firstEquation[2] r1 = firstEquation[3] x2 = secondEquation[1] y2 = secondEquation[2] r2 = secondEquation[3] dim temp(3) temp[1] = x1 temp[2] = -y1 temp[3] = r1 resultY = ((temp[1]*r2) - (x2*temp[3])) / ((x2*temp[2]) + (temp[1]*y2)) resultX = (r1 - (y1*resultY)) / x1 print "x = "; resultX print "y = "; resultY end subroutine

call getCrossingPoint(firstEquation, secondEquation) end</lang>

Output:

Igual que la entrada de FreeBASIC.

FreeBASIC

<lang freebasic>Dim Shared As Integer firstEquation(1 To 3) = { 3, 1, -1} Dim Shared As Integer secondEquation(1 To 3) = { 2,-3,-19}

Sub getCrossingPoint(firstEquation() As Integer, secondEquation() As Integer)

   Dim As Integer x1 = firstEquation(1)
   Dim As Integer y1 = firstEquation(2)
   Dim As Integer r1 = firstEquation(3)
   Dim As Integer x2 = secondEquation(1)
   Dim As Integer y2 = secondEquation(2)
   Dim As Integer r2 = secondEquation(3)
   Dim As Integer temp(3)
   temp(1) =  x1
   temp(2) = -y1
   temp(3) =  r1
   Dim As Integer resultY = ((temp(1)* r2) - (x2 * temp(3))) / ((x2 * temp(2)) + (temp(1)*y2)) 
   Dim As Integer resultX = (r1 - (y1*resultY)) / x1 
   Print "x = "; resultX

Print "y = "; resultY End Sub

getCrossingPoint(firstEquation(), secondEquation()) Sleep</lang>

Output:

x = -2
y =  5

QBasic

Works with: QBasic

Works with: QuickBasic

Translation of: FreeBASIC

<lang QBasic>DIM firstEquation(3) firstEquation(1) = 3 firstEquation(2) = 1 firstEquation(3) = -1 DIM secondEquation(3) secondEquation(1) = 2 secondEquation(2) = -3 secondEquation(3) = -19

CALL getCrossingPoint(firstEquation(), secondEquation()) END

SUB getCrossingPoint (firstEquation(), secondEquation())

   x1 = firstEquation(1)
   y1 = firstEquation(2)
   r1 = firstEquation(3)
   x2 = secondEquation(1)
   y2 = secondEquation(2)
   r2 = secondEquation(3)    
   DIM temp(3)
   temp(1) = x1
   temp(2) = -y1
   temp(3) = r1
   resultY = ((temp(1) * r2) - (x2 * temp(3))) / ((x2 * temp(2)) + (temp(1) * y2))
   resultX = (r1 - (y1 * resultY)) / x1
   PRINT "x = "; resultX
   PRINT "y = "; resultY

END SUB</lang>

Output:

Igual que la entrada de FreeBASIC.

True BASIC

Works with: QBasic

Translation of: QBasic

<lang qbasic>DIM firstequation(3) LET firstequation(1) = 3 LET firstequation(2) = 1 LET firstequation(3) = -1 DIM secondequation(3) LET secondequation(1) = 2 LET secondequation(2) = -3 LET secondequation(3) = -19

SUB getcrossingpoint (firstequation(),secondequation())

   LET x1 = firstequation(1)
   LET y1 = firstequation(2)
   LET r1 = firstequation(3)
   LET x2 = secondequation(1)
   LET y2 = secondequation(2)
   LET r2 = secondequation(3)

   DIM temp(3)
   LET temp(1) = x1
   LET temp(2) = -y1
   LET temp(3) = r1

   LET resulty = ((temp(1)*r2)-(x2*temp(3)))/((x2*temp(2))+(temp(1)*y2))
   LET resultx = (r1-(y1*resulty))/x1
   PRINT "x = "; resultx
   PRINT "y = "; resulty

END SUB

CALL getcrossingpoint (firstequation(), secondequation()) END</lang>

Output:

Igual que la entrada de FreeBASIC.

Yabasic

Translation of: FreeBASIC

<lang yabasic>dim firstEquation(3) firstEquation(1) = 3 firstEquation(2) = 1 firstEquation(3) = -1 dim secondEquation(3) secondEquation(1) = 2 secondEquation(2) = -3 secondEquation(3) = -19

sub getCrossingPoint(firstEquation(), secondEquation())

   x1 = firstEquation(1)
   y1 = firstEquation(2)
   r1 = firstEquation(3)
   x2 = secondEquation(1)
   y2 = secondEquation(2)
   r2 = secondEquation(3)
   dim temp(3)
   temp(1) =  x1
   temp(2) = -y1
   temp(3) =  r1
   resultY = ((temp(1)*r2) - (x2*temp(3))) / ((x2*temp(2)) + (temp(1)*y2)) 
   resultX = (r1 - (y1*resultY)) / x1 
   print "x = ", resultX
   print "y = ", resultY

end sub

getCrossingPoint(firstEquation(), secondEquation()) end</lang>

Output:

Igual que la entrada de FreeBASIC.

Julia

<lang julia>function parselinear(s)

   ab, c = strip.(split(s, "="))
   a, by = strip.(split(ab, "x"))
   b = replace(by, r"[\sy]" => "")
   b[end] in "-+" && (b *= "1")
   b = replace(b, "--" => "")
   return map(x -> parse(Float64, x == "" ? "1" : x), [a, b, c])

end

function solvetwolinear(s1, s2)

   a1, b1, c1 = parselinear(s1)
   a2, b2, c2 = parselinear(s2)
   x = (b2 * c1 - b1 * c2) / (b2 * a1 - b1 * a2)
   y = (a1 * x - c1 ) / -b1
   return x, y

end

@show solvetwolinear("3x + y = -1", "2x - 3y = -19") # solvetwolinear("3x + y = -1", "2x - 3y = -19") = (-2.0, 5.0) </lang>

Perl

<lang perl>use strict; use warnings; use feature 'say';

sub parse {

   my($e) = @_;
   $e =~ s/ ([xy])/ 1$1/;
   $e =~ s/[ =\+]//g;
   split /[xy=]/, $e;

}

sub solve {

   my($a1, $b1, $c1, $a2, $b2, $c2) = @_;
   my $X = ( $b2 * $c1  -  $b1 * $c2 )
         / ( $b2 * $a1  -  $b1 * $a2 );
   my $Y = ( $a1 * $X  -  $c1 ) / -$b1;
   return $X, $Y;

}

say my $result = join ' ', solve( parse('3x + y = -1'), parse('2x - 3y = -19') );</lang>

Output:

-2 5

Phix

Slightly modified copy of solveN() from Solving_coin_problems#Phix, admittedly a tad overkill for this task, as it takes any number of rules and any number of variables.

with javascript_semantics
procedure solve(sequence rules, unknowns)
--
-- Based on https://mathcs.clarku.edu/~djoyce/ma105/simultaneous.html
--  aka the ancient Chinese Jiuzhang suanshu ~100 B.C. (!!)
--
-- Example:
--  rules = {{18,1,1},{38,1,5}}, ie 18==p+n, 38==p+5*n
--  unknowns = {"pennies","nickels"}
--
--  In the elimination phase, both p have multipliers of 1, so we can
--  ignore those two sq_mul and just do (38=p+5n)-(18=p+n)==>(20=4n).
--  Obviously therefore n is 5 and substituting backwards p is 13.
--
    string res
    sequence sentences = rules, ri, rj
    integer l = length(rules), rii, rji
    rules = deep_copy(rules)
    for i=1 to l do
        -- successively eliminate (grow lower left triangle of 0s)
        ri = rules[i]
        if length(ri)!=l+1 then ?9/0 end if
        rii = ri[i+1]
        if rii=0 then ?9/0 end if
        for j=i+1 to l do
            rj = rules[j]
            rji = rj[i+1]
            if rji!=0 then
                rj = sq_sub(sq_mul(rj,rii),sq_mul(ri,rji))
                if rj[i+1]!=0 then ?9/0 end if -- (job done)
                rules[j] = rj
            end if
        end for 
    end for 
    for i=l to 1 by -1 do
        -- then substitute each backwards
        ri = rules[i]
        rii = ri[1]/ri[i+1] -- (all else should be 0)
        rules[i] = sprintf("%s = %d",{unknowns[i],rii})
        for j=i-1 to 1 by -1 do
            rj = rules[j]
            rji = rj[i+1]
            if rji!=0 then
                rules[j] = 0
                rj[1] -= rji*rii
                rj[i+1] = 0
                rules[j] = rj
            end if
        end for
    end for 
    res = join(rules,", ")
    printf(1,"%v ==> %s\n",{sentences,res})
end procedure

--for 3x + y = -1 and 2x - 3y = -19:
solve({{-1,3,1},{-19,2,-3}},{"x","y"})

Output:

{{-1,3,1},{-19,2,-3}} ==> x = -2, y = 5

Alternatively, since I'm staring right at it, here's a

Translation of: Raku

with javascript_semantics
function solve2(sequence e1,e2)
    atom {a1,b1,c1} = e1,
         {a2,b2,c2} = e2,
         x = (b2*c1 - b1*c2)
           / (b2*a1 - b1*a2),
         y = (a1*x - c1)/-b1;
    return {x, y}
end function
printf(1,"x = %d, y = %d\n",solve2({3,1,-1},{2,-3,-19}))

Output:

x = -2, y = 5

Python

<lang python>#!/usr/bin/python

firstEquation = [ 3, 1, -1] secondEquation = [ 2,-3,-19]

def getCrossingPoint(firstEquation, secondEquation):

   x1 = firstEquation[0]
   y1 = firstEquation[1]
   r1 = firstEquation[2]
   x2 = secondEquation[0]
   y2 = secondEquation[1]
   r2 = secondEquation[2]
   temp = []
   temp.append( x1)
   temp.append(-y1)
   temp.append( r1)
   resultY = ((temp[0]*r2) - (x2*temp[2])) / ((x2*temp[1]) + (temp[0]*y2)) 
   resultX = (r1 - (y1*resultY)) / x1 
   print("x = ", resultX)
   print("y = ", resultY)

if __name__ == "__main__":

   getCrossingPoint(firstEquation, secondEquation)</lang>

Output:

x =  -2.0
y =  5.0

Raku

<lang perl6>sub solve-system-of-two-linear-equations ( [ \a1, \b1, \c1 ], [ \a2, \b2, \c2 ] ) {

   my \X = ( b2 * c1   -   b1 * c2 )
         / ( b2 * a1   -   b1 * a2 );

   my \Y = ( a1 * X    -   c1 ) / -b1;

   return X, Y;

} say solve-system-of-two-linear-equations( (3,1,-1), (2,-3,-19) );</lang>

Output:

(-2 5)

Ring

<lang ring> firstEquation = [3.0,1.0,-1.0] secondEquation = [2.0,-3.0,-19.0] getCrossingPoint(firstEquation,secondEquation)

func getCrossingPoint(firstEquation,secondEquation)

    x1 = firstEquation[1] y1 = firstEquation[2] r1 = firstEquation[3] x2 = secondEquation[1] y2 = secondEquation[2] r2 = secondEquation[3]
    temp = []
    add(temp,x1) add(temp,-y1) add(temp,r1)
    resultY = ((temp[1]* r2) - (x2 * temp[3])) / ((x2 * temp[2]) + (temp[1]*y2)) resultX = (r1 - (y1*resultY)) / x1 
    see "x = " + resultX + nl + "y = " + resultY + nl

</lang>

Output:

x = -2
y = 5

Wren

<lang ecmascript>var solve = Fn.new { |e1, e2|

   e2 = e2.toList
   for (i in 1..2) e2[i] = e2[i] * e1[0] / e2[0]
   var y = (e2[2] - e1[2]) / (e2[1] - e1[1])
   var x = (e1[2] - e1[1] * y) / e1[0]
   return [x, y]

}

var e1 = [3, 1, -1] var e2 = [2, -3, -19] var sol = solve.call(e1, e2) System.print("x = %(sol[0]), y = %(sol[1])")</lang>

Output:

x = -2, y = 5

XPL0

This shows the vector routines from xpllib.xpl. <lang XPL0>func real VSub(A, B, C); \Subtract two 3D vectors real A, B, C; \A:= B - C [A(0):= B(0) - C(0); \VSub(A, A, C) => A:= A - C

A(1):= B(1) - C(1);
A(2):= B(2) - C(2);

return A; ]; \VSub

func real VMul(A, B, S); \Multiply 3D vector by a scalar real A, B, S; \A:= B * S [A(0):= B(0) * S; \VMul(A, A, S) => A:= A * S

A(1):= B(1) * S;
A(2):= B(2) * S;

return A; ]; \VMul

real E1, E2, X1, X2, X, Y; [E1:= [3., 1., -1.];

E2:= [2., -3., -19.];

X1:= E1(0); X2:= E2(0); VMul(E1, E1, X2); VMul(E2, E2, X1); VSub(E1, E1, E2); Y:= E1(2)/E1(1); E2(1):= E2(1)*Y; E2(2):= E2(2)-E2(1); X:= E2(2)/E2(0); Text(0, "x = "); RlOut(0, X); CrLf(0); Text(0, "y = "); RlOut(0, Y); CrLf(0); ]</lang>

Output:

x =    -2.00000
y =     5.00000