12685 Reputation

19 Badges

8 years, 265 days

MaplePrimes Activity

These are answers submitted by vv

The memory usage at the bottom of the worksheet refers to the Maple kernel.

The Java memory in the task manager is due to the GUI. It is not controlled by gc().
It seems that it is not released to the OS: just try  plot3d(x^2+y^2,x=-1..2,y=-1..1, numpoints=1000000);

The Java GUI is convenient for Maplesoft because it can be used in all platforms, but for the users ...
(It's a pity that the old Classic interface is gone.)

To use less memory, try to avoid graphics. You may also consider the command-line Maple.

evalindets(p, `*`, u -> `+`(op(u)));

However, if you have in mind a more general expression, you must decide what to do e.g. with a^2 ( = a*a), a/b (=a*b^(-1)) etc.


f := (2*y-1)*(4*y+6*x-3)/(y+3*x-1)^2;
F :=z -> 4*z*(2*z+3)/(z+3)^2;



proc (z) options operator, arrow; 4*z*(2*z+3)/(z+3)^2 end proc


simplify( F((y-1/2) / (x-1/6)) )  =  f;

(2*y-1)*(4*y+6*x-3)/(y+3*x-1)^2 = (2*y-1)*(4*y+6*x-3)/(y+3*x-1)^2




1. Replace e^(...)  with  exp(...)
(or define  e:=exp(1)).
2.  The integral cannot be computed symbolically.
If you are satisfied with numerical values, just assign values to your constants C:=..., ...
and then execute

evalf( Int(f1(g), g=0..infinity) );


It's simpler to express the recurrence in terms of 
X[n] = Sum(x[k], k=1..n)
instead of x[n]. Notice that x[n] = X[n] - X[n-1].

rsolve({u(1) = X[1], u(n + 1) = u(n) + (X[n + 1]-X[n] - u(n))/(n + 1)}, u(n));

           X[n] / n

f := (x1-x2)*(x2-x3)*(x3-x4)*(x4-x1): 
G := x1^2+x2^2+x3^2+x4^2-1:
H:=f + x5*G:
Groebner:-Basis(diff~(H, [X]), plex(X)):
S:=solve(%, explicit):
nops([S]);      #    40
S[-1], simplify(eval(f, S[-1]));

{x1 = 1/4 + sqrt(3)/4, x2 = sqrt(3)/4 - 1/4, x3 = 1/4 - sqrt(3)/4, x4 = -1/4 - sqrt(3)/4, x5 = 1/4},   -1/8

DirectSearch works well, not very fast though. (The absolute minimum is -0.125).

f := (x1-x2)*(x2-x3)*(x3-x4)*(x4-x1): 
G := x1^2+x2^2+x3^2+x4^2-1:
GlobalOptima(f, [G=0,x1>=0]);

[-0.125000010409962, [x1 = 0.183013027400331, x2 = 0.683012548155197, x3 = -0.683012850582002, x4 = -0.183012508983874], 4041]

eq1 := c[2] = Z^2/(2*(m + 2)):
eq2 := Int((m*(c[2] - x^2/(2*(m + 2))))^(1/m), x = 0 .. Z) = alpha:
IntegrationTools:-Change(eval(eq2,eq1), x=t*Z,t):
combine(value(%)) assuming m>0,Z>0:
Zsol := combine(solve(%, Z, explicit)) assuming m>0;

(It can be expressed using powers, without ln and exp).

After a change of variables, the integral reduces to

F := int(sin(cos(t))*cos(t),t);

so, for a purely transcendental function.
AFAIK for such functions the Risch algorithm is completely implemented in Maple.
Maple does not compute F, so F is not elementary.
It remains of course the question whether F could be expressed using some special functions.

simplify should be enugh, but combine is necessary here.
simplify(combine(r)) assuming x<=0;     # 0

simplify(combine(r)) assuming x::real;  #  x + |x|

V:= Z ->  -32/12*evalf(Int(eval(A,z=Z),[n0=0..1,u=0..infinity], epsilon=1e-3)):
plot(V, 1..10, numpoints=10, adaptive=false);

implicitplot implements many algorithms and has many options.
E.g. adding the option signchange = false, the line (asymptote) disappears.

The (sub)groups are represented by generators, without generating all the elements.
Both S_10 and S_11 have two generators, see Generators(Symm(10)) and Generators(Symm(11))
so using simple algorithms it will be easy to compute the cosets.

g := (x, T) -> T*x + x^2:  #just an example
dgdx:=(x,T) -> D[1](g)(x,T);
dgdx(1, 2);
dgdx(x, 1);
dgdx(x, T);

                dgdx := (x, T) -> D[1](g)(x, T)
                            1 + 2 x
                             g := g
                         D[1](g)(x, T)
                          --- g(x, T)

It is obvious that the result of odetest cannot be 0, because sol is a truncated series.
(strictly speaking, it's not a `series`, the type being `+`).
But this works as expected:

asympt(%,x); # just simplifies


First 7 8 9 10 11 12 13 Last Page 9 of 113