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?

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

Hi Paul, is that Plot example one that you saw in the lecture? I'm having trouble finding it in the notebook and I'm not sure how to accomplish something like that off the top of my head (or even after some searching). I know that you can do a more basic thing like Module[{x},x] to see the local name of x inside a module, but as far as seeing the names for automatically localized variables, I don't recall seeing that in the presentation and can't find it in the notebook. (Granted, I look at a lot of presentations and notebooks so it's quite possible that I've missed it, in which case a pointed would be helpful!)

Gotcha! The only cell-view switch I know about is cmd+shift+E, which shows the full cell expression, but—by default, at least—it doesn't show full context information. Dan is currently on holiday, but he should be able to provide you with a more concrete answer once he returns on Monday.

I decided to make a fun example to demonstrate some of the things we have learned in this series.

The function below tests the Collatz conjecture, calculating a sequence of expressions that—it is conjectured—will always end in 1. Together with the interactive tool that follows it, this function uses:

• An argument (see notebooks 1 and 2)
• A PatternTest, to make sure the argument is always an integer greater than 1 (see notebook 1)
• Recursion (see notebook 3)
• Overloading, to ensure the recursion stops (see notebook 3)
• Sow and Reap, to collect intermediary values (see notebooks 4 and 5)
• A Manipulate, to allow one to vary the starting value of the sequence (see notebook 5)
• A Module, to localise a variable (see notebook 5)

Function:

ClearAll[collatz];
collatz[n_?(IntegerQ[#] && # > 0 &)] := If[EvenQ[Sow@n], collatz[n/2], collatz[3*n + 1]];
collatz[1] := Sow@1;

Interactive tool:

Manipulate[
 Module[
  {data = Table[Reap[collatz[n]][[2, 1]], {n, 2, maxN, 1}]},
  Row[
   {
    ListLinePlot[
     data,
     PlotRange -> {{0, 120}, {0, 10000}},
     Frame -> {{True, False}, {True, False}},
     FrameLabel -> {"Sequence length", "Sequence values"},
     PlotHighlighting -> None,
     PlotStyle -> {
       Sequence @@ 
        ConstantArray[
         Directive[GrayLevel[0.5, 0.5], Thickness[0.001]], maxN - 2],
       Directive[Purple, Thickness[0.003]]
       },
     ImageSize -> 600
    ],
    Framed[
     Pane[
      Row[Last[data], ","],
      ImageSize -> {200, 300},
      Scrollbars -> {False, True}
      ],
     RoundingRadius -> 3
     ]
    },
   BaseStyle -> "Text"
   ]
  ],
 {{maxN, 3, "n"}, 3, 100, 1, Appearance -> "Open"},
 ContinuousAction -> True
]

Enjoy! :)

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}

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 Francisco, these workflows explain the details:

• Create a Package File
• Load a Package

For an example, take a look at the ImageStyler.wl file (which is referenced in the fifth notebook, Useful Tips).

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]].

I just did a search myself in the documentation and couldn't find anything particularly helpful… (no tutorial that explains how to create your own operator forms, anyway).

However, in case it's of interest to you, I did find some code on StackExchange that claims to list all of the bulit-in functions that have operator forms:

file = FileNameJoin[{$InstallationDirectory, "SystemFiles", "Kernel", 
        "TextResources", $Language, "Usage.m"}];

usage = Import[file, "HeldExpressions"];

usage //
  Cases[
    HoldPattern[
      _[_[sym_Symbol, "usage"] = _String?(StringContainsQ["operator form"])]
    ] :> sym
  ]

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.

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