```Contributor: KD TART

{
> I'm currently working on a small program for a Turbo Pascal class
> I am taking.  The assignment is to write a program that solves a system
> of equations via Cramer's Rule.  For example:
>
> 4x - 3y + 9z = 21
> 5x - 43y - 3z = 45
> 34x - 394y + 32z = 9
>
> and then find values for x, y, and z.
>
>    Now this is no problem:  I simply get input into a 3 x 4 array, which
> would look like this for the sample above:
>
> 4    -3     9     21
> 5    -43    -3    45
> 34   -394   32    9
>
>    The problem I am having is getting this input from the user.  Now I
> have thought of a few ways to accomplish this, namely:
>
> (1) Ask the user to enter the coefficients and the answer on a line and
> hit return, and do this for each equation--this method allows me to put the
> data directly into the array.
>
> (2) Give a rigid example of how and where to enter the equation, for
> example #####x(sign)#####y(sign)#####z = #####
> so I know where to read for the values to put into the array.
>
> (3) Possibly use the Val procedure and ask the user to input all number
> as in #1, but separate the numbers with dashes.
>
> (4) Possibly convert string values to their ascii equivalent, and see if
> they are numbers, turning non numbers into spaces.
>
> But, what I would rather do is to prompt the user for the whole equation
> and have him/her type it out naturally and then pick the numbers out of
> it to put into the 3x4 array.  Example:
>
> Enter equation #1:
> 3x + 4y - 8z = 45
> ...
>
>    This would seem to require storing the input as a string, and as far
> as I know, you can't pick values of a string (except in a limited sense
> with the Val function as touched upon above).  But I think that it has
> to be possible for me to process a naturally typed out equation!  And I
> would appreciate pointers to that effect.

The following code, written in Turbo Pascal 6, should do what you
want. You may want to test it more thoroughly than I did, and tidy up
the code a bit. It checks for validity of input. Values are stored as
reals.

It reads in the equation, and puts the values into the global array
eq_array.
}

program input_equations(input, output);

type
eq_string = string;

var
instr :eq_string;
eq_array :array [1..3, 1..4] of real;
eq_num :byte;
eq_ok :boolean;

procedure prepare_equation_string (var s :eq_string);
{ Removes spaces and converts all letter to upper case }
var
tempstr :eq_string;
n :byte;
begin
tempstr := '';
for n := 1 to length(s) do
if s[n] <> ' ' then tempstr := tempstr + upcase(s[n]);
s := tempstr
end;

function get_arguments (s :eq_string; var a1, a2, a3 :eq_string) :boolean;
{ Splits equation into argument.
eg, if s='3X+4Y-Z', then a1='3X', a2='+4Y', a3='-Z'.

If any argument is blank, or there are more than 3 arguments,
returns FALSE, otherwise returns TRUE }

function next_arg (s :eq_string) :eq_string;
var
n :byte;
begin
n := 2;
while (n <= length(s)) and not (s[n] in ['+', '-']) do
inc (n);
next_arg := copy (s, 1, n-1);
end;

begin
a1 := next_arg (s);
delete (s, 1, length(a1));
a2 := next_arg (s);
delete (s, 1, length(a2));
a3 := next_arg (s);
delete (s, 1, length(a3));
get_arguments := ((length(a1)*length(a2)*length(a3)) > 0) and
(s = '')
end;

function assign_values (var x, y, z :real; a1, a2, a3 :eq_string) :boolean;
var
x_assigned, y_assigned, z_assigned, ok_so_far :boolean;

function assign_value (s :eq_string) :boolean;
var
id :char;
value :real;
resultcode :integer;
ok :boolean;
begin
id := s[length(s)];
delete (s, length(s), 1);
if (s = '') or (s = '+') then
s := '1';
if s = '-' then
s := '-1';
val (s, value, resultcode);
ok := (resultcode = 0);
case id of
'X' : begin
x := value;
x_assigned := true
end;
'Y' : begin
y := value;
y_assigned := true
end;
'Z' : begin
z := value;
z_assigned := true
end
else
ok := false
end;
assign_value := ok
end;

begin
x_assigned := false;
y_assigned := false;
z_assigned := false;
ok_so_far  := assign_value (a1);
ok_so_far  := ok_so_far and assign_value (a2);
ok_so_far  := ok_so_far and assign_value (a3);
assign_values := ok_so_far and x_assigned and y_assigned and z_assigned;
end;

function extract_values(s : eq_string; var x, y, z, ans : real) : boolean;
var
ok_so_far : boolean;
n : byte;
lhs, rhs,
a1, a2, a3 : eq_string;
resultcode : integer;

begin
ok_so_far := true;
prepare_equation_string(s);
n := pos ('=', s);
if n = 0 then
ok_so_far := false                     { No = in equation }
else
begin
rhs := copy (s, n+1, length(s)-n);
if pos ('=', rhs) > 0 then
ok_so_far := false                 { More than one = in equation }
else
begin
lhs := copy (s, 1, n-1);
if (lhs = '') or (rhs = '') then
ok_so_far := false             { At least one side of equation }
else                             { is blank }
begin
ok_so_far := get_arguments (lhs, a1, a2, a3);
ok_so_far := ok_so_far and assign_values (x, y, z, a1, a2, a3);
val (rhs, ans, resultcode);
ok_so_far := ok_so_far and (resultcode = 0)
end;
end;
end;
extract_values := ok_so_far;
end;

begin
for eq_num := 1 to 3 do
begin
repeat
write ('Equation ', eq_num, ': ');