I have never participated in a webinar like this. The study materials .nb downloads. Don't look familiar or readable. What am I supposed to do with them?

Download files again , this has been corrected .

What is the Level I Certification in, exactly? Is it different from the Wolfram Technology Level I Certification?

Here is the series landing page, where you can see details and from where all session recordings will be linked: https://www.bigmarker.com/series/daily-study-group-programming-tutorials/series_details

The weekly quizzes will be announced on Fridays, and the exercises will be announced during the final week of the Study Group. Watch your email notifications for direct links to recordings, the quizzes and exercises, and additional resources.

The weekly quizzes will be announced on Fridays, and the exercises will be announced during the final week of the Study Group. Watch your email notifications for direct links to recordings, the quizzes and exercises, and additional resources.

Here is something to get you started:

Graph[{1 -> 2, 2 -> 3, 3 -> 1}, 
 EdgeShapeFunction -> 
  Function[{coord, edge}, 
   Tooltip[
    Triangle[{First[coord], Last[coord] + {0, 0.04}, 
      Last[coord] - {0, 0.04}}], {First@coord, Last@coord}]]]

The EdgeShapeFunction needs to be set to a pure function that will take the coordinates of the edge line and create something closer to your requirements. In the above example I created a triangle. The Tooltip is only intended to show what the inputs to the pure function look like when it tries to draw the edge.

I didn't see a recording for Day 2. Is there one?

How do choose not as a condition with patterns? For example,

mylist={1,1.5,2,3,3.14,2.718}
list /. _! Integer :> "Real"

I was also wondering how to replace all integers with "Int" and all reals with "Real" in one line. I think there is a way to use replace with lists

mylist /. {_Integer, _Real} :> {"Integer", "Real"}

The previous code does not work. How would I use conditions and patterns to replace each element of string list equal to False with Style[False, Red] and each element of string list equal to True with Style[True, Green]?

stringlist={True,False,False,True,False,False,True,False,True,True,False}

Example Notebook->

Re-read your last question. I think this is what you were looking for

Style[#, If[#, Green, Red]] & /@ stringlist

I am working on mapping the nearest nuclear reactor and first aim to select nuclear reactors that are in the United States. I have the following code: Select[EntityList[EntityClass["NuclearReactor", All]], EntityValue[#, "Countries"] == Entity["Country", "UnitedStates"] &]

but receive an empty list as a result for some reason. How can I select all nuclear reactors in the US? I would like to use the Select function.

I was am interested in converting various quantities such as the mass of the observable Universe, the number of particles in the observable Universe, the age of Universe, the speed of light, the surface area of the Universe as a ball and its cross-section, the width and volume of the Universe to Planck units. I am wondering if there is a way to specify with UnitConvert to convert to Planck length, time, and mass. I have read the documentation on UnitConvert and am wondering if there is a way to go about my project. The following code returns an error:

UnitConvert[{Quantity[1, "SpeedOfLight"],Quantity[1, "UniverseMass"]}, 
 TargetUnits -> {Quantity[1, "PlanckLength"], 
   Quantity[1, "PlanckMass"], Quantity[1, "PlanckTime"]}]

I was wondering if there is a way to specify PlanckUnits as the UnitSystem or define my own unit system. I found an example that relates to NonDimensionalTransform documentation.

1. What is the total number of posted recordings? In my email I found just 5. Is it all? Please post the link to recordings.
2. Could you please post a link to the most recent updates of the notebook files.

Thank you. M

UnitConvert would work as follows:

In[19]:= UnitConvert[Quantity[1, "SpeedOfLight"], "PlanckLength/second"]
Out[19]= Quantity[1.8549*10^43, ("PlanckLength")/("Seconds")]

In[18]:= UnitConvert[Quantity[1, "UniverseMass"], "PlanckMass"]
Out[18]= Quantity[7.*10^60, "PlanckMass"]

TargetUnits is an option available for use with visualization functions e.g. ListPlot

Symbolic computations can definitely be performed with Quantity expressions as described here: http://reference.wolfram.com/language/tutorial/SymbolicCalculationsWithUnits.html

I am registered in the course, but I am not getting the messages with the links to be able to attend the sessions.

I have noticed that the files at this link ( https://amoeba.wolfram.com/index.php/s/LWsQDeqpLeEW5MW?path=%2F ) have not been added to for several days. Is there somewhere else I should be looking for the most recent "Discussions" notebooks?

Thanks

How can I type the yellow-box form of a property? They appear italic in the example notebook, like "electric charge".

When I press ctrl+= and type elevation for example, I sometimes get a gray box that when confirmed turns into a string "Elevation". Sometimes I get "No Wolfram Language translation found." Never do I get a property that looks like what's in the example notebook.

An instructor answered that if you type EntityProperty["River", "Length"], then the property is printed in italic-yellow-box form like in the example notebook. Does that mean that the example notebook was written by evaluating EntityProperty and copy/pasting? What about "fertilizer production" which was used in the last example today, for which I don't know the entity class it applies to?

I get that, thanks. I'm just wondering if there's a shortcut for writing the italic-yellow-box form of an attribute. Because yes, if you type "area of New York City" in a natural language entry box you can get , but much of the time, notebooks don't include it in that form.

For example, this week's quiz has:

And yesterday's example notebook has:

So, is it the case that all these notebook authors created those cells by typing "area of New York City" then completely reformatting the expressions using copy/paste… or is there a way to type a property directly?

Thank you, that helps a lot! Have a good one.

Hi Peter,

Perhaps I am not understanding what you are trying to do. What is wrong with

squared = Function[x, x^2] (* or squared = #^2& *)

squared[5]
(* 25 *)

ClearAll[squared];
pureToNamed[named_, pure_] := named = pure

pureToNamed[squared, Function[x, x^2]]
squared[5]
(* 25 *)

Your example works fine too

SetDelayed[seventhpower,Function[x,x^7]]
seventhpower[2]
(* 128 *)

Sum[x, y]
(* x y *)

Perhaps you meant

Plus[x, y]
(* x + y *)

Consider

f[x_, y_] := If[x > 0, Plus[x, y], Sin[x*y]]

What Attributes should f implicitly have?

I have been working on a program that takes a resource function name as a string for input and then it assigns the name of the resource function to ResourceFunction[name_input]. The hard part is figuring out how many arguments a function receives, particularly if it is overloaded. Is there a simple way to figure out how many arguments a function takes (The multiple numbers of arguments a function takes is the hard part). I was trying to use the function ExpressiontoFunction to help me with my program. I want to help with the process of defining every single Resource Function I download defining it in a package on my computer and automate the process. For example, let's say I have the ResourceFunctions WolfieSay, Alphametic, and FunctionOverview. I would like to be able to type ProgramDefineNewResourceFunctionGlobal["WolfieSay"] and then output a definition where instead of having to type ResourceFunction["WolfieSay"] every time I can simply type WolfieSay[stuff I want to communicate]. It may not be possible but is something I am interested in creating. I would then like to be able to do the same thing with Alphametic and FunctionOverview.

Thank you! This is a great help.

Quiz 1, Problem 8. None of the answers seem to be correct. Am I missing something?

This would work after reformatting the input to "too bee or not". However, my grade is 90, and this frivolity seems to be the only plausible reason for its reduction.

This is about the question 8 of the Test 2: Which attribute of Plot causes it to return an error when the following expression is evaluated? Plot[Integrate[x,x],{x,-10,10}]: (a) HoldRest, (b) HoldFirst, (c) HoldAll, (d) Hold Pattern

To avoid the error, the function Integrate[x,x] can be evaluated to 0.5 x^2 before x is allowed to vary. This can be done, e.g., by switching to Plot[Evaluate[Integrate[x,x]], {x,-10,10}]. However, the question suggests to focus on the (alleged) attribute(s) of the Plot. Attributes[Plot] does not include any of the suggested choices (a)-(d). I would appreciate any possible hints that won't compromise the integrity of the Test.

Try evaluating an expression using Plot, then check the Attributes. Take a look at this post on MSE for details.

Pursuant to my question during today's session about why Remove[Global`square] and Remove[Global`fun1] were said to be necessary, I experimented with leaving it out. I tried the following extracts from the lesson notebook, starting with a fresh kernel:

In[1]:= Begin["mathOperations`"];
        square[x_] := x^2
        End[];
In[4]:= $Context (* current context *)
        square[10] (* returns unevaluated since the current context is not mathOperations` *)
        mathOperations`square[10]
Out[4]:= Global`
Out[5]:= square[10]
Out[6]:= mathOperations`square[10]
In[7]:= PrependTo[$ContextPath, "mathOperations`"];
In[8]:= square[10]
Out[8]:= 100

Although a Global`square did indeed exist, presumably created by the reference to the undefined square by In[5]:

In[9]:= Names["Global`*"]
Out[9]:= {Global`square}

But as observed, the short name square still refers to the function we created, presumably because mathOperations occurs in $ContextPath before `Globals`. Hence the Remove[] call in the original notebook was just an act of excess caution. Does this seem right?

You can add the definition(s) to $UserBaseDirectory/Kernel/init.m.

A reply from Jayanta Phadikar (original author of the Programming Tutorials):

It is correct that if context 1 precedes context 2 in $ContextPath, the system will use the context 1 definition. Here is an experiment:

In[7]:= Begin["context1`"];
func[] := "From Context 1";
End[];

Begin["context2`"];
func[] := "From Context 2";
End[];

In[26]:= $ContextPath = Flatten[Prepend[$ContextPath, {"context1`", "context2`"}]];
func[]

Out[27]= "From Context 1"

In[28]:= $ContextPath = Flatten[Prepend[$ContextPath, {"context2`", "context1`"}]];
func[]

Out[29]= "From Context 2" 

In practice we should however avoid keeping symbols that are common in two different contexts (it is fine of course to keep common symbols in Private contexts). Since without checking the order in $ContextPath we won't know which definition is being used. The red syntax coloring is exactly meant for this warning.

So the Remove expression was meant for ensuring that there is no duplication.

Side note: it is correct that the square symbol in the Global context was created by In[7].

There were several unsatisfactory answers (IMO) given in yesterday's session.

I had asked if resetting \ $`Line` erased the history entries, or if they persisted until a new entry was evaluated with the `In[]` number. The instructor didn't really answer the question at all (perhaps he didn't understand what I was asking) and simply reiterated that setting \$Line caused the In[] numbers to start again from that value. In a similar vein, someone had asked (I think) about measuring the amount of memory tied up in history entries and did not get a relevant answer.

In any case, for those who may be interested, experimentation shows that changing \$Line does not immediately erase any history entries. And I think an estimate of the amount of space used by previous results can be obtained by

Total[ByteCount /@ Out[Range[$Line - 1]]]

(Out[\$Line] itself has to be excluded to avoid recursion.) But I couldn't figure out how to find the space occupied by the In[] entries, given that I don't actually want to reevaluate them.

Which leads me to mention the third poor or missing reply yesterday. Someone suggested that the correct answer to Poll question 2 "How would you evaluate a previous input?" was not in fact "d. All of the above", as answers b. and c. merely retrieve a previous result, rather than reevaluating the expression that produced it. I agree completely. As stated, the answer should be "a. In[-k] for the input k lines back". Of course In[n] for the specific line n also works, as does re-evaluating the cell in question as suggested in answer e.

Michael, we have requested Support to get back to you on this over email.

Deadlines for Quiz and Exercise submissions:

• Quizzes (for Certificate of Program Completion): Aug 27, 2021
• Programming Exercises (for Level 1 Certification for Proficiency in Using the Wolfram Language): Sep 3, 2021

We do want you to use ListLinePlot3D. The output will look way cooler :)

Sorry about the expected output and auto grader solution not matching the exercise text. The exercise will be updated on Monday. Thank you for your patience.

There seem to be two possibilities: either the expected result (the picture) was correct while the proposed function was wrong, or vice versa. In any case, trying to solve under both assumptions was good for learning. The closest I could get under the first scenario (trying to reproduce the original plot using ListLinePLot3D) was by setting "Joined -> False" in ListLinePlot3D , which turned lines into points.

In my humble opinion, the original ( with the dots) picture is clear and instructive, while the second is beautiful, impressionistic and hardly interpretable. In combination with the story, it can make a nice NFT. Any way, thank you for the wonderful brain teaser. The errors like this must be included by design! PS. By the way, while playing with the functions, try using the "plane" version ListLinePlot [list, ColorFunction -> "Rainbow"] (both with "Filling->Bottom", shown below, and without it *), Aren't they nice?! "? :)

Here is the expected output for problem 2 with ListLinePlot3D:

So it seems that pi is not a good random number generator but the fact that you can generate pi using random number techniques (monte carlo method) still boggles my mind.

RNG's (Pseudo- RNG's) are at the core of Monte-Carlo

https://demonstrations.wolfram.com/MonteCarloEstimateForPi/

Pi in terms of Gaussian numbers and the distribution of primes (it has the feel of Monte-Carlo without RGNs) :)

https://tinyurl.com/p54hjtee

A few more words about MC and Pi.

Using the "weighting" or, equivalently, the " regular grid " approaches to determining the relative area of a circle (or the value of Pi) is not inferior to using MC with RNG. In both cases the error ~ N^(-1/2). MC is a nice Demo, but there is nothing really mind-boggling about it. Thanks for raising this questions. I had some suspicions before, but had never took time to think it through.

OH, GOOD! I was wondering. Thanks, Abrita!

Looks like the auto-grader is being very picky about how Entities or EntityClass is represented in the code. With the latest update, we hope that the FullForm representation of an Entity or EntityClass will be accepted for sure.

How can I modify, in place, a dataset like the planets data used in the session on Datasets?

For example, suppose I set planetData = ExampleData[{"Dataset","Planets"}] and a new moon of Jupiter is discovered. How would I add it, such that the value of planetData contains the new moon.

Or, suppose a new mission updates the mass and/or radius of known moons of any planet. I'd like to update those in place, again so that planetData returns all the correct information.

I'm working on a program with a much larger dataset that is structured similarly to the planet data, and I would like an efficient mechanism to perform these kinds of updates.

Peter, you probably do not need NSolve. Instead you can solve it analytically (or using Solve) in two lines. Then you can parametrise the solution (say, using masses, the length of the board, etc as the parameters, some fixed and others - unknown). Then you can suggest users to fix some of the parameters and find the others, in order to establish a neutral equilibrium.

In reality, in static case, if you are not interested in the elastic deformation of the board, you may end up with just one equation.

After the first part is done, you can select a proper interface for your "app". Wolfram presents a lot of choices.

I am also having issues with the autograder. The major one is that from the several possible solutions leading naturally to the same results, it choses just one and blocks all the others. The "guy" is very authoritarian.

Did anybody get the NB files for the Review III session (August 20)?

As a small addition to Michael's answer, I would recommend that you not use numbers in your set of equations, since WL is known to handle symbols.

More precisely, I think that NSolveValues[75kgf*(x-9m)+(x)*25kgf==0,x] does not work the way you want it to. Mathematica will interpret kgf and m as additional variables - and proposes in the suggestion bar to solve the equation for kgf and m .

After solving the equations symbolically, I would use something like

param = {Fadult -> Quantity[75, "kilograms"], 
  Fchild -> Quantity[25, "kilograms"], L -> Quantity[9, "meters"], 
  Fboard -> Quantity[15, "kilograms"]}

to get a numerical result.

As a follower of the SI, I personally would never use the unit "kgf".

Thank you for the information regarding the symbolic capabilities of Mathematica. I am wondering how to create a program like the one Wolfram Alpha has where you can type in the values of the known variables to get the target variable. I have the following code but would like to make it so that I can input the values with labels.

Manipulate[
 SolveValues[
  bigmass*Quantity[1, "StandardAccelerationOfGravity"]*
     distancefrompivotpoint + (length - distancefrompivotpoint)*
     smallmass*Quantity[1, "StandardAccelerationOfGravity"] == 0, 
  thingtosolve], {thingtosolve, {bigmass, smallmass, length, 
   distancefrompivotpoint}}]

Hi Gerrie,

ExampleData is part of the Mathematica install. It can be automatically updated via a paclet update (e.g. if a new moon was discovered) so changing it is not a good idea. Changes can be made to a copy and persisted for later use.

Structural changes to Dataset are sometimes easier to perform on the corresponding Normal expression and then converting back to Dataset. Here is an example of how to add a new moon to the earth using a subset of the data and broken down into steps so it is easier to follow. It can be done more directly but is harder to follow.

(* First 4 planets *)
data = ExampleData[{"Dataset", "Planets"}][[1 ;; 4]] // Normal
earth = data["Earth"]

(* Add a new moon *)
newEarthMoons = earth["Moons"] // 
Append["BlueMoon" -> <|"Mass" -> Quantity[10.^15, "Kilograms"], 
     "Radius" -> Quantity[1.5, "Kilometers"]|>]

(* Replace moons and earth *)
newEarth = <|earth, "Moons" -> newEarthMoons|>
newData = <|data, "Earth" -> newEarth|>
myPlanets = newData // Dataset

(* Save, clear, read *)
DumpSave[FileNameJoin[{NotebookDirectory[], "myPlanets.mx"}], myPlanets];
ClearAll@myPlanets
Get[FileNameJoin[{NotebookDirectory[], "myPlanets.mx"}]]
myPlanets

Sorry about the unsatisfactory answers.

Your conclusion is correct. "\$Line" is just a global variable that specifies the number of the current input line. It can be reset without erasing the input history. However as you start evaluating inputs with the new line number, new lines are numbered so as to overwrite previous ones with the same numbers.

There is however "\$HistoryLength" to specify the number of previous lines of input and output to keep in a Wolfram System session. So by resetting it you can reduce memory usage in a session by limiting the amount of history that is remembered.

At any point MemoryInUse gives the number of bytes currently being used to store all data in the current Wolfram Language kernel session. Here are some functions that provide information about the Wolfram System Session https://reference.wolfram.com/language/guide/WolframSystemSessionInformation.html but we do not have one that specifically gives the memory used just by the previous input lines.

As for the poll question, we could perhaps rephrase it to "Which of the following can be used to re-evaluate a previous input?"

What should I do after the 15_excercise deleted?

Thank you. Let me try :)