Daily recordings will be shared with the group each day, so you can catch up on any sessions you miss. Looking forward to it!

Hey Arben,

I've not used associations before and I am trying to imagine what is their superpower. I'm not really a software writer, I just play one when I'm trying to study or solve engineering problems. One idea that jumps off the page is using a list of variable value assignments that can be summoned in a program without actually defining the variables outside of the context of the operation using them. That's kind of neat. I'd have to try that out and see if it makes a program easier to write or understand. But I suspect that's just the tip of the iceberg (as is everything else in the Wolfram language).

What do you say is the superpower in using associations?

Hi David, Apologies for the bad link in today's recording email. The one below should take you right to the folder: https://wolfr.am/WSG48_Programming_Profeciency

Thanks for teaching and I look forward to gaining new insight and learning the various facets of the Wolfram Language and learning to code with Mathematica. The course in this series labeled with #34 for the most part was attended, although completion of the course-work is latent. Hastily, without having differentiated or juxtaposed the two sets of files, I'm wondering about the development or difference thereof. Also, is this the appropriate place to provide commentary or share what you are learning or problems that you may be stuck on in the sense of posing a problem that is confounding?

For the sake of convenience, I have the following two lines for reference with the time zone set to GMT-8 for current locale the default being +1 given the supposed original temporal datum or original time where it is that the Vatican City state is presently, as well as central Europe and Scandinavia. This is just for contrasting disparate times along the lines of DateObject[] and use of SolarTime[] and MoonPosition[] for scheduling, thinking with respect to calendrical arithmetic or geo-computation for arranging one's day according to a plan in the sense of avoiding scheduling conflicts and slotting time around attendance of the course.

Transpose@{Alphabet["Greek"][[1;;10]]//Capitalize,(QuantityMagnitude/@Table[(a-DateObject[List[1,1,11,0,0,0],"Instant","Gregorian",1.`]),{a,{DateObject[{2024,1,29,9,0,0}],DateObject[{2024,1,30,9,0,0}],DateObject[{2024,1,31,9,0,0}],DateObject[{2024,2,1,9,0,0}],DateObject[{2024,2,2,9,0,0}],DateObject[{2024,2,5,9,0,0}],DateObject[{2024,2,6,9,0,0}],DateObject[{2024,2,7,9,0,0}],DateObject[{2024,2,8,9,0,0}],DateObject[{2024,2,9,9,0,0}]}}])//Ceiling//FactorInteger}//Grid

and also

TableForm[Transpose[List[List["Lists and Associations","Assignments, Rules and Patterns","Syntax and Expressions","Writing a Program","Good Coding Practices","Interfaces and Deployment","Working with Data, Part I","Working with Data, Part II", "Developing Packages","Review Session"],List[DateObject[{2024,1,29,9,0,0},"Instant","Gregorian", -8.`],DateObject[{2024,1,30,9,0,0}, "Instant", "Gregorian", -8.`], DateObject[{2024,1,31,9,0,0}, "Instant","Gregorian",-8.`],DateObject[{2024,2,1,9,0,0},"Instant","Gregorian",-8.`],DateObject[{2024,2,2,9,0,0},"Instant","Gregorian",-8.`],DateObject[{2024,2,5,9,0,0},"Instant","Gregorian",-8.`],DateObject[{2024,2,6,9,0,0}, "Instant", "Gregorian", -8.`],DateObject[{2024,2,7,9,0,0}, "Instant", "Gregorian",-8.`],DateObject[{2024,2,8,9,0,0},"Instant","Gregorian",-8.`],DateObject[{2024,2,9,9,0,0}, "Instant","Gregorian", -8.`]]]]]

With respect to this is the question of how to seamlessly integrate sharing of snippets of code like this in and that within Wolfram|One this was drafted and then the sequence was right click the "cell object delineator" (For lack of the proper term, assuming that is the incorrect phrase or string for a potential association) and then through the "drop down menu" "Plain Text" was selected and then "Alt + Tab" to navigate to Notepad and then "Ctrl + V" in the window after left clicking and then copying again via the aforementioned technique and then tabbing or repeatedly using the "Alt + Tab" macro/technique or combined key-press selecting the Microsoft Edge window and then again (As with Notepad via Windows 11) left-clicking and then pasting or using the "Ctrl + V" key-combination after left-clicking. This is rather cumbersome and tedious in the sense of efficacy with respect to the users resource of time (Avoiding philosophical subtleties with respect to the complexity classes and dichotomy in the sense of Kolmogorov & also the power tower or sequential binary operation, to provide an errant opinion in the mode of assumption). Perhaps accessing this page from within the Mathematica console or the Wolfram|One program such as what was mentioned earlier with external APIs in some way navigating a directory safely and in a maximally efficient manner with respect to augmentations such as keypress (Again, lacking the lingo or appropriate terminology with respect to this programming language or the sequence of expressions in the sense of algorithm).

One question is about accessing this course via BigMarker through a secure channel or learning about ports and other nuanced aspects in the sense of being conservative with data and being able to readily upload information through the WDF or contribute in real-time to the Wolfram Function Repository without removing attention from the lecture such as with alternate channels of data in the sense of active execution for formatting and the like.

Hopefully, I can provide less loquacious or verbose inquiries, yet the actual procedure of the computer program (I assume algorithm is correct in the sense of encapsulating it lexically or calling it by one word, as I imagine that I may do if there is audio programming and "calling" the server/use of the kernel involves univocal definitions and sensitivity in terms of attenuation) is what I'm curious about and I've deviated from solving the puzzles or producing a solution set, to my own detriment.

Given that so much time is spent with low-level calculations in Mathematica such as the above, a curiosity is with more compact functions such as with the pure function or defining the concept parametrically (Only having a vague notion of that at present, in the sense of a region that may be implicit, explicit, or parametric, according with abstract or universal geometry [rudimentary mathematical constructions and later demonstrations is a crucial project at present with developing thinking methodically or discerning the methodology, which I think that the Documentation Center does a good job of as it is worded, that I've noticed up until now, although one curiosity, further still, tangentially, is about the LinkSnooper and modifying the formatting with notebooks for stylesheets and whatnot. CloudDeploy[] was noted at 0713 0750 0203 and APIFunction[] on 0863 that date, although I currently lack knowledge of their utility with respect to rough outline of the aforementioned project, failin to attend/being truent for the course on May 16, 2023 on Programming Fundamentals. There is a wonder from 11439 about notation and Boolean Algebra with nn*ee, b^^nnnn, &&, ||, !, and <> about Element[] for the atomic expressions and use of Distributed[], UndirectedEdge[], DirectedEdge[] for Galois Theory (Which was, FiniteField[] and the related group theoretic constructs, experimental as of version 13.3.0) with there a curiosity about Polynomial Algebra and the S- and K-combinatorics with the Chief Executive Officer expounding work from December 1920 (Find WikipediaData@"Combinatory Logic" for a more concise elaboration) and use of bit-vectors in the aforementioned sense of a directory and efficacious navigation through WolframScript via the command line without a graphical interface.

738904.0199

Anyone grok this list operation: Alphabet[][[;; 10 ;; 4]]

I understand Alphabet[]
I understand Alphabet[] [[;;10]]
I understand Alphabet[] [[;;4]]

I do not grok what's happening when the 2nd and 3rd statements are combined. I thought the ";;" operation acted like a pipe. The solution {a, e, i} isn't what I think a pipe should give.

Hello Coe!

Arben's explanation made me want to see it in color. This is what came of it. I hope it helps.

PLEASE SEE THE NOTEBOOK ATTACHED TO THIS COMMENT

Have fun!

Attachments:

776682000.nb

Yes! The evaluation system is effectively a huge database of pattern-matching term-rewriting rules. For example, think about:

D[x^3,x]

We know that this is "the derivative of x cubed with respect to x", and we know that when we see this pattern—the derivative of x^n_, if you will—that we should take the power, drop it to the front, and then subtract 1 from the power.

The Wolfram system is effectively doing the same thing: it sees that something matches the pattern D[x^n_,x] and says what we do: "I know what to do when I see that: D[x_n,x] :> n*x^(n-1) and that's what's returned to us.

When you write your own functions, you are effectively adding to this database of term-rewriting rules (and are often using those rules as foundations for your own definition). In this way, any program you write is just about matching patterns and transforming the appropriate ones into something new.

Arben, how do I post without replying to someone else's post (like I am doing now)?

I do have a question about Riffle[ ].

Riffle[{1,2,3}, {x, y}]

outputs {1,x,2,y,3}, understandably. But

Riffle[{x,y}, {1,2,3}]

outputs {x,1,y}. Why? I would have expected to get {x, 1, y, 2}.

Thanks.

My apologies folks, I mis-wrote the equality that I am asking about. Again -

In today's post-lecture questions "pat2 = _h" Case tells me that pat2 matches the following elements in exprs:

    {h[], h[a], h[b], h[a, b], h[a, a], h[a, b, c]}

Does this mean that **pat2 = _h = h_**? It seems like it, but this seems odd to me in that we are PATTERN MATCHING and, it seems to me, elements in one order should not necessarily be equivalent to elements in a different order.

Comment?

Hi Arben,

Would please clarify the following terms: vector, array, matrix, expression? And regarding the docs, what's the difference between options and properties in a function?

If you want to create a new question on Wolfram Community, please use the button "Start a new Discussion" on the right side of Community's homepage.

Then use the instructions here: http://wolfr.am/READ-1ST

Write "a x" with a space between a and x. Mathematica interprets the space as a multiplication.

Addendum to Lara's explanation: "ax" is read as one symbol, as opposed to "a x" which is read (in the example case) as two distinct symbols of a numeric type, so the space is interpreted by Mathematica as an implied multiplication.

Hey Coe—I'm not sure what you mean. The attached notebook is missing the spaces between the coefficients and thus produces the incorrect output. You want:

y=a x^2+b x+c

or, explicitly:

y=a*x^2+b*x+c

in order to get the correct polynomial expansion.

@ Steve, you can type your code between two backticks to prevent it from formatting via markdown, which is why the asterisks are being used for formatting rather than displaying.

When I enter everything without spaces I get the wrong answer. When I enter WITH explicit asterisks, I get the right solution. The attached image shows what is entered and the result.

Attachments:

Screenshot 2024-...jpg

Bang head with hand. I forgot. Thanks.

exp[[2, 2]] returns 2, the second part of the second part, I'd expect exp[[1, 1]] to return the first and only part of the first.

When I'm using those terms, I mean:

• Vector: something that you can describe with 1 index. It could have a length of 2 or a million, but you could get any singular element out of it by doing vec[[n]].
• Matrix: something that needs two indices to get any individual elements from: say, the element at the first row and third column could be accessed with mat[[1,3]].
• Tensor: generic term for anything where you'd need more indices to describe the position of a single element. Note that this is not really an appropriate definition in the physics sense, but I'm being a little loose with it. You can think of them as the general case of the special "one-index" and "two-index" cases of "vector" and "matrix", respectively.
• Expression: any sort of singular "thing" in Wolfram Language—that is, anything that's not a sequence like a,b. a is an expression, Plot[x,{x,0,5}] is an expression, and so on.

You can see more of the fun of conflicting definitions here.

[redacted]

Another way of saying the same thing: Mathematica is taking ax^2 to mean (ax)^2. This can be seen by asking for the FullForm.

In terms of today's lesson: AtomQ[ax] returns True , AtomQ[a x] returns False.

In[84]:= Clear[x, y, a, b, c]

In[85]:= y = a x^2 + b x + c

Out[85]= c + b x + a x^2

In[86]:= Expand[y^2]

Out[86]= c^2 + 2 b c x + b^2 x^2 + 2 a c x^2 + 2 a b x^3 + a^2 x^4

system: Apple M2 Ultra, 14.3 (23D56) Mathematica: 14.0.0.0 Mac OS X ARM (64-bit)

...and this can be seen: AtomQ[exp[[1]]] returns true.

pat2 is _h, which explicitly means: "any one thing with head h". This is not the same as h_, which means "any one thing—call it h". It is (except for perhaps some pathological edge cases) the same as h[_], which is "h of any one thing."

pat3 is x_, which means "any one thing—call it x." Every element of exprs is just a single thing, so they all match. Because we're not using that x anywhere, this pattern is equivalent to just _, i.e. "any one thing".

We might see a named pattern like x_ in a standard function definition:

f[x_]:=x^3

The x on the LHS has nothing to do implicitly with the "any one thing" denoted by the _. The x is just a dummy name that we give to that one thing (the one thing that appears in f's brackets) so that we can refer to it on the RHS. Consider the example:

f[x_]:=5

There's no mention of x on the RHS, so it's pointless to even name it on the LHS (in some sense.) It would be exactly the same to instead say:

f[_]:=5

The point is that "f of any one thing" should be 5. We don't care about the input here, so why bother to name it if we're never going to use it? In this sense, we are saying that f is a transformation rule that takes anything of the form "f of any one input, and I don't care what that input is" and returns 5.

Hi Michael—I think the issue comes from the formatting that this notebook has for that ListLinePlot input. Ideally, it would just be an input... but when you click into it, you can see that there's a kind of yellow box around it. Basically, this is a text cell formatted as input and so it won't evaluate correctly, if we're seeing the same thing. (I think your specific errors with respect to Dynamic elements here are kernel-specific and thus not "carried with" the notebook that you uploaded when I open it on my end, so I can't see for sure what your issue was.)

if you just start typing ListLinePlot in a new cell, you should be able to plot the data without issue. I think what's happening is that on our end, making the Hint/Solution buttons does something unfortunate to the formatting of code blocks that we had intended for you to type into. I'll look into this with our team.

Understanding this helps in navigating subjects that cross disciplinary boundaries. - GPT4

I'd highly recommend Professor Richard J. Gaylord's Wolfram Language Fundamentals

Arben, Thanks, that makes a lot of sense since both errors occurred at the same time. I'll try out your suggestions and see what happens.

Hi Everybody!

I would like to produce documents effectively (so programmatically) and I need to find help about producing cells, sometimes cells within cells (within cells?). Can anybody give a good reference? Such things as TextData, BoxData, ToBoxes, ToString and similar.

Yes, the very same! It's from τόμος, which I think is from τέμνω, which is something like "to cut/slice/section/portion".

Yes, I also found that I couldn't use the code output by those boxes in situ. Entering it into a new code cell works fine.

Perfect. I get it, thank you.

One thing that really attracted me to Wolfram was how the expressions in a book I picked up published in 1988 still computed. Thankful, in this universe there is forward compatibility, even amongst changes in scientific knowledge.

Although Show[Graphics3D[Stellate[ Icosahedron[ ]]]] wasn't forward compatible.

Heh, it's true :). At least in this case it's been superseded by something simpler and clearer!

In the "Check Your Understanding" exercise for pure functions we are told that Function[u, 3+#][x] is the correct syntax for returning 3+x given x as an argument.

I think that's incorrect (?)

Tree walking - inconsistency or design

Given some algebraic expression y, I can do y[[3,2,5,1,..]] to walk the tree (or the full form) to a particular node.I can also do y[[0]] which is the same as y//Head. However, y[[0,2]], for example, is an error in my notebook, though presumably it should be the same as y[[2]].

This seems to me an inconsistency, but perhaps it is that way on purpose???? (In y[[3,2,5,1,..]], presumably the "0" is implicit.)

This is probably not a big deal, but I am bothered by stuff like this - a sort-of reflection edge condition that doesn't seem sensible.

It seems to me the Head is just a node. I don't understand why it should be different from any other node. If it doesn't have a structure, why should any other node have a structure? I suppose there is something in the engine which interprets the head node differently from other nodes.

Hey everyone, care to take a stab at explaining why:

Total[{{a, b, c}, {u, v, w}, {x, y, z}}]

returns

{a + u + x, b + v + y, c + w + z}  (*One of our Day 4 "Check Your Understanding" questions*)

I've looked at the documentation for "Total" and still can't figure out how this result is obtained. Thanks in advance,

Hey Coe, I can explain this.

Total is documented to take the elements of a list and add them together. In other words:

Total[{a,b,c,...}] === Plus@@{a,b,c,...} === Plus[a,b,c,...]

In standard notation, that means that Total[{a,b,c,...}] just evaluates to a+b+c+.... Nothing too surprising here, I think.

The misunderstanding likely comes from two places.

Since Wolfram Language is fully symbolic by default, we never said what a, b, c and so on might be. They don't need to be reals or integers or even numbers—in fact, try this for me:

randomImages=Table[RandomImage[{0, 1}, {25, 25}], {2}]
Total@randomImages

If there is a sense in which the arguments inside the List fed to Total can be added, then Total will add them because it is very literally just performing the pattern-matching term-rewriting transformation rule I expressed above.

Now that we know what Total does, if we want to understand the output of Total[{{a, b, c}, {u, v, w}, {x, y, z}}], we need to ask: what does Plus do when fed multiple List objects?

You can try this out manually, but that's basically just rewriting the thing that we're not understanding in the first place. Instead, you might try Attributes[Plus]. You get back several attributes, but the important one here is Listable. If you check the documentation for that, you'll see examples which basically replicate the behavior that prompted this question:

In[1]:= {a, b, c} + {x, y, z}

Out[1]= {a + x, b + y, c + z}

This is to say: Listable functions automatically thread over their arguments when those arguments are lists. Most built-in mathematics functions are listable, and this attribute allows for highly optimized code compared to looping or even mapping.

In the case of Plus, this behavior also happens to correspond to the standard mathematical operation of addition acting on vectors, matrices, and tensors more generally. After all, if you have the vectors a, b, and c, you find their sum by element-wise addition, right? The same is true for matrices and so on. (And in fact, people are often lazy and will "add" a scalar to a vector when what they really mean is that they want to add a constant vector to a vector. For example, somebody might say x = <1,2,3>, then say something like x + 1, when really they mean x + <1,1,1>. This is also automatically handled by Listable; feel free to evaluate {a,b,c}+1 and see the result, or even {{a,b},{c,d}}+1.)

Thanks. That's really helpful.

Hey Arben,

Loving your class. Got a little exercise:

The transfer function of non linear power amplifiers produces inter-modulation products between the tones at their inputs. If the transfer function is expressed as a simple 5th order odd polynomial, and the input x is made of two sine waves at frequencies w1 and w2, you can easily find the mess that shows up at the output. It includes 3rd and 5th order inter-modulation products around the two tones, 3rd and 5th harmonics, and inter-modulation products around the harmonics. In RF systems we use band-pass filters to select only the fundamental tones and those tones around the fundamentals w1 and w2 (usually assumed to be closely spaced compared to the frequencies of the harmonics... Although audio systems will not be so cooperative.)

I've been playing around with some of the concepts I thought I was learning to take the output and literally select them, but it's not working yet. In the past I've just given up and brute forced it (yuk). This time round I'd like to learn how to do it right...help?

Attachments:

Selecting IM products.nb

Hello Phil,

Thank you for letting me know. I apologize for the confusion created.

Upon a detailed look, the behavior described seems to be related to the fact that Wolfram Cloud and Wolfram Desktop are two separate products. The basic plan for Cloud grants users the basic functionalities needed for a smooth Desktop operation, but it does not grant access to the Wolfram Cloud as a product in and of itself. Basic Plan restrictions

This is why the direct dynamic interaction within Wolfram Cloud is not available but the use of CloudPublish from Desktop, either programmatically or through the menu tool, works as expected.

I will try to improve my Q&A support with your feedback. I have already setup a basic account for testing of future questions. Thank you!

I get 6 on my notebook.

As do I. Coe, you might have given larger an incorrect definition that hasn't been overwritten for one reason or another—try restarting your kernel and running these two lines again? (Re: the new comment—the semicolon is fine. It's not necessary for SetDelayed definitions since the evaluation is, as claimed, delayed!)

We really do abhor a brute force solution. This is a fun little question; please see embedded response!

PLEASE SEE THE NOTEBOOK ATTACHED TO THIS COMMENT

Attachments:

148596520.nb

I really strive to provide pedagogically useful answers, so I appreciate it :). If I'm reading your (original) post correctly, you could also do pattern-matching or selection by going directly into the cosine terms, extracting the coefficients of the omegas with CoefficientList and grabbing only those cosine terms for which the absolute value of the difference is 1. This would make it so you don't even have to generate the desiredHarmonics list, if that's indeed what you want.

As for your new question, some more information would indeed be helpful. It's been a long time since I've dealt with this sort of thing, and certainly I've never approached it from the perspective of signal analysis and decomposition. But, fundamentally, you could write the same kind of thing as above with Cases, specifically recalling that Cases allows not just for pattern-matching but for term-rewriting too. So you could do something like:

Cases[expr,Cos[B___ Sin[ω t]]:>(full or truncated B-dependent sum here)]

This would extract all of the relevant cosine terms and rewrite them; you could update the rule to include both sine and cosine terms but I'm forgetting the way to do that right now. You could do something similar to the previous case and just extract all cosine or sine terms that have the right form, then use a simple /. to write a rule which appropriately converts the cosines and sines to their sum forms. You may also be interested in TruncateSum (new in 14), though this behavior was always manually implementable with a little elbow grease.

Otherwise, if you have an exact worked example, I'm pretty sure I could write something up reasonably quickly.

Hey Michael! The reason this happens is the order of evaluation. I have two suggestions for you to try which I think will clarify this behavior:

1. Trace[TreeForm[Plus[1,2]]]

2. TreeForm[List[a,b]] (=== TreeForm[{a,b}])

Let me know if this illuminates the difference for you.

Let's see:

PLEASE SEE THE NOTEBOOK ATTACHED TO THIS COMMENT

EDIT: Really better just to use Coefficient. I don't like CoefficientList anymore; it's dead to me. So this is probably the most efficiently and extensibly you could write it?

Cases[yexp, 
 c___*Cos[arg_] /; 
  Abs@Total@Coefficient[arg, {ω1, ω2}] == 1]

Attachments:

65878553.nb