LyAPAS (?) A russian cousin of APL ?
FDA
language called LyAPaS (I am not sure which letters are
supposed to be uppercase and lowercase) designed by
somebody in the 60/70 in the Soviet Union, and which had
some APLish look ? It might have been presented in an old
APL congress, but I cannot find any trace about it.
(Only 1 letter was allowed for variable names, though; but I
do remember using around 1970 a pre-release version of
APL\1130 which had that limitation too; the following pack,
delivered by punched cards too, allowed more reasonable
variable names).
This question is only loosely tied to APL itself, but seing
a reference to Iverson's original book reminded me about
that strange language; so if anybody has the answer, feel
free to mail it to me...
Eric Cordian
> For mere curiosity reasons, has somebody heard about a
> language called LyAPaS (I am not sure which letters are
> supposed to be uppercase and lowercase) designed by
> somebody in the 60/70 in the Soviet Union, and which had
> some APLish look ? It might have been presented in an old
> APL congress, but I cannot find any trace about it.
Yes, I have heard of it. I even remember a book on it which I read many
decades ago.
LYaPAS (The correct capitalization) is a Russian acronym which loosely
translates into English as something along the lines of "Logical Language
for the Representation of Coding Algorithms."
It was an APL-like language originally coded in octal for the fine Soviet
computer, the URAL-1.
The book, by the same name, was published in 1969 by Academic Press.
According to their online catalog, Rensselaer Polytecnic Institute has a
copy of the book in their library. Here's the URL.
http://opac.lib.rpi.edu/search/azamalloa+lorena+m/-65,-1,0,E/2browse
We really should add LYaPAS to the FAQ, as we get this question several
times a year.
--
Eric Michael Cordian 0+
O:.T:.O:. Mathematical Munitions Division
"Do What Thou Wilt Shall Be The Whole Of The Law"
Randy MacDonald
book about this language, when I went there in around 1980.
I don't recall having enough math under my belt to understand
it then, but I'm hoping to head down there in a month or so
so I'll be sure to check on it.
(It also had a Y2K book "The coming disaster in computer
software, or something like that.")
armi...@noos.fr (FDA) wrote in <39A8D20C...@noos.fr>:
>For mere curiosity reasons, has somebody heard about a
>language called LyAPaS (I am not sure which letters are
>supposed to be uppercase and lowercase) designed by
>somebody in the 60/70 in the Soviet Union, and which had
>some APLish look ?
--
|\/| Randy A MacDonald ||I'm leery of x where x=x is not true
|\\| ra...@godin.on.ca | Roger Hui
BSc(Math) UNBF '83 | I'd be more leery of the "=" myself.
Natural Born APL'er | R.A. MacDonald
I use Real J | APL: If you can say it, it's done.
------------------------------------------------<-NTP>----{ gnat }-
Randy MacDonald
http://www.info.fundp.ac.be/~jmj/Workshops/INTAS/2nd/Abstracts/basc.html
armi...@noos.fr (FDA) wrote in <39A8D20C...@noos.fr>:
>For mere curiosity reasons, has somebody heard about a
>language called LyAPaS
--
|\/| Randy A MacDonald |ICFP'00: Contest, or grad thesis?
|\\| ra...@godin.on.ca | R.A. MacDonald
BSc(Math) UNBF '83 |
Natural Born APL'er |
Tracker
LYaPAS (Russian acronym for "Logical Language for the...
...computer.
Randy MacDonald <ra...@godin.com> wrote in message
news:8F9E2679Ara...@24.2.9.59...
Derek Peschel
In article <39A8D20C...@noos.fr>, FDA wrote:
>For mere curiosity reasons, has somebody heard about a
>language called LyAPaS (I am not sure which letters are
>supposed to be uppercase and lowercase) designed by
>somebody in the 60/70 in the Soviet Union, and which had
>some APLish look ? It might have been presented in an old
>APL congress, but I cannot find any trace about it.
>
>(Only 1 letter was allowed for variable names, though; but I
>do remember using around 1970 a pre-release version of
>APL\1130 which had that limitation too; the following pack,
>delivered by punched cards too, allowed more reasonable
>variable names).
As other people have mentioned, you can find references with a Web search.
However, the pages I found are not very substantial. Since I happen to have
the book by Gavrilov and Zakrevskii which describes the language, I thought
I would mention some specific details. Unfortunately I do not understand
the book completely. (It is in English, but not all of the terms make
sense yet.)
The translator's preface says: "A. D. Zakrevskii remarks that the language
is largely inspired by Iverson (p. 8). One great practical inconvenience of
Iverson's notation has been removed, namely, the two-dimensional arrangement
of symbols [...]". So it's fair to say that Iverson's book inspired APL and
LYaPAS, and that APL (the software) did not inspire LYaPAS because they
developed independently.
The book also points out in several places that LYaPAS had a rather
restricted goal -- representing logical operations and logical algorithms.
So variables have explicit representations (words, or sets, of bits) and
sizes (e.g., 32 bits). Arrays are handled in a rather restricted way that
puts the burden on the programmer (this is one of the parts of the book I
don't understand). Input is compact and linear, like APL, but the operators
are much more low-level, for example:
bitwise OR
bitwise AND
bitwise XOR
wordwise addition
wordwise subtraction
wordwise multiplication
wordwise multiplication with rounding
wordwise division (leaving quotient and remainder)
bitwise NOT
wordwise reversal (001011 becomes 110100)
location of leftmost 1 bit
normalization (put most-significant 1 bit at the left)
left shift filling with 0 bits
right shift filling with 0 bits
rotation (any number of places)
count of 1 bits
reflection
assignment
increment and decrement
assignment of minimum (all 0s) and maximum (all 1s) values
The reflection operator is interesting. APLers will undoubtedly understand
the authors' explanation: "If we consider a 32-bit code--the value of the
variable i [left-hand argument]--as the development of the 5-dimensional
cube, the effects of the reflection operator can be represented as the
mirror exchange over the 4-dimensional edges, corresponding to the distinct
values of one of the five binary variables prescribed by the operand j
[right-hand argument]." Notes in brackets are mine. The book actually has
xi-sub-i and xi-sub-j.
Non-APLers will appreciate the translator's note: "In the first example
[j=0] bits are exchanged between adjacent columns, in the second [j=1]
between columns one removed, and in the last [j=2] between the first and
fourth, second and fifth, etc." Notes in brackets are mine.
The notation for these operations resembles APL somewhat, in that it
contains characters built up from simpler characters. Multiplication is
represented by the traditional cross symbol, and multiplication with
rounding by the cross symbol with an overbar.
Along with operations the language offers variables and arrays (one letter,
with different typefaces denoting different data types), subroutines with
parameters and return values, a "correction" routine to allow you to make
last-minute (non-interactive) patches to your program before it runs, syntax
checking, compilation, optimization, some storage allocation, and tracing.
The differences to APL become quite obvious when you look at those parts of
the language. LyAPAS ran on much tinier computers than APL ever did (the
smallest, URAL-1, had 1024 36-bit words). That explains the need for
compilation and also the lack of complete storage allocation (you must know
how arrays are laid out to use them, and you must declare how much space a
subroutine and its data uses).
As it turns out, the restriction to one letter per variable, and also the
nicely-designed character set, are irrelevant since all input was in octal
from tape or cards and all output was on a printer with eight octal digits
(or spaces) per line, as well as an optional minus sign at the left. These
I/O restrictions applied to Soviet computers in general, not just the
URAL-1. The task of encoding a program into octal form couldn't be done
reliably by a computer, and so someone had to do it. (Sounds like a good
job for a graudate student.)
The book contains a large selection of examples. They deal with sets
(finding minimum coverage), graphs (finding connectivity), Boolean functions
(factoring, decomposing, reducing to normal forms, etc.) and sets of logical
equations (solving). There are also examples to work with entire circuits
and finite-state automata. Finally, the book contains the LYaPAS source for
the compiler, but the machine-language parts have been omitted from the
translation. Someone might be able to port the system to modern hardware
with the information in the book, though the port would probably require a
fair amount of artistic license. (I suspect the machine-dependent parts
would have to be written from scratch. It would also be a good idea to redo
the I/O so that people didn't have to deal with octal.)
-- Derek
Charles Richmond
>
> For mere curiosity reasons, has somebody heard about a
> language called LyAPaS (I am not sure which letters are
> supposed to be uppercase and lowercase) designed by
> somebody in the 60/70 in the Soviet Union, and which had
> some APLish look ? It might have been presented in an old
> APL congress, but I cannot find any trace about it.
>
There are is a wide range of people on <a.f.c> who are
knowledgable in such ancient matters. IMHO you could turn
up more info there...
--
+-------------------------------------------------------------+
| Charles and Francis Richmond <rich...@plano.net> |
+-------------------------------------------------------------+