The method=float should be OK, as it should call externally if it can. The code shows that,

kernelopts(opaquemodules=false):
showstat(LinearAlgebra:-LA_Main:-`Determinant/float`);

Now, it sounds like Maple is creating too many copies of your data, along the way. Let's see how to cut that down.

Don't create your Matrix with storage=sparse, because there is only compiled C external fast routine for non-sparse storage (eg, full rectangular). So for a sparse storage Matrix Maple is going to copy it to full rectangular anyway.

And as Alec say, create it with datatype=float[8]. So that's one or two copies removed.

Each copy of a 6000x6000 float[8] Matrix will take about 36*8 MB of memory to store.

Now, Maple usually has to create at least one copy of your Matrix, so that it can do an LU decomposition on that in-place. It makes a copy so that it doesn't have to overwrite your own original data. So, it could take about 600MB or allocated memory to get the job done if you were simply to call Determinant() on a float[8] rectangular storage 6000x6000 Matrix. It sounds to me as if your machine has enough memory for that.

The rest is just for fun, in case you want to halve the memory requirement further.

If the original Matrix data is not important to you then you can do the steps yourself and act in-place on your original. That would save a copy. And the total memory use should then only be about 300MB or so. The tricky thing about doing it this way is to get the sign of the scalar result correct. Here's some code that does it on a random Matrix,

> N:= 6000;
                                   N := 6000

> with(LinearAlgebra):

> M := RandomMatrix(N,generator=-0.1..0.1,density=0.05,
>                   outputoptions=[datatype=float[8]]):
> for i from 1 to N do M[i,i]:=1.0: end do:

> # for testing only
> #origM := copy(M);
> #Digits:=trunc(evalhf(Digits)):Determinant(origM);

> P,M := LUDecomposition(M,inplace=true,output=['NAG']):

> d := proc(M::Matrix,n)
> local i,res;
>   res := 1.0:
>   for i from 1 to n do
>     res := res*M[i,i];
>   end do;
> end proc:

> evalhf(d(M,N));
                              9.68585766336265408
 
> quit
memory used=277.3MB, alloc=276.8MB, time=62.88

As I mentioned, getting the sign correct need a little more work. It can be done by walking through the permutation Vector P created above. I don't have time at the moment to figure out code for that, but someone may find it an amusing exercise. It's in the format of parameter IPIV of CLAPACK routine dgetrf.

Can anyone think of a way to get the determinant efficiently from sparse float[8] Matrix by doing a LinearSolve? I mention it because there is a sparse linear solver, whose use would not require copying to full rectangular storage.

acer

You may want to contact support@maplesoft.com

Without seeing the actual code it's difficult to tell whether it is exiting due to some limit near 500MB, or whether it is sitting at 500MB and failing to further allocate memory way past 2GB for some new rtable object. I would guess the latter, but without seeing the code cannot tell how it maybe made to work.

You might also consider uploadind your code to this site using the green up-arrow to access the site's FileManager.

acer