<rss xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" version="2.0">
  <channel>
    <title>MaplePrimes - comments on Post, Solving Sparse Linear Systems in Maple</title>
    <link>http://www.mapleprimes.com/posts/41191-Solving-Sparse-Linear-Systems-In-Maple</link>
    <language>en-us</language>
    <copyright>2026 Maplesoft, A Division of Waterloo Maple Inc.</copyright>
    <generator>Maplesoft Document System</generator>
    <lastBuildDate>Tue, 09 Jun 2026 14:14:56 GMT</lastBuildDate>
    <pubDate>Tue, 09 Jun 2026 14:14:56 GMT</pubDate>
    <itunes:subtitle />
    <itunes:summary />
    <description>The latest comments added to the Post, Solving Sparse Linear Systems in Maple</description>
    <image>
      <url>http://www.mapleprimes.com/images/mapleprimeswhite.jpg</url>
      <title>MaplePrimes - comments on Post, Solving Sparse Linear Systems in Maple</title>
      <link>http://www.mapleprimes.com/posts/41191-Solving-Sparse-Linear-Systems-In-Maple</link>
    </image>
    <item>
      <title>options for these sparse rational methods?</title>
      <link>http://www.mapleprimes.com/posts/41191-Solving-Sparse-Linear-Systems-In-Maple?ref=Feed:MaplePrimes:Solving Sparse Linear Systems in Maple:Comments#comment76570</link>
      <itunes:summary>
In the floating-point case, solving large sparse linear systems can be difficult. The existing solvers for such floating-point systems (hooked into LinearSolve) accept some options -- to control things like the choice of method, amount of fill-in, tolerances, etc. See ?IterativeSolver .

What sort of options do you expect that your rational solver implementation might need, if any?

ps. The documentation makes it appear that only symmetric/hermitian floating-point sparse systems can be solved with iterative methods. Yet trying it with real nonsymmetric float[8] sparse Matrices shows via userinfo that there are also distinct nonsymmetric solvers. All the sparse floating-point methods show NAG function names through userinfo, ie. with infolevel[LinearAlgebra] &gt; 0 .

acer</itunes:summary>
      <description>The latest comments added to the Post, Solving Sparse Linear Systems in Maple</description>
      <guid>76570</guid>
      <pubDate>Thu, 28 Jun 2007 16:45:26 Z</pubDate>
      <itunes:author>acer</itunes:author>
      <author>acer</author>
    </item>
    <item>
      <title>options for sparse rational methods</title>
      <link>http://www.mapleprimes.com/posts/41191-Solving-Sparse-Linear-Systems-In-Maple?ref=Feed:MaplePrimes:Solving Sparse Linear Systems in Maple:Comments#comment85357</link>
      <itunes:summary>I don't really want a bunch of options, but there are some magic numbers at the top of the file:
- the cutoff between SGE and Markowitz pivoting (30k rows or 12% dense)
- the cutoff between Markowitz and LAModular (95% dense)
- the size of the blocks in the Markowitz solver (n/3)
- the max number of heavy columns in SGE (4/3*sqrt(|A|))
- when to stop light block elimination in SGE (&amp;lt; sqrt(max_heavy) eliminated)
- number of light rows to recurse on in SGE (n-sqrt(n))

Right now I am trying to choose good defaults.  I think the SGE values work well, but the Markowitz block size seems insane.  It tries to solve n/3 equations in every step, and n/2 is often faster!  Now if multiple equations pivot on the same variable only one equation is selected and the others are not replaced, so as the system gets smaller there are more collisions and less equations are solved.  But still, this seems very counter-intuitive.  It's probably just a side effect of Maple's design, which always makes a copy when things are modified.

As for the NAG solvers, it's true that most iterative methods require a symmetric (and sometimes even positive-definite) matrix for efficiency and/or convergence.  Often there are modifications that can be made (like the &lt;a href="http://en.wikipedia.org/wiki/Biconjugate_gradient_method"&gt;biconjugate gradient method&lt;/a&gt; which slow the algorithm down but allow non-symmetric matrices to be solved.  Overall I am not that familiar with iterative methods, which is why I didn't try to implement one this time around.  If I have time or if there is demand for it I may try in the future.  There are some systems where I think it could really help.</itunes:summary>
      <description>The latest comments added to the Post, Solving Sparse Linear Systems in Maple</description>
      <guid>85357</guid>
      <pubDate>Thu, 28 Jun 2007 23:13:55 Z</pubDate>
      <itunes:author>roman_pearce</itunes:author>
      <author>roman_pearce</author>
    </item>
    <item>
      <title>Numeric sparse iterative solvers for nonsymmetric matrices</title>
      <link>http://www.mapleprimes.com/posts/41191-Solving-Sparse-Linear-Systems-In-Maple?ref=Feed:MaplePrimes:Solving Sparse Linear Systems in Maple:Comments#comment76560</link>
      <itunes:summary>acer writes:
&lt;blockquote&gt;
ps. The documentation makes it appear that only symmetric/hermitian floating-point sparse systems can be solved with iterative methods. Yet trying it with real nonsymmetric float[8] sparse Matrices shows via userinfo that there are also distinct nonsymmetric solvers. All the sparse floating-point methods show NAG function names through userinfo, ie. with infolevel[LinearAlgebra] &gt; 0 .
&lt;/blockquote&gt;

Yes, there is a conjugate-gradient-squared (CGS) method for nonsymmetric floating-point sparse linear systems.  Unfortunately, mention of this algorithm somehow got left out of the help pages but we'll try to remedy this in an upcoming release.  

Paulina Chin
Maplesoft</itunes:summary>
      <description>The latest comments added to the Post, Solving Sparse Linear Systems in Maple</description>
      <guid>76560</guid>
      <pubDate>Thu, 28 Jun 2007 23:49:03 Z</pubDate>
      <itunes:author>pchin</itunes:author>
      <author>pchin</author>
    </item>
    <item>
      <title>sparse LU</title>
      <link>http://www.mapleprimes.com/posts/41191-Solving-Sparse-Linear-Systems-In-Maple?ref=Feed:MaplePrimes:Solving Sparse Linear Systems in Maple:Comments#comment91582</link>
      <itunes:summary>Thanks for those details. Do you suspect that, even if you find reasonably good defaults for those magic numbers, some user-based control via options may be necessary for some problems to be solved?

Will there be some mechanism for repeated solving using different RHS's (but *not* all done at once)? I ask because depending on the method this can require saving the factorization or preconditioning.

There is also a real floating-point sparse direct solver available from LinearAlgebra[LinearSolve] with the method=SparseLU option.

The userinfo messages indicate that this uses NAG routine &lt;a href=http://www.nag.com/numeric/FL/manual/pdf/F01/f01brf.pdf&gt;f01brf &lt;/a&gt; to factorize and routine &lt;a href=http://www.nag.com/numeric/FL/manual/pdf/F04/f04axf.pdf&gt;f04axf&lt;/a&gt; to do the subsequent solving for a given RHS.

There is an indication that the NAG f01brf approach is based upon the somewhat well-known MA28 FORTRAN code. I don't have much experience with either SuperLU or MA48 (the successor to MA28?).

acer</itunes:summary>
      <description>The latest comments added to the Post, Solving Sparse Linear Systems in Maple</description>
      <guid>91582</guid>
      <pubDate>Fri, 29 Jun 2007 00:01:12 Z</pubDate>
      <itunes:author>acer</itunes:author>
      <author>acer</author>
    </item>
    <item>
      <title>sparse LU</title>
      <link>http://www.mapleprimes.com/posts/41191-Solving-Sparse-Linear-Systems-In-Maple?ref=Feed:MaplePrimes:Solving Sparse Linear Systems in Maple:Comments#comment91583</link>
      <itunes:summary>&lt;I&gt;Do you suspect that, even if you find reasonably good defaults for those magic numbers, some user-based control via options may be necessary for some problems to be solved?&lt;/I&gt;

No.  I will pick slightly conservative defaults, sacrificing some performance to guarantee that if the routines can solve the problem then they always do.  The current magic numbers are actually pretty good.  I'm hoping people will test a few systems and report back if there is a problem.

&lt;I&gt;Will there be some mechanism for repeated solving using different RHS's (but *not* all done at once)?&lt;/I&gt;

No, and this was a difficult decision.  The plan is to replace the code in solve, which solves linear systems with one right hand side.  I have made some optimizations for that case.  I wanted to focus on this one specific instance because:
1) the general problem of fixing sparse linear algebra is a megaproject
2) some people are skeptical of whether it can or should be done
3) it would be massively faster if we wrote it in C

Basically, I decided not to try to do too much.  I want to show the potential for solving these types of problems and provide a useful routine to attract support.  I know these computations are important, which is why I am even more concerned that they are done right if they are done at all.</itunes:summary>
      <description>The latest comments added to the Post, Solving Sparse Linear Systems in Maple</description>
      <guid>91583</guid>
      <pubDate>Fri, 29 Jun 2007 00:55:47 Z</pubDate>
      <itunes:author>roman_pearce</itunes:author>
      <author>roman_pearce</author>
    </item>
    <item>
      <title>Can you show how to use Maple's sparse solver for ...</title>
      <link>http://www.mapleprimes.com/posts/41191-Solving-Sparse-Linear-Systems-In-Maple?ref=Feed:MaplePrimes:Solving Sparse Linear Systems in Maple:Comments#comment200785</link>
      <itunes:summary>&lt;p&gt;&lt;a href="/posts/41191-Solving-Sparse-Linear-Systems-In-Maple#comment91582"&gt;@acer&lt;/a&gt;&amp;nbsp;&lt;/p&gt;
&lt;p&gt;Stiff ODE solvers (Rosenbrock) involve using the same coefficient matrix with different rhs. For example AX=b, followed by AX1=b1 (where b1 = linear function of b), etc. Simple LU deomposition will allow for one LU decomposition followed by multiple backsubstiution. Is it possible to do this with SparseLU or SparseDirect option?&lt;/p&gt;
&lt;p&gt;Thanks&lt;/p&gt;
&lt;p&gt;&amp;nbsp;&lt;/p&gt;</itunes:summary>
      <description>The latest comments added to the Post, Solving Sparse Linear Systems in Maple</description>
      <guid>200785</guid>
      <pubDate>Mon, 06 Jul 2015 01:50:37 Z</pubDate>
    </item>
  </channel>
</rss>