PL/I and some new Fortran features

[Mike Zimnov]

I try to transtalte to pl/i some Fortran module and have few questions:

1. Are PL/I PACKAGE similar to Fortran MODULE? What are differences?

2. As I see PL/I have no analog to SELECTED_REAL_KIND builtin. Is possible to translate
INTEGER, PARAMETER :: kp = kind(1.) ! For single precision
INTEGER, PARAMETER :: kp = kind(1D0) ! For double precision and the default
INTEGER,PARAMETER :: kp=SELECTED_REAL_KIND(20,550) ! For extended precision

and then use construtions like
REAL (kp), PARAMETER :: pi = 3.14159265358979323846264_kp

in PL/I?

[Robin Vowels]

On Apr 13, 6:09 pm, Mike Zimnov <mikez...@gmail.com> wrote:
> I try to transtalte to pl/i some Fortran module and have few questions:
>

> 2. As I see PL/I have no analog to SELECTED_REAL_KIND builtin. Is possible to translate
> INTEGER, PARAMETER :: kp = kind(1.) ! For single precision
> INTEGER, PARAMETER :: kp = kind(1D0) ! For double precision and the default
> INTEGER,PARAMETER  :: kp=SELECTED_REAL_KIND(20,550)   ! For extended precision

Equivalent to single precision is simply:
DECLARE X FLOAT;
equivalent to double precision is
DECLARE X FLOAT (15);
Equivalent to extended precision is:
DECLARE X FLOAT (18);

> and then use construtions like
> REAL (kp), PARAMETER :: pi = 3.14159265358979323846264_kp
>
> in PL/I?

DECLARE pi FLOAT (18) VALUE (3.14159265358979323e0);

[glen herrmannsfeldt]

Mike Zimnov <mike...@gmail.com> wrote:
> I try to transtalte to pl/i some Fortran module and have few questions:

> 1. Are PL/I PACKAGE similar to Fortran MODULE? What are differences?

> 2. As I see PL/I have no analog to SELECTED_REAL_KIND builtin. Is possible to translate
> INTEGER, PARAMETER :: kp = kind(1.) ! For single precision
> INTEGER, PARAMETER :: kp = kind(1D0) ! For double precision and the default
> INTEGER,PARAMETER :: kp=SELECTED_REAL_KIND(20,550) ! For extended precision

I suppose you could use the preprocessor in place of PARAMETER.

%DCL KP FIXED;
%KP=16;

Good or bad, PL/I does such typing at a higher level. You specify
the precision that you want, and the compiler gives you an appropriate
type. At the time PL/I was being designed, there was nothing close
to a standard floating point format. Even more, single precision on
some machines was close to double precision on others.

> and then use construtions like
> REAL (kp), PARAMETER :: pi = 3.14159265358979323846264_kp

> in PL/I?

I don't know if PL/I now has something closer to Fortran PARAMETER.
Constants have the base, mode, scale, and precision that they are
written in. You pi is FIXED DECIMAL(24,23). If you want a floating
point constant, add an E0 at the end, which would make it
FLOAT DECIMAL(24).

Note that PL/I has no feature like Fortran where constants have less
precision than written. In Fortran 3.14159265358979323846264 is single
precision, in PL/I it is more than double (on most machines).

If you want to specify the precision of a constant, I think you can
do something like FLOAT(3.14159265358979323846264,16) to specify
that you want 16 (decimal) digits. (The compiler will round up
to the next available floating point form.)

Fortran only allows you to specify precision in decimal digits.
PL/I allows you to specify in either binary bits or decimal
digits. Until very recently, there were no machines supporting
both binary and decimal floating point. Like Fortran, FIXED DEC
specified the required precision, but did not specify that
you actually wanted decimal floating point. I don't know that
any actual compilers have been upgraded to support decimal
floating point, but it should happen.

Otherwise, you can specify FLOAT BINARY(53) or something similar.
Or even:

%DCL KP FIXED;
%KP=16;
DCL X FIXED BINARY(KP*332/100);

or maybe

%DCL (KP,KPB) FIXED;
%KP=16;
%KPB=KP*332/100;
DCL X FIXED BINARY(KPB);

-- glen

[Shmuel Metz]

In <kkc4p0$d9v$1...@speranza.aioe.org>, on 04/13/2013

at 05:31 PM, glen herrmannsfeldt <g...@ugcs.caltech.edu> said:

>Until very recently, there were no machines supporting
>both binary and decimal floating point.

Such machines existed before PL/I.

--
Shmuel (Seymour J.) Metz, SysProg and JOAT <http://patriot.net/~shmuel>

Unsolicited bulk E-mail subject to legal action. I reserve the
right to publicly post or ridicule any abusive E-mail. Reply to
domain Patriot dot net user shmuel+news to contact me. Do not
reply to spam...@library.lspace.org

[John W Kennedy]

On 2013-04-14 01:05:17 +0000, Shmuel (Seymour J.) Metz said:

> In <kkc4p0$d9v$1...@speranza.aioe.org>, on 04/13/2013
> at 05:31 PM, glen herrmannsfeldt <g...@ugcs.caltech.edu> said:
>
>> Until very recently, there were no machines supporting
>> both binary and decimal floating point.
>
> Such machines existed before PL/I.

This is trivially true, of course, if "support" refers to software or
customer-writable microcode, but when it comes to ordinary
customer-accessible instruction sets, IBM certainly never had such
machines, and I'm not aware of any other.

--
John W Kennedy
"The whole modern world has divided itself into Conservatives and
Progressives. The business of Progressives is to go on making mistakes.
The business of the Conservatives is to prevent the mistakes from being
corrected."
-- G. K. Chesterton

[Shmuel Metz]

In <516ad27a$0$25606$607e...@cv.net>, on 04/14/2013

at 11:59 AM, John W Kennedy <jwk...@attglobal.net> said:

>This is trivially true, of course, if "support" refers to software or
> customer-writable microcode,

It doesn't.

>IBM certainly never had such machines,

IBM isn't the only computer vendor.

>and I'm not aware of any other.

RCA.

[glen herrmannsfeldt]

Shmuel (Seymour J.) Metz <spam...@library.lspace.org.invalid> wrote:
> In <516ad27a$0$25606$607e...@cv.net>, on 04/14/2013
> at 11:59 AM, John W Kennedy <jwk...@attglobal.net> said:

>>This is trivially true, of course, if "support" refers to software or
>> customer-writable microcode,

> It doesn't.

>>IBM certainly never had such machines,

> IBM isn't the only computer vendor.

>>and I'm not aware of any other.

> RCA.

What RCA once did isn't very well documented today, but I meant
(and should have specified) in hardware. Most likely that includes
microcode, but not software emulation.

Did RCA have compilers that could generate instructions for both,
either as specified in the program statements or a compile
time option?

As far as I know, there were no high-level languages before PL/I
that had a way to specify BINARY and DECIMAL floating point
in the language. (I don't know COBOL well at all. As well as I
do know it, you can specify binary and decimal for fixed point,
but not floating point.)

As well as I understand it, the intent in PL/I for FLOAT was to
specify the needed precision in binary bits or decimal digits,
and not with the intent that a machine supply both binary and
decimal floating point. (And counting IBM hex as binary.)

I did once use an IBM PL/I compiler that used binary arithmetic
for fixed decimal. (I actually tested for the overflow of
FIXED DEC(9,9) at 2.147483647, which it did as you would expect.)

Otherwise, the fortran KIND system allows one to specify the needed
number of decimal digits, in either INTEGER or floating point.
Fortran allows for the underlying implementation of either fixed
or floating point in any integer base greater than one.

-- glen

[Robin Vowels]

On Apr 14, 3:31 am, glen herrmannsfeldt <g...@ugcs.caltech.edu> wrote:

> Mike Zimnov <mikez...@gmail.com> wrote:
> > I try to transtalte to pl/i some Fortran module and have few questions:
> > 1. Are PL/I PACKAGE similar to Fortran MODULE? What are differences?
> > 2. As I see PL/I have no analog to SELECTED_REAL_KIND builtin. Is possible to translate
> > INTEGER, PARAMETER :: kp = kind(1.) ! For single precision
> > INTEGER, PARAMETER :: kp = kind(1D0) ! For double precision and the default
> > INTEGER,PARAMETER  :: kp=SELECTED_REAL_KIND(20,550)   ! For extended precision
>
> I suppose you could use the preprocessor in place of PARAMETER.
>
> %DCL KP FIXED;
> %KP=16;

That is largely irrelevant.
The exactly corresponding PL/I facility is to specify the number
of digits required, e.g.,

declare x float(10);

which selects an appropriate storage unit capable of storing
at least 10 decimal digits.

> Good or bad, PL/I does such typing at a higher level. You specify
> the precision that you want, and the compiler gives you an appropriate
> type.

It gives a storage unit capable of storing at least the
number of digits required, in whatever mode corresponding
to the declaration (decimal, bonary, fixed, float).
It's exactly the same as what's available with Fortran's
KIND type facility (examples of which are given above).

> At the time PL/I was being designed, there was nothing close
> to a standard floating point format.

More to the point, there was nothing consistent about word sizes,
and some machines were character- (byte)-oriented while others were
word-oriented.

> Even more, single precision on
> some machines was close to double precision on others.

In terms of floating-point, yes. Those terms weren't relevant to
binary integer or decimal integer, or scaled fixed-point.

> > and then use construtions like
> > REAL (kp), PARAMETER :: pi = 3.14159265358979323846264_kp
> > in PL/I?
>
> I don't know if PL/I now has something closer to Fortran PARAMETER.

I gave an example the day prior to your post.
You use the VALUE attribute in PL/I, which is exactly the same
as Fortran's PARAMETER.

> Constants have the base, mode, scale, and precision that they are
> written in. You pi is FIXED DECIMAL(24,23). If you want a floating
> point constant, add an E0 at the end, which would make it
> FLOAT DECIMAL(24).
>
> Note that PL/I has no feature like Fortran where constants have less
> precision than written.

Thank goodness! And it's not a Fortran "feature". It's archaic.

> In Fortran 3.14159265358979323846264 is single
> precision, in PL/I it is more than double (on most machines).
>
> If you want to specify the precision of a constant, I think you can
> do something like FLOAT(3.14159265358979323846264,16)  to specify
> that you want 16 (decimal) digits. (The compiler will round up
> to the next available floating point form.)
>
> Fortran only allows you to specify precision in decimal digits.
> PL/I allows you to specify in either binary bits or decimal
> digits. Until very recently, there were no machines supporting
> both binary and decimal floating point. Like Fortran, FIXED DEC
> specified the required precision,

Fortran does NOT have fixed decimal.

> but did not specify that
> you actually wanted decimal floating point. I don't know that
> any actual compilers have been upgraded to support decimal
> floating point, but it should happen.

IBM's PL/I supports decimal and binary floating-point.
Has done so for at least 3½ years, maybe more.

> Otherwise, you can specify FLOAT BINARY(53) or something similar.
> Or even:
>
> %DCL KP FIXED;
> %KP=16;
> DCL X FIXED BINARY(KP*332/100);

Why on earth would you want to do that!

>
> or maybe
>
> %DCL (KP,KPB) FIXED;
> %KP=16;
> %KPB=KP*332/100;
> DCL X FIXED BINARY(KPB);

You have to be joking.

[Robin Vowels]

On Apr 15, 7:14 am, glen herrmannsfeldt <g...@ugcs.caltech.edu> wrote:
> Shmuel (Seymour J.) Metz <spamt...@library.lspace.org.invalid> wrote:
>
> > In <516ad27a$0$25606$607ed...@cv.net>, on 04/14/2013

> >   at 11:59 AM, John W Kennedy <jwke...@attglobal.net> said:
> >>This is trivially true, of course, if "support" refers to software or
> >> customer-writable microcode,
> > It doesn't.
> >>IBM certainly never had such machines,
> > IBM isn't the only computer vendor.
> >>and I'm not aware of any other.
> > RCA.
>
> What RCA once did isn't very well documented today, but I meant
> (and should have specified) in hardware. Most likely that includes
> microcode, but not software emulation.
>
> Did RCA have compilers that could generate instructions for both,
> either as specified in the program statements or a compile
> time option?
>
> As far as I know, there were no high-level languages before PL/I
> that had a way to specify BINARY and DECIMAL floating point
> in the language. (I don't know COBOL well at all. As well as I
> do know it, you can specify binary and decimal for fixed point,
> but not floating point.)
>
> As well as I understand it, the intent in PL/I for FLOAT was to
> specify the needed precision in binary bits or decimal digits,
> and not with the intent that a machine supply both binary and
> decimal floating point. (And counting IBM hex as binary.)

PL/I was designed to be portable, and as for floating-point,
would use whatever hardware was available. At the time,
some machines provided decimal float, others binary float.
No doubt, IBM kept the door open in case some of its future
machines had decimal floating-point.

> I did once use an IBM PL/I compiler that used binary arithmetic
> for fixed decimal. (I actually tested for the overflow of
> FIXED DEC(9,9) at 2.147483647, which it did as you would expect.)

There's nothing unusual in that.
Some machines didn't have either floating-point hardware or
decimal fixed-point hardware.
CDC PL/I for the Cyber series used fixed binary for decimal
arithmetic, as only binary integer arithmetic was available
(as well as, of course, floating-point binary).

The GEORGE compiler (1958) used floating-point for all its integer
and floating-point computation.

> Otherwise, the fortran KIND system allows one to specify the needed
> number of decimal digits, in either INTEGER or floating point.

The Fortran KIND system is a somewhat clumsy and ham-fisted way
of specifying precision.

The PL/I method of specifying the number of digits directly
is user-friendly and intuitive.

> Fortran allows for the underlying implementation of either fixed
> or floating point in any integer base greater than one.

As does PL/I. And it permits the implementation of
decimal fixed-point arithmetic in either decimal or binary (or
indeed any other base).

[Robin Vowels]

On Apr 13, 6:09 pm, Mike Zimnov <mikez...@gmail.com> wrote:

> I try to transtalte to pl/i some Fortran module and have few questions:

> 2. As I see PL/I have no analog to SELECTED_REAL_KIND builtin. Is possible to translate
> INTEGER, PARAMETER :: kp = kind(1.) ! For single precision
> INTEGER, PARAMETER :: kp = kind(1D0) ! For double precision and the default
> INTEGER,PARAMETER  :: kp=SELECTED_REAL_KIND(20,550)   ! For extended precision
>
> and then use construtions like
> REAL (kp), PARAMETER :: pi = 3.14159265358979323846264_kp
>
> in PL/I?

In PL/I, the PLACES function tells you the number of binary digits in
a floating-point value.
For IEEE decimal floating-point, PLACES tells you the number of
decimal digits in a floating value.

However, in general, you don't need to know those values.
The Fortran KIND function enables the selection of a word
having single precision, etc.
The corresponding PL/I facility enables the same thing,
namely, the ability to specify the (minimum) working precision for
calculations. The compiler uses either single, double,
or extended-precision hardware according to the number of digits
specified for the variable.

[Robin Vowels]

On Apr 13, 6:09 pm, Mike Zimnov <mikez...@gmail.com> wrote:

> I try to transtalte to pl/i some Fortran module and have few questions:
>
> 1. Are PL/I PACKAGE similar to Fortran MODULE? What are differences?

A PL/I package is entirely different from a Fortran module.

The Fortran module is an attempt to improve on the basic deficiency
of Fortran that procedures cannot be nested to any depth.

It also provides the means to improve on (and eliminate) the
antiquated COMMON block mechanism, in that declarations
can be made available to a number of procedures (by means of the
USE statement).

PL/I packages can contain a number of procedures, and the names
of these can be "exported" outside the package.
A package can contain global declarations that can be used by
one or more of its contained procedures.

Many of the facilities of modules are already available in PL/I
without resorting to the use of packages.

[John W Kennedy]

If so, they did it carelessly. The ROUND built-in function was defined
on the assumption that the implementation was binary.

--
John W Kennedy
"Compact is becoming contract,
Man only earns and pays."
-- Charles Williams. "Bors to Elayne: On the King's Coins"

[gerardsch...@gmail.com]

On Saturday, April 13, 2013 8:05:17 PM UTC-5, Seymour J. Shmuel Metz wrote:

> on 04/13/2013 at 05:31 PM, glen herrmannsfeldt said:
>>Until very recently, there were no machines supporting
>>both binary and decimal floating point.

> Such machines existed before PL/I.
> --
> Shmuel (Seymour J.) Metz, SysProg and JOAT <http://patriot.net/~shmuel>

The IBM 1620 and IBM 1710 had decimal floating point (BCD),
no binary arithmetic at all.
______________________________________ Gerard Schildberger

[John W Kennedy]

On 2013-04-15 18:44:25 +0000, gerardsch...@gmail.com said:

> On Saturday, April 13, 2013 8:05:17 PM UTC-5, Seymour J. Shmuel Metz wrote:
>> on 04/13/2013 at 05:31 PM, glen herrmannsfeldt said:
>>> Until very recently, there were no machines supporting
>>> both binary and decimal floating point.
>
>> Such machines existed before PL/I.
>> --
>> Shmuel (Seymour J.) Metz, SysProg and JOAT <http://patriot.net/~shmuel>
>
> The IBM 1620 and IBM 1710 had decimal floating point (BCD),
> no binary arithmetic at all.

They were at least binary-coded decimal. The IBM 650 (bi-quinary) and
707x series (2-of-5) were not.

However, the issue is machines that had /both/ binary and decimal
floating point. No IBM system did until recent z/Architecture models,
but the RCA 601, from the era before RCA decided to make IBM clones,
apparently did.

--
John W Kennedy
"Though a Rothschild you may be
In your own capacity,
As a Company you've come to utter sorrow--
But the Liquidators say,
'Never mind--you needn't pay,'
So you start another company to-morrow!"
-- Sir William S. Gilbert. "Utopia Limited"

[Peter Flass]

Only the IBM implementation. The standard is quite clear.


--
Pete

[John W Kennedy]

The old IBM standard is indeed quite clear; ROUND for FLOAT ignores the
second argument and ORs the underlying binary of the first argument
with 1. (The ANSI standard may say something else, for all I know to
the contrary, but it has nothing to do with the present point.)

(I find, however, that the ROUND BIF is not part of the original
language, having appeared for the first time sometime around 1967-8.)

--
John W Kennedy
"I want everybody to be smart. As smart as they can be. A world of
ignorant people is too dangerous to live in."
-- Garson Kanin. "Born Yesterday"

[Shmuel Metz]

In <kkf674$a6j$1...@speranza.aioe.org>, on 04/14/2013

at 09:14 PM, glen herrmannsfeldt <g...@ugcs.caltech.edu> said:

>What RCA once did isn't very well documented today, but I meant (and
>should have specified) in hardware. Most likely that includes
>microcode, but not software emulation.

In this case it was some combination of microcode[1] and hardware.

>Did RCA have compilers that could generate instructions for both,
>either as specified in the program statements or a compile time
>option?

I never saw their COBOL, and I don't know whether there was an Algol
or FORTRAN compiler,

[1] RCA didn't use the term at the time. What IBM called a
microinstruction RCA called an elementary order.

[Mike Zimnov]

> and then use construtions like
> REAL (kp), PARAMETER :: pi = 3.14159265358979323846264_kp
>
> in PL/I?


DECLARE pi FLOAT (18) VALUE (3.14159265358979323e0);

So, if I use VALUE in that context, variable pi can not be changed anywhere in program like PARAMETER?

[Robin Vowels]

As I said, PL/I's VALUE is the feature corresponding to
Fortran's PARAMETER. You cannot assign values to a variable with
the VALUE attribute:

test: proc options (main);
declare pi float(15) value (3.1415626789);

pi = 1.23456;

end test;

C:\PLIFILES\VALUE.pli(4:1) : IBM1667I S Target in assignment is
NONASSIGNABLE.

[glen herrmannsfeldt]

Robin Vowels <robin....@gmail.com> wrote:

> On Apr 19, 1:12ï¿œam, Mike Zimnov <mikez...@gmail.com> wrote:
>> > and then use construtions like
>> > REAL (kp), PARAMETER :: pi = 3.14159265358979323846264_kp

>> > in PL/I?

>> DECLARE pi FLOAT (18) VALUE (3.14159265358979323e0);

>> So, if I use VALUE in that context, variable pi can
> not be changed anywhere in program like PARAMETER?

> As I said, PL/I's VALUE is the feature corresponding to
> Fortran's PARAMETER. You cannot assign values to a variable with
> the VALUE attribute:

Can you use one where a compile time constant is needed,
such as the dimension of a static array?

-- glen

[John W Kennedy]

On 2013-04-19 11:20:52 +0000, glen herrmannsfeldt said:

> Robin Vowels <robin....@gmail.com> wrote:

>> On Apr 19, 1:12 am, Mike Zimnov <mikez...@gmail.com> wrote:
>>>> and then use construtions like
>>>> REAL (kp), PARAMETER :: pi = 3.14159265358979323846264_kp
>
>>>> in PL/I?
>
>>> DECLARE pi FLOAT (18) VALUE (3.14159265358979323e0);
>
>>> So, if I use VALUE in that context, variable pi can
>> not be changed anywhere in program like PARAMETER?
>
>> As I said, PL/I's VALUE is the feature corresponding to
>> Fortran's PARAMETER. You cannot assign values to a variable with
>> the VALUE attribute:
>
> Can you use one where a compile time constant is needed,
> such as the dimension of a static array?

The term now is "restricted expression", rather than "compile-time
constant", and it applies to any expression that is capable of being
evaluated at compile time.

DECLARE LIMITS CHAR(7) VALUE ('001,080');
DECLARE LOW_LIMIT_PLACE FIXED BIN VALUE(1);
DECLARE LOW_LIMIT_LENGTH FIXED BIN VALUE(3);
DECLARE HIGH-LIMIT_PLACE FIXED BIN VALUE(5);
DECLARE HIGH_LIMIT_LENGTH FIXED BIN VALUE(3);
DECLARE MY_ARRAY(SUBSTR(LIMITS, LOW_LIMIT_PLACE, LOW_LIMIT_LENGTH):
SUBSTR(LIMITS, HIGH_LIMIT_PLACE, HIGH_LIMIT_LENGTH))
STATIC FLOAT;

...though of doubtful sense, is entirely legal.


--
John W Kennedy
"Information is light. Information, in itself, about anything, is light."
-- Tom Stoppard. "Night and Day"

[Robin Vowels]

On Apr 19, 9:20 pm, glen herrmannsfeldt <g...@ugcs.caltech.edu> wrote:
> Robin Vowels <robin.vow...@gmail.com> wrote:

> > On Apr 19, 1:12 am, Mike Zimnov <mikez...@gmail.com> wrote:
> >> > and then use construtions like
> >> > REAL (kp), PARAMETER :: pi = 3.14159265358979323846264_kp
> >> > in PL/I?
> >> DECLARE pi FLOAT (18) VALUE (3.14159265358979323e0);
> >> So, if I use VALUE in that context, variable pi can
> > not be changed anywhere in program like PARAMETER?
> > As I said, PL/I's VALUE is the feature corresponding to
> > Fortran's PARAMETER.  You cannot assign values to a variable with
> > the VALUE attribute:
>
> Can you use one where a compile time constant is needed,
> such as the dimension of a static array?

A variable with the VALUE attribute is an instance of a
named constant.
It is a compile constant. It can be used in a restricted expression.
There are specific examples in the manual covering your query.