Carl Love

Carl Love

26386 Reputation

25 Badges

11 years, 141 days
Himself
Wayland, Massachusetts, United States
My name was formerly Carl Devore.

MaplePrimes Activity


These are answers submitted by Carl Love

To address your first issue: Maple's int does not supply a constant of integration. If you need one, you can add it yourself, or you can use dsolve without initial conditions:

eq:= diff(v(x), x, x) = P*x/E/Iz;
                      d  / d      \   P x
                     --- |--- v(x)| = ----
                      dx \ dx     /   E Iz
dsolve(eq);
                             3               
                          P x                
                  v(x) = ------ + _C1 x + _C2
                         6 E Iz              

I noticed that you changed the initial condition on the derivative between your solution with int and your attempted solution with dsolve. You should specify the condition like this: D(v)(0) = -P*L^2/E/Iz/2. (If you need to specify a condition for a second derivative, then use (D@@2)(v)(0).) Putting it all together, we have

bcs:= v(L)=0, D(v)(0) = -P*L^2/E/Iz/2;
                                            2
                                         P L  
                  v(L) = 0, D(v)(0) = - ------
                                        2 E Iz
dsolve({eq, bcs});
                           3       2         3
                        P x     P L  x    P L  
                v(x) = ------ - ------ + ------
                       6 E Iz   2 E Iz   3 E Iz

 

 

To answer your original question, the initial triangle is different. It does not have any left turns. The "turtle" (i.e. cursor or pen in adult language) seems to start in the upper left with an initial heading (direction) horizontally to the right. So, the basic triangle (a downward pointing equilateral triangle) can be plotted via

SetTurtleAngle(60);

TurtleCmd("FRRFRRF");

Each edge of the triangle in represented by an F (Forward). We want to subdivide each edge. So we replace each F with the Koch recursion. We can do it like this

Snowflake:= n-> cat(Koch(n), "RR", Koch(n), "RR", Koch(n));

where Koch is the procedure from your original post, not the one from your Reply.

Finally, to plot it you can do

TurtleCmd(Snowflake(5));

Use the ImportData() command to launch a dialog/assistant that will read your data file into a Matrix. Then follow the instructions given by Preben.

Having only one equation, you can only solve for one variable per invocation of solve:

solve(equation1, {p[1]});

solve(equation1, {p[2]});

Also, looking closely at the end of your equation, I see that it is fourth order in p[2]. This may have been a typo on your part, since you said the equation was quadratic. It is still solvable, but the solutions are very large, and take about a minute to be generated.

It is unfortunate that solve does not simply give an error message when one asks for solutions for more variables than there are equations. Instead one gets the confusing "Warning: Solutions may have been lost".

     if given a permutation group

     1 2 3

     2 1 3

To me, that's a single permutation, not a whole permutation group. But perhaps you mean the group generated by the permutation.

The cycle factorization of the permutation can be done via

convert([2,1,3], disjcyc);
                            [[1, 2]]

But I don't know if that satisfies your questions about the "type" of permutation group and about polya counting. Let me know.

I think that what you want is

plots:-spacecurve([seq]([x[k],y[k],z[k]], k= 1..200));

But I don't know if that's "in the three-dimensional phase domain", and it's certainly not a "phase plane".


Anyway, please let me know if the spacecurve is what you want.

You need to make some assumptions for the IsDefinite to work.

assume(w1 >= 0, w2 >= 0, w3 >= 0, w4 >= 0, w5 >= 0, w6 >= 0);

I don't know if the overall program will work after these assumptions are made (you didn't attach the uploaded file), but that's the first hurdle.

Note that L(w1,w2,w3,w4,w5,w6,lam) is evaluated before being passed to NLPSolve. Thus, the fact that you did specify the nonnegativity assumptions in the call to NLPSolve does not cause those assumptions to be used while evaluating the arguments to NLPSolve.

This is a bit tricky; perhaps not suitable for the Maple beginner.

F:= (N::evaln(list(`=`)))-> (convert(N, `local`)@lhs = rhs) ~ (eval(N)):

u:= [a=x, b=w]:
p:= [1=4, 3=2, 5=2]:
F(u), F(p);
      [u(a) = 1, u(b) = w], [p(1) = 4, p(3) = 2, p(5) = 2]

seq(Matrix([[seq(a[k], k = x+m .. y+m)]]), m = 0 .. 2);

^^^^^^^

Obviously, the result of such a command is a sequence of Matrices, not a Matrix.

Here's my shortest code:

< seq(< a[x+m..y+m] >^%T, m= 0..2 ) >;

In particular, note the for any list L and valid indices a and b,

[seq(L[k], k= a..b)]

is the same thing as simply

L[a..b]

In Maple, when a negative real number is raised to a fractional power with an odd denominator, the result is not real. As it says at ?arithop or ?^,

For non-integer (complex) numeric powers y and (complex) numeric x, the expression x^y is evaluated as exp(y*ln(x)), where ln(x) is evaluated using the principal branch of the logarithm.

The function surd can be used to compute real odd roots of negative real numbers.  See ?surd for more information.

Since ln(-1) = I*Pi, the upshot of that first sentence is that for integer n, (-1)^(1/n) = cos(Pi/n) + I*sin(Pi/n):

radsimp((-1)^(1/3));
                         1   1    (1/2)
                         - + - I 3     
                         2   2      

cos(Pi/3)+I*sin(Pi/3);
                         1   1    (1/2)
                         - + - I 3     
                         2   2         
But

surd(-1, 3);
                               -1

or

use RealDomain in (-1)^(1/3) end use;
                               -1

(see ?RealDomain).

In this case, you need to circumvent the automatic simplification of x^0 to 1. You do this with

coeff(b, x, 0).

We make Points1 into an (M+1) x (N+1) x 3 listlistlist:

A:= [seq](Points1[(M+1)*k+1..(M+1)*(k+1)], k= 0..N);

plots:-surfdata(A);

And you can add the same options that you used for the pointplot3d command.

 

Please remove the with(linalg) from your worksheet. It works without it.

If they can be considered the same thing and also be considered the same as 1, then it is trivial:

Re ~ (sol);

Then proceed with whatever else you were doing with the repetitions.

If your goal is simply to remove the repetitions from a list L, and you don't care about the order, then it is trivial: convert to a set:

{L[]};

If you want to keep it a list, but you still don't care about the order, it is still trivial: convert to a set, then convert back to a list:

[{L[]}[]];

When order doesn't matter, removing repetitions, whether or not they exist, is much easier than detecting or finding them: The former can be done entirely in Maple's kernel.

 

An rtable is a Matrix, Vector, or Array. A list is not an rtable. FindRepetitions returns a list (so converting it to a list doesn't do anything). Why don't you use the numelems command that acer recommended? If your Maple version is less than 15, use nops for a list.

First 359 360 361 362 363 364 365 Last Page 361 of 381