interface for numerical integration, roots etc


On Tue, 25 May 2010, John Lapeyre wrote:

< Hi,
< 
< I made a start on writing emulators for Mma NIntegrate
< and FindRoot. 
< 
< The code is at:
<  https://sourceforge.net/projects/ribot/files/
< 
< Since there has been interest in developing the interface in
< maxima proper, I thought it might be better to write a
< maxima interface and write an Mma-like wrapper, rather than
< the other way around.
< 
< One of the main issues is how to pass options (these functions
< take many options). It would be nice to have a uniform, flexible
< system. For instance in perl, {} constructs an anonymous hash,
< which can be used to pass options
<   foo( x,y,x, { OPT1 => 1, OPT2 => "cat" })
< 
< Mma uses  OptionA -> 1, which is a special syntax for
<  Rule(OptionA,1).  So I use a routine that filters these
< rules from an argument list and stores them in a hash.
< But, it's not clear that this is the best way to implement
< something like this for maxima (assuming people want to get
< away from a big pile of randomly named global variables and
< a flat list of FORTRAN inspired arguments). I do like groupimg
< iterator-like things as lists-- [x,a,b]. They are easier to read,
< offer a more flexible interface, and are easy to process.
< 
< As said, I'd rather find something for maxima and then put an Mma layer
< on it-- something that is not so much of an issue with
< Array,Table,Tuples, etc.  Maybe its enough to only change Rule to rule
< and FunctionName to function_name... Or maybe
<   options(op1,val1,opt2,val2,...)
< Using 'esprel=10-3 as in the maxima quadpack interface is tempting,
< but not as a general soution because they look like equations.
< Maybe options( 'opt1=val1, ...) (and I think there may be 
< a way to automatically quote all the LHS's ?)

Hi John, you might be confusing form and substance. Remember that =>
in Perl is just a fancy , operator implemented by the parser. You can
do similar things in Maxima:

infix("->");
"->"(a,b) ::= buildq([a:a,b:b],['a,b]); 

allows you to pass options like in Perl:

(%o104) f(x,[y]):=[x,y]
(%i105) f(x,u->v);

(%o105) [x,[[u,v]]]
(%i106) (u:1,t:2,v:3,f(x,u->v,t->w));

(%o106) [x,[[u,3],[t,w]]]

(you see that -> quotes the lhs, just like Perl's =>)

so the interface changes, but underneath ...

I would be interested in seeing a way to define a function that allows
you to specify the argument type, e.g.

f(x::integerp) := ...

as you can in Maple. This was discussed a while ago, but I don't know
what came of it.

My 2p.

Leo

< 
< Following are notes on the current NIntegrate and FindRoot, which is
< working fairly well. There is a large amount of documentation on
< the Mma functions online.  Notice that find_root , newton, romberg,
< and quadpack are somewhat unified by this interface. There are
< many more examples in tests/rtest_mixima.mac and
< tests/rtest_nintegrate.mac.
< 
< * NIntegrate
< 
<   This makes calls to the maxima quadpack and romberg routines.
<   Multiple integrals are implemented automatically as in Mma, but via nesting, which is slow.
<   Details of the call are different from Mma.  Here is an example call
< 
<   NIntegrate(sin(sin(x)),[x,0,2], Rule(Method,NewtonCotesRule),
<     Rule(MinRecursion,2),Rule(MaxRecursion,12),Rule(PrecisionGoal,10),Rule(AccuracyGoal,Infinity);
< 
<   Specifiying the Rules is optional.
<   Method   can be one of Automatic NewtonCotesRule=RombergRule QagsRule Oscillatory=GaussKronrodRule6
<    GaussKronrod=GaussKronrodRule=GaussKronrodRule1 
<    GaussKronrodRule2 GaussKronrodRule3 GaussKronrodRule4 GaussKronrodRule5
< 
<   Some rules are duplicated for deprecated Mma
<   options. Here, the Rule Oscillatory does not work with
<   infinite intervals, whereas in Mma 3.0 it *only* works
<   with infinite intervals
< 
<   The default Method is Automatic which makes a few tests to
<   choose a method: Eg, Infinite interval, singularity at endpoints.
<   It is a good start, but needs improvment.
< 
<   Other options are PrecisionGoal and AccuracyGoal. Options
<   MinRecursion and MaxRecursion are only used with
<   RombergRule method.  See examples in
<   tests/rtest_mixima_nintegrate.mac
< 
< 
< * FindRoot
< 
<   With two boundary points, the secant method in maxima find_root is used.
<   Examples:
<   FindRoot(sin(x) = x/2,[ x, 0.1, %pi]);
<   FindRoot(sin(x) - x/2,[ x, 0.1, %pi], Rule(PrecisionGoal,3), Rule(AccuracyGoal,10));
<   FindRoot(sin(x) - x/2,[ x, 0.1, %pi]);
< 
<   With one starting point, Newton's method is used (using a modified version of the
<   maxima function to include, for instance, a limit on the number of iterations).
<   Examples:
<   FindRoot(sin(x) = x/2,[ x, 1.0]);
<   FindRoot(sin(x) = x/2,[ x, 1.0],Rule(MaxIterations,10));
<   FindRoot(sin(x) - x/2,[ x, 1.0]);
< 
<   The options PrecisionGoal and AccuracyGoal are supported by the secant method.
<   The options AccuracyGoal and MaxIterations are supported by Newton's method.	
< 
<   Note that in Newton's method AccuracyGoal determines how close the function evaluation
<   must be to zero, not how close the variable will be to it's true value.
<   Eg, the default AccuracyGoal is 6, but
<   FindRoot(((Sin((x-10))-x)+10),[x,0]); gives 9.98318 .
<   I more sophisticated stopping criterion ought to be used.
< 
< 
< John
< _______________________________________________
< Maxima mailing list
< Maxima at math.utexas.edu
< http://www.math.utexas.edu/mailman/listinfo/maxima
< 
< 

-- 
The University of Edinburgh is a charitable body, registered in
Scotland, with registration number SC005336.