Hi Nils,
On 2017-09-15, Nils Bruin <nbr...@sfu.ca> wrote:
> How fast is converting your list of matrices to a list of lists in gap?
> Perhaps GapMatrix->GapList->SageList->SageMatrix is faster.
If I understand correctly, what libgap uses *are* lists. But apparently
gap treats lists of lists as matrices and multiplies them accordingly.
Here are some more details:
1. libgap takes 16 seconds to read the raw data, which comprise about
twenty matrices and some more simple data.
sage: %time libgap.Read("path/to/my/data.gap")
CPU times: user 15.9 s, sys: 64 ms, total: 16 s
Wall time: 16 s
sage: G = libgap.eval('basicalg')
sage: M1 = G['1a4a1']['mat']
sage: M2 = G['4a1a1']['mat']
2. The "matrices" are in fact lists of lists:
sage: M1.IsList()
true
sage: M2.IsList()
true
sage: M2[1].IsList()
true
3. libgap sucks in multiplying the matrices:
sage: %time M = M1*M2
CPU times: user 2min 58s, sys: 20 ms, total: 2min 58s
Wall time: 2min 58s
4. Sage sucks in transforming the lists of lists:
sage: %time L1 = M1.sage()
CPU times: user 6min 55s, sys: 52 ms, total: 6min 55s
Wall time: 6min 55s
sage: %time L2 = M2.sage()
CPU times: user 6min 31s, sys: 96 ms, total: 6min 31s
Wall time: 6min 32s
5. Sage could, I think, do better in transforming a list
of lists into a proper matrix:
sage: K.<a> = GF(8)
sage: %time MS1 = MatrixSpace(K,len(L1),len(L2))(L1)
CPU times: user 4.71 s, sys: 20 ms, total: 4.73 s
Wall time: 4.78 s
sage: %time MS2 = MatrixSpace(K,len(L2),len(L1))(L2)
CPU times: user 4.58 s, sys: 40 ms, total: 4.62 s
Wall time: 4.57 s
6. And here is why I want the transformation:
sage: %time MS = MS1*MS2
CPU times: user 48 ms, sys: 0 ns, total: 48 ms
Wall time: 106 ms
By the way, the matrices aren't particularly large:
sage: MS1.dimensions()
(896, 1984)
sage: MS2.dimensions()
(1984, 896)
Using boilerplate (accessing libgap finite field elements standing
in a list with libGAP_ELM_PLIST and make_GapElement_FiniteField,
only doing a transformation if the element is nonzero, using
set_unsafe to define the elements of the matrix in Sage), I can
transform the libgap list of lists into a Sage matrix in about
20 seconds - still longer than reading *all* data into libgap from
a long string (the data file has more than 2.7*10^6 lines and
204*10^6 characters)!
An ideal solution for me would be either of the following:
- A way to make libgap use a matrix implementation that is as fast
as Sage matrices and is certainly a lot faster than treating
matrices as lists of lists. I was told long ago that GAP has
faster matrix implementations, but I don't know how to invoke
them.
- A way to transform a list of lists as above from libgap into
a sage matrix in about 1 sec.
- A way to make a gap-readable file sage-readable and read it
into sage in less than 30 seconds; I can make the file sage-readable,
but sage_eval apparently is not appropriate to actually read it.
Best regards,
Simon
--
You received this message because you are subscribed to the Google Groups
"sage-support" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to sage-support+unsubscr...@googlegroups.com.
To post to this group, send email to sage-support@googlegroups.com.
Visit this group at https://groups.google.com/group/sage-support.
For more options, visit https://groups.google.com/d/optout.
