Mr. Roman Pearce

## 1683 Reputation

19 years, 263 days
CECM/SFU
Research Associate

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

That's a bug

## expand...

Expand them out and test whether the difference is zero:

`f := (x^2+6*x+9)*(x-4);`
`g := (x+3)*(x^2-x-12);`
`expand(f-g);  # is zero`
`evalb(expand(f-g)=0);  # true or false`

## multicore algorithms...

http://www.mapleprimes.com/questions/37931-Using-Maple-On-Multiprocessor-Systems

Since this post a few more algorithms in Maple have been parallelized, but there is still a lot to do.

Upgrading a machine more than two years old generally doesn't make sense unless you can get the parts for free or nearly so.  A \$500 desktop will have a quad core processor, 8 GB of memory, and a fast video card.  It will be more than 10x faster, whereas any upgrades you do are unlikely to increase the speed of the machine by more than 30%.  Furthermore, other parts in computers, such as the hard drive and power supply, become unreliable after 5 years.  It's better to just get a new machine.

That being said, memory is the thing to get for old computers.  2GB of memory would be good.  The best way to do it is to find and cannibalize another old machine.

Another thing to consider is that faster machines also get bogged down by large Maple plots with many points.  This is a software problem.  In principle it is not unrealistic to plot hundreds of thousands of points smoothly on a Pentium II, and your machine could handle millions.  It can be done with fast software.  Perhaps Maple doesn't scale.

## recursive dense polynomials...

I hope I got this right.  You want to write a polynomial as recursive vectors of coefficients with respect to the variables.  This format is called "recursive dense".  Maple actually has a whole package for computing with these things.  You may like this:

`with(Algebraic:-RecursiveDensePolynomials);`
`f := randpoly([x,y,z]);`
`F := rpoly(f, [x,y,z]);  # prints nicely`
`op(F);  # see what is stored`
`op(2,F);  # is this what you want?`
`mulrpoly(F,F);  # compute`

## post code...

One thread per iteration doesn't make sense, as the result would be needed immediately for the next iteration.

What kind of polynomials?  In Maple 14 polynomial multiplication is multithreaded, so there could be a speedup if the polynomials are large.  Post your code and I'll try it on my Core i5.

Not any ideal, but ideals in a polynomial ring can be handled by the PolynomialIdeals package, which uses Groebner bases.

## Student packages...

The standard commands in Maple are intended to be used as industrial tools, so they aren't going to help you do anything other than check your answer.  Maple has some excellent Student packages for tutoring, so that is what you want.

Open up the Maple interface, and under the "Tools" menu take a look at "Tutors".  For example, under "Calculus - Single Variable" there is "Integration Methods" and it will give you some integrals (or you can type one in) and you can experiment with various rules. The system can also offer you hints, but you should avoid those unless you're really stuck.

## Groebner basis...

`sys := {y = z1 + z2^2, z1 = z2 + 3*exp(u), z2 = 2*u3*z1}:`
`sys := subs(exp(u)=expu, map(lhs-rhs,sys)):`
`with(Groebner):   # make polynomials`
`vars := [SuggestVariableOrder(sys)];`
`elim := {z1,z2}:  # try to get rid of these`
`tord := lexdeg(selectremove(member, vars, elim));`
`gb := Groebner[Basis](sys, tord);`
`subs(expu=exp(u), gb);`

This is not exactly "model reduction", as the Groebner basis will typically be larger, but it will eliminate variables. You can solve the first polynomial for the variable of lowest degree.  In this case it is degree 1 in y, but you may not be so lucky in general.

## Windows 32 and 64 bit icons conflict...

It looks like you're running the 32-bit version of Maple.  If you install both the 32 and 64-bit versions of Maple, the shortcuts may conflict.  Try uninstalling all Maples and then installing the 64-bit version only.  Alternatively, find the 64-bit version of Maple and make a shortcut to that.

## series and convert/polynom...

with(Statistics):

RV := 'RandomVariable(Geometric(1/3))+1':

R := `\$`('RV', 5):

RV := Statistics:-RandomVariable(Geometric(1/3)) + 1:

Q4 := 1/(alpha*R[1]+alpha^2*R[2]+alpha^3*R[3]+(1-alpha-alpha^2-alpha^3)*R[4]):

Q4t := convert(series(Q4, alpha, 5), polynom):

M := CodeTools:-Usage(Moment(Q4t, 1)):

Not that I can see, however why not make an empty document with just the header and then open that each time.  If you make it "read only" in the operating system you will be forced to save it under a different name.

## It's running out of memory while trying ...

It's running out of memory while trying to factor a polynomial.  Do you have the 64-bit version of Maple on the Core i7?  It should be able to use all 16GB of RAM.  Can you post the whole system, i.e. all the input?  If so, we can try it and maybe find something.

## lists passed by reference...

Lists and sets in Maple are always passed by reference, and there shouldn't be a lock to read them.  They are immutable.  You may find that garbage collection and other factors limit the parallel speedup of Maple code.  In general, simpler is better, and if there are performance problems then it's probably something that needs to be improved in the kernel.

## recursively flatten lists...

flat := a->`if`(type(a,list), op(map(procname,a)), a);

L := [[1,2],[3],[4,5,6,[[[7,8,[9]]],10]]];

[flat(L)];

 4 5 6 7 8 9 10 Last Page 6 of 19
﻿