Choosing the free CAS

[porky_...@my-deja.com]

Hello,

I was looking at the descriptions of different CAS and finally decided
to narrow it down to Maxima and FRICAS/OpenAxiom. I hope somebody can
answer the following questions:

1. What's the nature of the fork between FRICAS/OpenAxiom? Seems like
FRICAS points to OpenAxiom documentation, does that mean all their
features are essentially the same? Should I give a try to both or just
one of them?

2. A quick rundown on Maxima vs FRICAS/OpenAxiom. Again, may be
there's something on Web(?).

TIA,

PPJ.

[Richard Fateman]

On 1/27/2012 12:27 PM, porky_...@my-deja.com wrote:
...

>
> 2. A quick rundown on Maxima vs FRICAS/OpenAxiom. Again, may be
> there's something on Web(?).

It might be possible to give you more pertinent information if you first
said what you were hoping to do with a CAS.

[clicl...@freenet.de]

"porky_...@my-deja.com" schrieb:

If you are interested in a general-purpose CAS, you also might also want
to take a look at Reduce.

Martin.

[Waldek Hebisch]

porky_...@my-deja.com <porky_...@my-deja.com> wrote:
> Hello,
>
> I was looking at the descriptions of different CAS and finally decided
> to narrow it down to Maxima and FRICAS/OpenAxiom. I hope somebody can
> answer the following questions:
>
> 1. What's the nature of the fork between FRICAS/OpenAxiom? Seems like
> FRICAS points to OpenAxiom documentation, does that mean all their
> features are essentially the same? Should I give a try to both or just
> one of them?

- Fork situation is more complicated that you think, there are three
forks: Axiom, Open Axiom and FriCAS. And there a common precursor,
namely commercial Axiom system (released as free software in 2002).
Tim Daly, who was angaged in making Axiom free software and lead
the project decided to keep Axiom name. When I forked FriCAS
I decided to use quite distint name to avoid confusion. But
shortly ater that another fork happened and decied to use name
Open Axiom.

- Concerning documentation FriCAS points to "Axiom Book"
and "Axiom Wiki". Axiom Book is a text which originally was written
to about commercial Axiom system (which is precursor of all of the
forks). It was updated somewhat when Axiom was released as fee
software, but it does not describe new additions to FriCAS
(but old things work well enough to that it is still very useful).
FriCAS bundled more up to date version of Axiom Book for online
viewing. Unfortunaltly, the pdf and MathML versions that FriCAS
points to were created mostly by hand and up to date nobody
volunteered to re-do the work and regenerate them from bundled
version.
Axiom Wiki was created when Axiom became fee software. The
name come from project, but nowadays it tries to be neutral
and cover all forks.

- Concerning features: FriCAS tries to preserve backwards
compatiblity as long as it does not interfere with
new developements. So old documetation is still useful.
But there are entirely new subsystems:
* guessing package which is useful when you can compute
several terms of a sequents and want to find a formula
* large collection of special functions (original Axiom
had only a handful)
* "jet bundles" framewark, which implements completition
procedure to bring system of PDE-s into more manageble
form (and can also find symmetries of PDE-s).
and several smaller additions and improvements to existing
functions.

AFAIK Open Axiom made structural improvements and added
some routines for logic, but made almost no improvements
to mathemetical capabilites. AFAIK Axiom ported several
FriCAS improvements, restructured code, made some additions
to user interface and documentation but again made almost
no own additions to mathemetical capabilites

--
Waldek Hebisch
heb...@math.uni.wroc.pl

[porky_...@my-deja.com]

On Jan 28, 12:34 pm, Richard Fateman <fate...@cs.berkeley.edu> wrote:

Well, yes. Mea culpa. I should have done that. Well, as it stands now,
seems like I'll be doing lots of matrix manipulations and another one
is vector calculus. 3D-visualiation of the functions is very
important. What else? Probably symbolic integration and
differentiation. May be solving differential equations, again,
symbolically, and may be numerically as well.

TIA,

PPJ.

[porky_...@my-deja.com]

On Jan 28, 2:35 pm, Waldek Hebisch <hebi...@math.uni.wroc.pl> wrote:

> hebi...@math.uni.wroc.pl

Thanks a lot. That's an excellent write-up. I didn't realize there was
three! (not two) of them.

PPJ.

[Waldek Hebisch]

porky_...@my-deja.com <porky_...@my-deja.com> wrote:
>
> Well, yes. Mea culpa. I should have done that. Well, as it stands now,
> seems like I'll be doing lots of matrix manipulations and another one
> is vector calculus. 3D-visualiation of the functions is very
> important. What else? Probably symbolic integration and
> differentiation. May be solving differential equations, again,
> symbolically, and may be numerically as well.
>

Matrix manipulations means may things. FriCAS has rather complete
set of operations on symbolic matrices (Maxima probably too).
Currently FriCAS reuses symbolic routines for numerical work.
The effect is that some numerical operations (like computing
eigenvalues) are much slower than possible. FriCAS routines
for symbolic matrix computations are not the best known.
OTOH in the past I saw 8x8 system of equations for which
Maxima was unable to give answer in reasonable time while
FriCAS had no problem.
Maxima includes translation of Lapack routines to Lisp. For
light numerical work this may be an advantage. For heavy
machine precision numerical computations real Lapack is
preffered, because it is much faster. For FriCAS there
is a separate Lapack interface (currently limited to
a few crucial operations), however it need already
installed Lapack (and you need to spend some work installing
the interface).

Both FriCAS and Maxima include basic operations of vector
calculus. In FriCAS to get a vector you need to type
someting like:

vector [1, 2, 3]

FriCAS has mechanizm for abbreviations, so if you really
want you can shorten 'vector' to single character, but
this is probably still heavier than Maxima notation.

FriCAS can produce various 3D plots. Interface is not
pretty, but the plots are. 3D plots are limited to
explicitly parametrized surfaces (there is ablilty to
draw 2D implicit plots of algebraic curves). Note
that "explicitly parametrized" means that there is
a routine to compute coordinates corresponding to
parameters. In other words, if you provide equation
solver you can draw implicit surfaces, but FriCAS
will not provide solver for you. IIUC Maxima can
draw implicit plots without extra assistance from you.
FriCAS also has new graphic framework, in principle
quite capable, but currently it generates files
which you then see in a separate external program
like Blender -- depending on your needs this can
be an advantage or make it completely uninteresting.

FriCAS has quite strong integrator, if you want
elementary integral of an elementary function it is
much stronger than Maxima. If you want integral
of elementary function in terms of special functions
than Maxima probably is stronger. I write probably
because currently both FriCAS and Maxima use patterns
for this, but acutal paterns and maching is quite
different.

For differential equations FriCAS has symbolic solver,
a numeric one and one producing series expansions.

--
Waldek Hebisch
heb...@math.uni.wroc.pl

[clicl...@freenet.de]

Waldek Hebisch schrieb:
>
> [...] FriCAS routines for symbolic matrix computations are not the

> best known. OTOH in the past I saw 8x8 system of equations for which
> Maxima was unable to give answer in reasonable time while FriCAS had
> no problem.
>

As an example of this, here is a system of six equations in the six
unknowns [u,v,w,x,y,z] which also involves the 11 free parameters
[a,b,c,d,e,f,g,h,i,j,k]:

SOLVE([e*(j*i*z+3*k*i*z+e^2*w+6*i*z),j*e*(h*z+i*y)+k*(3*d*i*z+e*~
(2*h*z+3*i*y))+d*(3*e^2*w+5*i*z)+e*(e^2*v+5*h*z+5*i*y),j*e*(g*z+~
h*y+i*x)+k*(d*(2*h*z+3*i*y)+e*(g*z+2*h*y+3*i*x))+3*d^2*e*w+d*(3*~
e^2*v+4*h*z+4*i*y)+e*(e^2*u+4*g*z+4*h*y+4*i*x),j*e*(f*z+g*y+h*x)~
+k*(d*(g*z+2*h*y+3*i*x)+e*(g*y+2*h*x))-c+d^3*w+3*d^2*e*v+3*d*(e^~
2*u+g*z+h*y+i*x)+3*e*(f*z+g*y+h*x),j*e*(f*y+g*x)+k*(d*(g*y+2*h*x~
)+e*g*x)-b+d^3*v+3*d^2*e*u+2*d*(f*z+g*y+h*x)+2*e*(f*y+g*x),-a+j*~
e*f*x+k*d*g*x+d^3*u+d*(f*y+g*x)+e*f*x],[u,v,w,x,y,z])

The solution is about 10 kByte in size, but Derive 6.10 takes longer
than I cared to wait.

Martin.

[porky_...@my-deja.com]

On Jan 30, 3:46 pm, Waldek Hebisch <hebi...@math.uni.wroc.pl> wrote:

> hebi...@math.uni.wroc.pl

Thanks for all the info. I know I will need both eigenvalues and SVD,
not right now, but in a while. So I'll be looking at LAPACK and LAPACK-
to-FRICAS interface. I'm running Windows (Vista), so I"ll need to
better understand which particular flavor of LAPACK for Windows I
would need to install. Is there anything I can read about FRICAS +
LAPACK under Windows? Thanks,

PPJ.

[Waldek Hebisch]

FriCAS needs 10.9 s, but the solution I got is 87 kB, partially due
to pseudo 2-D output. But even if I delete all spaces it still 19 kB.
I guess the rest is due to different rendering of common factors.

--
Waldek Hebisch
heb...@math.uni.wroc.pl

[clicl...@freenet.de]

Waldek Hebisch schrieb:

Hooray! Hooray! Hooray! So FriCAS has a better pivoting strategy and
more efficient multivariate gcd computations, I guess.

Appended below is a solution as rendered by the Derive 6.10 simplifier
(Derive simplification excludes rational factorization which would here
collapse the denominators). This solution is 10389 Byte in size (tildes
and line breaks and tildes counted too).

Another 6-by-6 system, whose solution is even noticeably smaller:

SOLVE([-j*e*i*z-3*k*e*i*z+c*i-e*(e^2*w+3*i*z),-j*e*(h*z+i*y)-k*(~
3*d*i*z+e*(2*h*z+3*i*y))+b*i+c*h-d*(3*e^2*w+2*i*z)-e*(e^2*v+3*h*~
z+2*i*y),a*i-j*e*(g*z+h*y+i*x)-k*(d*(2*h*z+3*i*y)+e*(g*z+2*h*y+3~
*i*x))+b*h+c*g-3*d^2*e*w-d*(3*e^2*v+2*h*z+i*y)-e*(e^2*u+3*g*z+2*~
h*y+i*x),a*h-j*e*(f*z+g*y+h*x)-k*(d*(g*z+2*h*y+3*i*x)+e*(g*y+2*h~
*x))+b*g+c*f-d^3*w-3*d^2*e*v-d*(3*e^2*u+2*g*z+h*y)-e*(3*f*z+2*g*~
y+h*x),a*g-j*e*(f*y+g*x)-k*(d*(g*y+2*h*x)+e*g*x)+b*f-d^3*v-3*d^2~
*e*u-d*(2*f*z+g*y)-e*(2*f*y+g*x),a*f-j*e*f*x-k*d*g*x-d^3*u-d*f*y~
-e*f*x],[u,v,w,x,y,z])

Here I have abandoned the Derive calculation when the intermediate
result reached 10 MByte in size.

Martin.

[u=(a*(d^6*i^3*(j^3+6*j^2+11*j+6)-3*d^5*e*h*i^2*(j^3+6*j^2+11*j+~
6)+d^4*e^2*i*(g*i*(3*j^3+2*j^2*(5*k+14)+j*(15*k^2+65*k+83)+3*(3*~
k^3+17*k^2+34*k+26))+3*h^2*(j^3+6*j^2+11*j+6))+d^3*e^3*(f*i^2*(7~
*j^3+3*j^2*(5*k+19)+j*(9*k^2+84*k+152)+3*(9*k^2+39*k+44))-h*(g*i~
*(6*j^3+3*j^2*(5*k+17)+3*j*(7*k^2+32*k+47)+12*k^3+71*k^2+149*k+1~
26)+h^2*(j^3+6*j^2+11*j+6)))+d^2*e^4*(g*(g*i*(3*j^3+9*j^2*(k+3)+~
j*(10*k^2+55*k+78)+6*(k^3+6*k^2+14*k+12))+h^2*(3*j^3+6*j^2*(k+4)~
+j*(8*k^2+38*k+63)+2*(2*k^3+13*k^2+29*k+27)))-3*f*h*i*(3*j^3+j^2~
*(7*k+25)+j*(4*k^2+39*k+68)+6*(2*k^2+9*k+10)))+d*e^5*(f*(g*i*(3*~
j^3+2*j^2*(4*k+13)+j*(9*k^2+49*k+73)+3*(7*k^2+23*k+22))+h^2*(3*j~
^3+2*j^2*(4*k+13)+j*(4*k^2+44*k+73)+6*(2*k^2+10*k+11)))-g^2*h*(3~
*j^3+2*j^2*(4*k+13)+j*(9*k^2+49*k+73)+4*k^3+29*k^2+73*k+66))+e^6~
*(f^2*i*(j+2)*(j+3)*(j+3*k+4)-2*f*g*h*(j+k+3)*(j^2+2*j*(k+3)+5*k~
+8)+g^3*(j+k+2)*(j+k+3)*(j+k+4)))-b*e*(d^5*g*i^2*(k+1)*(6*j^2+2*~
j*(6*k+17)+3*(3*k^2+13*k+16))+d^4*e*i*(3*f*i*(2*j^3+4*j^2*(k+4)+~
j*(3*k^2+24*k+43)+3*(3*k^2+12*k+13))-g*h*(k+1)*(8*j^2+j*(16*k+47~
)+3*(4*k^2+18*k+23)))+d^3*e^2*(g*(k+1)*(g*i*(3*j^2+3*j*(2*k+7)+2~
*(3*k^2+13*k+18))+h^2*(3*j^2+6*j*(k+3)+4*k^2+20*k+27))-f*h*i*(8*~
j^3+16*j^2*(k+4)+j*(12*k^2+97*k+173)+3*(12*k^2+49*k+53)))+d^2*e^~
3*(f*(g*i*(3*j^3+9*j^2*(k+3)+j*(12*k^2+56*k+77)+3*(8*k^2+25*k+23~
))+h^2*(3*j^3+6*j^2*(k+4)+j*(2*k+5)*(2*k+13)+6*(k+2)*(2*k+5)))-g~
^2*h*(k+1)*(3*j^2+2*j*(3*k+10)+4*k^2+22*k+33))+d*e^4*(3*f^2*i*(j~
+3)*(j^2+j*(2*k+5)+3*k+5)-f*g*h*(3*j^3+j^2*(7*k+25)+j*(6*k^2+40*~
k+67)+3*(4*k^2+17*k+19))+g^3*(j+k+3)*(j+k+4)*(k+1))+e^5*f*(j+1)*~
(g^2*(j+k+3)*(j+k+4)-f*h*(j+3)*(j+2*(k+2))))-c*(d^6*g*i^2*(k+1)*~
(-3*j^2-3*j*(3*k+7)-9*k^2-36*k-38)+d^5*e*i*(g*h*(k+1)*(3*j^2+j*(~
11*k+25)+12*k^2+49*k+52)-3*f*i*(j^3+3*j^2*(k+3)+j*(k+2)*(3*k+14)~
+3*(k+2)*(3*k+5)))+d^4*e^2*(f*h*i*(3*j^3+j^2*(11*k+29)+j*(12*k^2~
+77*k+98)+6*(6*k^2+22*k+19))+g*(k+1)*(g*i*(j^2-j*(2*k+3)-2*(3*k^~
2+11*k+11))-h^2*(j^2+j*(4*k+9)+2*(2*k^2+9*k+10))))+d^3*e^3*(f*(g~
*i*(j^3-2*j^2*(4*k+1)-j*(15*k^2+57*k+31)-27*k^2-77*k-44)-h^2*(j^~
3+2*j^2*(2*k+5)+j*(4*k^2+28*k+35)+6*(2*k^2+8*k+7)))+g^2*h*(k^2+3~
*k+2)*(3*j+4*k+11))-d^2*e^4*(3*f^2*i*(2*j^3+3*j^2*(k+5)+j*(13*k+~
35)+12*(k+2))-2*f*g*h*(k+1)*(3*j^2+4*j*(k+4)+7*k+19)+g^3*(j+k+4)~
*(k+1)*(k+2))+d*e^5*f*(j+1)*(f*h*(3*j^2+j*(4*k+19)+6*(2*k+5))-2*~
g^2*(j+k+4)*(k+1))-e^6*f^2*g*(j+1)*(j+2)*(j+k+4)))/((j+1)*(j+2)*~
(j+3)*(d^9*i^3-3*d^8*e*h*i^2+3*d^7*e^2*i*(g*i+h^2)-d^6*e^3*(3*f*~
i^2+h*(6*g*i+h^2))+3*d^5*e^4*(2*f*h*i+g*(g*i+h^2))-3*d^4*e^5*(f*~
(2*g*i+h^2)+g^2*h)+d^3*e^6*(3*f^2*i+6*f*g*h+g^3)-3*d^2*e^7*f*(f*~
h+g^2)+3*d*e^8*f^2*g-e^9*f^3)) AND v=-(a*e*(3*d^5*i^3*(j^3+6*j^2~
+11*j+6)-d^4*e*h*i^2*(9*j^3+2*j^2*(10*k+37)+j*(30*k^2+130*k+199)~
+6*(3*k^3+17*k^2+34*k+29))+d^3*e^2*i*(h^2*(9*j^3+6*j^2*(5*k+14)+~
3*j*(14*k^2+64*k+83)+2*(12*k^3+71*k^2+149*k+117))-g*i*(j^3+2*j^2~
*(5*k+8)+j*(6*k^2+56*k+61)+6*(3*k^2+13*k+11)))+d^2*e^3*(3*f*i^2*~
(2*j^3+6*j^2*(k+3)+j*(3*k^2+33*k+52)+3*(3*k^2+15*k+16))-h*(g*i*(~
3*j^3+6*j^2*(k+4)+j*(13*k^2+43*k+63)+3*(4*k^3+17*k^2+25*k+18))+h~
^2*(j+2*k+5)*(3*j^2+3*j*(2*k+5)+2*(2*k^2+8*k+9))))-d*e^4*(2*f*h*~
i*(3*j^3+j^2*(11*k+29)+j*(9*k^2+64*k+88)+3*(7*k^2+29*k+28))+g*(2~
*g*i*(j+3)*(j+k+2)*(k+1)-h^2*(j+2*k+5)*(3*j^2+3*j*(2*k+5)+2*(2*k~
^2+8*k+9))))+e^5*(f*(g*i*(j+3)*(j+k+2)*(j+3*k+5)+h^2*(j+2)*(j+2*~
k+3)*(j+2*k+5))-g^2*h*(j+k+2)*(j+k+3)*(j+2*k+5)))-b*(d^6*i^3*(j^~
3+6*j^2+11*j+6)-d^5*e*h*i^2*(3*j^3+6*j^2*(2*k+5)+j*(24*k^2+92*k+~
101)+6*(3*k^3+16*k^2+29*k+19))+d^4*e^2*i*(h^2*(3*j^3+2*j^2*(8*k+~
17)+j*(32*k^2+126*k+127)+6*(4*k^3+22*k^2+41*k+26))-g*i*(3*j^3+2*~
j^2*(4*k+13)+3*j*(2*k^2+16*k+25)+18*(k+2)^2))+d^3*e^3*(f*i^2*(7*~
j^3+3*j^2*(5*k+19)+j*(9*k^2+87*k+155)+3*(9*k^2+42*k+47))+h*(g*i*~
(2*j^3+3*j^2*(k+5)-j*(5*k^2-k-28)-12*k^3-43*k^2-40*k+3)-h^2*(j+2~
*k+3)*(j+2*k+5)*(j+2*(k+2))))-d^2*e^4*(f*h*i*(9*j^3+27*j^2*(k+3)~
+j*(24*k^2+154*k+229)+3*(16*k^2+65*k+67))+g*(k+1)*(2*g*i*(j+3)*(~
k+1)-h^2*(j+2*k+5)*(3*j+4*k+9)))-d*e^5*(f*(g*i*(j^2-3*j*k-9*(k+1~
))*(k+1)-h^2*(j+2*k+5)*(3*j^2+j*(4*k+13)+6*(k+2)))+g^2*h*(j+k+3)~
*(j+2*k+5)*(k+1))+e^6*f*(j+1)*(f*i*(j+3)*(j+3*k+5)-g*h*(j+k+3)*(~
j+2*k+5)))-c*(2*d^6*h*i^2*(k+1)*(3*j^2+3*j*(3*k+7)+9*k^2+36*k+38~
)+d^5*e*i*(g*i*(3*j^3+6*j^2*(k+4)+j*(6*k^2+40*k+67)+6*(3*k^2+11*~
k+11))-2*h^2*(k+1)*(3*j^2+j*(11*k+25)+12*k^2+49*k+52))-d^4*e^2*(~
3*f*i^2*(2*j^3+4*j^2*(k+4)+j*(3*k^2+25*k+44)+3*(k+2)*(3*k+7))+h*~
(g*i*(3*j^3+2*j^2*(4*k+13)+3*j*(k^2+11*k+21)-12*k^3-35*k^2-13*k+~
28)-2*h^2*(j+2*k+5)*(j+2*(k+2))*(k+1)))+d^3*e^3*(2*f*h*i*(4*j^3+~
2*j^2*(7*k+19)+j*(15*k^2+84*k+113)+27*k^2+104*k+101)-g*(g*i*(j^3~
+2*j^2*(k+4)-j*(2*k^2-4*k-17)-6*(k^2+k-1))-h^2*(j+2*k+5)*(j^2+3*~
j-2*(2*k^2+5*k+2))))+d^2*e^4*(f*(g*i*(3*j^3+6*j^2*(k+4)-j*(3*k^2~
-17*k-53)-3*(3*k^2+k-8))-h^2*(j+2*k+5)*(3*j^2+3*j*(2*k+5)+2*(4*k~
+7)))+g^2*h*(j+2*k+5)*(k^2+3*k+2))+d*e^5*f*(j+1)*(2*g*h*(j+2*k+5~
)*(k+1)-3*f*i*(j^2+j*(2*k+7)+6*(k+2)))+e^6*f^2*h*(j+1)*(j+2)*(j+~
2*k+5)))/((j+1)*(j+2)*(j+3)*(d^9*i^3-3*d^8*e*h*i^2+3*d^7*e^2*i*(~
g*i+h^2)-d^6*e^3*(3*f*i^2+h*(6*g*i+h^2))+3*d^5*e^4*(2*f*h*i+g*(g~
*i+h^2))-3*d^4*e^5*(f*(2*g*i+h^2)+g^2*h)+d^3*e^6*(3*f^2*i+6*f*g*~
h+g^3)-3*d^2*e^7*f*(f*h+g^2)+3*d*e^8*f^2*g-e^9*f^3)) AND w=i*(j+~
3*(k+2))*(a*e^2*(3*d^4*i^2*(2*j^2+2*j*(2*k+5)+3*k^2+11*k+12)-4*d~
^3*e*h*i*(2*j^2+2*j*(2*k+5)+3*k^2+11*k+12)+d^2*e^2*(3*g*i*(j^2+j~
*(2*k+5)+2*(k^2+3*k+3))+h^2*(3*j^2+3*j*(2*k+5)+2*(2*k^2+8*k+9)))~
+d*e^3*(3*f*i*(j+2)*(j+2*k+3)-g*h*(3*j^2+3*j*(2*k+5)+2*(2*k^2+8*~
k+9)))+e^4*(g^2*(j+k+2)*(j+k+3)-f*h*(j+2)*(j+2*k+3)))-b*e*(3*d^5~
*i^2*(j^2+3*j*(k+2)+3*k^2+10*k+9)-d^4*e*h*i*(3*j^2+j*(11*k+20)+3~
*(4*k^2+13*k+11))+d^3*e^2*(h^2*(j+2*k+3)*(j+2*(k+2))-g*i*(j^2+j*~
(1-2*k)-2*(3*k^2+7*k+3)))+d^2*e^3*(3*f*i*(2*j^2+3*j*(k+3)+5*k+9)~
-g*h*(k+1)*(3*j+4*k+9))+d*e^4*(g^2*(j+k+3)*(k+1)-f*h*(3*j^2+j*(4~
*k+13)+6*(k+2)))+e^5*f*g*(j+1)*(j+k+3))+c*(d^6*i^2*(j+3*k+4)*(j+~
3*k+5)-2*d^5*e*h*i*(3*j*(k+1)+6*k^2+17*k+11)+d^4*e^2*(2*h^2*(j*(~
k+1)+2*(k^2+3*k+2))-g*i*(3*j^2+j*(2*k+11)-6*k^2-10*k+2))+d^3*e^3~
*(f*i*(7*j^2+3*j*(4*k+11)+18*k+32)+g*h*(j^2+3*j-2*(2*k^2+5*k+2))~
)+d^2*e^4*(g^2*(k^2+3*k+2)-f*h*(3*j^2+3*j*(2*k+5)+2*(4*k+7)))+2*~
d*e^5*f*g*(j+1)*(k+1)+e^6*f^2*(j+1)*(j+2)))/((j+1)*(j+2)*(j+3)*(~
d^9*i^3-3*d^8*e*h*i^2+3*d^7*e^2*i*(g*i+h^2)-d^6*e^3*(3*f*i^2+h*(~
6*g*i+h^2))+3*d^5*e^4*(2*f*h*i+g*(g*i+h^2))-3*d^4*e^5*(f*(2*g*i+~
h^2)+g^2*h)+d^3*e^6*(3*f^2*i+6*f*g*h+g^3)-3*d^2*e^7*f*(f*h+g^2)+~
3*d*e^8*f^2*g-e^9*f^3)) AND x=(d*(b*e*(d^6*i^2*(6*j^2+2*j*(6*k+1~
7)+3*(3*k^2+13*k+16))-d^5*e*h*i*(8*j^2+j*(16*k+47)+3*(4*k^2+18*k~
+23))+d^4*e^2*(g*i*(3*j^2+3*j*(2*k+7)+6*k^2+26*k+36)+h^2*(3*j^2+~
6*j*(k+3)+4*k^2+20*k+27))+d^3*e^3*(f*i*(3*j^2+2*j*(3*k+5)+3*(2*k~
+1))-g*h*(3*j^2+2*j*(3*k+10)+4*k^2+22*k+33))+d^2*e^4*(g^2*(j^2+j~
*(2*k+7)+k^2+7*k+12)-f*h*(j^2+j*(2*k+1)-6))-d*e^5*f*g*(3*j+2*k+9~
)+e^6*f^2*(j+3))-c*d*(d^6*i^2*(3*j^2+3*j*(3*k+7)+9*k^2+36*k+38)-~
d^5*e*h*i*(3*j^2+j*(11*k+25)+12*k^2+49*k+52)+d^4*e^2*(h^2*(j^2+j~
*(4*k+9)+4*k^2+18*k+20)-g*i*(j^2-j*(2*k+3)-6*k^2-22*k-22))+d^3*e~
^3*(f*i*(6*j^2+3*j*(3*k+8)+9*k+14)-g*h*(3*j*(k+2)+4*k^2+19*k+22)~
)+d^2*e^4*(g^2*(j+k+4)*(k+2)-f*h*(3*j^2+j*(4*k+11)+2*(k+1)))+d*e~
^5*f*g*(j^2+j*(k+3)-k-4)+2*e^6*f^2))-a*e^2*(d^6*i^2*(10*j^2+5*j*~
(3*k+10)+3*(3*k^2+14*k+20))-d^5*e*h*i*(15*j^2+3*j*(7*k+25)+12*k^~
2+59*k+90)+d^4*e^2*(g*i*(9*j^2+5*j*(2*k+9)+6*(k^2+5*k+9))+2*h^2*~
(3*j^2+j*(4*k+15)+2*k^2+11*k+18))-d^3*e^3*(f*i*(2*j^2+j*(10-3*k)~
-3*(k-4))+g*h*(8*j^2+j*(9*k+40)+4*k^2+25*k+48))+d^2*e^4*(f*h*(3*~
j^2+15*j+2*(k+9))+g^2*(3*j^2+3*j*(k+5)+k^2+8*k+18))-d*e^5*f*g*(3~
*j^2+j*(k+15)+3*(k+6))+e^6*f^2*(j+2)*(j+3)))/((j+1)*(j+2)*(j+3)*~
(d^9*i^3-3*d^8*e*h*i^2+3*d^7*e^2*i*(g*i+h^2)-d^6*e^3*(3*f*i^2+h*~
(6*g*i+h^2))+3*d^5*e^4*(2*f*h*i+g*(g*i+h^2))-3*d^4*e^5*(f*(2*g*i~
+h^2)+g^2*h)+d^3*e^6*(3*f^2*i+6*f*g*h+g^3)-3*d^2*e^7*f*(f*h+g^2)~
+3*d*e^8*f^2*g-e^9*f^3)) AND y=-e*(a*e^2*(3*d^5*i^2*(5*j^2+j*(9*~
k+25)+6*k^2+25*k+30)-d^4*e*h*i*(21*j^2+j*(37*k+105)+24*k^2+103*k~
+126)+2*d^3*e^2*(g*i*(5*j^2+j*(8*k+25)+6*(k^2+4*k+5))+h^2*(4*j^2~
+j*(7*k+20)+4*k^2+19*k+24))+d^2*e^3*(3*f*i*(j^2+j*(3*k+5)+5*k+6)~
-g*h*(9*j^2+15*j*(k+3)+8*k^2+41*k+54))+d*e^4*(g^2*(j+k+2)*(3*j+2~
*k+9)-2*f*h*k*(j+1))-e^5*f*g*(j+3)*(j+k+2))-b*e*(d^6*i^2*(8*j^2+~
j*(21*k+47)+3*(6*k^2+23*k+23))-3*d^5*e*h*i*(3*j^2+j*(9*k+19)+8*k~
^2+31*k+30)+d^4*e^2*(2*g*i*(j*(4*k+5)+6*k^2+20*k+15)+h^2*(3*j^2+~
10*j*(k+2)+8*k^2+34*k+33))+d^3*e^3*(f*i*(11*j^2+j*(15*k+47)+21*(~
k+2))-g*h*(j^2+j*(9*k+13)+8*k^2+35*k+30))+d^2*e^4*(g^2*(3*j*(k+1~
)+2*k^2+11*k+9)-6*f*h*(j^2+j*(k+4)+k+3))+d*e^5*f*g*(3*j^2+j*(k+1~
1)-k+6)-e^6*f^2*(j^2+4*j+3))+c*d*(d^6*i^2*(3*j^2+5*j*(3*k+5)+18*~
k^2+63*k+52)-d^5*e*h*i*(j^2+j*(17*k+21)+24*k^2+83*k+62)+2*d^4*e^~
2*(h^2*(3*j*(k+1)+4*k^2+15*k+11)-g*i*(3*j^2+9*j-2*(3*k^2+8*k+2))~
)+d^3*e^3*(f*i*(15*j^2+j*(21*k+67)+27*k+58)+g*h*(3*j^2+j*(7-3*k)~
-8*k^2-29*k-14))-d^2*e^4*(2*f*h*(4*j^2+j*(5*k+18)+5*k+14)+g^2*(j~
^2+j*(3-k)-2*k^2-9*k-4))+d*e^5*f*g*(3*j^2+3*j*(k+5)+k+10)-2*e^6*~
f^2*(j+1)))/((j+1)*(j+2)*(j+3)*(d^9*i^3-3*d^8*e*h*i^2+3*d^7*e^2*~
i*(g*i+h^2)-d^6*e^3*(3*f*i^2+h*(6*g*i+h^2))+3*d^5*e^4*(2*f*h*i+g~
*(g*i+h^2))-3*d^4*e^5*(f*(2*g*i+h^2)+g^2*h)+d^3*e^6*(3*f^2*i+6*f~
*g*h+g^3)-3*d^2*e^7*f*(f*h+g^2)+3*d*e^8*f^2*g-e^9*f^3)) AND z=-e~
^2*(a*e^2*(3*d^4*i^2*(2*j^2+2*j*(2*k+5)+3*k^2+11*k+12)-4*d^3*e*h~
*i*(2*j^2+2*j*(2*k+5)+3*k^2+11*k+12)+d^2*e^2*(3*g*i*(j^2+j*(2*k+~
5)+2*(k^2+3*k+3))+h^2*(3*j^2+3*j*(2*k+5)+2*(2*k^2+8*k+9)))+d*e^3~
*(3*f*i*(j+2)*(j+2*k+3)-g*h*(3*j^2+3*j*(2*k+5)+2*(2*k^2+8*k+9)))~
+e^4*(g^2*(j+k+2)*(j+k+3)-f*h*(j+2)*(j+2*k+3)))-b*e*(3*d^5*i^2*(~
j^2+3*j*(k+2)+3*k^2+10*k+9)-d^4*e*h*i*(3*j^2+j*(11*k+20)+3*(4*k^~
2+13*k+11))+d^3*e^2*(h^2*(j+2*k+3)*(j+2*(k+2))-g*i*(j^2+j*(1-2*k~
)-2*(3*k^2+7*k+3)))+d^2*e^3*(3*f*i*(2*j^2+3*j*(k+3)+5*k+9)-g*h*(~
k+1)*(3*j+4*k+9))+d*e^4*(g^2*(j+k+3)*(k+1)-f*h*(3*j^2+j*(4*k+13)~
+6*(k+2)))+e^5*f*g*(j+1)*(j+k+3))+c*(d^6*i^2*(j+3*k+4)*(j+3*k+5)~
-2*d^5*e*h*i*(3*j*(k+1)+6*k^2+17*k+11)+d^4*e^2*(2*h^2*(j*(k+1)+2~
*(k^2+3*k+2))-g*i*(3*j^2+j*(2*k+11)-6*k^2-10*k+2))+d^3*e^3*(f*i*~
(7*j^2+3*j*(4*k+11)+18*k+32)+g*h*(j^2+3*j-2*(2*k^2+5*k+2)))+d^2*~
e^4*(g^2*(k^2+3*k+2)-f*h*(3*j^2+3*j*(2*k+5)+2*(4*k+7)))+2*d*e^5*~
f*g*(j+1)*(k+1)+e^6*f^2*(j+1)*(j+2)))/((j+1)*(j+2)*(j+3)*(d^9*i^~
3-3*d^8*e*h*i^2+3*d^7*e^2*i*(g*i+h^2)-d^6*e^3*(3*f*i^2+h*(6*g*i+~
h^2))+3*d^5*e^4*(2*f*h*i+g*(g*i+h^2))-3*d^4*e^5*(f*(2*g*i+h^2)+g~
^2*h)+d^3*e^6*(3*f^2*i+6*f*g*h+g^3)-3*d^2*e^7*f*(f*h+g^2)+3*d*e^~
8*f^2*g-e^9*f^3))]

[jgg8...@gmail.com]

About the fork situation: Scratchpad started at IBM Research.
I was a member of that team. IBM sold Scratchpad to the Numerical
Algorithms Group (NAG). It was named Axiom and was a commercial
competitor to Mathematica and Maple. NAG withdrew Axiom from the
market and gave parts of it to me under the BSD license.

I rebuilt Axiom, moved it back to the GCL base, and restructued it
to use literate programming in the 2001-2002 time frame when the Axiom
project was released as open source. The Axiom website was converted
to a wiki and run on the axiom-developer.org server.

In 2007 there was much discussion about project goals. The FriCAS
project forked the code in the June/July 2007 time frame. The
Open-Axiom project forked the code in the September 2007 time
frame. The Axiom project continues on the original set of goals.
The wiki moved to the newsynthesis.org server.

As stated on http://en.wikipedia.org/wiki/Axiom_computer_algebra_system
the Axiom project focuses on the “30 Year Horizon”. The primary
philosophy is that Axiom needs to develop several fundamental
features in order to be useful to the next generation of
computational mathematicians. Knuth's literate programming
technique is used throughout the source code. Axiom plans to
use proof technology to prove the correctness of the
algorithms (such as Coq and ACL2).

Any of the systems would likely be useful for your work.

Tim Daly

[Waldek Hebisch]

porky_...@my-deja.com <porky_...@my-deja.com> wrote:

> On Jan 30, 3:46?pm, Waldek Hebisch <hebi...@math.uni.wroc.pl> wrote:
> > porky_pig...@my-deja.com <porky_pig...@my-deja.com> wrote:
> >
> > > Well, yes. Mea culpa. I should have done that. Well, as it stands now,
> > > seems like I'll be doing lots of matrix manipulations and another one
> > > is vector calculus. 3D-visualiation of the functions is very
> > > important. What else? Probably symbolic integration and
> > > differentiation. May be solving differential equations, again,
> > > symbolically, and may be numerically as well.
>

> Thanks for all the info. I know I will need both eigenvalues and SVD,
> not right now, but in a while. So I'll be looking at LAPACK and LAPACK-
> to-FRICAS interface. I'm running Windows (Vista), so I"ll need to
> better understand which particular flavor of LAPACK for Windows I
> would need to install. Is there anything I can read about FRICAS +
> LAPACK under Windows? Thanks,

I have no experience with LAPACK on Windows. Given all your
requirements currently probably the best way for you is to run
Linux in VirtualBox and install FriCAS there. On 32-bit
Windows people also used andLinux. FriCAS graphic routines
were originally written on Unix, and currently need Cygwin
libraries to run (Cygwin libraries (beside other things) convert
Unix style graphic calls to native Windows API). However
recently people had trouble building FriCAS under Cygwin.

--
Waldek Hebisch
heb...@math.uni.wroc.pl

[Waldek Hebisch]

I may be due to general strategy: FriCAS rather eagerly expands
things. IME without expansion it is hard to spot cancelation
and in matrix computation "unexpanded" quantites often get
much bigger than expanded ones. And of course one needs
reasonably efficient gcd (which FriCAS has) to cancel common
factors. Another things is FriCAS is a typed system, it first
assigns types to user input and then uses specialised routines
for given type. In particular in your case FriCAS automatically
chooses representation as rational functions. Some other CAS-es
may use tree representation which is likely to be less efficient.

> Appended below is a solution as rendered by the Derive 6.10 simplifier
> (Derive simplification excludes rational factorization which would here
> collapse the denominators). This solution is 10389 Byte in size (tildes
> and line breaks and tildes counted too).


> Another 6-by-6 system, whose solution is even noticeably smaller:
>
> SOLVE([-j*e*i*z-3*k*e*i*z+c*i-e*(e^2*w+3*i*z),-j*e*(h*z+i*y)-k*(~
> 3*d*i*z+e*(2*h*z+3*i*y))+b*i+c*h-d*(3*e^2*w+2*i*z)-e*(e^2*v+3*h*~
> z+2*i*y),a*i-j*e*(g*z+h*y+i*x)-k*(d*(2*h*z+3*i*y)+e*(g*z+2*h*y+3~
> *i*x))+b*h+c*g-3*d^2*e*w-d*(3*e^2*v+2*h*z+i*y)-e*(e^2*u+3*g*z+2*~
> h*y+i*x),a*h-j*e*(f*z+g*y+h*x)-k*(d*(g*z+2*h*y+3*i*x)+e*(g*y+2*h~
> *x))+b*g+c*f-d^3*w-3*d^2*e*v-d*(3*e^2*u+2*g*z+h*y)-e*(3*f*z+2*g*~
> y+h*x),a*g-j*e*(f*y+g*x)-k*(d*(g*y+2*h*x)+e*g*x)+b*f-d^3*v-3*d^2~
> *e*u-d*(2*f*z+g*y)-e*(2*f*y+g*x),a*f-j*e*f*x-k*d*g*x-d^3*u-d*f*y~
> -e*f*x],[u,v,w,x,y,z])
>
> Here I have abandoned the Derive calculation when the intermediate
> result reached 10 MByte in size.

Takes 6.04 sec. Solotion is smaller, but still about 50 kB.
By factoring numerators and denominators (which I did using
separate command) it shrunk to 40 kB. Below is first
component of the answer. Most of the size is whitespace,
but also you can see that FriCAS makes very little effort
to find common subexpressions.

u =
-
k
*
4 2 5 6 2
(9a d e - 9b d e + 9c d )g i
+
3 3 4 2 5
(- 12a d e + 12b d e - 12c d e)g h
+
2 4 3 3 4 2 2
(6a d e - 6b d e + 6c d e )g
*
i
+
2 4 3 3 4 2 2
(4a d e - 4b d e + 4c d e )g h
+
5 2 4 3 3 2
(- 4a d e + 4b d e - 4c d e )g h
+
6 5 2 4 3
(a e - b d e + c d e )g
*
2
k
+
4 2 5 3 3 4 2 5 2
((6a d e - 3b d e)g + (9a d e - 9b d e + 9c d e)f)i
+
3 3 4 2 5
(- 9a d e + 4b d e + c d e)g
+
2 4 3 3 4 2
(- 12a d e + 12b d e - 12c d e )f
*
h
+
2 4 4 2 2
(4a d e - 4c d e )g
+
5 2 4 3 3
(9a d e - 12b d e + 15c d e )f g
*
i
+
2 4 3 3
(4a d e - 2b d e )g
+
5 2 4 3 3
(4a d e - 4b d e + 4c d e )f
*
2
h
+
5 2 4 3 3 2
(- 5a d e + 2b d e + c d e )g
+
6 5 2 4
(- 4a e + 6b d e - 8c d e )f g
*
h
+
6 5 3 6 5 2
(2a e - b d e )g + (- b e + 2c d e )f g
*
j
+
4 2 5 6
(15a d e - 12b d e + 9c d )g
+
3 3 4 2 5
(27a d e - 27b d e + 27c d e)f
*
2
i
+
3 3 4 2 5
(- 23a d e + 18b d e - 13c d e)g
+
2 4 3 3 4 2
(- 36a d e + 36b d e - 36c d e )f
*
h
+
2 4 3 3 4 2 2
(12a d e - 8b d e + 4c d e )g
+
5 2 4 3 3
(21a d e - 24b d e + 27c d e )f g
*
i
+
2 4 3 3 4 2
(10a d e - 8b d e + 6c d e )g
+
5 2 4 3 3
(12a d e - 12b d e + 12c d e )f
*
2
h
+
5 2 4 3 3 2
(- 13a d e + 10b d e - 7c d e )g
+
6 5 2 4
(- 10a e + 12b d e - 14c d e )f g
*
h
+
6 5 2 4 3 6 5 2
(5a e - 4b d e + 3c d e )g + (- b e + 2c d e )f g
*
k
+
4 2 3 3 4 2 2
(a d e g + (6a d e - 3b d e )f)i
+
3 3 2 4 3 3 4 2
(- 2a d e g + (- 9a d e + 4b d e + c d e )f)h
+
2 4 2 5 3 3
2a d e g + (2a d e - 4c d e )f g
+


--
Waldek Hebisch
heb...@math.uni.wroc.pl

[clicl...@freenet.de]

Waldek Hebisch schrieb:
>
> clicl...@freenet.de wrote:
> >
> > Hooray! Hooray! Hooray! So FriCAS has a better pivoting strategy and
> > more efficient multivariate gcd computations, I guess.
>
> I may be due to general strategy: FriCAS rather eagerly expands
> things. IME without expansion it is hard to spot cancelation
> and in matrix computation "unexpanded" quantites often get
> much bigger than expanded ones. And of course one needs
> reasonably efficient gcd (which FriCAS has) to cancel common
> factors. Another things is FriCAS is a typed system, it first
> assigns types to user input and then uses specialised routines
> for given type. In particular in your case FriCAS automatically
> chooses representation as rational functions. Some other CAS-es
> may use tree representation which is likely to be less efficient.
>

It should be mentioned that systems of symbolic linear equations where
Derive takes orders of magnitude longer than expected from similar
systems are the exception rather than the rule. In such cases one has to
resort to tricks; for example, both six-by-six systems are solved within
seconds on a modern CPU if the default variable order is changed to
VariableOrder := [e, a, b, c, d, f, g, h, i, j, k]. They are also solved
quickly if the parameter e is set to unity; this does not restrict
generality here, and the full solutions can be reconstructed from the
e=1 results. But with Derive being locked away by Texas Instruments,
nothing will be done about such weaknesses.

The solution of the second system as rendered by Derive is 6649 Byte in
size, with line breaks and tildes counted too.

Martin.

[Gabriel Dos Reis]

OpenAxiom, since release 1.3.0, has had a Foreign Function Interface (FFI)
that allows you to interface your Spad library code with C/Fortran
dynamically loaded libraries.

See an overview and example of usage here:

https://parasol.tamu.edu/~gdr/OpenAxiom/ffi-draft.pdf


-- Gaby

--
Dr. Gabriel Dos Reis (g...@cs.tamu.edu), Assistant Professor
http://parasol.tamu.edu/people/~gdr/
Department of Computer Science & Engineering; TAMU
301, Bright Building -- College Station, TX 77843-3112

[porky_...@my-deja.com]

> hebi...@math.uni.wroc.pl

Thanks, that makes things a little bit more involved, since the laptop
I have is a bit limited in terms of both memory and processor speed,
so I'm not sure how efficient will be to run VirtualBox in it. In any
case, thanks a lot for all the information.

PPJ.