HDTenEightyP/NetNews huggingface dataset:
From: klinich@ohstpy.mps.ohio-state.edu
Newsgroups: sci.math.symbolic
Subject: Maple V graphics on PC
Date: 30 Dec 92 16:06:20 EST
Organization: The Ohio State University, Department of Physics

Help!!
  I am running Maple V on a '386 PC and cannot figure out how to print true
graphics other other than just character graphics.  The version I have is A
site-licensed version from the university, and I'm sure that it is  a
full-blown version.  How do I do it? 
                                                Thanks in advance
                                                     George


Newsgroups: sci.math.symbolic
From: masa@nws.e-technik.tu-muenchen.de (Matthias Sauer		)
Subject: mathematica package for universal algebra
Organization: Leibniz-Rechenzentrum, Muenchen (Germany)
Date: Mon, 21 Dec 1992 09:12:15 GMT

Hello out there,

does anybody know if there is a mathematica package for stuff concerning
universal and relational algebra?


Matthias Sauer
Institiute for Network Theory and Circuit Design
TU Munich
e-mail: masa@nws.e-technik.tu-muenchen.de
Newsgroups: sci.math.symbolic
From: hibrown@vidar.albany.edu (Herb Brown)
Subject: Maple share library
Organization: State University of New York at Albany
Date: Mon, 21 Dec 92 19:12:45 GMT

In article <1992Dec21.144600.28799@math.toronto.edu> madore@math.toronto.edu (Blair F. Madore) writes:
>
>Off the top of my head I can't remember the ftp address for the share library,
>but I'm sure info@maplesoft.ont.ca would help you.
>
>Blair


The Maple Share Library sites are:

        129.132.101.33  neptune.inf.ethz.ch
        129.97.140.58   daisy.waterloo.edu
        192.16.184.250  canb.can.nl   /pub/maple-ftplib
        141.212.103.21  freebie.engin.umich.edu  /pub/maple


Herb


-- 
Herb Brown  Math Dept  The Univ at Albany  Albany, NY 12222  (518) 442-4640
Director,                                          hibrown@math.albany.edu  
Computer Assisted Instruction in Mathematics       hibrown@csc.albany.edu
--------------------------------------------------------------------------
From: fateman@peoplesparc.Berkeley.EDU (Richard Fateman)
Newsgroups: sci.math.symbolic
Subject: Computer Algebra languages slow (was:Re: "shut up and deal the cards")
Date: 25 Dec 1992 19:52:35 GMT
Organization: University of California, Berkeley
NNTP-Posting-Host: peoplesparc.berkeley.edu

In article <1992Dec25.001234.21234@u.washington.edu> petry@zermelo.math.washington.edu (David Petry) writes:
>I gather
>that good Mathematica programmers must learn a bunch of slick tricks to
>write reasonably efficient programs.  That bothers me.
>
>Does anyone have any comments?

In a type-less language, a construction such as x:=x+1  (or x++) has to be
fairly general.  For example, x may be a symbolic expression, and adding
1 to it may be fairly expensive.
Other expensive operations include comparison, arbitrary-precision 
integer or floating-point arithmetic, etc.  Even when these features are
not used, the interpreter has to be prepared to check this possibility.
(Some interpreters are, nevertheless, faster than others (e.g. compare
Maple to Mathematica -- Maple is, I suspect, much faster.  It also has
a much simpler evaluation mechanism.)

In any interpreter-language, there is an inherent disadvantage to programming
"in the small".  Some of this disadvantage can be overcome by using types
(at least sometimes) as is possible in Lisp, and compiling.

Some well-known languages, by making type
declarations required all the time, inhibit some kinds of expressiveness
(there may be arguments on this point), but that's my current opinion.

Another way around this is to promote (as in Mathematica), high-level
transactions that do type-checking once, and then use those types for
the remainder of the operation.  For example, creating a Table with
the index computation type-checked but once.  If there is a bad fit
between the provided high-level commands and the needs of the algorithm,
that's too bad.

Finding the good fit, if there is one, is what Mr. Petry calls a trick,
and it is inherent in Mathematica's approach to efficiency in the
user language.







-- 
Richard J. Fateman
fateman@cs.berkeley.edu   510 642-1879
From: fc03@ns1.cc.lehigh.edu (Frederick W. Chapman)
Newsgroups: sci.math.symbolic
Subject: Re: Maple V Release 2 (was Re: Derive)
Date: 23 Dec 92 15:04:52 GMT
Organization: Lehigh University

In article <1h7hvjINNm2e@tamsun.tamu.edu>, bryan@kolsky.tamu.edu
(Bryan Milligan) writes:
>In article <1992Dec21.143617.28533@math.toronto.edu>  
>madore@math.toronto.edu (Blair F. Madore) writes:
>> MathCAD is a great product that was primarily numerical at first.
>> Now it has some good symbolics. If you're primarily interested in
>> symbolics
>> of course it's not the package for you. But many average users
>> with minimal symbolic requirements will find MathCAD the tool of choice.
>
>	I found it to be too slow on user input.  (Type, type,type,
>wait for the characters to appear on the screen. Repeat.)  I also found
>their upgrade policies a little expensive.  If you have minimal
>symbolic requirments, use Derive.

If you have minimal symbolic requirements and a 386 or 486 PC, use the
Student Edition of Maple -- at $99, only half the price of Derive!  If
you later need to upgrade to a full-blown symbolic computation
package, you won't have to relearn everything.  :-)

-- 
 
o ------------------------------------------------------------------------- o
|  Frederick W. Chapman, User Services, Computing Center, Lehigh University |
|    Campus Phone:  8-3218     Preferred E-mail Address:  fc03@Lehigh.Edu   | 
o ------------------------------------------------------------------------- o
| The day after the day after tomorrow is the last day before the rest of   |
| our country's future a week from the day before the day before yesterday! |
Newsgroups: sci.math.symbolic
From: Richard J. Gaylord <gaylord@ux1.cso.uiuc.edu>
Subject: all intersections of a list of sets
X-Xxdate: Wed, 30 Dec 92 18:59:49 GMT
X-Useragent: Nuntius v1.1.1d13
Organization: University of Illinois
Date: Thu, 31 Dec 1992 00:59:04 GMT
X-Xxmessage-Id: <A767A2250F02164B@gaylord.slip.uiuc.edu>

ulf wostner asked me how to return all of the intersections of a list of
sets.

eg., 

AllIntersections[{{a,b,c},{b,c,d},{c,d,e}}]
{{c}, {b, c}, {c, d}, {a, b, c}, {b, c, d}, {c, d, e}}

he and i are surprised that Outer[Intersection, sets, sets] doesn't work
at all {in fact, i can't figure out what its doing or why}.

anyway, i made up a nested anonymous function kind of thing to do it. 

AllIntersections[set_] :=
Union[Flatten[Map[(Map[Function[y, Intersection[#,y]], set])&,set], 1]] 

AllIntersections[{{a,b,c},{b,c,d},{c,d,e}}]
{{c}, {b, c}, {c, d}, {a, b, c}, {b, c, d}, {c, d, e}}

its functional but pretty near unreadable, even to me 5 minutes after i
wrote it [anyone who says functional code is more readable than
procedural code clearly hasn't read alot of anonymous function code].

there ought to be a better yet still functional way. any suggestions?
Newsgroups: sci.math.symbolic
From: Richard J. Gaylord <gaylord@ux1.cso.uiuc.edu>
Subject: how to randomize the elements in a list?
X-Xxdate: Thu, 24 Dec 92 09:38:24 GMT
X-Useragent: Nuntius v1.1.1d13
Organization: University of Illinois
Date: Thu, 24 Dec 1992 15:32:41 GMT
X-Xxmessage-Id: <A75F35906F019B12@mm-mac18.mse.uiuc.edu>

i want to randomize the elements in a list. 

i use  'a sample without replacement' function:

a program that randomly selects r numbers from the list Range[n],
removing each number from the list as it is selected.

cardDealing[n_, r_] := 
  NestList[Delete[#,
        Random[Integer,{1,Length[#]}]]&,Range[n],r]


SeedRandom[0]

cardDealing[10, 10]
{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 
 {1, 2, 3, 4, 5, 6, 8, 9, 10},
 {1, 2, 3, 4, 5, 8, 9, 10}, 
 {1, 2, 3, 4, 8, 9, 10}, 
 {1, 2, 3, 4, 9, 10}, 
 {1, 3, 4, 9, 10}, 
 {1, 4, 9, 10},
 {1, 4, 10}, 
 {1, 10}, 
 {1}, {}}

it clear in this example, that the randomized list is
{7,6,5,8,2,3,9,4,10,1}. the question is how to get this answer. i have a 
way which is shown below 

SeedRandom[0]

Flatten[Map[Apply[Complement,#]&,Partition[NestList[Delete[#,
        Random[Integer,{1,Length[#]}]]&,Range[10],10],2,1]]]

{7, 6, 5, 8, 2, 3, 9, 4, 10, 1}

basically i use Partition[cardDeal, 2, 1] to create pairs of succesive
elements from the cardDealing list  and then use Map[Apply[Complement,#]&
to determine what element has been removed in successive lists.

can someone come up with a one-liner which does this more directly? i
should be able to just keep track of what i'm taking from the list rather
than what's left in the list each time i select but i can't figure out
how to do that in either in a one-liner or without an AppendTo [dreaded
assignment] statement kind of thing.

anyway, any alternative code in any style for doing this would be worth
looking at.

perhaps santa will leave the answer for christmas.
From: petry@zermelo.math.washington.edu (David Petry)
Newsgroups: sci.math.symbolic
Subject: Re: "shut up and deal the cards"
Date: 30 Dec 1992 23:28:58 GMT
Organization: University of Washington, Mathematics, Seattle
NNTP-Posting-Host: zermelo.math.washington.edu



[we're comparing the following programs]

>Transpose[Sort[Transpose[{Table[Random[],{Length[lis]}], lis}]]][[2]]


>randomize[L_] := Module[{a,b,k,p=L}, 
>			For[k=Length[L],k>1,k--,
>				b=Random[Integer,{1,k}];
>				a=p[[k]];
>				p[[k]]=p[[b]];
>				p[[b]]=a];
>			p]


In article <Bzv5LK.969@news.cso.uiuc.edu> gaylord@ux1.cso.uiuc.edu (Richard J. Gaylord) writes:
>
>  ...         i found David's procedural program very difficult to
>decipher (i had to spend time figuring out all of the assignment
>satements) 

The assignment statements are a standard method for swapping the elements
of a list.  For clarity, I should have written a separate procedure
called "swap" to do that.

>            while i was able to write my functional program in a  direct
>way by simply implementing what i wanted to do with the entire list using
> built-in functions 

Likewise, I was able to write my program in a direct way, while I had some
difficulty deciphering Mr. Gaylord's.  All that shows is that it is 
relatively easy to transform an idea into a program, but a little harder
to read a program and figure out its underlying idea.

>many people may not find 'functional' thinking to be obvious to do but
>that's primarily  because they haven't learned how to do it 

Well, it seems that this whole issue came up because it wasn't obvious
how to use functional programming to randomize the order of elements
in a list.  In afterthought it may be obvious.


>...    functional programming does appear to be a trick to the person
>unfamiliar with it

One point I was trying to make is that the program can be written
procedurely in a very straightforward manner using very simple assignment
statements which virtually any programming language has.  In contrast,
the functional program requires intimate knowledge of complex functions,
and seems to use them in peculiar ways.  

How many people out there know how the Mathematica function "Sort" behaves 
on a nested list like {{1,4},{5,1},{3,2}} ?  Why doesn't it return
{{1,4}, {1,5}, {2,3}} ?

Why should a matrix operation like "Transpose" appear in a function that 
randomizes the order of elements in a list?

In this particular case, the issue of time complexity of programs doesn't 
really arise, since the procedural program is O(n) while the functional
program is O(n log(n)), but in many instances the functional program
can be much much worse than the procedural program.

Is there any theory behind Mathematica which says that its functions are
in some sense 'complete' or 'orthogonal' ?  It seems to me that if you 
insist on functional programming, then you are limited by the functions
available to you.




David Petry


Newsgroups: sci.math.symbolic
From: kuwata@triples.math.mcgill.ca (Masato Kuwata)
Subject: "factor" in Maple V
Organization: /etc/organization
Distribution: USA
Date: Tue, 29 Dec 1992 18:04:30 GMT

Could someone tell what's wrong with this?

    |\^/|      MAPLE V
._|\|   |/|_.  Copyright (c) 1981-1990 by the University of Waterloo.
 \  MAPLE  /   All rights reserved.  MAPLE is a registered trademark of
 <____ ____>   Waterloo Maple Software.
      |        Type ? for help.
> P:=193439*t^2  - 74110*t^3  - 223858*t^4  - 74110*t^5  + 193439*t^6  + 197465*t^7  + 51743*t^8 + 197465*t + 51743;
>                  2          3           4          5           6           7
    P := 193439 t  - 74110 t  - 223858 t  - 74110 t  + 193439 t  + 197465 t

                  8
         + 51743 t  + 197465 t + 51743

_____________________________________________________________________________
> factor(P);
Error, (in factor/combfact) modp1: invalid arguments to function Degree 
_____________________________________________________________________________

Thanks in advance.

Masato Kuwata

Newsgroups: sci.math.symbolic
From: madore@math.toronto.edu (Blair F. Madore)
Subject: Re: Maple V Release 2 (was Re: Derive)
Organization: Department of Mathematics, University of Toronto
Date: Mon, 21 Dec 92 14:36:17 GMT

In article <1gjahlINNn9s@access.usask.ca> jake@skatter.usask.ca writes:
>
>According to a recent post by a WMS employee, about 80 Maple routines of
>over 2000 have been licensed by the MathCad folks.  Whoever they are.
>

this is a somewhat deceptive statement. MathCAD now has some serious 
symbolic capabilities. Just the ability to enter, manipulate and use
symbolic equations is a huge step.
Those abilites are not recognized when people say/imply that ONLY 80
out of 2000 routines are available.

MathCAD is a great product that was primarily numerical at first.
Now it has some good symbolics. If you're primarily interested in symbolics
of course it's not the package for you. But many average users
with minimal symbolic requirements will find MathCAD the tool of choice.

Blair Madore
madore@math.utoronto.ca

Newsgroups: sci.math.symbolic
From: phr@telebit.com (Paul Rubin)
Subject: Re: Bug: Mma thinks Sqrt[3] is rational
Organization: Telebit Corporation; Sunnyvale, CA, USA
Distribution: usa
Date: Sun, 3 Jan 1993 08:46:37 GMT

Check your Mathematica manual.  0.5 is not the same as 1/2,
and 0.75 is not the same as 3/4.
From: jaffer@zurich.ai.mit.edu (Aubrey Jaffer)
Newsgroups: sci.math.symbolic
Subject: jacal1a0 computer algebra system available.
Date: 24 Dec 92 16:18:14 GMT
Organization: M.I.T. Artificial Intelligence Lab.

My first try didn't seem to make it; sorry for the repost.
======================================================================
This message announces the availability of JACAL release jacal1a0.

JACAL is a symbolic mathematics system for the simplification and
manipulation of equations and single and multiple valued algebraic
expressions constructed of numbers, variables, radicals, and algebraic
functions, differential, and holonomic functions.  In addition,
vectors and matrices of the above objects are included.

JACAL is written in Scheme.  A version of Scheme (IEEE P1178 and R4RS
compliant) written in C is available with JACAL.  SCM runs on Amiga,
Atari-ST, MacOS, MS-DOS, OS/2, NOS/VE, VMS, Unix and similar systems.

JACAL source is available via FTP (detailed instructions follow) from:
altdorf.ai.mit.edu:archive/scm/jacal1a0.tar.Z (or later revision).

SLIB is a portable scheme library which JACAL requires:
altdorf.ai.mit.edu:archive/scm/slib1c3.tar.Z

SCM is a small Scheme implementation under which JACAL will run.
altdorf.ai.mit.edu:archive/scm/scm4a15.tar.Z

  ftp altdorf.ai.mit.edu [18.43.0.246] (anonymous)
  bin
  cd archive/scm
  get jacal1a0.tar.Z
  get slib1c3.tar.Z
  get scm4a15.tar.Z

`jacal1a0.tar.Z' is a compressed tar file of the JACAL Scheme code.
`slib1c3.tar.Z' is a compressed tar file of a Scheme Library.
`scm4a15.tar.Z' is a compressed tar file of the C code distribution.

Remember to use binary mode when transferring the files.
Be sure to get and read the GNU General Public License (COPYING).
It is included in scm4a15.tar.Z and jacal1a0.tar.Z.
Newsgroups: sci.math.symbolic
From: Richard J. Gaylord <gaylord@ux1.cso.uiuc.edu>
Subject: "shut up and deal the cards"
X-Xxdate: Thu, 24 Dec 92 14:46:58 GMT
X-Useragent: Nuntius v1.1.1d13
Organization: University of Illinois
Date: Thu, 24 Dec 1992 20:46:01 GMT
X-Xxmessage-Id: <A75F7DE25301164B@gaylord.slip.uiuc.edu>

i figured out a way to deal a bridge hand that's more than three times
faster than the  version i posted a littel while ago.. 

deck = Flatten[Outer[List,{c,d,h,s},Join[Range[2,10],{J,Q,K,A}]],1];

SeedRandom[2]
Timing[Partition[Transpose[Sort[Transpose[{Table[Random[],{52}],
deck}]]][[2]],13];]
{0.166667 Second, Null}

SeedRandom[2]
 Timing[Partition[Map[#[[2]]&,
Sort[Array[{Random[],#}&,52]]]/.Thread[Range[52]->deck],13];]
{0.516667 Second, Null}

=================

the speed comes (i think) because i directly create the list
{...{Random[], card}...} and use Transpose rather than a replacement rule
(once again reaffirming the efficiency of functional programming.)

good night to all and to all, a good night.
Newsgroups: sci.math.symbolic
From: Richard J. Gaylord <gaylord@ux1.cso.uiuc.edu>
Subject: Re: "shut up and deal the cards"
X-Xxdate: Wed, 30 Dec 92 18:53:15 GMT
X-Useragent: Nuntius v1.1.1d13
Organization: University of Illinois
Date: Thu, 31 Dec 1992 00:52:31 GMT
X-Xxmessage-Id: <A767A09BA501164B@gaylord.slip.uiuc.edu>

Subject: Re: "shut up and deal the cards"
From: David Petry, petry@zermelo.math.washington.edu
Date: 30 Dec 1992 23:28:58 GMT
In article <1htbbqINNdli@shelley.u.washington.edu> David Petry,
petry@zermelo.math.washington.edu writes:

 It seems to me that if you 
>insist on functional programming, then you are limited by the functions
>available to you.

==================

no. that's what anonymous functions are for. see the message i am posting
called "all intersections of a list of sets" to see anonymous functions
used (and possibly abused).
Newsgroups: sci.math.symbolic
Subject: Re: how to randomize the elements in a list?
From: a_rubin@dsg4.dse.beckman.com (Arthur Rubin)
Date: 24 Dec 92 16:27:09 GMT
Organization: Beckman Instruments, Inc.

In <BzrsII.7vu@news.cso.uiuc.edu> Richard J. Gaylord <gaylord@ux1.cso.uiuc.edu> writes:

>i want to randomize the elements in a list. 

>i use  'a sample without replacement' function:

>a program that randomly selects r numbers from the list Range[n],
>removing each number from the list as it is selected.

>cardDealing[n_, r_] := 
>  NestList[Delete[#,
>        Random[Integer,{1,Length[#]}]]&,Range[n],r]

cardDeal[n_, r_] := 
  First /@ Rest[NestList[RotateLeft[Rest[#1], 
       Random[Integer, {1, Length[#1] - 1}]] & , Range[0, n], r]]


--
Arthur L. Rubin: a_rubin@dsg4.dse.beckman.com (work) Beckman Instruments/Brea
216-5888@mcimail.com 70707.453@compuserve.com arthur@pnet01.cts.com (personal)
My opinions are my own, and do not represent those of my employer.
My interaction with our news system is unstable; please mail anything important.
Newsgroups: sci.math.symbolic
From: Richard J. Gaylord <gaylord@ux1.cso.uiuc.edu>
Subject: Re: how to randomize the elements in a list?
X-Xxdate: Thu, 24 Dec 92 13:55:13 GMT
X-Useragent: Nuntius v1.1.1d13
Organization: University of Illinois
Date: Thu, 24 Dec 1992 19:54:19 GMT
X-Xxmessage-Id: <A75F71C19201164B@gaylord.slip.uiuc.edu>

gaylord@ux1.cso.uiuc.edu (Richard J. Gaylord)

thanks to all the santas out there.

Hal Varian pointed out that the standard package
DiscreteMath/Permutations.m contains the following definition:

RandomPermutation[n_Integer?Positive] :=
        Block[{t},
                t = Array[{Random[], #} &, n];
                t = Sort[t];
                Map[ #[[2]] &, t ]
        ]

this is really clever [those wri guys ain't too shoddy] since it uses the
built-in Random function which is quite fast.

functionalizing this (so as not to offent my aethetic sensibilities), we
can write

randomPermutations[n_] := Map[#[[2]]&,Sort[Array[{Random[],#}&, n]]]

an alternative to using Array is, of course, to use Table

Map[#[[2]]&,Sort[Table[{Random[],i},{i,n}]]]


there seems to be a small (miniscule) speed advantage to Table over Array

SeedRandom[0]
Timing[Map[#[[2]]&,Sort[Array[{Random[],#}&,5000]]];]
{21.3167 Second, Null}

SeedRandom[0]
Timing[Map[#[[2]]&,Sort[Table[{Random[],i},{i,5000}]]];]
{20.8333 Second, Null}

=============================

what i really want to do is shuffle with a deck of cards which i created
using 

deck = Flatten[Outer[List,{c,d,h,s}, Join[Range[2,10],{J,Q,K,A}]],1]
{{c, 2}, {c, 3}, {c, 4}, {c, 5}, {c, 6}, {c, 7}, {c, 8}, {c, 9}, {c, 10},
{c, J}, 
 {c, Q}, {c, K}, {c, A}, {d, 2}, {d, 3}, {d, 4}, {d, 5}, {d, 6}, {d, 7},
{d, 8}, 
 {d, 9}, {d, 10}, {d, J}, {d, Q}, {d, K}, {d, A}, {h, 2}, {h, 3}, {h, 4},
{h, 5}, 
 {h, 6}, {h, 7}, {h, 8}, {h, 9}, {h, 10}, {h, J}, {h, Q}, {h, K}, {h, A},
{s, 2}, 
 {s, 3}, {s, 4}, {s, 5}, {s, 6}, {s, 7}, {s, 8}, {s, 9}, {s, 10}, {s, J},
{s, Q},
 {s, K}, {s, A}}

so, i think the fastest way to create a random deck of cards is to use:

shuffledDeck = Map[#[[2]]&,Sort[Array[{Random[],#}&,
52]]]/.Thread[Range[52]->deck]

{{s, 10}, {d, 10}, {c, 9}, {s, 3}, {c, Q}, {h, 10}, {s, 8}, 
 {c, 6}, {h, 2}, {h, 3}, {d, 9}, {d, K}, {d, Q}, {c, A}, 
 {h, 9}, {h, K}, {d, 8}, {d, 7}, {d, 6}, {c, J}, {h, J}, 
 {s, 6}, {d, A}, {h, A}, {s, 9}, {h, 7}, {s, Q}, {c, 10}, 
 {d, J}, {d, 3}, {c, 8}, {h, 5}, {s, 5}, {c, 5}, {d, 5}, 
 {c, 2}, {d, 2}, {c, 7}, {c, 3}, {s, J}, {s, 7}, {h, 4}, 
 {c, 4}, {d, 4}, {s, K}, {s, 4}, {h, 6}, {s, 2}, {s, A}, 
 {h, 8}, {h, Q}, {c, K}}

=======================

what really started this was thinking about dealing out a bridge hand and
realizing that rather than shuffling the cards and  dealing them out in
the usual way, it was better to simply randomize the deck and then use

Partition[shuffledDeck, 13]

this is pretty neat too; perhaps not as neat as a christmas eve pardon
[talk about playing santa], but still pleasing. too bad i don't know how
to play bridge.
Newsgroups: sci.math.symbolic
From: dhw@plex-1.ann-arbor.mi.us (David West)
Subject: Re: "shut up and deal the cards"
Organization: Plex-1, Michigan's Public Access Usenet Gateway  (Ann Arbor).
Date: Sun, 27 Dec 1992 17:53:26 GMT

In article <Bzv5LK.969@news.cso.uiuc.edu> Richard J. Gaylord <gaylord@ux1.cso.uiuc.edu> writes:
>and one has to select the site with the lowest random number
>(eg., the most vulnerable cell). 
>
>the way i finally did it was to sort the list {..{Random[], {a,b}..} and
>take the second part of the first element in the sorted list. 
[...]
>i was able to write my functional program in a  direct
>way by simply implementing what i wanted to do with the entire list using
> built-in functions (one key to functional programming is to deal with a
>list as a single data object without unnecessarily deconstructing it) 

Does this mean that heaps are awkward to implement in Mathematica?  They 
should give an O(N) speed improvement over sorting the whole list.

-David West
From: mstankus@oba.ucsd.edu (Mark Stankus)
Newsgroups: sci.math.symbolic
Subject: Max[Sqrt[2],Sqrt[3]]=>Sqrt[3] program
Date: 3 Jan 93 21:58:49 GMT
Distribution: usa
Organization: Mathematics @ UCSD

There was some talk a while ago about a program to compute 
the maximum of two exact numerical expressions and return
the largest. It combined Max[],N[] and something else. Could
someone send me the solution?

Thanks,
Mark Stankus
-- 
mstankus
mstankus@oba 
Newsgroups: sci.math.symbolic
From: TOBIAS@cip.physik.uni-stuttgart.de ()
Subject: Q:Simplification of algebraic expressions ?
Organization: CIP-Pool Physics Dept, University of Stuttgart, FRG
Date: Tue, 22 Dec 1992 08:09:43 GMT
X-News-Reader: VMS NEWS 1.24

I am looking for references of any sort (source, articles, books)
concerning the (automatic) simplification of algeb. objects.
I`ve nothing found in the typical "computer algebra" books.

There is always said: " .. is done by pattern matching ..."

Nice. But i think it isn`t as simple.

(Supose (3*x + 6)^5  Expand  ... and now how to do a simple pat.match.?)

Thanks in advance. Tobias.