My code in Pascal does not want to work correctly. What is the problem in?

Question

I am writing program: sum of real numbers using recursive function. What is wrong with it? It shows me just last entered numebr.

type
 Indexy = 1..100;
 TPoleReal = array [Indexy] of Real;

var
 j: word;
 r, realRes: real;
 tpr: TPoleReal;


function SoucetCisel(n: TPoleReal; j: word): real;
 begin
   if j>0 then begin
     SoucetCisel:=SoucetCisel + n[j];
     j:=j-1;
   end
 end;


begin i:=0; j:=0;
while not seekeof do begin
  read(r); Inc(j);
  tpr[j]:=r;
  writeln(j, ' ', tpr[j]);
end;
realRes:= SoucetCisel(tpr, j);
writeln(realRes);

end.

Answer 1

As I told you in a comment before. Try this code for your pascal program:

type
 Indexy = 1..100;
 TPoleReal = array [Indexy] of Real;

var
 j: word;
 r, realRes: real;
 tpr: TPoleReal;


function SoucetCisel(n: TPoleReal; j: word): real;
 begin
   if j>0 then begin
     SoucetCisel:=SoucetCisel(n, j-1) + n[j];
   end
 end;


begin i:=0; j:=0;
while not seekeof do begin
  read(r); Inc(j);
  tpr[j]:=r;
  writeln(j, ' ', tpr[j]);
end;
realRes:= SoucetCisel(tpr, j);
writeln(realRes);

end.

Answer 2

For debugging purposes I suggest you simplify the main part of your code to

begin
  i:=0;
  j:=0;
  tpr[j] := 1;
  Inc(j);
  tpr[2] := 2;
  realRes:= SoucetCisel(tpr, j);
  writeln(realRes);
end.

That should make it make it much easier to appreciate what the problem is.

The first problem with your SoucetCisel function is that it isn't actually recursive.

A recursive function is one which calls itself with altered arguments, as in the archetypical Factorial function

function Factorial(N : Integer)
begin
  if N = 1 then
    Factorial := 1
  else
    Factorial := N * Factorial(N - 1);
end;

The recursive call in this is the line

Factorial := Factorial(N - 1);

Your SoucetCisel doesn't do that, it simply adds the initial value of the function result to the value of n[j], so it is not recursive at all.

The other problem is that, as written, it has no defined return value. In all the Pascal implementations I've come across, the return value is undefined on entry to the function and stays undefined until some value is explicitly assigned to it. The function result is usually some space on the stack which the compiler-generated code of the function reserves but which initially (on entry to the function) holds some random value, resulting from previous usage of the stack.

So, what the result of your SoucetCisel function is evaluated from is effectively

SoucetCisel := ARandomNumber + n[j]

which of course is just another random number. Obviously, you fix this aspect of your function by ensuring that an explicit assignment to the function result is made immediately on entry to the function. As a general rule, all execution paths through a function should lead through a statement which explicitly assigns a value to the function result.

Then, you need to rewrite the remainder of it so that it actually is recursive in the way your task requires.

While you're doing those two things, I would suggest that you use a more helpful parameter name than the anonymous 'n'. 'n' is usually used to refer to an uninteresting integer.

update I'm not sure from your comment whether it was supposed to be serious. In case it was, consider these two functions

function SumOfReals(Reals : TPoleReal; j : word): real;
var
   i : Integer;
begin
  SumOfReals := 0;
  for i := 1 to j do
    SumOfReals := SumOfReals + Reals[i];
end;

function SumOfRealsRecursive(Reals : TPoleReal; j : word): real;
var
  i : Integer;
begin
 SumOfRealsRecursive := Reals[j];
 if j > 1 then
   SumOfRealsRecursive := SumOfRealsRecursive + SumOfRealsRecursive(Reals, j -1);
end;

These functions both do the same thing, namely evaluate the sum of the contents of the Reals array up to and including the index j. The first one does so iteratively, simply traversing the Reals array, which the second does it recursively. However, it should be obvious that the recursive version is absolutely pointless in this case because the iterative version does the same thing but far more efficiently, because it does not involve copying the entire Reals array for each recursive call, which the recursive version does.