Carl Love

Carl Love

26668 Reputation

25 Badges

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

MaplePrimes Activity

These are answers submitted by Carl Love

Just change the = between the seqs to =~.

Or you can make a seq of equations:

seq(seq(p[j,c]= 1/(1+exp(-(mu+cat(tau,j)+cat(eta,c)+mix[j,c]))), j= 2..3), c= 1..3);

which is more efficient than the =~ option.

You wrote: map2(myfunc, phi, p1, {CH||(1..5)});

But that needs to be map[3], since you are replacing the 3rd argument of myfunc with a set/list. Note that map2 is an abbreviation for map[2], but that there is no such abbreviation for higher indices.

You wrote: Is it not by default for Maple to 'adapt' to computer and use multi thread then?

It can't be done automatically (yet); each piece of code needs to be inspected for multithreading possibility. If the computation of later iterations depends on the results from earlier iterations, then multithreading isn't possible. I believe that reviewing the whole library for multithreading possibilities is an ongoing process at Maplesoft. For example, Maple 17 introduced multithreaded garbage collection, which is done automatically (no input is required from the user). The user can control this via kernelopts(gcmaxthreads).

You wrote: ANS1:=w1*a+w2*b+(1-w1-w2)*b

I'll assume that you meant for the final b to be c; otherwise, the cs are totally unused.

With that assumption, all of the above code can be compressed to:

ANS:= < w1, w2, 1-w1-w2 > ^%T .

     Matrix([Threads:-Seq](Threads:-Map[3](myfunc, phi, p, [CH||(1..5)]), p= [p||(1..3)]))


returning a 5-vector for ANS.

First, there is no need to wrap z(.., 1) with Vector(...); it is automatically converted to a column vector by the indexing.

Since Statistics:-Tally is prepared to take vectors (or lists), you could use it, send the output to a table, and index the table for the element that you want. Sounds complicated, but all it is is

Statistics:-Tally(z(.., 1), output= table)[1];


The reason that you got an error is that you forgot to include phi, your first argument to myfunc, in your map2 call. So, it should be

map[3](myfunc, phi, p1, {CH||(1..5)});

To make that run multi-core, replace map with Threads:-Map.

Taking specific values of n, we get equations in a, b, c, d. We solve those equations.

T:= n-> add(binomial(n,j)^4, j= 0..n):
EQN:= n-> (n+1)^3*T(n+1) = (2*n+1)*(a*n^2+a*n+b)*T(n) + n*(c*n^2+d)*T(n-1):
solve({seq}(EQN(k), k= 1..4), {a, b, c, d});

                 {a = 6, b = 2, c = 64, d = -4}


So the solution is not in the ranges -30..30.

theta:= (n::{odd,posint})-> 
          2*sin((n+1)*beta/2)/(n+1)/beta +
          `if`(n=1, 1,

@jenniferchloe In order to end up with a closed curve, it needs to be a closed curve (a polygon) at the initial level. And you can't do that with just any angle. To make an initial equilateral triangle, you need to make turns of 120 degrees. If the angle is set at 60, each of those turns is RR. So, to do the spiky 80-degree thing all the way around,

  1. set the angle to 40
  2. make the initial triangle with RRR turns (3*40 = 120)
  3. replace every single turn in the recursion with a double turn (2*40 = 80).


The equation can be entered like this:

w(x,y) = 4*F/Pi^4/E[2]/I/a/b*


   n= 1..infinity), m= 1..infinity


"Solving" it is another thing. It's not exactly clear what "solve" means in this case.


Try this:

plot(sin(x), labels=[typeset(convert(a, `local`)[0]), "some text"]);

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
                          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;
                                         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



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


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.

First 361 362 363 364 365 366 367 Last Page 363 of 384