Based on my previous experience ( about 6 classes taken at different times), I would recommend the following.
(1) Create a notebook, say "Class3_my practice and questions". Let's call it MNB (my notebook).
(2) Open the downloaded class notebook(s), typically one or two (CNBs).
(3) The goal is to reproduce in MNB the most of activities presented in CNBs. Also, consider some variations of the offered examples, mark the difficulties and formulate the questions.
(4) In doing so, make sure to create sections in MNB ( using Alt-1 - Alt-6 shortcuts, with textual inserts using Alt-7) reflecting the corresponding sections in CNBs (so that the general structure of MNB is similar to CNB, but it may include some additional sub(-sub)sections such as "My question to the forum", or "some additional examples", or "the definition of such and such function...").
(5) Watch the pieces of the class video addressing the questionable parts (in case you do not have time to watch the whole video).
(6) As a result, you should have a few unanswered questions. Never hesitate to post them on the forum. This is good for all the participants! So, consider it a public service :)
(7) In parallel, create the notebooks Quiz1, 2, etc for solving the quiz problems. Each lecture contains (hints to) the answers to some Quiz questions. Doing it continually makes the Quiz activities less stressful (make sure not to discuss directly the Quiz questions on the forum, but you can discuss any related general issues ).

Good luck.

I must confess that I am totally confused about the concept of precision in Mathematica / Wolfram Language. Let me share this confusion with you:

Additional notes on this comment from above.

"If it sees n g[x] as a pattern, maybe it will see {point1,point2,n} * h[Ball[]] as an upvalue for h, and then construct n Balls from point1 to point2, but only if the symbol h is used."

I want to create a simple "extension" using tagged delayed assignments (up values) to allow n points to be enumerated over a line from point1 to point2. We try this naively and find that the implicit multiply operation is listable, so we get a list of the multiplied values.

In[150]:= ClearAll[g]
g /: n_List g[x_] := g2[g1[n], x]
{point1, point2, n} g[x]

Out[152]= {point1 g[x], point2 g[x], n g[x]}

This is not what we want. Instead of using the Times[] function, we will use h, which is not listable, in the above instead.

In[144]:= ClearAll[g]
g /: h[n_List, g[x_]] := g2[g1[n], x]
h[{point1, point2, n}, g[x]]

Out[146]= g2[g1[{point1, point2, n}], x]

g1 can be a function to generate the n points and then it is passed to g2 which does the volume rendering of x. Maybe there is an existing function for this, but this is a fun exercise anyway.

Basically, we are recognizing a certain context involving an outer scope of the function g, and then doing something special to it when we recognize it. This is an amazing ability! WOW!

I learned a lot in writing this stuff up. Tagged delayed assignments are really cool, and I had fun playing with the concepts which I had just recently learned.

Expanding on your comments, Arben, we see indeed that integrating using Sphere vs. Ball clearly gives different answers.

In[6]:= Integrate[1, {x, y, z} \[Element] Sphere[]]

Out[6]= 4 \[Pi]

In[7]:= Integrate[1, {x, y, z} \[Element] Ball[]]

Out[7]= (4 \[Pi])/3

Using RegionMeasure allows the dimension of the integration to be specified.

In[8]:= RegionMeasure[Sphere[]]

Out[8]= 4 \[Pi]

Agreeing with your comment, Arben, Sphere[] is 2-dimsional, and its 3-D measure gives zero. WOW - that's a gocha.

In[10]:= RegionMeasure[Sphere[], 3]

Out[10]= 0

Note the correct answers using Ball[] below.

In[9]:= RegionMeasure[Ball[]]

Out[9]= (4 \[Pi])/3

In[11]:= RegionMeasure[Ball[], 3]

Out[11]= (4 \[Pi])/3

As a final note, we see and understand the next result.

In[12]:= RegionMeasure[Ball[], 4]

Out[12]= 0

Arben, thank you for your kind response. Indeed, the use of Ball in place of Sphere makes everything work wonderfully. I went on to play around with some cool and fun examples, and I am including the updated notebook. Here is a highlighted example from the attached notebook, where it finds a closed form solution.

Attachments:

regionintegration-v3.nb

@lara wag please find below the response from Dave Withoff:

This is a common generic problem in propagation of uncertainty that I first (several decades ago) saw referred to as "The Problem of All Errors Being Treated as Independent".

The result from b-b, for example, could reasonably be expected to be zero, since b-b is zero for any number b, and this is obviously true even if b is a number chosen from an interval.

That, however, is not how the calculation is done, or how propagated errors are typically calculated. If b is an interval, say, for example, Interval[{1,5}], then b-b becomes Interval[{1,5}] - Interval[{1,5}] and the calculation is done by working on the range of possible answers for any number in the interval {1,5} minus any other number also in the interval {1,5}, without the restriction that the two numbers have to be the same number.

This is a very common issue in numerical analysis, specifically in working out accumulated error in numerical algorithms. Parameters that come up in numerical algorithms almost always occur in lots of places within the numerical calculation. If those parameters have some uncertainty, the uncertainty in the result is overestimated if the values of the parameter are treated as different independent values everywhere that each parameter occurs.

Although a better error estimate can be obtained by recognizing that the value of a parameter is always the same, even if that value might be uncertain, this makes the propagation of error calculation so much more difficult that it is usually done only in limited examples. It is not typically done in results from functions like Solve.

In the result from

In[]:= Solve[x^2 + b x == 6, x][[2]]

Out[]= {x -> (1/2)*(-b + Sqrt[24 + b^2])}

for example, the parameter b occurs in two different places. If that parameter is replaced by Interval[{1,5}] the result is

In[]:= {x -> (1/2)*(-b + Sqrt[24 + b^2])} /. b -> Interval[{1, 5}]

Out[]= {x -> Interval[{0, 3}]}

which is the result returned by Solve. For any value of b in the interval {1,5} that solution is always between 1 and 2, so the result could instead be Interval[{1, 2}]. The actual interval returned by Solve is bigger because the two appearances of b in the result are treated as independent.

Hi Zbigniew,

I think all of your questions are related to the fact that by default the frontend only shows 6 digits for MachinePrecision values, irrespective of what precision values is passed to N.

sol // InputForm
(* {-3.035090330572526, 1.0350903305725259} *)

This can be changed, e.g.

(* For the current frontend session *)
SetOptions[$FrontEndSession, PrintPrecision-> 16]

(* For the current and future frontend sessions *)
SetOptions[$FrontEnd, PrintPrecision-> 16]

(* For the current notebook *)
SetOptions[InputNotebook[], PrintPrecision-> 16]

Or you can use NumberForm.

NumberForm[sol[[1]], 16]
(* -3.035090330572526 *)

In my previous post I used the function SolveValues. Please note its naming inconsistency with DSolveValue and NDSolveValue. Why is one plural while the others are singular? Shouldn't, perhaps, for naming consistency, a SolveValue version be added to WL? (obviously we have to keep SolveValues now that a number of already written programs are using it).

I'm glad to hear it! I might be biased, but I do think it's pretty cool that you're able to achieve such a result. Also—while this may be a bit trivializing in some sense, we really do have a function for everything! Try out RegionMeasure, if you'd like, e.g.: Manipulate[ RegionMeasure /@ {Disk[{0, 0}, d], Sphere[{0, 0, 0}, d], Ball[{0, 0, 0}, d], Cuboid[{0, 0, 0}, d {1, 1, 1}]}, {d, 1, 5, 1}] This can be useful to provide some insight which is relevant to the dimensionality question we're discussing (somewhat paradoxically). On a related note, you might try something like Volume[Sphere[]] and get a (previously-)surprising result.

Or, you could make the variation continuous, then Plot to see the problem another way: Plot[Evaluate[ RegionMeasure /@ {Disk[{0, 0}, d], Sphere[{0, 0, 0}, d], Ball[{0, 0, 0}, d], Cuboid[{0, 0, 0}, d {1, 1, 1}]}], {d, 1, 5}, ScalingFunctions -> {"Log", "Log"}] (adding PlotLegends->"Expressions" would make it explicit, to wit.)

EDIT: I'd be loathe to forget RegionDimension!

I feel like I am doing something exceedingly stupid, but am having trouble getting the volume of a sphere as given below.

This calculation gives 7.06858347057703478654094869079, which is off by a factor of 4.

Looking for a possible application for upvalues, I made the following definition:

f[x_ /; x < 1] := 1;

f[x_ /; x >= 1] := x x x;

Sqrt[f[x_] /; x >= -2 && x <= -1 ] ^:= 3;

If I now want to test the effectiveness of my definition by calculating a square root of f[-1.5], it does not seem to work at first glance:

Sqrt[ f[-1.5]] returns 1, and not the expected 3.

The same applies to a function plot:

Plot[Sqrt[ f[x]], {x, -5, 5} ]

On closer analysis, it turns out that the calculation first calculates the inner term, and the kernel then forgets that the inner value arose by evaluating f[x], and accordingly does not apply the upvalue.

If I forbid the evaluation of the inner term, we get the expected results:

Sqrt[ Unevaluated[ f[-1.5]]]

Plot[Sqrt[ Unevaluated[f[x]]], {x, -5, 5} ]

This shows me that upvalues do not allow the overloading of functions similar to OOP that I had hoped for. Always thinking about disallowing the evaluation of the inner term limits the usability in my eyes.

However, this begs the question. What is a real life use case for the upvalues?

As @Lori Johnson mentions, if you paste a URL into a text cell it will be pasted correctly and even change into a hyperlink. You can create a text cell in a notebook as shown here: https://reference.wolfram.com/language/workflow/CreateATextCell.html

Hi Abrita! Thank you, Abrita, and everyone working to put them together!

Something like this?

Plot[Evaluate[Abs[x /. sol]], {b, -5, 5},
 PlotRange -> All,
 PlotStyle -> ColorData[3, "ColorList"],
 PlotLegends -> "Expressions"]

Michael—sequences can indeed be a little tricky, but they're a great tool to add to your arsenal. You can really start manipulating things at a low level once you have a grasp on them and how they work with patterns!

Range[10] /. {p___, q_, r_} :> {Hold[ 2 p], q r}

shows what's happening with 2 p. It is computing 2X2X3X4X5X6X7X8

p (from the RHS of the rule) is really a fragment of an expression. It needs to be explicitly turned into a list to get the output you are looking for. Maybe something like:

Range[10] /. {p___, q_, r_} :> Append[2 {p}, q r]

Posted exercises for days 1, 2 and 3 in the series download folder.

Thanks Doug. The "Dynamic Updating Enabled" is on, or else the t1 2D slider wouldn't work either. Maybe my installation is corrupted somehow.

Hi. If I define an uppervalue x by: x /: _[x] = 0, How can I clear it?

Thank you very much, Abrita and Dave!

I would never have thought of that...

Thank you for the thourough explanation.

Dave Withoff suggests the following: XOR matrix multiplication is defined differently in different contexts, but a typical definition can be computed using the Inner function, as in

In[]:= x = {{1, 1, 1}, {1, 1, 1}, {0, 0, 0}};
In[]:= y = {{0, 0, 1}, {1, 0, 1}, {0, 1, 1}};
In[]:= Inner[BitXor, x, y, BitOr]

Out[]= {{1, 1, 0}, {1, 1, 0}, {1, 1, 1}}

which shows XOR matrix multiplication defined as matrix multiplication with bitwise XOR in place of multiplication and bitwise OR in place of addition.

Other definitions can be computed using combinations of logical functions, bitwise logical functions, and matrix operations like Inner and Outer.

Thank you Lara for cheering me up. But I'm still ready to let gravity take its course ... :)

I am adding to the ""If it sees n g[x] as a pattern" from above.

Using a tagged delayed assignment to generate a list of volumes along a line

Two relatively simple lines of code make it easy to generate volume objects along a straight line.

LinePoints[{p1_, p2_, n_}] := Table[p1 + (p2 - p1) k/n, {k, 0, n}];
UsingA /: GenerateLinearRegion[n_List, UsingA[x_]] := 
 Region[RegionUnion[Map[x[#] &, LinePoints[n]]]]

Here UsingA is a tagged delayed assignment. Its use makes it easy to generate volumes. For example

GenerateLinearRegion[{{0, 5, 0}, {15, 0, 0}, 10}, UsingA[Ball]]

generates a series of 11 Ball objects from {0,5,0} to {15,0,0}, and is shown below.

Another example is here.

A more complex structure is also easy to generate.

These examples are from the attached notebook, which includes more illustrations.

The tagged delayed assignment is a really cool feature of WL.

Attachments:

volumesTaggedDelay.nb

Thanks for your response to the Print issue I posted. The CellPrint code you provided works well. Based on that, I went back to the Print Help. My take on that is that Print generates something like CellPrint, though my attempt to use FullForm[HoldForm[Print[...]]] did not work. How does one find what the underlying Wolfram Language code of Print is or is Print just a function unto itself? That is, how do I find out whether Print is using CellPrint?

Since Print has no options, I tried Grid with Frame -> True, which shows that the width is set to that of the wider of the two lines of text. This suggests that at least part of the Print problem may have to do with cell width being set this way. To fix this, I added to Grid the option ItemSize. Here is the code, which works fine:

Grid[{{Style["Options for Plot and ListPlot", Bold, 16, 
Orange]}, {Style["Options in Common", Italic, 14, Blue]}}, 
Alignment -> Center, Frame -> True, ItemSize -> 50]

Attached file "GDorfman_GridToCenterText.nb" has the above code with and without ItemSize along with the corresponding output.

Attachments:

GDorfman_GridToC...nb

[WSG22] Daily Study Group: A Guide to Programming and Mathematics with WL

Input NRoots[x^2 == 5, x]

gives me an error: ... General: 5 is not a valid variable.

What's wrong?

Please post more 'stackoverflow'-like post like this in the future... it benefits a LOT.. on a very LONG run..

Notebook 19SolvingEquations.nb has now been added.

Hi Abrita!

The first chunk you posted:

Range[10] /. {p___, q_, r_} :> {Hold[ 2 p], q r}

...helped me find a solution to something related to what Richard Hewens posted. I found a different solution but I like yours so much better. THANK YOU! :-D

Q&A transcript from Day 5 of Week 1 has been added to the download folder. We'll add the digest from this week at the end of the week.

@Thomas Ray Worley please feel free to email wolfram-u@wolfram.com if you are facing issues with the notebooks. We will be happy to help you troubleshoot further. You should be able to open all the notebooks in the same way.

Thanks Richard. That second reason should always be kept in mind.

Thanks Richard.

It appears that f[x_] := f[x] =. .. is more efficient. Is there ever a case in which it should not be used?

When defining functions, when is it better to use f[x_] := f[x] =. ..instead of just f[x_] := ...? Why?

This is really helpful - thank you!

Bravo, Richard. You have a sharp eye. Not everyone would have noticed this nuance.

Hi Richard—I'm looking into this. For the time, I can note that it's not a property of Defer, since Hold and Unevaluated (at least) do the same thing. The current thought is that it's a formatting property of Times, and formatting is a bit of an arbitrary choice that language designers have to make. I do agree that it's strange that the additive identity does not format the same way for Plus, though.

Abrita: "So what is essentially happening with the {#^2 & /@ p, q r} part of the expression is {#^2 & /@ 1, 2, 3, 4, 5, 6, 7, 8, q r} i.e. #^2 is mapped over the single element 1 and therefore gives the result {1, 2, 3, 4, 5, 6, 7, 8, 90} This would give the expected result: Range[10] /. {p__, q, r_} :> Join[#^2 & /@ {p}, {q r}]" **************************************************************************

Thanks! This opens a window to many opportunities such as this one: Range[10] /. {p__, q, r_} :> Flatten[{2 {p}, {q r}}]. Yet, I still have a question: what kind of object is p without {}? In other words, what is the sequence of "bare" comma-separated numbers from the WL perspective? I understand that in our case it is a "list" of arguments. But this is not a List. What is it?

Maybe you have already responded by saying that this is a fragment of an expression.. But there should be also some rules (default) telling M how to treat those... Could you please clarify?

For example, what is the rule leading to 2 p = 2X2X3X4X5X6X7X8? It even seems to contradict the treatment of p in the previous example where p was reduced to its first element (as you said, the "single element 1").

Thank you. M

Hi Syd, The link is included in the reminder emails you have been receiving from the Wolfram U Team. It is also shared during the session.

Responding to multiple-choice Qs does not contribute to certification. It's for self-testing. Watching the lectures and passing the quizzes do.

Where is the link to the download folder?

Is it possible to access the NB files and quizzes for this class in the cloud?