I was hoping that someone could give me a tip as to what I am missing in
the following program that gives me the following compile error.  Our
assignment is simple, solve a quadratic equation given the variable a, b
and c.  Here is my program:

Program quadratic (input, output);
{This program computes the answer, x, to the quadratic equation
ax^2+bx+c=0}

var
  a, b, c : real;

const
  d = sqr(b)-(4*a*c);

begin
  writeln ('Input the values of a, b, and c');
  readln (a) ;
  readln (b) ;
  readln (c) ;
  if d > 0 then
    begin
      writeln ('the two roots are');
      writeln ((-b + sqrt(d))/(2*a):20:5);
      writeln ((-b - sqrt(d))/(2*a):20:5);
    end
  else if d = 0 then
    begin
      writeln ('the root is');
      writeln (-b/2*a);
    end
  else if d < 0 then
    begin
      writeln ('the roots are');
      writeln ((-b + sqrt(abs(d))/2*a));
      writeln ((-b - sqrt(abs(d))/2*a));
    end
  else
    writeln ('I suck');
end.

Program looks fine to me, but I get a compile error with my constant, d:
here is the error message;

$ pas hw2_3.pas
00009      0  0   d = sqr(b)-(4*a*c);
                          1     2 3
%PASCAL-E-SYNERRCTE, (1) Error in compile-time expression
%PASCAL-E-SYNERRCTE, (2) Error in compile-time expression
%PASCAL-E-SYNERRCTE, (3) Error in compile-time expression
%PASCAL-E-ENDDIAGS, PASCAL completed with 3 diagnostics

I think what you really want here is make a function out of d.

  Function d(a,b,c: Real);
    Begin
    d := sqr(b)-(4*a*c);
    End;

Now the expression "if d > 0 then..." should do what you were expecting
your constand d to do.

I think what you really want here is make a function out of d.

  Function d(a,b,c: Real);
    Begin
    d := sqr(b)-(4*a*c);
    End;

Now the expression "if d(a,b,c) > 0 then..." should do what you were
expecting your constand d to do.

I suggest, here you simply declare a variable to hold the discriminant,
and compute it later, when you will have read the values needed:
  var
    d: real;

Alas, standard Pascal does not allow you to express your thoughts
lucidly. You cannot define run-time constants (i.e. constants
calculated from values obtained at run-time). You cannot even define
initial values for variables (which is the 1st work-around for your
problem coming to my mind).

The same error is made below, in the d<0 branch, while it is not made
in the d>0 branch.

Your program will report two real solutions where the equation really
has two complex ones. Replace the preceding lines with:
     begin
       writeln ('the two roots are');
       writeln (-b/2/a, ' + ', sqrt(abs(d))/2/a, '*i');
       writeln (-b/2/a, ' - ', sqrt(abs(d))/2/a, '*i');
     end

In a language that allows for run-tim constants, the hole program
would be more lucid; in particular the declaration of d's datatype
and its value would not be separated by other stuff (which can be
several hundred lines of code, in more realistic examples).

In the following example, note that keyword delimiters, and types,
are written in uppercase, while identifiers are in lower case.
Note also that LOC REAL declares a real-typed variable, while REAL
(without the LOC) declares a constant. In the language used below,
everything declared in an IF part is visible throughout the remaining
part of the IF clause (i.e. from the point of declaration through
the IF, and THEN parts, down to the end of the ELSE part); same holds
for an ELIF part, where ELIF is an abbreviation for ELSE IF.
  BEGIN # This program computes the answer, x,  #
        # to the quadratic equation ax^2+bx+c=0 #
    LOC REAL a, b, c
  ; write (("Input the values of a, b, and c", newline))
  ; read ((a, b, c))
  ; IF REAL d = a*a - 4*a*c
    ; d = 0
    THEN write (( "The root is ", -b/2/a, newline ))
    ELIF REAL s = sqrt (ABS d)
    ; d > 0
    THEN write ( ( "The two roots are:", newline
                 , (-b+s) / (2*a)      , newline
                 , (-b-s) / (2*a)      , newline
               ) )
    ELSE write ( ( "The two roots are:"      , newline
                 , -b/2/a, " + ", s/2/a, "*i", newline
                 , -b/2/a, " - ", s/2/a, "*i*, newline
               ) )
    FI
  END

FI is IF spelled backwards; this ends the IF statement, and thus
mends a syntactic ambiguity Pascal has inherited from Algol 60,
known as "the Problem of the Dangling ELSE".

You see, a well-designed language, such as Algol 68 (used in the
example above) lets you express your thoughts more lucidly. Too bad
that Niklaus Wirth impatiently has left the Algol 68 design team and
rushed into defining and implementing Pascal.

Run-time constants are not directly part of Extended Pascal.  We had
a simila feature during some of the public drafts, but allowing constants
to have run-time values also allows constants to end up with run-time
size also (ie, array constants).  The issue of constants with run-time
size bothered many people and caused some language issues that nobody
on the committee felt strongly enough to fix.  So, we removed the whole
concept from the standard.  You can indirectly make yourself a variable
with an initial value that is readonly afterwards by using schema types
and using the schema discrimants as your run-time constants.

"Alan M. Evans" <look...@airmail.net> wrote:

{not tested yet}

...
var d  : real = (sqr(absolute (b)) - 4*absolute(a) * absolute(c));