Hi folks! We've been enjoying your Level 2 certification submissions so far. If you're curious about whether an idea you have would be fit to submit, please feel free to ask in this thread. (If you have technical questions, however, please wait for the next Programming Proficiency Office Hour session, which is currently scheduled for July 25.)

Thanks for pointing this out, Lori! When I updated the question, the number of answer choices changed and messed up the key—but I'd failed to notice it. It should be fixed soon.

Could you please advise if this program would be suitable for me if I only know how to set up and configure development environments and have just started learning programming languages?

Understood, thank you for the advice. Special thanks for "Most importantly, have fun! Write original code about things you know and things you're interested in."

I would do something like this

Cases[listA, x_List /; First[x] == b]

{{b, a, a}, {b, a, b, a}, {b, b, a}, {b, a, b, a, b}}

Cases[listA, x_List /; First[x] == b] /. {a -> b, b -> a}

{{a, b, b}, {a, b, a, b}, {a, a, b}, {a, b, a, b, a}}

blank

Thanks Doug. Works great.

I wonderful (and sometimes confusing) to see in how many different ways something can be coded in Wolfram.

Yes but it is still confusing

listA /. x_List /; First[x] == b :> ReplaceAll[x , {a -> b, b -> a}]

{{a, b, a}, {a, b, b}, {a, b, a, b}, {a, b, b, a, a}, {a, b, a, 
  b}, {a, a, b}, {a, b, a, b}, {a, b, a, b, a}, {a, a, a, a}}

works
but

listA /. x_List /; First[x] == b :> x /. {a -> b, b -> a}

{{b, a, b}, {a, b, b}, {b, a, b, a}, {b, a, a, b, b}, {a, b, a, 
  b}, {a, a, b}, {b, a, b, a}, {a, b, a, b, a}, {b, b, b, b}}

does not .......

Maybe Arben can tell us why ?????

Thanks Arbin

Yes it is the Parenthesis (good to know )

listA /. x_List /; First[x] == b :> (x /. {a -> b, b -> a})

{{a, b, a}, {a, b, b}, {a, b, a, b}, {a, b, b, a, a}, {a, b, a, 
  b}, {a, a, b}, {a, b, a, b}, {a, b, a, b, a}, {a, a, a, a}}

The issue is here:

/; _First

The /; means that you write some test afterward—not only is _First not a component of a test, but it's not the correct pattern syntax. Recall that what follows a Blank (_) should be a head to be matched; i.e. you can't put an arbitrary function there and take it to be acting on whatever the blank is.

If you have

listA= {{a, b, a}, {b, a, a}, {a, b, a, b}, {a, b, b, a, a}, {b, a, b, a}, {b, b, a}, {a, b, a, b}, {b, a, b, a, b},{ a, a, a, a}} (*i removed the errant comma*)

and want to do {a -> b, b -> a} on any sublist that starts with b, you could do something like

listA /. l_List /; First[l] == b :> (l /. {a -> b, b -> a})

if you wanted to use Condition. Better yet, just match the pattern directly:

listA /. {b, rest__} :> ({b, rest} /. {a -> b, b -> a})

Hi Updating Name (Rohit?),

I suspected that I did not use First correctly :-)

Your solution works excellent. Also if I nest the sublists deeper and irregular (different nesting levels). That is great.

Do I understand it correctly, if I say :

{b, rest__} looks at all the innermost sublists and if there is such a sublist that starts with a 'b' and has one or more elements, then the replacement takes place?

Thanks again for your valuable help,

Best, Bert

You reply faster than I can edit. Wow :-)

Hey Mike, we'll get back to you soon about this. In the meantime, please don't worry about any timeline issues—as far as we're concerned, you've submitted your project within the deadline and that's that.

Hey Michael—I'm sorry about that! I finished grading it 2-3 weeks ago; I'm not sure what got blocked up in the process but we're on it. (Spoiler: you passed)

Edit: you should have it later today.

Right, thanks Arben :-)

I just got my first connection through a chat Nb with chatGPT and asked the same question. After two misses, and restating my question more precise (and partly double), I gotv a working answer :

Map[If[First[#] === b, # /. {a -> b, b -> a}, #] &, listA]

It's nice to see it work, although your solution is more refined, I think, and probably faster :-)

But the A.I. solution shows me again the pure function, which I understand in theory, but in practice I often seem to do it wrong. It will come, some day.

Also, in the If statement (which I also used, I first used == instead of what I should have done : ===. I dodged my error by using SameQ[]. So I think this A.I. coding help can be useful in the learning process.

Arben, I tried using Timing[...] and AbsoluteTiming [...] on 3 different instructions to accomplish the same thing: Power, an anonymous function using Keys, and an anonymous function using indexing. I used a large enough list of associations so that Timing was non-zero. All three had Timing between about 2.1 and 2.8 seconds, and AbsoluteTiming between about 3.7 and 3.9 seconds. I ran this in Mathematica 14 on an HP Envy running Windows 11 Home 64-bit OS. My notebook is attached as file TimingExample_1mar24.nb .

I expected Power to be clearly faster but it wasn't. Please explain these timing results.

Attachments:

TimingExample_1mar24.nb

Using

shortListOfAssoc = {<|"a" -> 1, "b" -> 2|>, <|"a" -> 3, "b" -> 4|>, <|    "a" -> 5, "b" -> 6|>}; 

I added Timing, AbsoluteTiming, and Repeated timing to the file I uploaded before, TimingExample_1mar24,nb , which is attached. (I also added RepeatedTiming for listOfAssoc that I ran previously.) My respective results for shortListOfAssoc using Power, anonymous function with tags, and anonymous function with indices are as follows:

Timing: all three were 0.

AbsoluteTiming: 0.0000124, 0.0000111, 0.0000101

RepeatedTiming: 1.3700510^-6, 2.1609110^-6, 4.3709*10^-6

Attachments:

TimingExample_1mar24.nb

Hi Arben,

I could not properly formulate my question in The Office Hours Session as I had only joined in at the very end (a miscalculation on my part). So thank you for suggesting I pose my question here.

I am trying to make a kind o’f Rhythm Evolver’ by means of an Evolutionary process. One thing is that I need to detect the degree of ‘regularity’ in a rhythm as a fitness score parameter.

This way I also try to find out if Nesting as a ‘regularity’ in music is easily, or at all recognised by listeners. Nesting is the most complicated and hidden regularity. Repetitions are much easier recognised.

Let’s just talk about just one line (one rhythm instrument, e.g. Kick drum), as I think it is already difficult enough.

A hit is 1, no hit is 0.

1. I have already been given a way to detect ‘Repetition’, ‘Symmetry’ and ‘Permutations’ of parts (also here in the Community :-)

Now I am looking for a way to detect ‘Nesting’.

E.g. The following 3 parts : {1,0,0,1} {1,0,0,1,0,1,1,0} {1,0,0,1,0,1,1,0,0,1,1,0,1,0,0,1}
all come from the nesting Rule : 1->{1,0}. and 0-> {0,1} starting with {1,0} and applied respectively 1x, 2x and 3x.

I want to go the other way, and see if in a rhythm line, that has been evolved , there is any sort of Nesting as regularity. Not with these specific rules and specific initial condition. I want to detect ANY Nesting (any rules, any initial condition).

So, given the line { 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1}, I should detect that the bold part (1, 0, 0, 0, 1, 1, 0, 1, 1) is a nested part from:

               Initial conditions {1,0} with the rules : {1 -> {0, 1, 1}, 0 -> {1, 0, 0}}

It is no really important that I detect what rules and which initial condition, but I want to detect which part of my Rhythm Line is a Nested part in any form.

I am not sure if it is possible, without trying all the rules. This due Stephen Wolfram’s ‘Computational Irreducibility’ .

What are your thoughts?

Thanks, Bert

Thanks Arben. Do you mean by "if the cases are 1:1 . . ." that the rules are of equal length?

So {1->{1,0,1} and 0->{0,0,1}} is 1:1 and {1->{1,0,1} and 0->{0,1}} is Not?

Reverse the nesting rules is not quite possible, I guess, as I do not know which rules might have been used. Also, the nesting might be 2 or 3 deep, so I do not know the length to parse. It feels a bit like backwards running a C.A., which is possible in some cases, but not very often.

Checking for repetitions in a rhythm line is easy, but this Nesting looks like a different animal :-)

As the computation comes into a repeated process of measuring the amount of Nesting in a rhythm ( so thousands of these detection measurements), it might be an idea to create a lookUp table with all the possible nestings for two elements (0 and 1). If a take as a max of number of initial elements, as well max number of elements in a rule to be 3 (which I think servers my purpose) then there would be 14 possible initial conditions and 12 rules for 0 and twelve rules for 1. As these rules are 'mirrored, I need only to take into account half of them. Then I create the lookup table for all Nestings from level 1 to say 3, which should be enough. From there on I could use SequenceCases or SequencePositions.

This will still leave the challenge for detecting Nesting in a complete rhythm, where I use 16 possible values for the possible simultaneous occurances of hits from 4 instruments together. This will explode with lookUp tables, I am afraid.

Best, Bert

What is the deadline for using the Level 2 discount code I received? (I took the first WSG24 this year)

I have a project idea but haven't had much time since the course ended and probably won't for a couple weeks longer.

Never mind, (content removed)

Today's lecture should do you well :).

In[53]:= 
listA = {{{{1, 2}, {3, 4}}, {{5, 8}, {9, 12}, {14, 17}}}, {{{11, 13}, {15, 17}}, {{18, 20}, {22, 24}}, {{26, 31}}}};
listA /. {x_Integer, y_Integer} :> {y - x}

Out[54]= {{{{1}, {1}}, {{3}, {3}, {3}}}, {{{2}, {2}}, {{2}, {2}}, {{5}}}}

More to the style you'd imagined—and faster for a large list—is:

In[57]:= Map[{-Subtract @@ #} &, listA, {-2}]

Out[57]= {{{{1}, {1}}, {{3}, {3}, {3}}}, {{{2}, {2}}, {{2}, {2}}, {{5}}}}

And the best version, I think:

``` In[69]:= Apply[{#2 - #1} &, listA, {-2}]

Out[69]= {{{{1}, {1}}, {{3}, {3}, {3}}}, {{{2}, {2}}, {{2}, {2}}, {{5}}}}```

Hi Bert—I thought you wanted the extra braces still for some reason, so I had added them back in! They disappear with Apply because Subtract (and indeed -) wants two arguments provided as a sequence, not as a list—that's why we use Apply, because Apply[Subtract,{a,b}]===Subtract[a,b]. Hence, you can see the difference between Apply[Subtract[#2,#1]&,...] and Apply[{Subtract[#2,#1]}&,...].

I see why writing the Subtract out is helpful for clarity, though I would say that getting an intuitive sense of what something like #2-#1&@@ is really doing is indispensable to working efficiently with Apply and its siblings. I would say you can think of it as "an operation which strips out the second and first arguments of ANY structure and gives me their difference". It works on lists, it works on sums and products, it works on any arbitrary g[a,b] with the action that #2-#1&@@g[a,b]===b-a.

Also, you can type code between backticks here, like `hello_` in order to prevent any unwanted markdown formatting. You can start a new line with 3 backticks, press enter, then type/paste code and do another new line with 3 backticks in order to get the formatted boxes you see in my previous reply.

Since you're Apply-ing, you get rid of the List structure. In that context, what does #[[2]] or #[[1]] mean?

Suppose there is an external database or other data source. Unfortunately, in this external data source, the keys are in lower case with underscores ("snake_case"), e.g. company_name. To work properly in Wolfram Language, the keys must be in camel case, e.g. companyName.

Here is an example that works on a List of Associations:

AssociationThread[
   StringReplace[Keys[#], 
     MapApply[Rule, 
      Transpose@{"_" <> # & /@ Alphabet[], 
        ToUpperCase[Alphabet[]]}]] -> Values[#]] & /@ data

To be honest, from my perspective it looks ugly, especially the "Transpose" part. Any ideas on how to make this transformation more concise?

... or is there a built-in function for this that I don't know about? I saw this resource function https://resources.wolframcloud.com/FunctionRepository/resources/ToCamelCase/, but I wasn't able to make it run in this "key of association" problem.

Notebook with sample data attached.

Thank you, Arben, for your super-fast reply.

Interesting - so it works with quotation marks. - Thank you!

Thank you very much, R, impressive! I was looking for something like that.

I think you just do exactly what you said you want to do, i.e. assign the variables before you take the derivative:

D[
Log[x^2 + y^2 + z^2] /. {x -> Sin[t], y -> Cos[t], z -> Tan[t]}
, t]

Or even before you take the Log, but I think that gives you the same answer:

D[Log[(x^2 + y^2 + z^2) /. {x -> Sin[t], y -> Cos[t], z -> Tan[t]}],
  t]

Take Rohit's answer, but also note that if you were to write x'[t] and so on—that is, explicitly note the time dependence—D will take those derivatives symbolically and you can plug in values for the time-dependent functions after the fact, at which point the derivatives will be evaluated.

I've noticed in other people's examples that you can stick the /. operation all over the place. What is wrong with that? (my own answer would be that if you are writing longer code, it gets hard to read and understand - I'm just asking a more generic question about WL grammar rules) Carl

My suggestion is to use the standard functional call (ReplaceAll[], etc.) until you thoroughly understand them. You should always -- always -- be able to see and say the long form when the shortcut is being used. IMHO, it's a big problem to use shortcuts if you don't always have the formal name of the function call on the tip of your tongue. Note: even things like _x have a standard form: Blank[x]. Computers have the ability to expand any shortcut within a microsecond; we should be ability to translate either way with a similar amount of minimal computational overhead.

You want to be able to rattle off a spell with the ease of Hermione Granger and avoid the clumsiness of Neville Longbottom. You should have no "lost in translation" moments between a shortcut and its normal form.

I kinda wish that the Notebook editor would have a means of flipping something to its normal form (and vice versa). I also wish that the Help documentation would always show both forms on examples; it tends to be prejudiced towards the shortcuts. I like to verbalize the normal form when I look up something in the docs.

Will there be another one of these classes?

I'm having problems understanding number three which works with Set Delayed Rule and Blank.

I couldn't catch on C++ a long time ago in college. Maybe that's why I don't understand this concept. Object orientated programming. My problem seems that there's too much overlap in definitions. There's no similarly to compare it to. The concept is Invisible.

There's a few things happening with the blank, and the "f" and the "x" those are all condensed things or overlapping definitions. Left to right replacement. Got that. what is "f" and "x" or x or x you could call them "Head" or a function. of the [ ]. I'm struggling to find an explanation of what x or x is Now I do understand that is is just a blank to be filled in but the x or f is a distraction. why not just _ without f or x that make more sense.

Now I tried to make this work and nope. nothing works. Is it because of the Delayed rule? That's a new idea. I guess I haven't tested that out yet. changing :> to -> instead. I can try that next. I don't understand what to do to get the replacement happening it seems that it should be just happening if there are blanks in the right place but maybe it's because of the Delayed rule. I tried changing the delay to a rule and it's the same. I used Trace. With Trace I just get {} and without Trace I get the same out as I put in f[1,2,3] I don't know if the rule is even working or able to work on f[1,2,3] that's my problem I don't see how the problem is applied to f[1,2,3] it seems it is not.

Thanks for the useful reference. Fills in some of the blanks in Arden's excellent lectures. I always like several points of view.

I worked on a exercise to from EIWL which was just adding up a list and I wanted to do it with Plus, Range. I failed and spent a hour learning. Then came back to it.

Recap. I was working on trying to use a symbol to do the adding or multiplying with @@ I could not get it to work. I could not figure out what was happening. I tried a lot of things. Nothing seemed to work. I looked up Trace, TreeForm, and a whatever I came across. I played around with the documentation changing the code around.

I figured out how to do it, after my nap. Checking with TreeForm told me the "path" of the code that I could not see. Checking the documentation on how to properly write it over and over. I could see that Plus was not getting worked on the List. So I knew I wrote it wrong.

The hour of work was not wasted. From that hour of work. That is how I got the code to be "visible". I worked with TreeForm and the documentation trying out Map, ThreadMap, Funny because I was using Apply in the first place I just wrote it wrong.

I found a you-tube video on Lists that was helpful. I also read some tutorials on how to properly write wolfram code. I read the Filled in Notebooks, and whatever I came across. So it was a bunch of hopping around sources then a long break and back to finally finding the correct way to write it. It helps that I realize that I'm trying to write it the way I think it works and that is wrong. I need to find how it is supposed to be written.

Merry coding to everyone.

Have a look at https://www.math.unl.edu/~tshores1/Public/Math208F07/Math208DifferentialsHandout.pdf

https://solitaryroad.com/c353.html

etc. Google is your best friend here.

On the L1 exam, do I take a list shown as {1, 2, 3, a, b, c} verbatim or am I to interpret the list as {1, 2, 3, "a", "b", "c"}? I wasn't sure since the color coding as done in Mathematica didn't carry over to the exam.

(confirming here for, well, official confirmation.)

Use Partition. It can be done in one instruction, but to make it clearer, I break it down:

lst = {1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0};

par = Partition[lst, 3, 1]

Cases[par, {0, 1, 0}]

In attached file Symmetries.nb , I've written and executed a module to find the symmetries you are interested in and a function to count the number of subsequences in an ordered list of length at least 2.

The module creates a random list of zeros and ones of length at least 2, finds all its ordered subsequences of length at least 2, and lists all its symmetric subsequences. I assume that subsequences of length 1 are of no interest because they are trivially symmetric.

The simple function counts the number of subsequences of length 2 or more from a list of length at least 2. The code uses the function to print a table of the counts for lists of length 2 through 15.

Although I compute the number of subsequences as a sum, it's easy to derive the formula by just evaluating the sum. Given a list (i.e., an ordered list) of length n, the number of subsequences of it of length k is just the number of leftmost positions of sequences of length k, namely n-(k-1) = (n+1) - k. Now, sum for k = 2 to n. Since (n+1) is a constant, the sum of the first term is (n-1)(n+1) = n^2 - 1. The sum of the second term is just 1 less than the sum of the first n integers, namely n(n+1)/2 - 1 = (n^2)/2 + n/2 -1. So the number of subsequences of length at least 2 of a list of length n is (n^2 - 1) - ((n^2)/2 + n/2 -1) = ((n^2)/2 - n/2 = n(n-1)/2. So, instead of using the sum to define the function numSequences , one could define it as numSequences[n_Integer /; n >= 2] := n(n-1)/2 . I used the sum just to make the code easy to understand.

Attachments:

Symmetries.nb

I worked through your Nb. Thanks for the work you've done. It works well and I learned a thing or two, which I can apply on other places in my project.

Really appreciate your help, as well as Rohit's.

I am happy to see your explanation for the derivation for the formula for the number of (ordered) subsequences in an n-sequence. Very helpful. I tried Select i.s.o Cases and that works fine as well. I guess that you put the parenthesis around # === Reverse[#] in Select[subSequences, (# === Reverse[#]) &]; for clarity. It also works without them.

Thanks again , Gerald

I thought so, but a useful practice :-)

I have not run any benchmarks but I suspect that using the built-in PalindromeQ may be faster than # === Reverse[#] &.

Use the Sequence* family of functions

list = {1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0}

SequenceCases[list, {0, 1, 0}, Overlaps -> True]

SequencePosition[list, {0, 1, 0}]

Overlaps -> True is the default for SequencePosition which is a little inconsistent

Hi B.

In which sense is Overlaps -> True inconsistent? I saw in the docs, that SequencePosition has the same Overlaps option. Is it also inconsistent there?

What I meant is that the default value of Overlaps is True for SequencePosition and False for SequenceCases. That seems inconsistent to me.

For symmetry something like this?

list = {0, 0, 0, 1, 0, 1, 1, 0, 1}
Subsequences[list, {3, Length@list}] // Select[PalindromeQ]

For permutations generate all of them and test each with SequencePosition?

perms = Permutations[{1, 0, 1}]
list = {1,0,1,x,x,x,x 0,1,1,x,x,x,x,1,1,0}
SequencePosition[list, #] & /@ perms

Hi Rohit,

I wanted to take your idea a little further, more general, but I run into a snag I do not understand. SequenceCases[pattern1, {0, 1, 0}, Overlaps -> False] from your previous post. This works great :-)

But now to find more general patterns : list={0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1} patternToFind = {x, y, x_} SequenceCases[list, patternToFind, Overlaps -> False]

I get {{1, 1, 1}, {1, 0, 1}, {1, 0, 1}} as result.

Why is the [1,1,1} there? I specified the first and third to be the same, but the second element to be different. I expected to get {1,0,1} and {0,1,0}. The result also misses the {0,1,0}.

Any good ideas?

Great Rohit, thanks.

I had understood that {x,y,x} was different from {x,x,x} as a pattern .

I had the 'Overlaps -> True' first, but as I did not have x != y , I got about way too much solutions.

Now it works fine :-)

Best , Bert

Precisely! When I talk about pattern matching, I always talk about x_ as "something—call it x" for exactly this reason.

Is the 5th question in the level 1 exam :-

"Beginning with data = {{15000, , 89000,, ............"

correct/valid ?

Questions are randomly (actually, pseudorandomly) selected from a pool; the odds that any person would have the same 5th question are rather low.

I had a question on my L1 quiz where there were 3 possible answers, plus "all of the above". It turned out that 2 of the 3 were giving the correct response and one was giving a different response; none of the answers could possibly be right. I was running my quiz notebook off of the Wolfram Cloud; that appears to be the reason for the one buggy response. I answered the question as if the function was behaving correctly. I sent an e-mail to wolfram-u@wolfram.com noting the bad behavior and filed it as a bug in Mathematica.

Here are my rules in taking a Wolfram quiz or cert test. It took me a while to figure these out...

1. Try as hard as you can on every single question.

2. Realize that you may still get some questions wrong no matter what you do or know. Don't sweat it.

3. Appreciate the difficulty in authoring a perfect quiz. There may be bugs, bugs may creep in over time, and you may get some "no win" questions. Flag questions you're pretty sure are buggy in e-mail to Wolfram U. Remember rules 1 and 2, and have fun.

Hi Arben,

I have another question about Manipulate and it ties in with my questions from 3 days ago about 'Stepping back' to previous settings in Manipulate.

One has to be quite careful not to create a loop in a Manipulate construct. E,g. a= a+2 gives already a loop. If done like aNew = a+ 2, then it's ok. More 'funny things' might happen in a more complex Manipulate construction.

My question is : How is the order of the calculations in a Manipulate? Does it go from top to bottom, like line for line (and left to right)? Always? What if I change a parameter (slider) whose appearance is only after 20 lines of code? Is still all the code run from the top, or does the re-calculation start where the changed value first appears (e.g. line 20)?

How can I step through the code and watch the changing variables, like in 'Step-Debug'? Thanks a lot,

Bert

Hey Bert! I didn't know the answer to this one off the top of my head. After some investigation, I have to say "it's complicated."

From the Advanced Dynamic Functionality Tutorial:

Dynamic expressions can be nested, and the system takes great care to update them only when necessary. Particularly when the contents of a Dynamic contain further interactive elements, it is important to keep track of what will stay static and what will update, when a given variable is changed.

It seems as if for any given dynamic expression, there's a step which involves "tracking down" what pieces of the expression can/will change when certain dynamic variables are updated, and it's those pieces which end up being reevaluated.

Part of the issue here—and I think why you probably didn't think that the quoted section was useful when you first read it—is that Manipulate is making its own DynamicModule under the hood. This means that even if you're not typing Dynamic[x], the fact that you have (say) {x,1,10} as the second argument to Manipulate means that the constructed DynamicModule does have Dynamic[x] in there—which is why the quoted section is actually relevant, even if you aren't personally typing Dynamic[x].

I am having email problems. How do I join the class without today's link? Sorry about this!

I think I have just sorted the problem,...Thank you!

As we're fleshing out project ideas for the level 2 certification, is there someone we can meet with to make sure we're on the right track?

I really like this idea! @Arben Kalziqi, @Jamie Peterson, can we make this happen?

While I (hopefully clearly) do enjoy answering everybody's questions here, for something as involved as the Level 2 projects I'm afraid it's not really feasible from a time/involvement perspective.

Whoa! While I can't speak for @Kari Grafton, my intent was never to turn this proposed discussion group into a place for Wolfram staffers to guide us through any steps of the L2 project process. My intention was to have an informal conversation between participants in the process. In what I'm visualizing, it's probably the case that WR staff participation in the discussion would be counterproductive.

As proposed, the L2 cert process is a solitary interaction between a developer and Wolfram Research. The process is isolated; there's no sense of community in that process. A successful course (like this one) nurtures a sense of community in the participants; that's what I was looking for in a L2 Wolfram Community discussion.

Maybe the discussion group is about encouraging participants to create a project worthy of putting in one of the designated repositories. That project may or may not be sufficient for a L2 certification; that's not really important. I think this is very different from what Arben and Jamie were hearing when they reacted to this discussion.

What is clear: I need to choose words carefully for the first message of the discussion group. Let people know this has nothing to do with anything official that WR is doing. Let them know it's about community. The discussion is more like Stephen Covey's idea in The 8th Habit: Find Your Voice, and Inspire Others to Find Theirs

My best suggestion is to use today's Study Group survey to request your registration at the March 1 instructor office hours, which will also be available as part of the upcoming Programming Proficiency course sequence. Register for the course sequence here.

Hi Jamie, Cassidy, Abrita, Arben!

Thank you for all your hard work that goes into making these study groups enjoyable. [big smiley]

I enjoyed the fill-in-the-blank format of the Level 1 quiz. Keep that coming. The Level 2 Certificate is on my agenda (the Nutrition Report looks interesting) as are almost every new webinar and WSG. Artisinal Calculus, why, yes, I think I will!

I'm sleeping in today but I will see y'all soon. Stay safe. Stay healthy. Lori

Hi Kari!

Nice to meet you! Absolutely. My goal is to learn at least one new piece of creative programming each time, be reminded of a command I may have forgotten, etc. I am seldom disappointed :D

Do you collect session notebooks, too? They're like conference handouts. There are always "goodies" inside.

Aww, that's a very nice thing to say. Thank you, Arben!!!

Will do! Have a fun weekend :D

Hi Philip,

The code you posted is incomplete, there are several symbols that are not defined sEDNH, pressure, defGrad, ....

I also don't understand what you are trying to accomplish with combined. It just adds an additional level of nesting to dgrad because names includes all of the elements in dgrad

dgrad == First /@ combined
(* True *)

If you just want to pick out the matches to names here is a functional way to do it. There is no need to initialize combined

combined = Select[dgrad, MemberQ[names, First@#] &]

Thanks for the feedback. I am reading several files into my notebook and I ended up simplifying it too much without providing the needed context. Hopefully the attached notebook rectifies this. I basically have three lists that contain data keyed to a list of names. I wish to combine all of the data into one list, but only for the items in the list names.

My background is Fortran, so I instantly think of loops, however the Wolfram language intrigues me and I really want to use it effectively. Phil

Rohit, Thanks for the solution. It looks much better that the Do loop and gives me new avenues to explore. Phil

Does the word "Private" have some particular significance. What would be the problem with using some other word like [...]

"Private" has no significance. If you go to the Wolfram Language Documentation for Begin, you'll see the examples there use "MyContext`". "Private" is not a keyword in the WL, but [IMHO] the fact that it is a keyword in many programming languages means it should probably be avoided in examples in Wolfram courses. OTOH, "MyContext" is definitely un-keywordy.

It's really helpful to use the Wolfram Language Documentation as the first place to go with questions like this. I don't think that Arben has emphasized the wonderful Wolfram documentation in this course. Docs are available on the web; they are also typically installed in a Mathematica install and can be accessed through a Mathematica window. Carpe documenta!

If there are bugs/shortcomings in the documentation, you can file a support ticket with Wolfram.

As far as Private not being a keyword, I just looked up that word in the documentation. Simple. "Private" the String is used as an option in some functions, but that doesn't leak out and affect other things. If a word isn't mentioned in the doc entry for some function, it shouldn't have any magic way to affect that function.

The other thing I noticed with your questions: if you're curious what happens when you do X, just try it. If the kernel behaves in some inexplicable way, that's the point in time to investigate further. I imagine Stephen Wolfram sitting (or standing) in his office in MA; I bet it's in his muscle memory just to try something about before looking it up in the docs or (gasp!) asking another staffer for clarification.

Good question! While there is significant overlap between the Wolfram Language and Mathematica Level 1 certifications, we are making changes to focus the Wolfram Language certification on programming, and the Mathematica certification on using the product for technical computation. The Level 1 pages and the exam questions will be reflecting these latest changes in upcoming days and weeks.

Hi Andres,

Here is one way to do it

augmentedData = <|#, "LogDiameter" -> Log[#Diameter]|> & /@ data
Dataset@augmentedData

This relies on the implicit addition of key/value pairs to an Association when wrapped in Association. E.g.

assoc = <|"a" -> 1, "b" -> 2|>
<|assoc, "c" -> 3|>
(* <|"a" -> 1, "b" -> 2, "c" -> 3|> *)

I just wanted everyone to know that the notebooks for the book "Query" are available at: Query notebooks. I have found them to be a helpful companion to our class.

Hi Rohit, this should be fixed now—works for me, as well. You may need to clear cookies/cache to get it to work, though, as a version with the wrong permissions may be cached on your end.

It will depend on your keyboard layout, but a QWERTY layout should have the | accessible by pressing shift and . The < is just a less-than sign, so that's <|association here|>.

oh god, it escapes even when there's nothing in front of it? blegh, thanks Rohit!

Taiboo: indeed, you want shift + backslash—shift + \

Hey Taiboo—we have two versions of our notebooks, generally speaking. One is the instructor version, which I use when teaching live and which we use for making edits. Then, there's a more monochrome "handout" version which has some formatting changed for consistency's sake and to work nicely on the cloud.

1. I don't think so, but if you have a question about a particular question you can ask me. (I also think that if you email us, we can manually pull your answers and which were correct.)
2. No Nulls for me. You might get them if you don't Enable Dynamics when prompted.

I have some questions about the Manipulate construction: I have a manipulate with let's say 4 adjustable parameters.

1. How can I make a button (Previous) to go to the previous values, without getting into an endless loop, which can easily happen in a Manipulate, as if one parameter is changed, everything is recalculated. I tried several ways, like putting the values in a nested list, but somehow there is always something that is not working. Ideally, I want to be able to step back several steps and also forward again (up to the last values I had). I hope my explanation is clear enough :-)

2. How can I keep the last used values for the 4 parameters when I run the manipulate again? I believe that in a DynamicModule construction, that goes by itself.

3. How can I easily save the values of the 4 params as a named Preset? Eg.: Preset1. I know that I can do 'Paste snapshot, which gives me all of the original code with the values of the moment, along with the result. This takes a lot of Notebook space, especially when the Manipulate code is substantial. I only want the values of the parameters, so I can load them back in later.

Somehow my post got posted under another name, so here I go again ;

Thanks Arben for your answers and for the truly excellent teaching you do. You bring something extra to the table, sometimes very subtle. Your teachings are top on all levels :-)

For the moment I reply to your answer to my questions 2+3.

I had also come up with creating secondary variables for the adjustable parameters in the Manipulate and assign the these params to the secondary variables. This way They are remembered outside the Manipulate loop. Also handy for debugging.

Building on your example, I came up with the following, which keeps the last used value when I run Manipulate again. (see code at end).

I can also make presets this way and via a Button load them back into Manipulate. I had hoped that there might be an easier way (a Wolfram function) that would do the job, as sometimes I have quite a lot of adjustable parameters in my Manipulates. But it is doable this way.

I'll post a Nb about my first question later.

Manipulate[ kValue = k; Plot[Sin[k x], {x, 0, 2 [Pi]}], {{k, kValue}, .5, 3, Appearance -> "Labeled"}]

TOPICS

It would be great if the following topics are covered, OR if there are other courses which cover them (I appreciate that some of these were touched on a bit):

custom packages , non-trivial function bodies, ordinary looping (includingPython-type looping), IDEs which work well, custom types (as in OO programming), name spaces, enums.

At least indicate what Wolfram language calls these structures, and where they are.

For example, list indexing was covered to excess, but there was only just brief touches of defining complicated functions. Custom packages are crucial for organizing any but the simplest programs, and ditto for IDEs. Sometimes speed is not important but flexibility in looping might be needed. Etc.

Thank you

Not in the file provided.

The 2D slider

Manipulate[coordinate, {{coordinate, {0, 0},   "Coordinate"}, {-1, -1}, {1, 1}}] (* 2D slider *)

How would I do a 3D sider?

Manipulate[coordinate, {{coordinate, {0, 0,0},   "Coordinate"}, {-1, -1,-1}, {1, 1,1}}] (* 3D slider *) 

does not work

We Create 3D graphics on a 2D surface so we should be able to create a 3D slider .

I have noticed recently how graphics programs use a 3 button mouse to allow 3D movement in a 3D graphic , Is this not a possibility