2
$\begingroup$

I am trying to determine the nullspace of a large symbolic matrix. The single core evolution seems to take too long. I tried Parallelize[] on the commands LinearSolve[] and on NullSpace[] without success. I got messages like

NullSpace[M] cannot be parallelized; proceeding with sequential \ evaluation

Is there any way to parallise the computation of the Nullspace? My only idea is to slice the matrix like

Matrix[[1+k;;100+k,All]]

and then to compute the nullspace for each slice. Then calculate the intersection of the nullspaces as described here (maybe there is a more efficient way than to do this).

Any suggestion is highly appreciated.

$\endgroup$
8
  • $\begingroup$ I am pretty certain the performance of the built in algorithms are not easy improved. There may be a way to improve performance, depending on the structure of the matrix. Unfortunately you do not provide any information on that (other than large and symbolic). It would help if you can indicate how sparse the matrix is and whether there are many repeated sub-elements. $\endgroup$
    – Sander
    Commented Nov 10, 2014 at 9:30
  • $\begingroup$ It is not about improving built-in algorithm. The built-in algorithm works only sequentially. Therefore it is conceivable that applying Nullspace in parallel to slices and the intersecting them is faster than just one sequential computaiton. $\endgroup$
    – warsaga
    Commented Nov 10, 2014 at 14:34
  • $\begingroup$ There is a method posted here. Alternatively, find null spaces of certain submatrices and find the intersection of the result. $\endgroup$ Commented Nov 10, 2014 at 15:41
  • $\begingroup$ Do you know what the most efficient way to compute these intersections would be? $\endgroup$
    – warsaga
    Commented Nov 10, 2014 at 19:08
  • $\begingroup$ Be aware that NullSpace does use a multithreading algorithm (check MKL) which, in your case as you are using symbolic matrices, does indeed become sequential operation. You will continue to run into complications when paralellizing NullSpace; as it is already multi threaded so you are unlikely to avoid the conflicts you are introducing (in other words, the warning that NullSpace[M] cannot be parallelized has a specific meaning). You probably need to write your own NullSpace equivalent function if you need to go parallel to avoid that constraint. $\endgroup$
    – Sander
    Commented Nov 11, 2014 at 0:47

0

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.