HDTenEightyP/NetNews huggingface dataset:
From: hays@ssd.intel.com (Kirk Hays)
Newsgroups: comp.lang.misc,comp.compilers
Subject: Re: Rounding modes.
Keywords: arithmetic, PL/M
Date: 28 Aug 92 20:06:41 GMT
Article-I.D.: comp.92-08-176
Reply-To: hays@ssd.intel.com (Kirk Hays)
Organization: Intel Supercomputer Systems Division

napi@jaring.ism.my (Mohd Hanafiah Abdullah) writes:
|> Is there any High Level Language which allows one to select the different
|> rounding modes as provided by the IEEE 754 floating point standard?

All the various members of the PL/M-x86 family allowed direct access to the
floating point modes of the IEEE compliant FPUs via a built-in variable.
-- 
Kirk Hays
hays@ssd.intel.com
-- 
Send compilers articles to compilers@iecc.cambridge.ma.us or
{ima | spdcc | world}!iecc!compilers.  Meta-mail to compilers-request.
From: mbk@lyapunov.ucsd.edu (Matt Kennel)
Newsgroups: comp.lang.misc
Subject: Re: Scientists as Programmers (was Re: Small Language Wanted)
Date: 1 Sep 92 20:06:47 GMT
Organization: Institute For Nonlinear Science, UCSD
NNTP-Posting-Host: lyapunov.ucsd.edu
X-Newsreader: Tin 1.1 PL3

bevan@cs.man.ac.uk (Stephen J Bevan) writes:
:    Despite what the CS gurus say, allowing the introduction of
:    additional functions is not the same thing.
: 
: Semantically it is, and that is what really counts.

Well that just about sums up the schism here. 

Scientist computer not bit one syntax about care.


: Some languages do allow you to define infix operators (Haskell and ML),
: but there are very few that allow you to define distfix syntax.
: Of those that do they are either quite old or designed for completely
: different purposes than numerical work.  Also a problem with distix is
: that it is very easy to get ambiguities and unless you are going to
: introduce some user defined precedence (which I'm not even sure would
: solve the problem), the only solution is to put parentheses around
: phrases.

Yeah, so deal with it!

:  Once you do this, you might as well be using a prefix or
: posfix only language.


:    Also, mathematicians and scientists are accustomed to using
:    whatever syntax they like, as long as it does not lead to confusion.
: 
: Confusion for who?  I get very confused when I read books that use
: |A| to mean three different things depending on the context (which
: isn't always immediately obvious).  With all due respect to
: mathematicians and scientists, just because they are accustomed to
: creating syntax on the fly, it doesn't meant that they are any good at
: it (where "good" is totally subjective, but I'll take it to mean that
: other people find it readable and better (another subjective term)
: than anything else).  For example, I'm sure Frege thought he had a
: great notation for his logical formulae, but IMHO (and with plenty of
: hindsight :-) it was needlessly complicated. 

I think it would be nice to "import" a set of syntax rules for whatever
particular domain you're using, so as to make programming in that domain
easiest.  It won't make compiler writing easiest, but then again, 
we have our biases, and we don't care that much how hard that task is.
:-)

: This extends to CS people as well, there seems to be something inside
: most of them that drives them to invent a "new" language even though
: it rarely has anything new in it.  It usually consists of a different
: permutation of symbols to describe the same semantics that underlies
: thousands of other languages. (There are a some languages that warrant
: the title "new", but they are very few and far between)

This is the singularity at the core of the problem.

Computer scientists have this bias that the choosing the 
particular permutation of symbols (how disparaging!) is either trivial
or irrelevant.

: bevan

--
-Matt Kennel  		mbk@inls1.ucsd.edu
-Institute for Nonlinear Science, University of California, San Diego
-*** AD: Archive for nonlinear dynamics papers & programs: FTP to
-***     lyapunov.ucsd.edu, username "anonymous".
From: bevan@cs.man.ac.uk (Stephen J Bevan)
Newsgroups: comp.lang.misc
Subject: Re: Scientists as Programmers (was Re: Small Language Wanted)
Date: 29 Aug 92 18:15:07 GMT
Organization: Department of Computer Science, University of Manchester
In-reply-to: mbk@lyapunov.ucsd.edu's message of 29 Aug 92 06:46:11 GMT

In article <17n6fjINNhvt@network.ucsd.edu> mbk@lyapunov.ucsd.edu (Matt Kennel) writes:
   I have no idea what Mr Rubin really wants but here are a couple of 
   easy ones of the top of my head:

    P, D, Q <- singular_value_decomposition(A);

How about :-

(p,d,q) = singular_value_decomposition A


   Array index notation:

   for all i <= j: a(i,j) <- sum over (k) ( b(i,k)*c(j,N,k) )

I'm not _exactly_ sure what the above does (e.g. is N constant?), so
the following may be wrong (but it is better than my previous attempt
which I hopefully cancelled correctly :-)

foo b c = array bds vs
  where
    vs = [ (i,j) := f i j | (i,j) <- range bds, i <= j ]
    f i j = sum [ b!(i,k)*c!(j,n,k) | k <- range (klb,kub) ]
    bds = ((ilb,jlb),(iub,jub))
    ((ilb,klb),(iub,kub)) = bounds b
    ((jlb,_,_),(jub,n,_)) = bounds c

An alternative (and possibly more efficient) version of _vs_ is :-

  vs = [ (i,j) := f i j | i <- range (ilb,iub), j <- range (i,jub) ]

Note this is untested as I currently don't have a compiler installed.
As to the notation, I'll do you a deal: you explain the one you're
using and I'll explain the one I'm using :-)


   I won't bore you with the obvious complex numbers, exponentiation, etc.

Why not, you may be pleasantly suprised.

bevan
Newsgroups: comp.lang.misc
From: ah739@cleveland.Freenet.Edu (Leslie J. Somos)
Subject: Re: Indentation
Reply-To: ah739@cleveland.Freenet.Edu (Leslie J. Somos)
Organization: Case Western Reserve University, Cleveland, OH (USA)
Date: Thu, 27 Aug 92 20:18:10 GMT


In a previous article, rh@smds.com (Richard Harter) says:
[...stuff...]
>>In article <1992Aug18.065110.20337@smds.com> rh@ishmael.UUCP (Richard Harter) writes:
>>> One can argue that this freedom of decision is actually undesirable,
>>> that a language which eliminates irrelevant decisions is better.
>
>>Certainly. That's the whole point of higher level languages after all.
>
>Too general.  [This sentence no verb.]  One can distinguish between
>forcing a choice between essentially equivalent alternatives and the
>eliminating the alternatives altogether. 

Let's have some more choices than just 2.
"Anybody who says there are two sides to any question
suffers from a lack of imagination." -- ?

>                                          Let me give some examples.
>
>Consider the language FL (short for fascist layout). 
[...]

OK, I believe most people would agree that choices in program layout are
just fluff, unimportant (in languages that don't care).

[...]
>Now consider the language FVN (short for fascist variable names).
[...]

STOP RIGHT THERE.  I, for one, will not agree that choice of variable
names is not important.  Of course, the compiler doesn't care, about
names or layout, that's why obfuscating programs work.
But variable names are _very_ important to humans who must read
programs.



You can have all kinds of constraints on what a compiler will/won't
accept, or relax them all you want.  From a programmer's point of
view, the most important audience for a program is a programmer.
We don't care how hard it is for the compiler to handle it, we
would like to make it easy to understand a program that we have to
look at.

--
Leslie J. Somos    ah739@Cleveland.Freenet.Edu
From: hendrik@vedge.UUCP (Hendrik Boom)
Newsgroups: comp.lang.misc
Subject: ML/1 wanted
Date: 26 Aug 92 18:00:28 GMT
Organization: Visual Edge Software, St. Laurent, Quebec

I'm looking for an ancient macro processor, P.J. Brown's ML/1.
Macro processors have gone out of vogue during the 70's, and this
one (late 60's or early 70's) was one of the best when they were in
their heyday.  Can anyone find me a copy?  I used to have one,
but it's become lost over the years, and I especially cannot
find my copy of the documentation.  The one I had 20 years
ago was available via DECUS on the PDP-7, and machine-independent source
(in an esoteric notation) was also available.

-- 
-------------------------------------------------------
Try one or more of the following addresses to reply.
at work:	hendrik@vedge.com,  iros1!vedge!hendrik
at home:	uunet!altitude!ozrout!topoi!hendrik
Newsgroups: comp.lang.misc
From: oususalg@cs.montana.edu (Glassy)
Subject: Mutating Data Organization:  Practical?
Organization: Montana State University, Bozeman Montana USA
Date: Tue, 1 Sep 1992 14:26:43 GMT

A small idea yesterday:

Suppose the machine representation of one's data could transparently
mutate in response to the way one uses it.

For example, say I start out with a mythical data structure called a
'u-list' (universal list?).  I append a lot of data, one element at a
time, to it.  So at first I'd like the u-list simply to have a
singly-linked list representation in the machine.

Then for a while, I do a bunch of random accesses.  Now I'd like the
u-list to turn into an array.

Then I access the data with another (say, clumpy) pattern, like a[1],
a[21], a[2], a[22]... Now I'd like the data to somehow change its
organization to maximize locality of reference (wrt the specific
machine I'm on).

How often would the data's organization have to mutate?  Say, once
every few runs of the program.  Data on reference/use patterns would be
stored for each run, accumulated, analyzed, and possibly a new
organization applied every so often (e.g., once every 5 runs?).

Is this nuts?  Has it been done?  If so, in what contexts?

It may be tempting to reply:  well, just use a XYZ representation,
where XYZ is one of:
   skip-list, avl-tree, threaded-splay-tree, etc., etc.

but I think this misses the point.  (I think.)  There is no single
existing data structure that does *everything* well, i.e. use minimal
storage, and perform sequential access, random access, prepend, append,
arbitrary insertions, etc, all in constant order.  (at least, I haven't
run across such a data structure yet!)  so:  if my use of the data has
a pattern to it that changes (relatively) slowly over time (e.g.  over
a 5-run period), then having the data change its internal
representation to best suit what i seem to be doing with it *now*,
might make sense.

i mentioned that i'd like to do this mutation 'transparently', because
as a user of the data, i don't care what its internal representation
is, as long as i can efficiently monkey with the data right *now* :-).

thoughts?

-- 
Lou Glassy (oususalg@cs.montana.edu)                  C Delenda Est
Newsgroups: comp.lang.misc
From: stevef@bony1.bony.com (Steve Faiwiszewski)
Subject: Re: ACTOR
Organization: Lost in NYC
Date: Tue, 1 Sep 92 22:42:15 GMT

In article <1502@outland.UUCP> mike@adpgate.UUCP ( ADP OPuS) writes:
>in seeing a SIG for comp.lang.actor on the net?


There's an Actor mailing list.

To join the Actor mailing list send mail to actor-request@seq.uncwil.edu
To send a message to the Actor mailing list send to actor@seq.uncwil.edu

There's also a mail server for Actor files.  To quote:

From: spell@seq.uncwil.edu (Chris Spell)

Here is the basic instructions:

Send a message to:
	actor-mail-server@seq.uncwil.edu

Subject line doesn't matter.

The first line of the message should be:
	ACTOR

If you are on bitnet, then next line should be:
	PATH  username%host.bitnet@vxc.uncwil.edu

Now you can request anything you would like from the archives.
For instance, I would suggest that you get the INDEX file first.
The index file is just a "ls -lR" of the actor directories.  You
can do this by adding this line to the message:
	send INDEX

After all requests of the server, you should put this line:
	exit

The server gets confused when it sees something that it doesn't
understand.  It isn't very smart, but it works.

To recap:
Typical message:
	To: hp-mail-server@seq.uncwil.edu
	Subject: Doesn't matter, it's ignored

	ACTOR
	send INDEX
	send util/enhanc.zip
	exit

Oh, two more things.  If you want anything from a directory
under the main directory just precede the request by the
directory name as in the example above.  Also if you are
requesting a file from a compuserve account you will need to set
the limit to something under 50k.  Be sure you add the LIMIT
command before you reqest any files.  For example:
	LIMIT 40K

If you have anything to submit to the archives, please mail it
to me "spell@seq.uncwil.edu" or if you by chance have FTP then
put it in the actor/Uploads directory.

-----------------------------------------------------------------------------
Hope this helps



-- 
Internet: stevef@bony1.bony.com   |  ____________________________
bang : {uupsi,uunet}!bony1!stevef | / If cows could fly, everyone \
                                  ||| would carry an umbrella     ||
  Opinions? What opinions?        | \_____________________________/
From: mw@ki.fht-mannheim.de (Marc Wachowitz)
Newsgroups: comp.lang.misc
Subject: Re: Origin of "curried"
Date: 27 Aug 92 14:30:43 GMT
Organization: Fachhochschule fuer Technik Mannheim
X-Newsreader: Tin 1.1 PL4

banksd@hydra.rtp.dg.com wrote:
: The discussion of "dope vector"'s etymology reminds me -- what 
: is the origin of the obligatory "curried add" in lisp examples? 
: Have you ever encountered this sense of "curry" elsewhere?
Haskell B. Curry did quite a bit work in formal logic and lambda calculus, and
thus his name is used for the method to treat multi-parameter functions as
functions of one parameter yielding further functions.

E.g. instead of add x y = x + y  (assume "+" to be primitive here), you could
define          add x   = lambda y . x + y
and             add1    = add 1
by replacement  add1    = lambda y . 1 + y
etc.

-------------------------------------------------------------------------------
Marc Wachowitz, mw@gandalf.ki.fht-mannheim.de, 75742@novell1.rz.fht-mannheim.de
  *  wonder everyday    *    nothing in particular    *    all is special  *
From: cliff@cs.arizona.edu ("Cliff Hathaway")
Newsgroups: comp.lang.icon
Subject: Icon RBBS particulars
Date: 31 Aug 92 16:18:57 GMT
Distribution: inet
Organization: The Internet


Some folks have requested the particulars for connecting to the Icon 
electronic bulletin board.

Phone:  602-621-2283
Settings:  8N1 (8 bits, no parity, 1 stop bit)
	   1200 - 9600 baud

Downloads can be done via kermit, Xmodem or Ymodem.

We try to log in to the RBBS several times a week to check for messages,
but email to icon-project is a more reliable means of getting a prompt
reply from us.

We try to ensure that the RBBS is available as much as possible.  When we
do bring it down for maintenance, we do it during normal working hours for
us (0800 - 1700 Mountain Standard Time).


    Cliff Hathaway
    Dept. of Computer Science (602)621-4291
    University of Arizona     cliff@cs.arizona.edu 	        (internet) 
    Tucson, Ariz. 85721	      {cmcl2,noao,uunet}!arizona!cliff	(uucp)
From: Paul_Abrahams@MTS.CC.WAYNE.EDU
Newsgroups: comp.lang.icon
Subject: VEMD.386 for MS-DOS Icon
Date: 2 Sep 92 22:48:38 GMT
Distribution: inet
Organization: The Internet

Has anyone successfully used VEMD.386, the floating-point emulator that
comes with MS-DOS Icon Version 8.5, under Windows 3.1?  When I tried it,
the program hung and I could only break out by closing the window.  I
have no way of knowing whether the problem has to do with Windows or with
the peculiarities of my machine (a Gateway 386/33 Cache).
 
Paul Abrahams
From: TENAGLIA@mis.mcw.edu (Chris Tenaglia - 257-8765)
Newsgroups: comp.lang.icon
Subject: Sorting strings
Date: 2 Sep 92 14:55:07 GMT
Distribution: inet
Organization: Medical College of Wisconsin (Milwaukee, WI)

> From:	IN%"newross!dynastar!nr@princeton.edu"  2-SEP-1992 08:42:26.93
> To:	IN%"icon-group@cs.arizona.edu"
> Subj:	Icon question about sorting

> I have a set of strings that I want to sort.  I would like the case of
> letters to be ignored during sorting, but I don't want the results to
> come out all in one case.  The only thing I've been able to think of
> is ugly: make a new set of mapped strings, sort that, and then for
> each element of the original array find the position in the mapped
> list.  There must be a better way; what is it?

> -- 
> Norman Ramsey
> nr@princeton.edu

I've had this and the problem of wanting to sort on a key that was several
non-contiguous fields in the strings. Unfortunately, I had to use a brute
force method of forming a sort list with the sort keys prepended to the
front of each string in the list. I also wanted to be able to sort in reverse
order, so I had to convert those fields as I built the sort key with a
map(line,&cset,reverse(&cset)). Then comes the sort, and then you've got to
strip the keys off, leaving your sorted data. Well maybe you could define
the first n bytes of each line as a general purpose sort key, and ignore
it during other processing? That depends on whether the data is your file
or someone elses' I suppose. Depending on the OS, sometimes they have a SORT
utility. You'd write your data to a temp file, use the OS SORT with all the
magical options via a system() command, and then reload the sorted data.

Chris Tenaglia (System Manager) |  "The past explained,     
Medical College of Wisconsin    |   the future fortold, 
8701 W. Watertown Plank Rd.     |   the present largely appologized for."
Milwaukee, WI 53226             |   Organon to The Doctor
(414)257-8765                   |     
tenaglia@mis.mcw.edu
From: Paul_Abrahams@MTS.cc.Wayne.edu
Newsgroups: comp.lang.icon
Subject: Icon BBS
Date: 29 Aug 92 22:13:36 GMT
Article-I.D.: MTS.493113
Distribution: inet
Organization: The Internet

A small suggestion:  the information on the Icon BBS included in
the Icon Newsletter should include the available baud rates and
the required parity and stop bit settings.  (For now, perhaps you
could post that information as a response to this message.)
Thanks.
 
Paul Abrahams
From: nowlin@iwtqg.att.com
Newsgroups: comp.lang.icon
Subject: Re: sorting question
Date: 2 Sep 92 14:10:00 GMT
Distribution: inet
Organization: The Internet


 > I have a set of strings that I want to sort.  I would like the case of
 > letters to be ignored during sorting, but I don't want the results to
 > come out all in one case.  The only thing I've been able to think of
 > is ugly: make a new set of mapped strings, sort that, and then for
 > each element of the original array find the position in the mapped
 > list.  There must be a better way; what is it?
 > 
 > -- 
 > Norman Ramsey
 > nr@princeton.edu

Let Icon do that for you.  Tables were born for this kind of thing:

        procedure main()
                t := table()
                while s := read() do t[map(s)] := s
                every write((!sort(t))[2])
        end

This program reads strings, one per line from standard input, and prints
them back out in sorted order, ignoring case.  Just what you asked for as
far as I can tell.

Jerry Nowlin
From: ralph@CS.ARIZONA.EDU ("Ralph Griswold")
Newsgroups: comp.lang.icon
Subject: Re:  Icon compiler for DOS or SUN
Date: 27 Aug 92 12:58:01 GMT
Distribution: inet
Organization: The Internet

There are many public-domain implementations of Icon, including ones
for the platforms you want, available from cs.arizona.edu.  cd /icon
and get READ.ME.

If you need further information, let me know.
    
Ralph E. Griswold			ralph@cs.arizona.edu
Department of Computer Science 		 uunet!arizona!ralph
The University of Arizona		602-621-6609 (voice)
Tucson, AZ 85721			602-621-9618   (fax)
From: goer@MIDWAY.UCHICAGO.EDU ("Richard L. Goerwitz")
Newsgroups: comp.lang.icon
Subject: sorting
Date: 3 Sep 92 14:32:19 GMT
Distribution: inet
Organization: The Internet

Jan says:

	Wouldn't it be most convenient if Icon allowed the programmer to
	define his/her own compare-function used in the sort() procedure?

In general, one should (IMHO) be able to count on the various built-in
functions remaining static.  If somebody needs an exotic sort procedure,
it should be named something else.  It just makes for easier-to-read-and-
maintain code.  I personally detest working on code where somebody has
gone in and redefined built-ins!

Sorting is often usefully done in a case-insensitive manner, and I note
that you suggest using a keyword to turn on this behavior.  The problem
here is that you're using a side-effect that will confuse people merci-
lessly.  If you need a case-insensitive sort for certain things, it is
very easy just to create a procedure to do it yourself.  Jerry Nowlin's
posting a couple of days ago was a fine example of this.  By creating a
user-defined sort procedure, and naming it something other than "sort,"
you'll tip anyone who reads your code off that you're not doing a stan-
dard system sort.

If in fact a case-insensitive sort were added to Icon, I'd say it would
be better to do it as a different function (e.g. sorti).  Icon is big, and
its intrinsic namespace could easily become cluttered, though, so perhaps
the best idea would be to implement a new sort as a library procedure.

I haven't checked the IPL for a sort routine, but I'd guess that that
would be the very sort of thing the Icon Project would have included in
its distribution.  If one is not there, well, then if somebody writes one
that handles arbitrary types and structures the same way as the system
sort, I'd certainly think it would be good to post it here, and at the
same time send a copy to the Icon Project for possible inclusion in the
Icon Program Library distribution.



   -Richard L. Goerwitz              goer%midway@uchicago.bitnet
   goer@midway.uchicago.edu          rutgers!oddjob!ellis!goer
From: nr@cs.Princeton.EDU
Newsgroups: comp.lang.icon
Subject: Icon question about sorting
Date: 1 Sep 92 18:58:28 GMT
Organization: Princeton University, Dept. of Computer Science
Originator: nr@dynastar

I have a set of strings that I want to sort.  I would like the case of
letters to be ignored during sorting, but I don't want the results to
come out all in one case.  The only thing I've been able to think of
is ugly: make a new set of mapped strings, sort that, and then for
each element of the original array find the position in the mapped
list.  There must be a better way; what is it?

-- 
Norman Ramsey
nr@princeton.edu
From: gnik@dcs.glasgow.ac.uk (David King)
Newsgroups: comp.lang.icon
Subject: Denotational semantics for Icon?
Date: 2 Sep 92 13:23:03 GMT
Organization: Glasgow University Computing Science Dept.

Does anyone know if a formal semantics exists for Icon? If so could
you tell me where I could get hold of it.


Thanks very much

-- 
David  J.  King		 --------------------- 
Department of Computing Science		gnik@dcs.glasgow.ac.uk
University of Glasgow,  G12 8QQ		Phone:  (041) 339 8855
Newsgroups: comp.lang.icon
From: beede@sctc.com (Mike Beede)
Subject: Re: sorting
Organization: SCTC
Distribution: inet
Date: Fri, 4 Sep 1992 14:05:54 GMT

goer@MIDWAY.UCHICAGO.EDU ("Richard L. Goerwitz") writes:

>Sorting is often usefully done in a case-insensitive manner, and I note
>that you suggest using a keyword to turn on this behavior.

It's been several years since I used Icon, so I don't know whether
this is workable: can't you pass in the comparison function as an
argument?  This abstracts the sorting algorithm from the ordering
function, which seems to be Mom-and-Apple-Pie.  The procedure should
be called something other than ``sort'', unless ``sort'' with a single
parameter could use the default comparisons, and with two use the
user-supplied one.  

I agree completely that using a side-effect to control sorting
behavior would be extremely unfriendly.

-- 
Mike Beede         Secure Computing
beede@sctc.com     1210 W. County Rd E, Suite 100           
------------------ Arden Hills, MN  55112
                    (612) 482-7420