Python and Web VPython

First, let’s discuss Python. It boasts a variety of helpful libraries, such as numpy and matplotlib, which can be accessed through Anaconda or Google Colab.

Alternatively, there's Web VPython, an online adaptation of Python featuring several impressive capabilities:

• User-friendly, animated graphs, though 3D visualizations aren't included.
• Support for vectors, which are universally appreciated.
• 3D visual objects, although this guide won't utilize them.
• Accessible online, with limited functionality on mobile devices (not generally recommended).
• Best of all, it’s free.

Web VPython can be accessed via glowscript.org or trinket.io. Both platforms offer similar features, but I personally prefer trinket. If you opt for trinket.io, ensure you select "glowscript" when starting a new project; otherwise, you'll be limited to standard Python without the additional physics functionalities.

Let's dive into the road test. I’ll present a task for you to tackle, followed by the corresponding code. Don't worry; I'll include comments unless the code is self-explanatory.

Remember: programming often has multiple solutions. You’re not obligated to follow an elegant approach that confuses you. It’s perfectly acceptable to take a less efficient path as long as it makes sense to you.

Conditional Loops

Task: Begin with x = 0. Create a loop to print the value of x, incrementing by 0.2 until x reaches 1.

Here’s the code, with comments to clarify:

• Do not modify line 1; it’s essential for trinket.io.
• A loop requires a condition and a colon. Indentation indicates that the lines belong to the loop.
• We could debate whether to use x < 1 or x <= 1. In most cases, it doesn't significantly impact the outcome, especially with small increments.
• I've often overlooked updating the x value, leading to an infinite loop. Avoid this mistake!
• Just to clarify, x = x + dx is not an algebraic equation; it assigns a new value to x by adding dx.

Graphing a Function

Expect a lot of graphing. Let’s kick off with a straightforward task.

Task: Plot the function with parameters A = 0.5 and ? = 4.3 from t = 1 to 6.

• A graph consists of three components. First, you need to establish the axes, which can be done with g1 = graph(). You can customize attributes like title, xtitle, ytitle, width, and height. Note that line wrapping is acceptable as long as it follows a comma.
• The next component is gcurve. You can name it anything, but I usually opt for f1, f2, etc. A useful property to set is color, such as blue.
• Finally, plot a single point within the loop (f1.plot(t,f)). Does it matter if you plot before or after updating time? With a small dt, it’s generally inconsequential. Just follow your intuition.

Task: Plot the following two functions:

From x = 0 to 3. Let's tackle this with a bonus: Python functions. Here’s the code.

Comments: - Yes, it's possible to have two curves on one graph. Just assign them different names. Different colors can also be helpful, though not mandatory if you're feeling adventurous. - These functions are simple, making them perfect for practice. Line 7 introduces the function F1. The line def F1(xt): indicates that we’ll pass a variable, referred to as xt within the function. After some calculations, we return the resultant value, mimicking a mathematical function.

Double Nested Loops

Task: Print all combinations of double digits from 1 to 5 (e.g., 11, 12, …55).

• I’m utilizing two counters, n1 and n2, both ranging up to N=5. Notice that my while loop checks n2 <= N instead of just <. This ensures that N (which equals 5) is included.
• For the second loop, remember to reset n1 at the beginning since it may have reached five in the previous iteration.

Alternatively, this task can be achieved differently:

The line for i in range(1,6): iterates through values starting at 1 and ending before 6 (thus stopping at 5). While this method appears cleaner, the previous one might seem more intuitive to many. Ultimately, do what makes you feel comfortable—it's all about happy coding.

Vectors

What would physics be without vectors?

Task: Create the following two vectors.

Calculate: - A + B - A dot B - A cross B - 3*A - Magnitude of (A cross B)

This task is fairly straightforward.

Numerical Calculations: Euler Method

This represents the core of Python in physics applications.

Task: Plot a solution for the following differential equation.

From t = 0 to 3 with an initial angle of ? = ?/4 and ?-dot = 0 rad/sec. Use L = 0.5 m and g = 9.8 N/kg (as experienced on Earth).

• There's not much to elaborate on without delving deeply into the Euler method.
• The key takeaway is to always calculate the highest derivatives first. This means using the differential equation to determine the value of thetaddot (theta-double-dot) — as shown on line 15.
• Next, update the value of thetadot.
• Finally, update theta.

Note: This approach can generally be applied to any differential equation with initial conditions. Solving boundary condition problems requires different techniques.

Lists and Stuff

In VPython, we don't have numpy arrays, but lists serve a similar purpose.

Task: Create a list A = [1,2,3,4,5].

• Print A.
• Print the second item in the list.
• Print the length of the list.
• Iterate through the list and print all values of A.
• You can create a list by assigning a variable to a set of values enclosed in square brackets [].
• To access elements, use square brackets as well. The first element is A[0], while the last can be accessed with A[-1].
• The for a in A: construct is very useful, as it iterates through each element in the list A, referring to them as a one at a time.

Second part. Task: Create a list of times from 0 to 1 with time intervals of dt = 0.01.

• Start with an empty list: t = [].
• Use tt as a temporary time variable (don’t confuse it with t).
• To append an element, treat it like a regular variable: t = t + [tt].
• While there's an append() method available, I prefer this approach.

Third part. Task: Iterate through the previous list (let’s revisit list A) and add values from a new list B = [-4,2,-3,1,2] to A, skipping the first and last elements.

• You can also iterate using an index (i). In this case, use i from 1 to one less than the length of A, thereby excluding both the first and last elements.
• The same logic applies to C = A + B.

Animated Graphs

Animated graphs may not be essential, but they’re visually appealing. Plus, I often forget how to create them.

Task: Create an animated graph of the following:

Where A = 0.2, k = 0.5, w = 1.1 from x = 0 to 5 and t from 0 to 4 seconds.

• Let's take a moment to appreciate how visually appealing this is. Now, onto the comments.
• Understand that we calculate f values for various x values and repeat this for different times, which is why we employ a double loop.
• Line 15 is crucial. rate(100) restricts the code to a maximum of 100 loops per second, controlling the animation speed. A higher value results in faster display.
• Line 17 is vital. This initializes an empty list to store the values we intend to plot, which can be named anything you prefer.
• Line 20 adds a data point to this list, resulting in a list of lists containing both x and f coordinates.
• After populating the list with x values, you can plot the entire dataset at once using f1.data = f1data.
• Keep in mind that f1data = [] should be inside the loop to clear previous data for the next time interval, effectively enabling the animation.
• When creating the graph, set the maximum and minimum y-values to keep the graph stationary, preventing odd visual effects from auto-scaling during each time frame.

Plotting a List

Task: Use the function f(x) = 2x² - 3x for values of x between 0 and 1, with dx = 0.01. Create two lists: one for x values and another for f, then plot f against x.

Yes, this may seem repetitive, but it’s essential to master plotting from a list.

• I start with empty lists for x and f. The first step is to populate these lists with values, utilizing a temporary variable xt to step forward.
• Plotting is straightforward, using the index i to traverse the list (assuming x and f are of equal length, which they are).

That concludes this guide. While there’s much more to learn, this should provide a solid foundation to get you started.