roman_pearce

Mr. Roman Pearce

1688 Reputation

19 Badges

20 years, 75 days
CECM/SFU
Research Associate
Abbotsford, British Columbia, Canada

I am a research associate at Simon Fraser University and a member of the Computer Algebra Group at the CECM.

MaplePrimes Activity


These are replies submitted by roman_pearce

No, I want to convert all the coefficients of a polynomial to hfloats, similar to how evalf makes them software floats. Also, I wanted to find out how slow hfloats were compared to small integers.
You mean volume rendering like this? No, Maple does not have that. It would be very cool if it did though. At one point there was a Maple add-on called Nvizx which did high performance visualization, but the company seems to be gone.
You mean volume rendering like this? No, Maple does not have that. It would be very cool if it did though. At one point there was a Maple add-on called Nvizx which did high performance visualization, but the company seems to be gone.
No, I'd be interested if you can find one though. There are plenty of parallel numerical routines for linear algebra, finite element, simulation etc. For computer algebra systems, parallelism is mostly experimental. Some specialized software has parallel routines, for example, Trip or Piranha. Maple 14 should have parallel multiplication in expand, but due to all the overhead and Amdahl's law it's hard to get a large speedup from just that. Obviously there is a lot of work going on, etc.
The time command measures cpu cycles, so it is adding the cpu time of all processors. Use time[real]() instead to measure real time. You probably aren't going to get much of a speedup for something like adding. Also, the threads package in Maple 13 is not yet "mature" and there are still some performance problems to be addressed.
Your computer has multiple cpu cores. Programs must be explicitly designed to use more than one core at a time, i.e. multithreading. It's quite complicated. In Maple some operations can do this, but not many, and they generally have to be large computations. You can't parallelize something really fast, like adding 10 small integers. Here's an example of how make some linear algebra computations use multiple cores. In the future there will be more computations like this, and you won't have to do anything: http://www.mapleprimes.com/blog/dave-l/blas-in-maple#comment-7274 But for right now there is quite a lot of work to be done in adding parallel algorithms to Maple, and all other software for that matter.
I thought I would update this post with a few multiplication benchmarks. I used an Intel Core i7 920 2.66GHz with 6GB of ram running 64-bit Linux. Here is the Maple code for three problems tested below:
# 1771 x 1771 = 12341 terms
restart: f := expand((1+x+y+z)^20): g := f+1: time[real](expand(f*g));
# 5456 x 5456 = 39711 terms
restart: f := expand((1+x+y+z)^30): g := f+1: time[real](expand(f*g));
# 10626 x 10626 = 135751 terms
restart: f := expand((1+x+y+z+t)^20): g := f+1: time[real](expand(f*g));
And here are the benchmark results I have collected so far:
Fermat 3.9.9i     1.100    8.490   106.970
Pari 2.3.3        0.444    3.961    39.566
Singular 3-1-0    0.570    6.450    30.680
Magma V2.16-6     0.300    3.790    13.000
Trip 1.0.0        0.047    0.368     1.630
Maple 13          1.523   26.622    95.176
Maple 14          0.029    0.180     0.733
In the current Maple interface you specify the number of exponents per word, so 64-bits gets you higher degrees and/or fewer words per monomial. The monomials are not limited in size, but they do use a dense format. We assume that all variables could appear in all terms. In the data structure we are adding to the kernel the monomials are always one word long. Then 64-bits gives you higher degrees and more variables. It always uses grlex order and the variables are sorted in Maple's set order. The packing is fixed by the number of variables and the range is different for 32 and 64-bit machines. On a 64-bit machine a polynomial with 3 variables stores 4 exponents (the first is the total degree), 16 bits each, so the maximum total degree and the maximum degree in each variable is 65535. Beyond that the kernel won't use the structure. For a 32-bit machine this limit is 255, which is much more restrictive but still widely applicable.
All links will almost certainly work. That's a basic thing.
In general you can let n be the "real world" speedup of your parallel routine. Amdahl's law really hurts. In sequential programming you often think that a relatively cheap operation, like an extra linear pass through the data, doesn't matter. The focus is entirely on complexity. In parallel programming that's not good, because quite often you can't effectively parallelize operations that are linear time because of memory bottlenecks. So you need to avoid them altogether or you'll get killed by Amdahl's law.
Magma is generally the fastest system for integers, rationals, and finite fields. Singular should be fastest for rational function coefficients and non-commutative Groebner bases.
Magma is generally the fastest system for integers, rationals, and finite fields. Singular should be fastest for rational function coefficients and non-commutative Groebner bases.
The Groebner[Basis] command can choose the order of the variables like this:
G := Groebner[Basis](system, 'tord'):
You can also get lex order:
L := Groebner[Basis](system, 'tord', order=plex):
I wasn't willing to wait for that to finish, but if it does you could start factoring the system with
S := Groebner[Solve](L, tord):
You can watch the progress of Groebner algorithms by setting:
infolevel[Groebner] := 5:
You can also try using the RegularChains package. You can download Singular from here. There are tutorials on the website.
The Groebner[Basis] command can choose the order of the variables like this:
G := Groebner[Basis](system, 'tord'):
You can also get lex order:
L := Groebner[Basis](system, 'tord', order=plex):
I wasn't willing to wait for that to finish, but if it does you could start factoring the system with
S := Groebner[Solve](L, tord):
You can watch the progress of Groebner algorithms by setting:
infolevel[Groebner] := 5:
You can also try using the RegularChains package. You can download Singular from here. There are tutorials on the website.
Maple doesn't have the algorithms to cope with this type of system. It is positive dimensional (HilbertDimension=3) and not easy to factor or eliminate variables. You can compute a graded reverse lex Groebner basis using FGb, but little else. I suggest you try the Singular computer algebra system.
First 10 11 12 13 14 15 16 Last Page 12 of 39