Doh! Thanks Paul! I don't know why I did not think of the first option right away, but I didn't; and it does work. Exactly as it should; and exactly what I was looking for. Come think of it, it's a perfect little example of how the syntax of the Wolfram language works. So thanks for the tip.

Carl

Regarding Mapping of operators: How do I map the derivative operator onto a list of expressions?

For example, instead of doing

{D[-Sqrt[4 - x^2], x], D[Sqrt[4 - x^2], x]}

I'd like to have the list of expressions {-Sqrt[4 - x^2], Sqrt[4 - x^2]} and map the Derivative operator onto the list directly. But there is this pesky 'x' in the definition of the operator D[f,x]. How is that done?

No, mostly made up, it was in the live presentation, but I don't think shows in the notebook. I assume it a front end maybe cell type or something. The presenter switch back and forth but I didn't hear if he indicated how. I was thinking it was a plot, but not sure - just some expression that had a mixture of localized and global in the expression.

In the lecture, you show the full local names on a few occasions. How is that done? For instance x=1; y=3, Plot{ x, {x,0,y}; x might show as x=1; y=3, Plot{ x$12345, {x$12345,0,y}; x clearly showing the localize, temporary definition of the x inside the Plot... How do you switch between the two views of the cell?

In the last session, I mentioned that Alternatives (a pattern object) and Or (a function) are not interchangeable. Here's an example to demonstrate how they differ.

Consider trying to extract all of the cases from a list that are either 2 or True. Using Alternatives (|) gives the correct result:

Cases[{1, 2, 3, True, 4}, 2 | True]
(* {2, True} *)

However, using Or (||) gives an incorrect result:

Cases[{1, 2, 3, True, 4}, 2 || True]
(* True *)

This is because Or immediately evaluates if any of its arguments resolve to True or False. In this case, 2||True evaluates to True, so Cases only picks out the items that match True.

Hi Laurence, can you give me some more details? It would be best if you could write down a simple example that includes the setup you want to start with and the result you want to end with. I may then be able to help with the steps in between.

Thanks. I'm looking forward to the details. The lonely p is because the working code uses p rather than n, and I didn't catch the typo before submitting.

Hi Hubert, your questions can be answered with overloading – something we will be covering in today's session (Extending Capability).

To solve (c), you can use OrderlessPatternSequence, and to solve (b), you can use Condition (/;). Both of these were covered in the first session (The Basics). To solve (a), you can use Message, which will be covered in the fourth session (Error Handling).

Here's some code to get you started:

ClearAll[getClass];

getClass::orderTooLow = "The order you have provided (`1`) is too low. It must be an integer greater than 2.";
getClass::badArgs = "Bad arguments. getClass takes exactly 2 arguments: an 'order' and a 'cycle'. The order must be an integer greater than 2 and the cycle must be a valid permutation cycle.";

(* Main definition: *)
getClass[
    OrderlessPatternSequence[
     order_?IntegerQ,
     cycle_?PermutationCyclesQ
     ]
    ] /; order > 2 := (* Your function *);

(* Order provided is too low: *)
getClass[
   OrderlessPatternSequence[
    order_?IntegerQ,
    cycle_?PermutationCyclesQ
    ]
   ] := (
   Message[getClass::orderTooLow, order];
   $Failed
   );

(* Arguments provided are either invalid, too numerous or too few: *)
getClass[badArgs___] := (
   Message[getClass::badArgs];
   $Failed
   );

You can add more definitions / error messages to handle more cases.

P.S. – you seem to have a lonely p in your function definition.

I want to construct a function that inputs an element of the symmetric group of n objects and returns the conjugacy class of this element. The inputs are thus the positive integer "n" and something like "Cycles[{{1,3,2}}}]" so my starting point is

getClass[n\_, cycle\_ ]

I know that in practice I tend:

1. to forget to to include the argument n,
2. I input an incorrect value of n (a cycle like Cycles[{{1,3,2}}}] permutes objects 1,2,3 so n>= 3 at least
3. I tend to mess up the ordering of the argument.

So I want to build getClass[n_,cycle_] so

• a) getClass[somecycle] returns a message like "order missing",
• b) getClass[q,somecycle] returns "order is too low" if q is incorrect
• c) evaluates getClass[somecycle,n] equally well as getClass[n,somecycle]

I can handle c) by using PermutationCyclesQ, which will tell me if a particular argument is actually a cycle, and thus test if the first argument is a cycle or not.

I'm not sure how to proceed to handle the rest or make it work smoothly. The current working version of getClass is:

getClass[p_, cycle_] := Module[{listofcycles, shortlistofcycles, padding},
  listofcycles = Flatten[List @@ cycle, 1];
  shortlistofcycles = Table[Length[listofcycles[[k]]], {k, 1, Length[listofcycles]}];
  padding = p - Sum[shortlistofcycles[[k]], {k, 1, Length[shortlistofcycles]}];
  If[padding != 0, AppendTo[shortlistofcycles, Table[1, {q, 1, padding}]]];
  Reverse[Sort[Flatten[shortlistofcycles]]]]

Thus for instance getClass[3,Cycles[{{1,3,2}}}] returns {3}

getClass[4,Cycles[{{1,2},{3,4}}] returns {2,2}

Hi Carl, this is covered in the third notebook in this series (Extending Capability) in the optional section, Operator Forms and Subvalues. Although the usual syntax for a function might be f[x_, y_] := g[x, y], it's perfectly acceptible to write f[x_][y_] := g[x, y], or even f[x_][y_][z_] := g[x, y, z] (and so on). These are known as operator forms, and are valid because the code on the left-hand side of the SetDelayed symbol (:=) is just a pattern—it can be more or less whatever you like.

For a concrete example, consider the Select function. It is normally used like this: Select[Range[10], EvenQ]. However, it can also be used as an operator like this: Select[EvenQ][Range[10]].

Thanks for first lecture. I am interested in learning more about sequences. Your introduction is difficult for me to apply to a sequence of mathematical operations. I want to write a function to accept pullback metrics and compute the sequence as a parameter varies. Any guidance/suggestion would be appreciated. Larry

Wolfram U is looking forward to starting this Daily Study Group on Monday, along with @Daniel Robinson. Seats are still available! Sign up here.