Carl Love

Carl Love

24855 Reputation

25 Badges

10 years, 122 days
Natick, Massachusetts, United States
My name was formerly Carl Devore.

MaplePrimes Activity

These are answers submitted by Carl Love

Just apply coeff twice:

S:= A*sin(x)*cos(z) + B*sin(2*x)*cos(z) + C*sin(3*x)*cos(2*z):

coeff(coeff(S, sin(2*x)), cos(z));


The command that you want is ?subsindets. For example,

subsindets(expr, anything, simplify);

As you're learning to use this, you will quickly come to a situation where you don't want to apply the transformer to absolutely every subexpression, yet there is no convenient type (the type in the example is anything) that restricts it to what you do want. At that point you'll need to learn ?frontend.

Both subsindets and frontend are built-in kernel commands, so they are more efficient than user-defined procedures.

If you literally want to apply map to all levels of an expression, you can easily make a recursive version of map. For example,

DeepMap:= proc(f, expr)
    option system, remember;
    f(`if`(expr::atomic, expr, map2(procname, args)), args[3..-1])
end proc;

(This one applies f to the outermost level also.) (This handles the basic map, not any of map's indexed versions.)

The subs command only does "syntactic" substitutions, i.e. the item being substitued for must occur as a distinct entity within Maple's internal representation of the expression. It is more of a "programmer level" command than "user level", and it makes no claim as to the mathematical validity of what it does. To perform algebraically valid substitutions, use algsubs.


Use ?LinearAlgebra,LeastSquares:

   X:= LinearAlgebra:-LeastSquares(A,Y);

It is a nuisance that geom3d requires you to label every object. The object model used in that package is much older than the modern one based on modules. In the modern module model, an object "is what it is", so to speak, regardless of what, or even if, you name it; in the older model, an object's properties are based on looking it up by name. (To "deconstruct" it, it seems that the evolution of the object model is analogous to the evolution of social classes.) But you can reuse the labels in geom3d, so the easiest way to do what you want is

    [seq](sort(Equation(TangentPlane(P, S, point(A, pt[])), [x,y,z])), pt in L);

(where all points are named A and all planes are named P).

If you do require distinct names for each object (so that you can look up their properties without recreating them), it is possible to construct names based on the numerical values of the point using nprintf:

            Equation(TangentPlane(nprintf("P%a",pt), S, point(nprintf("A%a", pt), pt[])), [x,y,z])
      ,pt in L

Unique names can also be created with cat, which is what John May did.

I made two very small changes to your procedure, and I almost got the series that you indicated, the only difference being that I got an alternating series. Here are a few tips to help you debug your procedures:

  1. Indent after each level of do loop.
  2. Use the trace command -- in this case trace(Ad) -- before running the procedure. This will show you the result of each assignment (":=") statement. 

And here are the small changes that I made:

  1. Do not use unevaluation quotes; for example use u[i,k] rather than 'u[i,k]'.
  2. Use add, not sum.

Construct a graph of 12 vertices, one for each set. I'll label the vertices simply 1 - 12 rather than S[1] - S[12]. Two vertices will share an edge iff the corresponding sets do not intersect. Then the answer is simply the size of the largest clique in the graph.


   [2, 4, 5, 8, 10], [1, 3, 6, 7, 11], [2, 5, 6, 9, 10], [1, 5, 6, 9, 11], [1, 3, 4, 7, 12], [2, 3, 4, 8, 12]

 , [2, 5, 10, 11, 12], [1, 6, 10, 11, 12] , [3, 4, 10, 11, 12], [1, 3, 7, 8, 9], [2, 4, 7, 8, 9], [5, 6, 7, 8, 9]


use GraphTheory in CliqueNumber(Graph({seq}(seq({i,j}, j in LL[i]), i= 1..12))) end use;


Looking at the graph with DrawGraph, one can easily see many 3-cliques. (3-cliques are easy to see because they are just triangles.) One example is {1,4,5}.

One problem in your code is that your comments block some of the essential code. In any line containing a #, anything to the right of the # is ignored. (So there's also no need to use quotation marks in your comments.) For example, you have a line

#` Step 4`  for i from 2 to M2 do

So, the part for i from 2 to M2 do will be ignored.

I almost never use 2D-input. I only use it when it is part of someone else's worksheet that I'm playing around with. The only way that I know how to get a new line is Control-Enter, same as in 1D input. When I use that, I don't get the extra space. What is the usual way to get a new line, the way that does give the extra space?

I've modified the above so that the axes don't change due to the erasure, and the original axes will be restored if the VIEW is reverted to default by a subsequent display. So it is now more like erasing part of a blackboard (and circles will remain circles), whereas before it was like cutting off part of the blackboard. I do this by keeping track of the extreme upper, lower, left, and right points as they pass through the transformer procedure. Then I add an invisible (color= white) plot of the two extreme points: lower left and upper right.

It probably goes without saying that this procedure should work for any 2D plot, not just BubblePlot.

Eraser:= proc(Plot::specfunc(function,PLOT))
# Uses the VIEW specification of a PLOT structure to erase points outside the view.
# Input: PLOT structure with VIEW; Output: The PLOT structure, modified.
     ,minx:= infinity, miny:= infinity, maxx:= -infinity, maxy:= -infinity
     ,View:= indets(Plot, specfunc(anything, VIEW))
   if View = {} then  return Plot  end if;
   if nops(View) > 1 then  error "Multiple VIEWs found: %1", View  end if;
   View:= View[];
            [x1,x2,y1,y2] =~ [op(1..4, map(op, subs(DEFAULT= -infinity..infinity, View)))]
               if not(x::numeric and y::numeric) then  return [args][1..2]  end if;
               if x < minx then  minx:= x  end if;  if x > maxx then  maxx:= x  end if;
               if y < miny then  miny:= y  end if;  if y > maxy then  maxy:= y  end if;
               `if`(`or`(x1 > x,x > x2, y1 > y,y > y2), [undefined$2], [x,y])                  
            end proc
   # Add two invisible (white) points at extreme corners of original plot so axes don't change.
   # plottools:-transform removes VIEW, so put it back.
       [plots:-pointplot([[minx,miny],[maxx,maxy]], color= white), newPlot]
      ,view= [op(1..2, View)]
end proc:

Indeed, here is the procedure.  It takes a PLOT structure containing a VIEW as input and returns the PLOT structure with the appropriate points erased.

Eraser:= proc(P::specfunc(function,PLOT))
# Uses the VIEW specification of a PLOT structure to erase points outside the view.
     ,View:= indets(P, specfunc(anything, VIEW))
   if nops(View) = 0 then  return P  end if;
   if nops(View) > 1 then  error "Multiple VIEWs found: %1", View  end if;
   View:= View[];
               [x1,x2,y1,y2] =~ [op](map(op, subs(DEFAULT= -infinity..infinity, View)))
              ,(x,y)-> `if`(`or`(x1 > x,x > x2, y1 > y,y > y2), [undefined$2], [x,y])
end proc:

We can use plottools:-transform like an eraser on an existing PLOT structure by converting points outside a desired view to undefined. Then they will stay undefined if the VIEW is subsequently enlarged. (I'm using all caps for certain words because that's how they appear in the PLOT structure.)

a:= Statistics:-BubblePlot([4, 5, 2, 3], [1, 2, 7, 8], [8, 1, 3, 2]):
Eraser:= (x,y)-> [x, `if`(4 <= y and y <= 9, y, undefined)]:
a1:= plottools:-transform(Eraser)(a):
plots:- display(a1);

           [plot not shown in post]

plots:-display(a1, view= [default, 0..9]);

           [plot not shown in post]

The above procedure Eraser is ad hoc, for your particular view; but I can easily generalize it so that it will extract the range(s) from the VIEW option of an existing PLOT.

Note that however you change the view in a BubblePlot, the circles will be distorted to ellipses because they are created as POLYGONs, rather than as single points. This also means that they may be cut by an invisible horizontal or vertical line. If you want to erase points without changing the axes (which means that circles would stay circles), I'll have to think of something else.

I assume that you mean a memory limit, so that you can access your virtual memory. The command is (for example, to increase to 16 GB)

kernelopts(datalimit= 16*Unit(gibibyte));

However, having read your other recent post, I know that a lack of memory is not the true cause of your troubles. Get your bugs worked out on a smaller version of your problem first!

Addressing the OP's direct question: No, there is no limitation on set size. If you have the RAM for it, the Maple kernel can handle it. The Maple kernel will give you an explicit error message if it runs into any memory limitation.

I am assuming that by "create" you mean "plot". And I am assuming that your question could be rephrased as "How can one plot a function with a restriction on the abscissae ('x values') or on the ordinates ('y values')?" If those are not what you meant, please let me know.

There are many ways to do it. Here are just a few. Which one you choose may depend on what types of algebraic manipulation you need to do to the function before or after plotting (such as, how you decided on 0.2 and 1.3).

Method 1a: piecewise, abscissa-oriented:

f:= piecewise(Or(And(x>=0.19740,x=3.3390, x

plot(f, x= 0..2*Pi, discont);

Method 1b: piecewise, ordinate-oriented:

f:= piecewise(tan(x) >= .2 and tan(x) < 1.3, tan(x), undefined);

plot(f, x= 0..2*Pi, discont);

Method 2a: restricted plot, abscissa-oriented:

   [plot(tan(x), x= 0.19740..0.91510), plot(tan(x), x= 3.3390..4.0567)]
   ,view= [0..2*Pi, DEFAULT]

Method 2b: restricted plot, ordinate-oriented:

plot(tan(x), x= 0..2*Pi, y= 0.2..1.3, discont);

First 358 359 360 361 362 363 364 Page 360 of 364