7

I've been using NSolve a moderate (50-100 equations) size system of linear equations and it has been working splendidly (Solve on the other hand is extremely slow) and I thought I'd look up the method it is using is there anyway to:

a) See which method Mathematica chooses to use for a particular set of equations?

b) See what are the available methods to NSolve. The documentation for NSolve doesn't show anything specific under Details and Options.

J. M.'s missing motivation
  • 124,525
  • 11
  • 401
  • 574
Jānis Šmits
  • 431
  • 3
  • 10
  • http://reference.wolfram.com/language/tutorial/SomeNotesOnInternalImplementation.html – Dr. belisarius Jan 16 '14 at 11:25
  • 1
    _ 
    Polynomial root finding is done based on the Jenkins-Traub algorithm.

For sparse linear systems, Solve and NSolve use several efficient numerical methods, mostly based on Gauss factoring with Markowitz products (approximately 250 pages of code).

For systems of algebraic equations, NSolve computes a numerical Gröbner basis using an efficient monomial ordering, then uses eigensystem methods to extract numerical roots._
    – Dr. belisarius Jan 16 '14 at 11:26
  • So if I understand correctly from "Solve and NSolve use several efficient numerical methods, mostly based on Gauss factoring with Markowitz products" - NSolve uses this in all cases concerning linear equations? Still why is NSolve so much quicker than just Solve if the method is essentialy the same. And is there a way to tell Mathematica to explicitly print the method it's using not just for NSolve but other functions where there is a variety of methods to choose from? – Jānis Šmits Jan 16 '14 at 11:30
  • Still why is NSolve so much quicker than just Solve numerical methods in general are faster than symbolic, but not as accurate, everything else being equal. – Nasser Jan 16 '14 at 12:46
  • I mean if Solve and NSolve essentialy use the same method "Gauss factroing with Markowitz products" why should the speed of the calculation differ. I'm ok with NSolve not being as accurate but that would imply that it takes a different approach to get the result. – Jānis Šmits Jan 16 '14 at 12:56
  • @JānisŠmits It might be nice to upvote Mark's answer, now that you have the rep. pts. to do so. (I assume since it is accepted that you think it's useful.) – Michael E2 Dec 29 '15 at 18:36
  • 1
    I upvoted it and so far I seem to be the only one to have done so. I know what prevents Mark McClure from upvoting it but not so sure what stops others... – Daniel Lichtblau Dec 29 '15 at 18:44

2 Answers2

8

To answer part b):

Here are some settings meth for Method -> meth for NSolve:

"EndomorphismMatrix"
"CompanionMatrix"
"Legacy"
"Aberth"
"JenkinsTraub"
"Homotopy"

I found them by searching on the site, and you can find various discussions of them by search for each one. This question, closely related to this one, also seems relevant:

What algorithms does NSolve use?

In addition, options can be passed via the Method option, in the from Method -> {subopt -> value,...}. These may be found this way:

Internal`NSolveOptions[]
(* V10 result:
  {"ComplexEquationMethod" -> Automatic, "MonomialOrder" -> Automatic, 
   "ReorderVariables" -> True, "SelectCriterion" -> (True &), 
   "Tolerance" -> 0, "UseSlicingHyperplanes" -> True}
*)
Michael E2
  • 235,386
  • 17
  • 334
  • 747
2

The basic algorithm might be the same yet the underlying data types are certainly different. Generally, plain old arithmetic with exact rationals is much slower than machine arithmetic with floating point approximations, particularly if the underlying integers grow larger than the largest machine integer on your system, which is 9223372036854775807 on my Mac. Here's an example where the only difference is the starting point, 1 vs 1.0:

Nest[1 + 1/# &, 1, 1000000]; // Timing
Nest[1 + 1/# &, 1.0, 1000000]; // Timing
(* Out:
  {4.714536, Null}

  {0.031917, Null}
*)
Mark McClure
  • 32,469
  • 3
  • 103
  • 161
  • 2
    You are of course right, I tried: Solve[N[equations],variables] and NSolve[equations, variables] and now they work equally quickly. Although I am still wondering how you can ask Mathematica which method it chooses to use if you don't tell it explicitly. – Jānis Šmits Jan 16 '14 at 16:30