In mathematics you can write f(f(f(x))) as f^3(x). I've trawled through the Maxima manuals but can't find a way to express this for an arbitrary power.
Maxima doesn't have a built-in operator for that. But I think you can define a workable solution yourself. Maybe this works for you:
(%i1) infix ("o^") $
(%i2) matchdeclare (ff, symbolp, xx, all) $
(%i3) tellsimp ((ff o^ 0)(xx), xx) $
(%i4) tellsimp ((ff o^ 1)(xx), ff(xx)) $
(%i5) matchdeclare (nn, lambda ([e], integerp(e) and e > 1)) $
(%i6) tellsimp ((ff o^ nn)(xx), (ff o^ (nn - 1))(ff (xx))) $
I've defined simplification rules for "o^" since I want it to be applied only if it appears in a function call expression (i.e., something like (f o^ 3)(x), not just f o^ 3 by itself), and the second argument is a literal, nonnegative integer.
You have to write a space between "o^" and the following token, since otherwise the parser gets confused.
Here are some examples:
(%i7) (h o^ 0)(u);
(%o7) u
(%i8) (h o^ 1)(u);
(%o8) h(u)
(%i9) (h o^ 2)(u);
(%o9) h(h(u))
(%i10) (h o^ 3)(u);
(%o10) h(h(h(u)))
(%i11) (h o^ n)(u);
(%o11) h o^ n(u)
(%i12) %, n=2;
(%o12) h(h(u))
(%i13) h o^ 3;
(%o13) h o^ 3
(%i14) %(z);
(%o14) h(h(h(z)))
(%i15) (h o^ -1)(u);
(%o15) h o^ (- 1)(u)
Note that in cases which don't match the rules, the expression is not simplified. This leaves the door open to defining additional rules to handle those cases, without changing the stuff that already works.
The display of unsimplified expressions (e.g. %o11) is ambiguous; this is a bug.
Related
I cannot find anything about this, sorry.
If I have expressions with the symbolic function f(x) and now I want to replace in these expression f(x) by its explicit form how to do it?
For example:
I have
f(x):= x^2+sin(x)
and in the differentiation
diff (%e**sqrt(f(x)*a), x,2);
I want to replace now f(x) by the expression above?
Thanks
Karl
(%i1) i: integrate(f(x)*f(4*x), x, 0, 1) $
(%i2) f(x):= x^2+sin(x) $
(%i3) ev(i, f);
1
/
[ 2 2
(%o3) I (sin(x) + x ) (sin(4 x) + 16 x ) dx
]
/
0
-- Function: ev (<expr>, <arg_1>, ..., <arg_n>)
Evaluates the expression <expr> in the environment specified by the
arguments <arg_1>, ..., <arg_n>. The arguments are switches
(Boolean flags), assignments, equations, and functions. 'ev'
returns the result (another expression) of the evaluation.
I'm struggling with getting maxima to simplify expressions in the way that I want them.
rhs(solve(a*x-3=b*y,x)[1]);
returns
(b*y+3)/3
However, I'm wanting to display the result to students and so I want the output to be
(b*y/3) + 1
Is there some simplification that I can do to a rational expression in this form to get the output I want?
You can undo the effect of ratsimp in this case by dividing each term in the numerator by the denominator. Here is a simple-minded implementation:
(%i1) unratsimp (e) :=
block ([foo, bar],
[foo, bar]: [num(e), denom(e)],
map (lambda ([foo1], foo1/bar), expand (foo))) $
(%i2) 1 + a/b + c*d/3 - %pi*x/y;
%pi x c d a
(%o2) (- -----) + --- + - + 1
y 3 b
(%i3) ratsimp(%);
(b c d + 3 b + 3 a) y - 3 %pi b x
(%o3) ---------------------------------
3 b y
(%i4) unratsimp(%);
%pi x c d a
(%o4) (- -----) + --- + - + 1
y 3 b
(%i5) unratsimp((b*y + 3)/3);
b y
(%o5) --- + 1
3
I don't know how general that is; it's just the first thing I tried, but maybe it's enough for your purpose. I don't know a built-in function for this.
The results %o4 and %o5 are maybe not exactly as a human would write them. Convincing Maxima to display the terms in + and * expressions in a different way is not straightforward -- Maxima has strong ideas about how to order terms in an expression which are assumed throughout the code. But I think that others have asked questions, which might have answers, about displaying expressions -- you might search Stackoverflow if you are are interested.
The command you can use here is multthru:
(%i1) e1:(b*y+3)/3;
(%o1) (b*y+3)/3
(%i2) multthru(e1);
(%o2) (b*y)/3+1
In this case also the following will work
(%i3) distrib(e1);
(%o3) (b*y)/3+1
(%i4) expand(e1);
(%o4) (b*y)/3+1
I'm struggling to find a way to switch from a symbolic declaration of the differential operator to its implementation
I give you an example.
F: (10-'diff(x(t),t)^2 -2*x(t)*'diff(x(t),t) -5*x(t)^2)*%e^(-t);
E: ratsimp(diff(F, x(t)) - diff(diff(F, 'diff(x(t),t)), t));
sol: ode2(E, x(t), t);
sol: ev(sol, [%k1 = C1, %k2=C2]);
trans_cond: diff(F, 'diff(x(t), t));
trans_cond: ev(trans_cond, sol);
trans_cond: at(trans_cond, [t=1]);
The corresponding output maintains the symbolic notation whereas I would like to evaluate the diff() obtained after the last substitution.
Giving the result:
% 4*C1-C2^(-2)
Another solution. The nouns option for ev causes the evaluation of symbolic derivatives, and also any other noun expressions such as symbolic integrals, symbolic summations, etc.
(%i2) 'diff(4*x^2, x);
d 2
(%o2) -- (4 x )
dx
(%i3) ev (%o2, nouns);
(%o3) 8 x
A shorter form of ev(..., nouns) is recognized by the interactive console. You can input ..., nouns instead.
(%i5) %o2, nouns;
(%o5) 8 x
Here is ev(..., nouns) applied to symbolic integral:
(%i6) 'integrate (x^2, x);
/
[ 2
(%o6) I x dx
]
/
(%i7) %, nouns;
3
x
(%o7) --
3
and here, to a symbolic summation:
(%i8) 'sum (f(k), k, 1, 3);
3
====
\
(%o8) > f(k)
/
====
k = 1
(%i9) %, nouns;
(%o9) f(3) + f(2) + f(1)
Found the answer, ev() carries the option diff which solves all the symbolic differentiation in the expression.
In Wolfram Mathematica we can define an operator acting on a function (i.e. function that returns function) e.g. as for the operator of multiplication by the first argument acting on a functions of two arguments in the example below
X[f_] = Function[{x, y}, x*f[x, y]]
Then we can apply this operators to any function with any 2 arguments
In[2]:= X[g][z, t]
Out[2]= z g[z, t]
There is a similar construction in Maple
X:=proc(f) option operator; local x,y;
unapply(x*f(x,y),x,y)
end;
with the similar mode of application
> X(g)(z,t);
z g(z, t)
In Maxima I tried this
X(f):=lambda([x,y],x*f(x,y));
but when trying to apply it I get
(%i5) X(g)(z,t)
(%o5) z*f(z,t)
so, it looks like f is not recognized as an argument of function X when I used lambda.
Is there any way to solve this problem?
In case of Maple and Mathematica this type of operators helps a lot to manipulate with linear differential operators
Maxima lambda doesn't evaluate any of the expressions inside the body of it, so f is not evaluated (to g). That's the behavior you are seeing. The motivation for it that I can see is that the lambda body might contain expressions which don't have the expected effect until some variables have values, e.g. length, for ..., print, etc.
You can get the expected behavior by substituting into the body. Here are two ways to do that. The first uses the function subst which I think is maybe the most obvious.
(%i1) X(f):= subst ('f = f, lambda([x,y],x*f(x,y)));
(%o1) X(f) := subst('f = f, lambda([x, y], x f(x, y)))
(%i2) X(g);
(%o2) lambda([x, y], x g(x, y))
(%i3) X(g)(z, t);
(%o3) z g(z, t)
The second uses the function buildq which is effectively a substitution function which quotes (does not evaluate) the expression into which something is substituted.
(%i4) X(f) := buildq ([f], lambda ([x, y], x*f(x, y)));
(%o4) X(f) := buildq([f], lambda([x, y], x f(x, y)))
(%i5) X(g);
(%o5) lambda([x, y], x g(x, y))
(%i6) X(g)(z, t);
(%o6) z g(z, t)
Finally, if you are interested in creating lambda expressions using evaluated expressions more often, you could create your own kind of lambda for that. I'll call it evlambda here.
(%i11) evlambda (a, b) := apply (lambda, [a, b]);
(%o11) evlambda(a, b) := apply(lambda, [a, b])
(%i12) X(f) := evlambda ([x, y], x*f(x, y));
(%o12) X(f) := evlambda([x, y], x f(x, y))
(%i13) X(g);
(%o13) lambda([x, y], x g(x, y))
(%i14) X(g)(z, t);
(%o14) z g(z, t)
The key here is that evlambda is defined as an ordinary function, so its arguments are evaluated. So by the time lambda is applied, b has been evaluated so it contains g.
Note that this evlambda won't do anything useful with length, for ..., and print, which is to be expected.
(%i15) foo : evlambda ([l], 1 + length(l));
length: argument cannot be a symbol; found l
-- an error. To debug this try: debugmode(true);
(%i16) bar : evlambda ([n], for i thru n do print (i));
Unable to evaluate predicate 1 > n
-- an error. To debug this try: debugmode(true);
(%i17) baz : evlambda ([x], print (x));
x
(%o17) lambda([x], x)
(%i18) baz(5);
(%o18) 5
The last one, with print, evaluates print when baz is defined (so x is the output), but then not again when baz(5) is evaluated -- this behavior is to be expected since evlambda evaluates its arguments.
Consider the following statements:
(%i1) matchdeclare([a,b], constantp);
(%o1) done
(%i2) defmatch(match, a*x+b);
(%o2) match
(%i3) match(2*x+3);
(%o3) [b = 3, a = 2]
I want to generalise this pattern in a function. But then it doesn't seem to work anymore:
(%i1) matchForm(test, form, constants) := block(
matchdeclare(constants, constantp),
defmatch(match, form),
match(test)
);
(%o1) matchForm(test, form, constants) :=
block(matchdeclare(constants, constantp), defmatch(match, form), match(test))
(%i2) test: 2*x+3;
(%o2) 2 x + 3
(%i3) form: a*x+b;
(%o3) a x + b
(%i4) constants: [a,b];
(%o4) [a, b]
(%i5) matchForm(test, form, constants);
defmatch: evaluation of atomic pattern yields: a x + b
(%o5) false
Debugging a bit, a bit it seems like the issue is that matchdeclare doesn't accept the argument to be a variable. Is ther any way to make a function like I try to make in maxima?
I haven't tried this, but: perhaps you can get the effect you want via
apply (matchdeclare, [constants, 'constantp]),
which will evaluate constants before calling matchdeclare.