Dear Ralf, oldk1331 and Themos, thanks for your answers.
I'll comment on/answer various points below and I'll make up a list of my
impressions in another "constructive criticism" post.
>That's an interesting skill set. May I ask how did you get in touch
>with FriCAS?
I heard about Axiom more or less when I ended my PhD and Axiom was commercial.
At that time I computed in Macsyma (without x). Then in my post-doc I started
using Mathematica. Got a job and more time for "CAS fun", I started to look
around for viable Open Source alternatives to Mathematica (say beginning 2000).
I became aware that Axiom was OS but I was scared by the immensity of its
documentation, the strong type system, and by what seemed to me a slow source
development. I followed the Aldor transition to OS looking from time to time at
the forum, and after a while I realized that there were no more one but three
"Axioms" around. FriCAS looks to me the healthier project. (The strong type
system fear evaporated meanwhile thanks to a little immersion in Haskell.)
Concerning my question on evaluation, the motivation is just theoretical, to
understand the evaluation mechanism: I have no precise application in mind.
@oldk1331 and @Themos, thanks for suggesting delayed assignment. I knew about
==. If I write (a==b; b==1; a) then a is evaluated with b bound to 1. The post
was more about understanding of "what is a on the LHS and b on the RHS of the
assignment", that why I used := .
@oldk1331:
>Do you have any problems on installation?
I've installed installed the binaries in a test machine (linux debian) this we.
I'll talk about problems I faced in the "constructive criticism" email.
@oldk1331:
>The "fixed-point infinite evaluation" sounds like delayed assignment
>I mentioned above.
Mmm... in my Mathematica-biased understanding, immediate evaluation and delayed
evaluation refer to *when* the RHS of an assignment is evaluated, at the
assignment time or when a variable is re-used. My question was not about when
evaluation is performed but more about *how* evaluation is performed. In
Mathematica assignments ( = immediate and := delayed) define immediate or
delayed global rules that are stored somewhere in the environment and
evaluation means "repeatedly apply all the rules in scope until the result does
not change". That is what I meant by "fixed-point infinite evaluation" and the
they point is the fact that the rules are repeatedly evaluated.
@oldk1331:
> BTW, is this possible in Sympy?
In my knowledge, in Sympy the LHS of an assignment is a plain python variable
and in the RHS one has an object representing a mathematical object, say an
expression. Assignment of a python variable is immediate (unless one cheats and
uses a nullary function, but that has an heavy function-like syntax). There is
no rule-storing and repeated application as in Mathematica. I'm not aware of a
way to automatically have this fixed-point evaluation. On the other hand I
guess that if one has an *explicit* list of rules one might create a function
that applies them until the result is fixed.
@Ralf
Thanks for your enlightening explanation!
If I understand correctly, the "variables" on the LHS of assignments are Aldor
(whatever) variables that are bound (refer to) to more complicated Aldor
objects with type in some domain, like Variable(b).
Let me write down another example to test if I've understood (could you tell me
if I'm wrong?)
a:=a
-- "a" on the LHS is an Aldor variable (a reference to an object) , "a" on the
RHS is an object of type Variable(a) coercible to Symbol.
a:=1
-- "a" on the LHS is the same Aldor variable as above. "a" now reference to
"1:Integer" and the value a:Variable(a) -- no mor linked -- disappears from the
scope.
f(x) == x+a -- who is "a" on RHS?
f(z)
--- => z+1 so "a" above was an Aldor variable
If my understanding is correct, the situation is pretty much like Sympy, [1],
where you would write the above test as
a = Symbol("a")
-- "a" on LHS a python ref. On the RHS you create explicitly a Symbol
object named "a".
a = 1
-- "a" on LHS a python ref.
def f(x): return x+a
-- "a" on LHS a python ref, presently bounded to 1.
f(Symbol("z"))
-- returns Symbol("z")+1, which is shown as z+1
[1] http://docs.sympy.org/latest/gotchas.html#variables
>For example, tell me a CAS that distinguishes between a (multivariate)
>polynomial that is "distributed" (i.e. stored as a list of pairs where
>each pair consists of a coefficient and the corresponding exponent
>vector of the variables) or that is "recursive" (i.e. it is a
>(univariate) polynomial in the main variable whose coefficients are
>(recursive) polynomials in the other variables.
I understand. (Actually it seems that also mathemagix [2] does it :) but I'm
not a mathemagix user. )
[2] http://www.mathemagix.org/www/multimix/doc/html/multivariate.en.html
Thanks,
ric
--
You received this message because you are subscribed to the Google Groups
"FriCAS - computer algebra system" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at https://groups.google.com/group/fricas-devel.
For more options, visit https://groups.google.com/d/optout.
