HDTenEightyP/NetNews huggingface dataset:
From: katherle@daisy.uwaterloo.ca (Kate Atherley)
Subject: Re: MAPLE: Reading list of points from external file
Organization: University of Waterloo
Distribution: sci
Date: Tue, 17 Nov 1992 17:14:40 GMT

In article <1e93eeINNj59@pith.uoregon.edu> joe@decoy.uoregon.edu (Joe St Sauver) writes:
>In article  
><ROSE.92Nov10172623@t524i5.telematik.informatik.uni-karlsruhe.de>  
>rose@t524i5.telematik.informatik.uni-karlsruhe.de (Ortwin Rose) writes:
>> 
>> I have a list of points generated by another program, and would
>> like to create a three-dimensional plot of the surface using
>> MAPLE. Now, I did NOT find a solution to read these points from
>> an external file into a list of points that can be used by
>> "plots[pointplot]" within MAPLE! Since this is quite an easy
>> task, I am quite sure that such a solution does exists. Any
>> pointers how to proceed are appreciated!
>
>Ortwin,
>
>I am currently confronting a comparable problem -- I have a user with
>huge matrices which he needs to manipulate. 
:
>But, after extensively searching the new Springer Verlag Maple V 
>manual set, let me refer you to section 11.8.5 in the Maple V
>Language Reference Manual:
>
>   "It is not possible in the present version of Maple to read
>   arbitrarily formatted data [from a text file]."  (pp. 191)
>
>That, to me, was just inconceivable, particularly for a package
>which goes to some extreme to justify claims that it is a 
>"programming language." To me, anything which cannot read data 
>from a file in some relatively common format (i.e., free format, 
>comma delimited format, fixed format or SOMETHING other than 
>Maple-specific statement format) is NOT a programming language.

I posted in response to the original user's questions, stating
that there is a function, surfdata, in the Maple Share Library, 
available by anonymous ftp, that does exactly what the user wants 
to do.

It is true that Maple V cannot read data files, without
some massaging of the file into valid Maple statements.
However, our latest release, Maple V Release 2 has addressed this
problem, with the addition of the functions readline and sscanf.

Kate
Waterloo Maple Software Technical Support
support@maplesoft.on.ca
Newsgroups: sci.math.symbolic
From: knapp@spot.Colorado.EDU (David Knapp)
Subject: Availability of Quantum Mechanics packages for Mma?
Keywords: CAS
Organization: University of Colorado, Boulder
Date: Sun, 15 Nov 1992 23:42:26 GMT


Hello,

I was wondering if any of you would know if there exists packages for mma
especially for QM calculations.   By specific I mean containing definitions
of spinors, standard hamiltonian for SHO etc.

Does such a thing exist? I've not seen an FAQ here which has that info.


-- 
David Knapp                                   University of Colorado, Boulder
Perpetual Student                                 knapp@spot.colorado.edu
Looks like hate *is* a family value after all and Colorado families are for it.
From: gjc@mitech.com (George J. Carrette)
Newsgroups: sci.math.symbolic
Subject: Re: Serious Programming (was: Re: MAPLE resources reccomendation)
Date: 18 Nov 92 11:39:12 GMT
Organization: Mitech Corporation, Concord MA

In article <1992Nov17.232239.9748@access.usask.ca>, jake@skatter.usask.ca writes:
> Having recently discovered (?) and read with some interest Mr. Fateman's
> review of the Mathematica system, and now this particular comment, I begin
> to wonder if any system, anywhere in whatever stage of development, can
> be said to embody a syntax of which Mr. Fateman would be a "fan".

> This is not intended to abuse Mr. Fateman.

If you mean to impose upon Fateman the following burden you describe as:

> I ... would like to see him state exactly what ... before ...

Then you would indeed be abusing him or -anyone- on which you would
seek to impose that kind of burden, before you are willing to consider
their opinions further.

Of no particular burden to Mr. Fateman would be to investigate
what systems he has been involved in -building- and to analyze his comments
in light of those experiences. Of course, that puts the burden on -you-,
but at that point you can take your best shots.


-gjc
Newsgroups: sci.math.symbolic
From: saj31052@uxa.cso.uiuc.edu (Scotty A Johnson)
Subject: MAPLE resources reccomendation
Organization: University of Illinois at Urbana
Date: Mon, 16 Nov 1992 22:19:08 GMT

I am considerig getting MAPLEV, but on my campus Mathematica
dominates, so there are no places where I can really try it out
to get a "feel" for it.

So, I would like to find a good book which details the environment
and the syntax, etc. for using Maple.

A quick reference sheet or card would ALMOST do it, if I also
had a list of all of the standard libraries, etc.

I understand that Maple is more powerful than Mathematica.
Is this true?

Also, I am used to using MACSYMA from a class I had a couple years
ago.  Is Maple similar to this?  I found MACSYMA to be very well
done, and simpler to use than Mathematica.

Thanks,

  Scotty AJ
-- 

------------------------------------------------------------------------------
Scotty A. Johnson     "The beast with the four foot tail."     Iguana@uiuc.edu
------------------------------------------------------------------------------
Newsgroups: sci.math.symbolic
From: schreine@risc.uni-linz.ac.at (Wolfgang Schreiner)
Subject: Re: Multiprocessor Implementations of Symbolic Software?
Organization: RISC-Linz, Johannes Kepler University, Linz, Austria
Date: Tue, 17 Nov 1992 08:38:32 GMT

In article <1992Nov12.042527.10730@colorado.edu>, sherod@newton.Colorado.EDU 
(Scott Herod) writes:
> Are there multiprocessor implimentations of any of the larger 
> symbolic software packages?  It seems that this is the wave of
> future esp. since many of these packages stress functional as
> opposed to procedural programming.
> 
> Scott Herod
 
We developed a parallel programming interface PACLIB for the 
computer algebra package SACLIB which is a library of C
functions that supports in particular polynomial arithmetic.
PACLIB is built on top of the uSystem kernel of the 
University of Waterloo that provides light-weight concurrency 
under UNIX.

PACLIB is based on C and supports the following features:

* light-weight concurrency based on a functional model (in C)
* non-determinism and speculative parallelism
* functional streams and shared buffers
* parallel garbage collection

A compiler for a functional language into PACLIB-C is 
currently under development.

The PACLIB package runs on a Sequent Symmetry shared memory
computers with 20 processors under Dynix/ptx but it should be
portable to any UNIX machine supported by the uSystem package.

A user manual for PACLIB can be derived via anonymous ftp 
from melmac.risc.uni-linz.ac.at (140.78.140.60) in form of
a compressed dvi file pub/reports/parlab/pacuser.dvi.Z.

Best regards, WS

-- 
--------------------------------------------------------
Wolfgang Schreiner
Research Institute for Symbolic Computation (RISC-Linz)
Johannes Kepler University, A-4040 Linz, Austria
Tel: +43 7236 3231 66  Fax: +43 7236 3231 30
Email: schreine@risc.uni-linz.ac.at
--------------------------------------------------------
Newsgroups: sci.math.symbolic
From: withoff@mosquito.wri.com (David Withoff)
Subject: Re: The Real Meaning of Efficiency?  (Re: Serious Programming, etc.)
Organization: Wolfram Research, Inc.
Date: Thu, 19 Nov 1992 20:32:02 GMT

In article <1eghvuINNi6i@crcnis1.unl.edu> me@ienext.unl.edu writes:
>In article <18NOV199217533011@reg.triumf.ca> orwell@reg.triumf.ca (BALDEN,  
>RON) writes:
>> What is important to me is the
>> total time spent formulating and solving a problem.  
>> 
>(More sensible remarks deleted)
>
>I agree with you completely.
>This is because the programs I write are generally one-shot affairs---I  
>run them once and then they are history. In most other cases when the  
>program *is* used repeatedly it executes quickly enough that I don't  
>really care whether it can be made to run even faster. In any case, the  
>time I spend programming in typically much greater than the time the  
>computer spends executing my code. 

I usually stay out of religious discussions, but the above reminded me
of a time several years ago when I was bragging to a friend about a
trick I had found that saved several microseconds in execution of a
Z80 assembly language program.  My friends response: "How many
microseconds did it take you to come up with this idea?"

Dave Withoff
From: mstankus@oba.ucsd.edu (Mark Stankus)
Newsgroups: sci.math.symbolic
Subject: Inequalities posting: Errors.m
Date: 20 Nov 92 19:33:41 GMT
Organization: Mathematics @ UCSD

(* The following package allows an abort to be executed.
   An example of its usage would be
   
      foo defintitions here
           ...
      foo[x___] := BadCall["foo",x];

*)
(* :Title: 	Errors // Mathematica 1.2 and 2.0 *)

(* :Author: 	Mark Stankus (mstankus). *)

(* :Context: 	Errors` *)

(* :Summary:
*)

(* :Alias:
*)

(* :Warnings: 
*)

(* :History: 
*)
BeginPackage["Errors`"];

Clear[BadCall];

BadCall::usage = 
    "BadCall[string,rest] reports an error message \
     indicating that the routine with name \
     given by string was called incorrectly and rest \
     is the nonheaded list of parameters sent to that routine. \
     BadCall records the erroneous arguments. See \
     WhatAreBadArgs. BadCall then makes the aggresive move \
     of calling Abort[]!";

Clear[WhatAreBadArgs];

WhatAreBadArgs::usage = 
     "WhatAreBadArgs[] returns the error list of the \
      most recent call to BadCall. See BadCall.";

Begin["`Private`"];

BadCall[name_String,param___] := Block[{},
    Print["Severe error from :-( ",name];
    ErrorArgs = List[param];
    Print["The parameters are (as a list)",Short[ErrorArgs,3]];
    Print["Bad argument can be retrieved by a call to WhatAreBadArgs"];
    Print["\n\n Here is the stack:\n\n\n"];
    Print[Shallow[Stack[_],{2,4}]];
    Abort[];
];

BadCall[___] := Block[{},
      Print["If you see this message, send a message to ncalg and"];
      Print["tell us that we have a bad call error."];
      Abort[];
];
      
WhatAreBadArgs[] := ErrorArgs;

End[];
EndPackage[]
-- 
mstankus
mstankus@oba 
Newsgroups: sci.math.symbolic
From: katherle@daisy.uwaterloo.ca (Kate Atherley)
Subject: Re: MAPLE resources reccomendation
Organization: University of Waterloo
Date: Tue, 17 Nov 1992 17:23:09 GMT

In article <Bxtxzy.CJD@news.cso.uiuc.edu> saj31052@uxa.cso.uiuc.edu (Scotty A Johnson) writes:
>I am considerig getting MAPLEV, but on my campus Mathematica
>dominates, so there are no places where I can really try it out
>to get a "feel" for it.
>
>So, I would like to find a good book which details the environment
>and the syntax, etc. for using Maple.
>
>A quick reference sheet or card would ALMOST do it, if I also
>had a list of all of the standard libraries, etc.

You will probably find the three Maple manuals of interest, in
particular, the First Leaves Tutorial Introduction to Maple.
All three books (the tutorial, the Library Reference Manual
and the Language Reference Manual) are available through 
Springer-Verlag (1-800-SPRINGER).

There are also some introductory Maple documents available
from our Share Library.   For more information, please
contact info@maplesoft.on.ca .  We do have information about
other books available.

Kate
Waterloo Maple Software Technical Support
support@maplesoft.on.ca


Newsgroups: sci.math.symbolic
From: PEARCES@UK.AC.BHAM.IBM3090
Subject: Eliminating zeroes from multi-valued expressions in MAPLE
Date: Mon, 16 Nov 1992 19:48:18 GMT
Organization: The University of Birmingham, United Kingdom

I`m a MAPLE user with a big problem.
The following expression has
zeroes at phi_d := {.9807315053, 2.160861149}.

            162265091            2    446229  1/2
   (223 (- ----------- sin(phi_d)  + --------)
               4000                     11

                162265091            2    7689337  1/2
      + 100 (- ----------- sin(phi_d)  + ---------)   )
                   4000                      85

      ^ 2
Does anyone know how to find the function left after
eliminating each pole. My MAPLE procedure fails to work properly
even if I only wish to evaluate the value of the expression at each
pole when the pole has been removed. Simple dividing the expression
by an (phi_d-0.98073...) and taking the limit of the resultant expression
as phi_d approaches 0.98703.... Doesn`t work in MAPLE either.
Please Help.
Yours with thanks.
Stephen Pearce.
Newsgroups: sci.math.symbolic
From: ethanb@ptolemy.astro.washington.edu (Ethan Bradford)
Subject: Making the transition to universal CAS access (was Re: Teaching CS to science students)
To: siegman@EE.Stanford.EDU (Anthony E. Siegman)
Organization: U. of Washington
	<1992Nov20.183648.4441@alchemy.chem.utoronto.ca>
	<By6311.8FC@helios.physics.utoronto.ca>
	<1992Nov23.180716.1740@EE.Stanford.EDU>
Date: Mon, 23 Nov 1992 22:30:49 GMT

When I started college, calculators were forbidden from tests because
it was unfair that only a few students had them.  By the time I was
done, almost everybody had one and they were universally allowed.  Now
students are not learning tricks to simplify arithmetic and the
calculation of transcendental functions (like logarithms) because it
is much easier to enter the raw numbers into their calculators.

The analogous thing is in the process of happening with symbolic
algebra systems and algebra.  Is it a bad thing?  Probably not.  While
the transition is being made there will be a problem of fairness and
convenience, but it will pass.

-- Ethan
Newsgroups: sci.math.symbolic
From: Richard J. Gaylord <gaylord@ux1.cso.uiuc.edu>
Subject: Re: MAPLE resources reccomendation
X-Xxdate: Tue, 17 Nov 92 05:04:11 GMT
X-Useragent: Nuntius v1.1.1d12
Organization: University of Illinois
Date: Tue, 17 Nov 1992 11:02:29 GMT
X-Xxmessage-Id: <A72E2DCB57029B19@mm-mac25.mse.uiuc.edu>

Date: Mon, 16 Nov 1992 23:09:14 GMT
In article <ETHANB.92Nov16150914@ptolemy.astro.washington.edu> Ethan
Bradford, ethanb@ptolemy.astro.washington.edu writes:
>In article <Bxtxzy.CJD@news.cso.uiuc.edu> saj31052@uxa.cso.uiuc.edu
(Scotty A 
>Johnson) writes:

>According to my experience, Maple is somewhat more powerful in just
>about every way.  Mathematica's only advantages are in pattern
>matching .............
>
........... I don't know why Wolfram
>decided to invent a new mathematical syntax for Mathematica; I found
>it very inconvenient when I was a Mathematica user.

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

this comment indicates a basic lack of understanding of the mathematica
programming  language.  there are MAJOR differences in the languages of
mathematica and maple (and macsyma). mathematica not only has  pattern
matching (which can be very important) but it has many more built-in
functions for functional style programming. 

other miscellaneous points:  what about  mathematica's graphics or its
notebook front end? 

the basic question iswhat do you want out of your cas? if you are going
to do serious programming,  mathematica  is totally in front of the
others.
From: ethanb@ptolemy.astro.washington.edu (Ethan Bradford)
Newsgroups: sci.math.symbolic
Subject: Re: MAPLE resources reccomendation
Date: 16 Nov 92 23:09:14 GMT
Article-I.D.: ptolemy.ETHANB.92Nov16150914
Organization: U. of Washington
To: saj31052@uxa.cso.uiuc.edu (Scotty A Johnson)

In article <Bxtxzy.CJD@news.cso.uiuc.edu> saj31052@uxa.cso.uiuc.edu (Scotty A Johnson) writes:

   I understand that Maple is more powerful than Mathematica.
   Is this true?

According to my experience, Maple is somewhat more powerful in just
about every way.  Mathematica's only advantages are in pattern
matching and in having a seperate compute server and user interface
(so that you can have an interface on your PC to Mathematica running
on a mainframe, or (even if they both run on the same machine) so that
you can type while a big computation is being done.

   Also, I am used to using MACSYMA from a class I had a couple years
   ago.  Is Maple similar to this?  I found MACSYMA to be very well
   done, and simpler to use than Mathematica.

Maple syntax is very similar to Macsyma.  I don't know why Wolfram
decided to invent a new mathematical syntax for Mathematica; I found
it very inconvenient when I was a Mathematica user.
From: gaylord@ux1.cso.uiuc.edu (Richard J. Gaylord)
Newsgroups: sci.math.symbolic
Subject: Rootterdam Competition in Mathematica Journal
Date: 16 Nov 92 17:05:08 GMT
Article-I.D.: news.BxtJGM.472
Organization: University of Illinois
X-Xxdate: Mon, 16 Nov 92 11:06:44 GMT
X-Useragent: Nuntius v1.1.1d12
X-Xxmessage-Id: <A72D314486049B16@mm-mac22.mse.uiuc.edu>

in the latest issue of the Mathematica Journal, the results of the
programming competition at the Boston and the Rotterdam Mathematica
meetings were reported.

I've already expressed in this group my (self) righteous indignation over
the  choice  for most elegant program in Boston of a  pattern-matched
function over the clearly aesthetically superior as well as faster
functional program so i'll only discuss  the 'split' function program
from Rotterdam. split takes two lists, the first of which is an arbitrary
list and the second of which is a list of non-negative integers whose sum
is the length of the first list.

The function works like this:

split[{a,b,c,d,e,f,g},{2,0,3,1,1}]
{{a,b},{},{c,d,e},{f},{g}}

clearly, the second list tells you how to 'split up' the first list.

the winner of the contest for elegance was:

splitElegant[lis_,parts_] :=
    Take[lis,#]& /@
       Rest[FoldList[#[[2]]+{1,#2}&,{0,0},parts]]

the winner of the contest for efficiency was:

splitFast[list_,parts_] := 
     Block[{accumulation = FoldList[Plus,0,parts]},
       Inner[Take[list,{#1,#2}]&,
           Drop[accumulation,-1]+1,
           Rest[accumulation],
           List]]     

It was reported in the article that splitFast is 50% faster than
splitElegant. I tested this:

parts = Table[Random[Integer,{0,5}],{500}]; 

parts/.List->Plus
1255

lis = Table[Random[Integer,{1,10}], {parts/.List->Plus}];

Length[lis]
1255

Timing[splitElegant[lis,parts];]
{2.05 Second, Null}

Timing[splitFast[lis,parts];]
{1.35 Second, Null}

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

the first point i want to raise is that splitElegant is really not that 
elegant if elegant also means it should be readable. 
[ how long it took you to figure out what the anonymous function #[[2]]
+{1,#2}& does?]

i have come up with an alternative program which slightly faster than 
splitFast and is  more elegant than splitElegant {my dog darwin concurs
with this judgement and he's incredibly picky about his code} :


split[lis_, parts_] := 
 Map[Take[lis, #]&, 
  Drop[Thread[List[# + 1, RotateLeft[#]]]& [FoldList[Plus,0,parts]], -1] ]

Timing[split[lis,parts];]
{1.28333 Second, Null}


the nice thing about the split function given here is that it follows a
prime directive of functional programming:

"never disassemble a list and then reassemble the list". 


as an aside: in order to increase speed i used Thread[List[a,b]] rather
than the somewhat slower Transpose[{a,b}] .  mathematically oriented
people may find that using Transpose  increases the elegance of the
program further. 

i don't suppose they're accepting any late entrie to theRotterdam
Confereence contest?
Newsgroups: sci.math.symbolic
From: mroussel@alchemy.chem.utoronto.ca (Marc Roussel)
Subject: Space efficiency (Was: The Real Meaning of Efficiency?)
Organization: Department of Chemistry, University of Toronto
Date: Fri, 20 Nov 1992 05:13:51 GMT

     Others have rightly pointed out that a concept of time efficiency that
does not include the programmer's time is inadequate in a modern
research environment.  Unfortunately, almost everyone seems to have
ignored space efficiency in designing their symbolic algebra libraries.  I
spent several frustrating hours yesterday trying to do a tricky
calculation with Maple on a busy machine, all because the size of the
computation kept growing beyond available resources.  (We have 128MB of
memory, of which about 30MB was available during this session.  I did
eventually manage to run my job by changing my approach to the problem,
but the relatively trivial computation I was engaged in should have fit
in 30MB.  The library routines involved were obviously written by someone from
the "RAM is cheap" school of thought.)  What I and, I'm sure, many
other scientists could really use is the ability to tell a symbolic
algebra program whether to trade time for space or vice-versa.  Quite
often, making some sort of compromise is the only way to get the
calculation through the machine.  I'm perfectly willing to compromise on
turn-around time if it's the difference between successfully completing
a calculation and staring at yet another "Object too large" message.
     I do know about FORM.  One of these days, I'll have to take a good
hard look at it.  My preliminary impression (based on inspecting the
manual) is that the type of computations which I most commonly carry
out are not naturally expressed in FORM's language.
     I would be interested to hear whether the major players (the Symbolic
Computation Group, Wolfram Research, the vendors of various Macsyma variants,
etc.) worry much about space efficiency when they are creating new
library code.  I get the impression that the answer is no, at least for
Maple and Mathematica.

				Marc R. Roussel
                                mroussel@alchemy.chem.utoronto.ca
Newsgroups: sci.math.symbolic
From: steve@ramsey.cs.laurentian.ca (Stephen R. Czapor)
Subject: Re: Maple V Release 2
Keywords: Maple V Release 2 Groebner
Organization: Dept. of Computer Science, Laurentian University, Sudbury, ON
Date: Sat, 21 Nov 1992 21:41:27 GMT

In article <1992Nov19.123922.7991@alf.uib.no> stromme@mi.uib.no (Stein Arild Stromme) writes:
>What about the grobner package? Is nothing new here? Still no other
>term orders than tdeg and plex? Please, Maple!
> 
>Stein 

Unfortunately, nothing new (other than bug fixes) made it into
the Groebner basis package this time.  I have written some code for
a number of additions, including:
	- choice of finite field coefficients
	- other choices of term orderings
	- faster computation of lexicographic bases through
	  a non-standard selection strategy
	- basis conversion (e.g. total degree to lexicographic)
	- computation of matrices X, Y, R such that
	     X F = gbasis(F),  Y gbasis(F) = F,  R gbasis(F) = 0
However, as a "part-time developer" with other responsibilities,
installation of new code has taken a back seat.

This is not to say that these additions will not be made soon.
As things are completed, they will likely be installed in the
share library (until appearing in the next release).

I should also add that, apart from bug reports, I have heard
_relatively_ few requests for extensions to the grobner package.
This is changing, as more people actually start to use it.
Could you (and any other interested parties) post your "wish-
list", so that we can establish some development priorities ?
(In particular, what specifically would you like to see re-
garding options for term orderings ?)

----------------------------------------------------------------------
Stephen R. Czapor (steve@ramsey.cs.laurentian.ca)
Dept. of Mathematics & Computer Science
Laurentian University, Sudbury, Ontario, Canada
Newsgroups: sci.math.symbolic