William,
On Mon, May 2, 2011 at 9:07 PM, you wrote to Stefan:
...
So the answer to your question "How is it possible ..."
is, "It is not
possible, in the context of piecewise functions."
because no matter what
the system does, you gain no new information other than
what you inputted,
until you let the system know what y is, numerically.
I think we should be careful not to give the wrong
impression about
the capabilities of Axiom. It is not quite accurate to
say that what
Stefan wants to do is "impossible" in Axiom since Axiom
does contain
some rather sophisticated ways of representing symbolic
expressions. I
think it may be correct to claim that at the present
time the Axiom
library is fundamentally "algebraic" in orientation and
not "symbolic"
but the dividing line between these two views of
computer algebra is
not so clear cut.
In particular, Axiom's InputForm domain represents
"algebraically"
everything that can be evaluated in Axiom in purely
symbolic form.
Normally this is only an intermediate representation
which is
immediately evaluated by Axiom. But with the help of a
simple symbol
substitution routine like the following we can do a lot
more in a
purely symbolic manner.
(1) -> sub(f:InputForm, x:Symbol, y:InputForm):InputForm
== ( _
atom? f => (symbol? f => (symbol f = x =>
y;f);f); _
[sub(g,x,y) for g in destruct f]::InputForm)
Function declaration sub :
(InputForm,Symbol,InputForm) -> InputForm
has been added to workspace.
Type: Void
(2) -> sub
(2)
sub (f,x,y) ==
if atom?(f)
then
if symbol?(f)
then
if symbol(f)= x
then y
else f
else f
else ([[sub(g,x,y) for g in destruct(f)]]) ::
InputForm
Type:
FunctionCalled(sub)
The function 'sub' operates on symbolic "input form" f
by replacing
symbol x with input form y wherever x occurs. I think it
should be
fairly obvious how this recursive routine works except
perhaps for
'destruct' which breaks a top-level input form into a
list of
lower-level input forms. In this way the routine
traverses the entire
tree structure representing the given input form.
Now the function that Stefan has in mind can be written
in a fairly
transparent manner.
(3) -> ex:InputForm := parse("if x<10 then 2*x else
5*x^2"); expr ex
(3)
if x < 10
then 2x
2
else 5x
Type: OutputForm
The function 'parse' returns an unevaluated input form
for the
expression inside "...". The function 'expr' prints this
in a readable
manner. (InputForm is displayed in this form by default
in OpenAxiom.)
(4) -> test1(x0)==sub(ex, x,x0)
Type: Void
In the definition of 'test1' the function 'sub' replaces
the symbol x
with the input form of x0. The result remains
unevaluated.
(5) -> expr test1(y)
Compiling function sub with type
(InputForm,InputForm,InputForm) ->
InputForm
Compiling function test1 with type Variable(y) ->
InputForm
(5)
if y < 10
then 2y
2
else 5y
Type: OutputForm
But this need not always be the case.
(6) -> interpret test1(3)
Compiling function test1 with type PositiveInteger ->
InputForm
(6) 6
Type:
PositiveInteger
(7) -> interpret test1(13)
(7) 845
Type:
PositiveInteger
The function 'interpret' evaluates an input form. This
is possible
only because in the above two instances x is replaced
with a numeric
value. But in general the argument to test1 need not be
numeric and we
can keep the unevaluated symbolic form. For example we
can write:
(8) -> expr test1(x+1)
Compiling function test1 with type Polynomial(Integer)
-> InputForm
(8)
if x + 1 < 10
then 2(x + 1)
2
else 5(x + 1)
Type: OutputForm
Perhaps this is not nearly as obvious as the way it
might be done in
Mathematica or Maple - especially for someone just
beginning to use
Axiom but I think it is equivalent to what is done in
these other
systems and it is fair to say that it is in keeping with
the view in
Axiom that everything is fundamentally algebraic.
Regards,
Bill Page.
...
On Sat, 30 Apr 2011 20:40:28 +0200
Stefan Karrmann <address@hidden> wrote:
Dear all,
I'm new to axiom and have a problem with piecewise
functions.
test1 (x | x < 10) == 2*x
test1 (x | x < 10) == 5*x^2
test1
-> test1 (x | x < 10) == 2x
test1 (x | ^ x < 10) == 5x
Type:
FunctionCalled
test1 y
->
2
5y
I expected something like (if y < 10 then 2*y else
5*y**2).
How is it possible to pass a Variable to a piecewise
function respecting
the pieces?
PS: Using a block and => or explicit if-then-else does
not help.
--
Kind regards,
Stefan