Compare,
(3+4*y^4)/(12*y);
diff((3+4*y^4)/(12*y),y);
with,
(3+4*y^4)/12*y;
diff((3+4*y^4)/12*y,y);
acer
Do you mean like this?
> changecoords(x^2+y^2,[x,y],polar):
> lprint(%);
x^2*cos(y)^2+x^2*sin(y)^2
> changecoords(x*y*z,[x,y,z],spherical,[r,theta,phi]):
> lprint(%);
r^3*sin(phi)^2*cos(theta)*sin(theta)*cos(phi)
acer
To do it in Maple, see the help-page ?Calculus1,VolumeOfRevolution
I am sure that there are lots of references on the web. Here is
one.
acer
Look, compare these,
A := < < 1 | 2 > , < a | 3 > > ;
a := 5;
A;
a := 17;
A;
lprint(A);
restart:
A:=matrix([[1,2],[a,3]]);
a:=5;
evalm(A);
A[2,1];
a:=17;
A[2,1];
So, you can see that whether using matrix or Matrix, the [2,1] entry does change as `a` changes. The printing differs. But some people will like having `a` get printed, because it shows that A will get updated as `a` changes. And some other people will like having the value of `a` get printed instead.
There are other ways in which last_name_eval matrices (arrays) differ from Matrices (rtables) in terms of evaluation rules. Choose what works the way you prefer, perhaps.
acer
Without considering anything about this particular integrand, here's an idea. In the definite case, x is known to be nonnegative and real. In the indefinite case, nothing is assumed about x, so it could be negative, or complex valued, etc, which could be causing difficulties in obtaining a general solution.
So it'd make more sense to point out instead that this next doesn't produce a result,
int(sin(x)*sin(x^3+x), x) assuming x>0;
Now notice that Maple 11 returns unevaluated on these too,
int(sin(x)*sin(x^3+x), x=0..N) assuming N>0;
int(sin(x)*sin(x^3+x), x=1..infinity);
So perhaps the infinite integral matches some very special pattern.
acer
If you select the superscripted object (the input, not the output) with the mouse, then right-click, you should get a context-menu for operations on it.
Try this context-menu operation (which should act in-place): 2-D Math -> Convert To -> Atomic Identifier (checkbox). Once that check-box is checked/toggled, the input object should no longer be a table entry.
You may have to repeat this, for each occurence. I'm not sure. And copy & paste of that input object might remove that quality in the new pasted input. But it should behave more like an atomic name. You can even typeset neat things like t^N - t^N as output.
acer
I'm not quite sure exactly what you are after. But maybe this will be enough to inspire you.
------- cut here, file wrapmaple ----------
#!/bin/bash
argc="$#"
argv="$*"
export argc argv
maple $*
------- cut here, eof file wrapmaple -------
And so now, after `chmod u+x wrapmaple`,
%./wrapmaple -s
maple> getenv(argv);
"-s"
maple> getenv(argc);
"1"
Ok, so argv isn't an array, and it's not **argv. And you'd have to do a little more to get argv[0] (which I assume you want to be just `maple`). But maybe it'll help some.
acer
It's easy enough to write a procedure to do this sort of thing. For example,
f := proc(s,n)
use StringTools in
CharacterMap( cat($"a".."z"), Rotate(cat($"a".."z"),26-n), s );
end use;
end proc:
f("this is a test",1);
f("this is a test",-3);
Of course, it is inefficient to Rotate the lowercase alphabet many times. You could also create all such rotations (as well as the alphabet itself), store them, and re-use them. You could make a Array of such rotations global or local to your procedure, as you wished.
acer
Try the help-pages ?solve,details and ?fsolve,details .
For this example, fsolve is only going to produce one root at a time. There's nothing wrong with that, and it's not unreasonable behaviour for a root-finder when no range is supplied.
As for solve, well, you asked it to return a representation of all the roots, by setting an environment veriable to control that. It may be that the result expressed by solve is redundant, sure. Duplication in the returned result could be a bug to fix. But the form of the result, and how that expresses the full set of all solutions, can make sense.
I read today that the equivalent result from some TI calculator is something like @n1*Pi . I don't see why that syntax is so much less obscure to the new user.
acer
Allowing private messages is an editable setting here.
To change it, click on "my account" at the top of the left navigation margin. On the page that then appears, click on the "edit" tab. If you then scroll down, you could see a check-box titled, "Private message settings".
acer
You can use plots[display] to place more than one plot into the same "diagram".
Also, there's no need to assign to q, l, x1, x2, and x3. You can simply use subs and eval to get that effect, without having to unassign them for each plot.
restart:
Mg_1:=x->(8/25*q*(5*l-x)^2-9/5*q*l*(5*l-x)):
Mg_2:=x->(-3*q*l^2+q*l*(4*l-x)):
Mg_3:=x->(-q*l*(3*l-x)):
s1:={q=1,l=10}:ss1:=eval({x1=5*l},s1):
s2:={q=1,l=10}:ss2:=eval({x2=4*l},s2):
s3:={q=1,l=10}:ss3:=eval({x3=3*l},s3):
p1:=plot(subs(s1,eval(Mg_1)),0..eval(x1,ss1)):
p2:=plot(subs(s2,eval(Mg_2)),0..eval(x2,ss2)):
p3:=plot(subs(s3,eval(Mg_3)),0..eval(x3,ss3)):
plots[display]([p1,p2,p3]);
# Maybe you'll have many of them, and wish
# to automate their creation.
seqplots:=seq( plot(subs(s||i,eval(Mg_||i)),0..eval(x||i,ss||i)), i=1..3 ):
plots[display]([seqplots]);
I wouldn't be surprised if some of the eval() calls above could be optimized out of the code.
acer
You asked Maple to solve the equality, while you asked Mma about the inequality.
As I previously mentioned, Maple doesn't produce a result for the inequality that you had previously supplied (whether using the extra inequalities x>-infinity,x
I suspect that I got confused (not the first time) about assuming. I believe that `int`, `simplify`, `dsolve`, `is`, and things-which-primarily-use-`is` can make good use of the assuming facility. But `solve` may not properly be in that collection, which is a pity.
It's a documentation bug, that there is no clear indication about precisely what supports `assume` and `assuming`.
So, instead of using `assuming`, one could try this,
solve({x^2+y^2 = 1,x>-infinity,x
-infinity,y-infinity,x
What does this mean?
Reduce[x^2+y^2<1,{x,y}] which returns -1
I guess that that was an instance of chopped output.
Do you realize that, in the absence of "assuming" qualification, by default Maple's `solve` treats the variables as if they might be complex-valued? And do you know that, also by default, Mma's Reduce treats the variables as if their were from the purely real domain?
So, I suppose that you could compare these two,
Mma% Reduce[x^2+y^2<1,{x,y}, Complexes]
Maple> solve(x^2+y^2<1,{x,y});
or these two,
Mma% Reduce[x^2+y^2<1,{x,y}]
Maple> solve(x^2+y^2<1,{x,y}) assuming x::real, y::real;
Maple's solve is not very strong at inequalities, however. It's been getting stronger, I believe, but it's functionality is not yet mature.
Can anyone explain this example to me, in Maple 11?
> solve(x^2+y^2 = -1, {x, y}) assuming x::real, y::real;
{y = y, x = (-y^2-1)^(1/2)}, {y = y, x = -(-y^2-1)^(1/2)}
acer
Within the procedure, right after where you have it call NLPSolve, could you simply assign the return value and/or arguments of the NLPSolve call into an Array declared as a global?
acer
