**[**Back to MATH SWAG index**]** **[**Back to Main SWAG index**]** **[**Original**]**

*{
> 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**[40];
**var
**instr :eq_string;
eq_array :**array **[1..3, 1..4] **of **real;
eq_num :byte;
x, y, z, answer :real;
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, ': ');
readln (instr);
eq_ok := extract_values (instr, x, y, z, answer);
**if not **eq_ok **then
**writeln ('Equation not in suitable format, try again');
**until **eq_ok;
eq_array [eq_num, 1] := x;
eq_array [eq_num, 2] := y;
eq_array [eq_num, 3] := z;
eq_array [eq_num, 4] := answer;
**end**;
**end**.

**[**Back to MATH SWAG index**]** **[**Back to Main SWAG index**]** **[**Original**]**