The equation tan(y) = 2*tan(x) defines y implicitly as a function of x.  Well, perphas "defines" is too strong a word, since there are multiple solutions for y.  However, if I am not mistaken, there exists a unique continuous solution y(x) that goes through the origin, that is, y(0)=0, and is defined for all x.

Question 1: How do we plot the graph of y(x)?

I have a roundabout solution as follows.  Differentiate the equation tan(y(x)) = 2*tan(x) with respect to x and arrive at a first order differential equation in y(x).  Solve the differential equation with the initial condition y(0)=0.  Surprisingly, Maple obtains an explicit solution:

which we can plot:

plot(rhs(%), x=0..2*Pi);

Question 2: Is there a neat way of getting that solution with algebra only, without appealing to differential equations?

In Maple 11 we have:

> A := <a,b,c>:
> a := 1:  b := 2: c := 3:
> convert(A, list);
                                   [1, 2, 3]

In Maple 2015 we have:

> A := <a,b,c>:
> a := 1:  b := 2: c := 3:
> convert(A, list);
                                   [a, b, c]

Is that change really intended?

I have a table whose indices and entries are strings, as in:

    T := table(["green" = "gruen", "red" = "rot", "blue" = "blau"]);

Thus, T["green"] evaluates to "gruen" but T["asdf"] evaluates to T"asdf".

What is a good way to detect that "green" is a predefined index into the table but "asdf" is not?  I do it in a somewhat clumsy way, as in:

> has("green", [indices(T, 'nolist')]);
        true

> has("asdf", [indices(T, 'nolist')]);
        false

I suspect that there ought to be a less elaborate way of doing that.

I wish to evaluate the expression

knowing that

where a is a constant.  It is not hard to see, assuming enough differentiability,  that the expression evaluates to

I know how to do this when all the derivatives are expressed in terms of the diff() operator.  Here it is:

eq := diff(u(x,t),t) = a^2*diff(u(x,t),x,x);
expr := diff(u(x,t),t,t);
eval['recurse'](expr,[eq]);

However, I would prefer to do the computations when all derivatives are expressed in terms of the D operator but cannot get that to work.  What is the trick?

Consider

> z := Int(f(t-s), s=0..1);

The result is clearly a function of t (and definitely not a function of s, which is a dummy variable).  Let's define

> F := unapply(z, t);

Then

> F(q);

as expected.  However:

> F(s);

which is not correct, as this confuses the argument s of F with the dummy integration variable s.  How would you salvage the situation?