Quagga: combine code files into an LLM prompt

Thu, 10 Oct 2024 00:00:00 +0000

A command-line utility made for programmers that combines multiple text files into a single prompt suitable for Large Language Models (LLMs).

https://github.com/evgenyneu/quagga

Making a JavaScript simulation of two interacting galaxies

Sat, 01 Aug 2020 00:00:00 +0000

Start

What’s this about?

In this post I want to show how to make a simulation of two interacting galaxies that runs in a Web browser, written in HTML, CSS and JavaScript languages. I won’t explain everything, because I would need to write a post ten times longer than it is (and who wants to read that?). Instead, here I just want to briefly show the main ideas that will hopefully make this simulation appear less magical.

Who made this possible?

The idea and the physics code of this simulation are not mine. This work is based on the laboratory manual written by my teacher Daniel Price from Monash University. All I’ve done was port Daniel’s Fortran code to JavaScript and draw in some buttons. Similar simulation was done in 1972 by Alar and Juri Toomre in their Galactic Bridges and Tails paper, an inspiration for Daniel’s simulation.

I also learned how to simulate moving bodies in space from my Monash astronomy teachers Adelle Goodwin, Melanie Hampel, John Lattanzio and Rosemary Mardling (in alphabetical order).

Lastly, most of the 3D code is not mine either, I copy-pasted it from WebGL Funamentals tutorials.

The main idea

This simulation contains two galaxy cores that move around the common center of mass, located at the origin of the coordinate system (Fig. 1).

Figure 1: The main idea behind the simulation.

The two cores move in the X-Y plane. If we only consider the cores, then this is just a two-body problem that we coded previously. However, this time we want to add stars that move around each core in circular orbits. The stars form discs that are tilted at adjustable angles with respect to the X-Y plane.

A spherical cow

This model includes a big simplification of reality: the stars in the simulation only feel gravity from the two galactic cores, but not from other stars. This simplification makes the model very unrealistic. In a real galaxy, the mass is not located at the center, but instead contained in the stars and dark matter and distributed throughout the galaxy. For example, our Milky Way contains a supermassive black hole Sagittarius A* in its center, but the black hole is “only” about one millionth (0.000001) of the mass of the galaxy.

But unrealistic simplifications are sometimes useful because they can help us understand something fundamental about nature. For example, it would have been much harder for Galileo and Newton to discover that an unperturbed object moves at constant velocity without ignoring friction and gravity, which are always present in our daily life.

Downloading the code

Enough talking, let’s look at the code, which is located at github.com/evgenyneu/two_galaxies. To download the code, open a Terminal app and run

git clone https://github.com/evgenyneu/two_galaxies.git

This requires Git program to be installed, and it will download the code into two_galaxies directory.

Exploring the code

Open two_galaxies directory in any coding text editor of your choice. I use Atom (Fig. 2), other editors I recommend are Sublime Text and Visual Studio Code.

Figure 2: HTML code of the simulation viewed in Atom editor.

The simulation is a web app, and is written in the only three languages any Web browser can understand: HTML, CSS and JavaScript.

HTML code

The HTML code is located in index.html file (Fig. 2). It contains the layout of the web page and its elements, such as the black canvas for drawing stars, buttons and sliders. It also contains code written in GLSL ES language, which stands for OpenGL Shading Language. This code is for showing 3D graphics using the graphics processing unit (GPU). GPU is a computer hardware that is optimised to draw coloured triangles, points and lines on your screen very fast, which makes it possible to animate thousands of stars in real time in this simulation.

CSS code

The CSS code of the simulation is located in css/two_galaxies.css file (Fig. 3). This code is for setting the styles of HTML elements, things like positions, sizes and colors. For example, Fig. 3 shows .TwoGalaxies-button style which is used for all square buttons in the simulation. It sets the size of the buttons to be 45 by 45 pixels.

Figure 3: CSS code of the simulation.

JavaScript code

Most of the simulation code is in JavaScript files, located in js directory (Fig. 4). Unlike HTML and CSS, which are languages specific to web development, JavaScript is a general purpose programming language used to encode the logic of a program. For example, Fig. 4 shows a function numberOfStarsInOneRing that calculates the number of stars in a ring of a galaxy. The entry point of the program is located in the main.js file.

Figure 4: JavaScript code of the simulation.

Run the simulation locally

Next, I want to show how to run the simulation on your computer so you can tinker with the code and see the effects. In order to do this, you need to install a web server, which is a program that runs web sites. There are many web servers available, but the simpler ones come with Python and Node.js.

Option 1: running a web server with Python

First, install Python. Next, in the Terminal, change to the two_galaxies directory where you downloaded the code earlier:

cd two_galaxies

and start the web server:

python -m http.server

You can now open http://0.0.0.0:8000/ URL in your web browser and see the simulation (Fig. 5).

Figure 5: Running the simulation locally using Python web server.

The purpose of using a local web server is that you can make changes to the code, refresh the web browser and see the effects.

Option 2: running a web server with Node.js

Alternatively, instead of Python you can use a web server that comes with Node.js. First, install Node.js. Next, from the Terminal, install the web server:

npm install http-server -g

Finally, from two_galaxies directory, start the web server and navigate to http://127.0.0.1:8080 URL in your web browser to see the simulation:

npx http-server

How the simulation works?

Conceptually, this simulation is very simple. All it is doing is showing moving circles on the screen. The trick is to calculate their positions and then change positions with time. This is done using three steps:

First, for each star we calculate three numbers — its x, y, and z coordinates in 3D space — and then use them to draw a coloured circle on screen. These are initial positions of the stars, and that’s where we see them after the web page is first loaded.
Next, after a short time interval, we want to calculate new positions using Newton’s second law (we will return to this physics later):
\[\vec{F} = m \vec{a}. \tag{1}\]
Finally, we repeat this 60 times a second (or at a different rate, depending on refresh rate of your monitor), and this gives an impression of a moving collection of stars.

Simple.

Counting the stars

Our first job is to calculate the initial positions of stars. But before that, we need to know the number of stars in each ring of a galaxy (Fig. 6).

Figure 6: A single galaxy is made of stars placed in circular rings.

This is done with the following function, located in js/physics/initial_conditions.js file:

export function numberOfStarsInOneRing(ringNumber, multiplier) {
  return ringNumber * multiplier;
}

This function returns the number of stars in a given ring of a galaxy. The ring number is passed using input parameter ringNumber, and the increase in the number of stars in each next ring is specified with multiplier parameter. For example, the function will return 6 stars for the first ring when we call numberOfStarsInOneRing(1, 6), 12 for the second ring numberOfStarsInOneRing(2, 6), an so on, adding 6 more stars to the next ring.

Now that you have a local web server running, you can experiment with the code and see the effects. For example, change the return statement from

return ringNumber * multiplier;

return 7;

Then refresh the web browser, and you will see funny galaxies shown on Fig. 7.

Figure 7: Galaxies with seven stars in each ring.

Next, we need to calculate the total number of stars in one galaxy. This is done by numberOfStarsInAllRingsOneGalaxy function:

export function numberOfStarsInAllRingsOneGalaxy(numberOfRings,
                                                 multiplier) {
  var stars = 0;

  // Loop over each ring, starting from the one closer to the center
  for(let ringNumber = 1; ringNumber <= numberOfRings; ringNumber++) {
    // Calculate the number of stars in one ring and add it to total
    stars += numberOfStarsInOneRing(ringNumber, multiplier);
  }

  return stars;
}

Here, inside the loop, we call function numberOfStarsInOneRing for rings 1, 2, and up to the total number of rings, adding the number of stars in each ring to the galaxy’s total.

Positioning stars in a galaxy

Now that we know the number of stars in one galaxy we can calculate their intial positions and velocities. This is done in galaxyStarsPositionsAndVelocities function located in js/physics/initial_conditions.js file:

export function galaxyStarsPositionsAndVelocities(args) {
  let stars = numberOfStarsInAllRingsOneGalaxy(args.numberOfRings);
  var positions = Array(stars * 3).fill(0);
  var velocities = Array(stars * 3).fill(0);
  ...

It starts with calculating the total number of stars in one galaxy, by calling numberOfStarsInAllRingsOneGalaxy function and saving the result in stars variable. Then it creates two arrays to store positions and velocities of the stars. Since we are dealing with 3D, each coordinate requires three numbers x, y and z. That’s why the size of the arrays is three times larger than the number of stars: Array(stars * 3).

We will need to keep this in mind when accessing positions and velocities form these arrays. For example, positions[0] will be the x-coordinate of the first star and positions[1] will be its y-coordinate. The x-coordinate of the second star is positions[4], and z-coordinate of the seventh star is positions[3*6 + 2], or positions[20], and so on.

Next, we want to set the angle of galaxy inclination (Fig. 8) with respect to the X-Y plane, which is passed to this function as parameter args.galaxyAngleDegree. This angle is chosen by the user in degrees, but we want to convert it to radians, using the fact that 180 degrees is π (3.1415) radians:

var galaxyAngleRadians = args.galaxyAngleDegree * Math.PI / 180;

Figure 8: A galaxy inclination angle of 60 degrees. The angle is measured from the X-Y place, where the galaxy cores are moving.

Next, we look at each galaxy ring separately, starting with the first ring using the for loop:

// Loop over the rings of the galaxy
for(let ringNumber = 1; ringNumber <= args.numberOfRings; ringNumber++) {
  // Find distance of stars in current ring from the galaxy center
  let distanceFromCenter = ringNumber * args.ringSeparation;

  // Find number of stars in the ring
  let numberOfStars = numberOfStarsInOneRing(ringNumber,
                                             args.ringMultiplier);

Inside the loop, we calculate the distance of the star (and the ring) from galactic center (Fig. 9), which is equal to the ring number times the separation between rings args.ringSeparation.

Figure 9: Calculating distance from a star in the third ring to the galactic center and the angle between two neighbours.

We will later need an angle between two neighbouring stars in the same ring, in radians (Fig. 9). To calculate it, we first use numberOfStarsInOneRing function to get the total number of stars in the current ring. Next, we use the fact that the angle of the full ring is 360 degrees, or 2π radians. This means that the angle between two adjacent stars is 2π / numberOfStars:

// Find number of stars in the ring
let numberOfStars = numberOfStarsInOneRing(ringNumber,
                                           args.ringMultiplier);

// Calculate the angle between two neighbouring stars in a ring
// when viewed from the galaxy center
let angleBetweenNeighbours = 2 * Math.PI / numberOfStars;

Calculating initial speeds of the stars

Our goal is to calculate the initial velocity of each star in the galaxy, but first we need to find the speeds of stars. Velocity is a vector, pointing in the direction of movement. The length of a velocity vector is equal to the speed. When the simulation starts, we want our rings to be circular. This means that all stars in the same ring must have equal speeds, otherwise the symmetry of the circle would be broken. Let’s calculate this speed.

Consider a single star. Since we chose to neglect gravity from other stars, the galactic core is the only object that attracts our star (Fig. 10). The core exerts force \(F\) on the star of mass \(m\). This causes the star to accelerate with acceleration \(a\), resulting in a circular orbit instead of a straight line.

Figure 10: Galactic core exerting gravitational force on an orbiting star.

In math language, this can be expressed with Newton’s second law:

\[F = m a \tag{2}.\]

The acceleration \(a\), also called centripetal acceleration, for a body moving in a circle of radius \(r\) with speed \(v\) is given by

\[a = \frac{v^2}{r}. \tag{3}\]

Substituting \(a\) into Eq. 2 gives:

\[F = m \frac{v^2}{r}. \tag{4}\]

Next, we use another of Newton’s discovery - the law of universal gravitation:

\[F = \frac{G m M}{r^2}, \tag{5}\]

which allows us to calculate gravitational force \(F\) between two masses \(m\) and \(M\) that are distance \(r\) apart. Here \(G\) is a number called gravitational constant:

\[G = 6.67 \times 10^{-11} \frac{\text{m}^3}{\text{kg} \ \text{s}^2}. \tag{6}\]

Next, we equate equations 4 and 5:

\[m\frac{v^2}{r} = \frac{G m M}{r^2}. \tag{7}\]

Mass of the star \(m\) and distance \(r\) cancels:

\[v^2 = \frac{GM}{r}. \tag{8}\]

Finally, we take the square root of both sides and get the expression for the speed of the star we wanted:

\[v = \sqrt{\frac{GM}{r}}. \tag{9}\]

Now we return to our galaxyStarsPositionsAndVelocities function, and find this equation in the code:

let starSpeed = Math.sqrt(args.coreMass / distanceFromCenter);

You might have noticed a small difference. Our JavaScript code does not have constant \(G\). Why? Because we made constant \(G\) equal to one.

[reader stares in disbelief]

Let me explain…

Changing units of length, mass and time

You can see that constant \(G\) (Eq. 6) has units of \(\frac{\text{m}^3}{\text{kg} \ \text{s}^2}\). Here \(\text{m}\) (meter) is a unit of length, \(\text{kg}\) (kilogram) is a unit of mass, and \(\text{s}\) (second) is a unit of time. We will now do a trick that I saw astronomers do many times, and which confused me a lot until my teacher John Lattanzio explained it to me.

We want to change the units of length, mass and time in order to make constant \(G\) equal to one in these units.

The point of this is to avoid putting constant \(G\) anywhere in the code. Another reason for this, is to make our mass, length and time numbers small, since stellar masses and distances are very large numbers when expressed in meters and kilograms.

Here is one way of changing the units. We first define the new units

\[\begin{aligned} \text{Unit of length:} \ U_L &= a \ \text{m} \\ \text{Unit of mass:} \ U_M &= b \ \text{kg} \tag{10} \\ \text{Unit of time:} \ U_T &= c \ \text{s}, \end{aligned}\]

where \(a\), \(b\) and \(c\) are numbers we want to find. Our goal is to make gravitational constant \(G\) equal to one in these units. This is done by taking Eq. 6, replacing the number \(6.67 \times 10^{-11}\) with \(1\) and also replacing \(\text{m}\), \(\text{kg}\) and \(\text{s}\) with new units: \(U_L\), \(U_M\) and \(U_T\):

\[G = 1 \frac{U_L^3}{U_M U_T^2} \tag{11}.\]

Next, we substitute new units from Eq. 10:

\[G = 1 \frac{(a \ \text{m})^3}{(b \ \text{kg}) (c \ \text{s})^2} = \frac{a^3}{bc^2} \frac{\text{m}^3}{\text{kg} \ \text{s}^2}. \tag{12}\]

Equating this with Eq. 6 gives

\[\frac{a^3}{bc^2} \cancel{ \frac{\text{m}^3}{\text{kg} \ \text{s}^2} } = 6.67 \times 10^{-11} \cancel{ \frac{\text{m}^3}{\text{kg} \ \text{s}^2} }. \tag{13}\]

The units cancel and we get

\[\frac{a^3}{bc^2} = 6.67 \times 10^{-11}. \tag{14}\]

This equation can not be solved, because it has three unknown variables \(a\), \(b\) and \(c\). Since one of our goals was to make new units small (Eq. 10), we can pick some arbitrary large numbers for \(a\) (length) and \(b\) (mass) and then calculate \(c\) (time) using Eq. 14.

Let’s start with with the length \(U_L\). Stellar distances are often measured with a unit of length called parsec (pc), which is a typical distance between stars:

\[1 \ \text{pc} = 3.086 \times 10^{16} \ \text{m}.\]

Galactic distances are even larger, and are often measured in thousands of parsecs, or kiloparsecs (kpc). For example, Earth is eight kiloparsec away from the center of Milky Way. Since we are simulating galaxies, it will make sense to use kiloparsec as our unit of length:

\[U_L = 1000 \ \text{pc}.\]

We can now convert kiloparsecs to meters, use Eq. 10 and calculate \(a\):

\[\begin{aligned} a \ \text{m} &= (1000 \ \text{pc}) \ \frac{3.086 \times 10^{16} \ \text{m}}{1 \ \text{pc}} \\ a &= 3.086 \times 10^{19}. \end{aligned}\]

This gives the new unit of length we were looking for:

\[U_L = 3.086 \times 10^{19} \ m.\]

Next, we want to choose a suitable value of \(b\) for the unit of mass. We are working with galaxies, so it would be natural to use mass of Milky Way as our mass unit. There are about 300 billion (\(3 \times 10^{11}\)) stars in Milky Way, but we will round it to a 100 billion (\(10^{11}\)). We will assume that the average stellar mass is equal to the mass of the Sun, which is about

\[M_\odot = 2 \times 10^{30} \ \text{kg}.\]

Multiplying the Solar mass by the number of stars (\(10^{11}\)) gives the unit of mass we wanted:

\[U_M = (2 \times 10^{30} \ \text{kg})(10^{11}) = 2 \times 10^{41} \ \text{kg}.\]

Therefore, the number \(b\) is

\[b = 2 \times 10^{41}.\]

At last, we can calculate the unit of time by using Eq. 14, substituting numbers \(a\) and \(b\), and finding \(c\):

\[\begin{aligned} c &= \sqrt{\frac{a^3}{(6.67 \times 10^{-11})(b)}} \\ &= \sqrt{\frac{(3.086 \times 10^{19})^3}{(6.67 \times 10^{-11})(2 \times 10^{41})}} \\ &\approx 4.7 \times 10^{13}. \end{aligned}\]

We have found that in order to make constant \(G\) equal to one in new units (Eq. 11), we need to choose the unit of time to be

\[U_T = 4.7 \times 10^{13} \ \text{s}.\]

This is a very large number, let’s convert it to years, using the fact that there are 3600 seconds in one hour, 24 hours in one day, and 365 days in a typical year:

\[\begin{aligned} U_T &= \left( \frac{4.7 \times 10^{13} \ \cancel{\text{s}}}{1} \right) \left( \frac{1 \ \cancel{\text{h}}}{3600 \ \cancel{\text{s}}} \right) \left( \frac{1 \ \cancel{\text{d}}}{24 \ \cancel{\text{h}}} \right) \left( \frac{1 \ \text{y}}{365 \ \cancel{\text{d}}} \right) \\ &\approx 1.5 \times 10^6 \ \text{y}. \end{aligned}\]

We have calculated the new unit of time to be 1.5 million years. Let’s see if this number makes sense. Our animation advances by about one unit of time after each animation frame. If refresh rate of the computer screen is 60 frames per second (a typical screen in 2020), then in one second of our time the simulation will advance by 90 million years. This is comparable to the 250 million years, which is the time it takes the Sun to rotate around the center of Milky Way. This means that unit of time \(U_T = 1.5 \times 10^6 \ \text{y}\) is reasonable.

Let’s remind us what we’ve done. Our goal was to get rid of constant \(G\) in code by making it equal to one. We have accomplished this by choosing the following units of length, mass and time, which are also more suitable to galactic scales:

\[\begin{aligned} \text{Unit of length:} \ U_L &= 3.1 \times 10^{19} \ \text{m} \\ \text{Unit of mass:} \ U_M &= 2.0 \times 10^{41} \ \text{kg} \\ \text{Unit of time:} \ U_T &= 4.7 \times 10^{13} \ \text{s}. \tag{15} \end{aligned}\]

Calculating initial positions of stars in one galaxy

Let’s return to our galaxyStarsPositionsAndVelocities function. Remember, we are inside a loop and want to calculate initial positions of stars for a single ring. We have already calculated the total number of stars numberOfStars in that ring. Now we want to go over all stars in the ring and calculate their positions. We start with another a loop:

// Loop over all the stars in the current ring
for(let starNumber = 0; starNumber < numberOfStars; starNumber++) {
  // Find the angle of the current star relative to the first
  // star in the ring
  let starAngle = starNumber * angleBetweenNeighbours;

Inside the loop we go from the the rightmost star counterclockwise, and we want to calculate the angle to the current star with index starNumber. This angle starAngle is just the star index multiplied by the angle between neighbours, as shown on Fig. 11.

Figure 11: Calculating star angle for the blue star. The star is in the third ring, which has 18 stars. The angle between two neighbours is thus \(360 \degree / 18 = 20 \degree\). Since our blue star is the fourth star along the ring, the starNumber index is 3 and star angle is \(3 \times 20 \degree = 60 \degree\).

Calculating star’s position

It has been a long preparation but now we are ready to calculate the initial position of the star:

// x coordinate
positions[iStar * 3] = distanceFromCenter * Math.cos(starAngle) *
                           Math.cos(galaxyAngleRadians);

// y coordinate
positions[iStar * 3 + 1] = distanceFromCenter * Math.sin(starAngle);

// z coordinate
positions[iStar * 3 + 2] = -distanceFromCenter * Math.cos(starAngle) *
                           Math.sin(galaxyAngleRadians);

In code above we assign x, y and z coordinates to the elements of positions array for the star with index iStar. This index is 0 for the first star, 1 for the second star, 10 for the eleventh star and so on. I admit, the math looks a bit intimidating, but we can understand it with trigonometry and two pictures.

To calculate the star’s position we need three numbers, which we found earlier:

distanceFromCenter: Distance of the star from the center of the galaxy (Fig. 9),
starAngle: Star angle (Fig. 11),
galaxyAngleRadians: Galaxy inclination angle (Fig. 8).

For simplicity, let’s first ignore galaxyAngleRadians, which means the galaxy is not tilted and all the stars lie in the X-Y plane, as shown on Fig 12.

Figure 12: Calculating a star's position when the galaxy is not tilted and all stars are in the X-Y plane.

Then, we multiply the hypotenusedistanceFromCenter by the cosine of the angle to get the x coordinate, and by the sine for the y coordinate. The z coordinate is zero, since the galaxy is not tilted:

// x coordinate
positions[iStar * 3] = distanceFromCenter * Math.cos(starAngle);

// y coordinate
positions[iStar * 3 + 1] = distanceFromCenter * Math.sin(starAngle);

// z coordinate
positions[iStar * 3 + 2] = 0;

Next, we tilt the galaxy around the Y-axis by galaxyAngleRadians angle, as shown on Fig. 13.

Figure 13: Calculating a star's position of the tilted galaxy.

The key idea here is to think of the galaxy tilt as rotation of the previous x-axis from Fig. 12 around the y-axis. The previous x value distanceFromCenter * cos(starAngle) now becomes the hypotenuse. We then multiply this hypotenuse by cos(galaxyAngleRadians) to get the new x coordinate, and by sin(galaxyAngleRadians) to find the z coordinate. The y-coordinate does not change because the galaxy is tilted around the y-axis:

// x coordinate
positions[iStar * 3] = distanceFromCenter * Math.cos(starAngle) *
                           Math.cos(galaxyAngleRadians);

// y coordinate
positions[iStar * 3 + 1] = distanceFromCenter * Math.sin(starAngle);

// z coordinate
positions[iStar * 3 + 2] = -distanceFromCenter * Math.cos(starAngle) *
                           Math.sin(galaxyAngleRadians);

Notice that we use the negative sign for the z coordinate because we chose to tilt the galaxy clockwise.

To be continued…

I will keep extending this article and cover more code from the simulation.

Thanks 👍

Daniel Price: my Monash astronomy teacher, who wrote the Fortran code and the laboratory manual this simulation is based on.
Adelle Goodwin, Melanie Hampel, John Lattanzio and Rosemary Mardling: my Monash teachers, who taught me astronomy and how to simulate movement of masses in space.
webglfundamentals.org: that’s where I learned how to do 3D drawing in the web browser for this simulation. Relevant sections are “Fundamentals”, “2D translation, rotation, scale, matrix math” and “3D”. My 3D code is based on examples from these chapters.
Galactic Bridges and Tails: a 1972 paper by Alar and Juri Toomre that analyses similar simulations. I mean, just look at the size and quality of the paper, the attention to detail. Imagine amount of work that went to create all those diagrams by hand. I have not seen anything like that.
1941 paper by Erik Holmberg: an even earlier simulation that used physical light bulbs and light sensors instead of computers. I’m super lucky to be able just to press buttons on my laptop.

The logistic function

Thu, 12 Mar 2020 00:00:00 +0000

In this article I want to discuss the logistic function that can be used to describe the spread of an infectious disease.

How infection spreads?

Infectious disease is the one that can spread from human to human. Each sick person can infect healthy people around her. And each of those newly infected people will, in turn, give the virus to even more people. In math language this means that the rate of increase of N (the number of infected people) with time t is proportional to the number of infected people:

(1)

where r is a number that determines how fast infection spreads (i.e. how infectious is the disease). This is a first order linear differential equation, and it has the general solution of the form:

(2)

where A is initial number of infected people at time zero, and e is another number equal to about 2.718.

This is a very simple infection model but it can be accurate at the beginning of an epidemic. If we start with just one infected person (A=1) and use rate r=1, then after just five days the number of infected people will be nearly 150 (Fig. 1).

Figure 1: Exponential growth of infection that starts with one infected person.

The virus spreads fast… like a virus. Remarkably, it will take only 23 days until entire population of Earth (nearly 8 billion people) is infected.

What happens when we run out of healthy people? Logistic function happens.

The model shown on Fig. 1 can be very accurate at the start, when most people are healthy. But at some point there will be more ill people around, so there will be more interaction between people who are already infected. As a result, the rate of infection of healthy people will slow down. This can be written in math language as

(3)

where K is the total number of people.

At the start of an epidemic, the number of infected people N is small, and therefore Equation 3 gives almost the same result as Equation 1. In other words, at the beginning, Equation 3 describes exponential spread of disease. However, as the number of infected people N gets closer to the total number of people K, the term N/K starts to approach 1, and (1 - N/K) terms approaches zero. Consequently, the rate of change dN/dT also approaches zero. This means that the spread of the disease slows down when many people are ill.

Equation 3 sounds reasonable and it is called logistic growth model. This equation can be solved symbolically to get the general solution:

(4)

where r is the growth rate number, K is total number of people in the population, and Q is a number that relates to the initial number of sick people A as follows:

(5)

Equation 4 is a famous equation and it is called the Logistic Function. Sal Khan has made excellent videos where he shows how to derive it from the logistic growth model (Equation 3).

What does the logistic function look like?

A plot of a logistic function looks like this:

Figure 2: Logistic growth of infection that starts with one infected person (solid blue line). Orange dashed line shows exponential growth, for comparison.

In this plot we used values K=8 billion, r=1 and Q=8 billion - 1. You can try different values on Desmos. We can see that initially, logistic and exponential functions are the same. But after about 20 days the number of infected people starts to grow more slowly for the logistic function, until N levels off at 8 billion people.

Sick! Literally.

Modelling real data

We can use logistic function to model the spread of COVID-19 infection using real data. These data are the number of confirmed cases in different countries at successive days.

Figure 3: Modeling confirmed cases of COVID-19 worldwide, excluding China.

The orange circles are confirmed cases, and the solid blue line is the model. The bright shaded region around the model line indicates model’s uncertainty.

For this model, we used an arbitrary population size of K=7.8 million. And the initial number of infected people was A=8. The model predicted the growth factor to be around r=0.18. The code for the model is here, and if you want to understand how it works, there is a Statistical Rethinking textbook by Richard McElreath, which is pure gold, in my opinion. :)

Tarpan: plots and summaries for cmdstanpy library

Tue, 11 Feb 2020 00:00:00 +0000

Tarpan is a collection of Python functions for making plots and summaries from the output of cmdstanpy library, which is a statistical inference tool:

https://github.com/evgenyneu/tarpan

Four stages of the early Universe

Sat, 25 May 2019 00:00:00 +0000

The following image shows four stages of evolution of the early Universe, from 1 second to 350 thousand years since the Big Bang. During that period the Universe cooled as it expanded in size. This article is based on excellent textbook An Introduction to Modern Cosmology by Andrew Liddle.

Figure 1: Four stages of the Early Universe.

Universe at one second after the Big Bang

At one second after the Big band the Universe was a hot soup of freely moving particles - protons, neutrons and electrons. In these high energy conditions the protons and neutrons were transforming into each other. The two particles have slightly different masses, and this mass difference determined the neutron-to-proton ratio: for each neutron there were five protons.

Universe at 340 seconds

At 340 seconds, the Universe cools down enough for complex nuclei like Helium to exist. The Helium-4 is made of two protons and two neutrons, and at these temperatures most particles are no longer moving fast enough to break Helium down into free particles. The formation of Helium consumes all existing neutrons, resulting in the Universe consisting mostly of single protons (also called Hydrogen nuclei), Helium-4 nuclei and free electrons. During the period between 1 and 340 seconds some neutrons decay into protons, which decreases the neutron-to-proton ratio from 1/5 to 1/7. This ratio remains fixed to the present day and can be observed.

Helium abundance is 25%

Another very important quantity that is fixed at 340 seconds is the abundance of Helium-4 nuclei in the Universe. This abundance is observed in the old globular clusters to be about 25%, which means that 25% of the the total mass of all the particles in the Universe are in the form of Helium-4. Here is how this abundance can be found theoretically.

Firstly, we use the fact that a Helium-4 nucleus contains two neutrons and two protons. Secondly, we assume that after 340 seconds there is one neutron per seven protons in the Universe. Therefore, for each Helium nucleus there are also 12 free protons (Figure 2).

Figure 2: Calculating the number of helium nuclei and free protons in the Universe, which is 340 seconds old, given the neutron-to-proton ratio of 1/7.

The abundance of Helium-4 is the mass of Helium-4 nuclei divided by the mass of all particles (including Helium-4). If we assume that protons and neutrons have the same mass, this ratio turns out to be precisely 1/4 (Figure 3).

Figure 3: Calculating the primordial helium abundance.

This means that after 360 seconds, the Universe consisted of 25% Helium-4 and 75% Hydrogen (neglecting very small amounts of other elements). This is the starting chemical composition of the Universe before formation of stars and other large objects, and this composition is measured to be mostly unchanged to the present day.

Universe at 60,000 years

The Universe becomes less dense as it expands. The density of both particles and light decreases. However, it turns out that density of light decreases faster than the density of particles as the Universe becomes larger. As a result, the density of matter becomes equal to the density of light at some time during expansion. Cosmological models predict that this happens when the Universe is about 60,000 years old. Since then, there is more matter per cubic meter than light.

Universe at 350,000 years and the cosmic microwave background

Another very important transition happens when the Universe is about 350,000 years old. Before that time, Helium and Hydrogen nuclei did not have electrons because it was too hot for the electrons to remain attached to the nuclei. An electron that became bound to an nucleus was immediately knocked off by an energetic photon. As Universe expanded, the photons became less energetic, and at 350,000 years most photons could no longer prevent electrons form binding to Helium and Hydrogen. As a result, the nuclei captured electrons, and light was able to move freely through space without bumping into free electrons. In other words, the Universe became transparent.

Some photons that were emitted when the Universe was 350,000 years old are still traveling through space today and are being detected by astronomers. This old light is called cosmic microwave background.

References

An Introduction to Modern Cosmology 3rd Edition by Andrew Liddle Publisher, Amazon.
Source for the Figure 1 in Sketch format.
Source for the Figure 2 in Sketch format.
Source for the Figure 3 in Sketch format.

Programming a three-body problem in JavaScript

Sat, 29 Sep 2018 00:00:00 +0000

Please use a newer browser to see the simulation.

0.10

In this tutorial we will program motion of three bodies in HTML and JavaScript. This work is built upon the two-body simulation code. I want to say huge thanks to Dr Rosemary Mardling, who taught me astrophysics in Monash University. This work is based on Rosmary’s ideas and code. As always, feel free to check the full source code, and use it for any purpose.

Three-body simulations

The little buttons under the slider run the following simulations.

Figure eight

This is a stable three-body system discovered by Cris Moore [5]. The system remains stable even if we change the masses of all bodies a little bit, to 0.99 for example. Just for fun, try increasing the speed of this animation by clicking the clock icon and moving the slider. At certain speeds you will see weird stroboscopic effects. Be careful, this can make you dizzy.

Sun, Earth and Jupiter

This simulation uses true masses, velocities and distances of the Sun, Earth and Jupiter. We can measure one period of the Earth’s orbit in the simulation to be around one second (may depend on computer speed and refresh rate of the monitor). This means that the simulation is working correctly, because it is run at one year per second.

Lagrange point L5

Here the Earth is located near a special point in space called the Sun-Jupiter L5 Lagrange point. Notice that the radius of the Earth’s orbit is smaller than that of Jupiter initially. Planets that are closer to the Sun have shorter orbital periods. Therefore, normally, the Earth would overtake Jupiter. We can check this by decreasing Jupiter’s mass and clicking the Reload button on the bottom right of the simulation screen. However, the combined gravity from Jupiter and the Sun traps the Earth, and it is destined to remain at L5 point behind Jupiter.

Kepler-16

This is a simulation of a binary star system that also has a planet with a mass of 1/3 of Jupiter’s. Both binary stars are smaller than the Sun. The orbital plane of the planet is located edge-on to us. Consequently, when the planet moves in front of the stars, it blocks some of their light. This is precisely how this planet was discovered [6]. The simulation tells us that the system appears to be stable, at least in the short term.

Chaotic

This is an example of how an orderly system can quickly become erratic. When the simulation is running on the computer, small calculation and rounding errors accumulate over time and make the system unpredictable. The simulation is so sensitive to small changes that it may even look different when you run it with the same settings but in different browsers.

The coordinate system

Let’s begin implementing our simulation. We will be using a coordinate system with its origin located at the center of mass of the three bodies, as shown in Fig. 1. We use this origin because, as it turns out, the center of mass of any number of bodies remains motionless or moves with constant velocity.

Figure 1: A coordinate system with the origin at the common center of mass of the three bodies.

The equations of motion

The main equation for this simulation is the Newton’s equation of universal gravitation:

(1)

Combining this equation with Newton’s second law F = m a, we can derive three equations of motion:

(2)

Here the double dots above the variables mean second time derivatives. The vector

(3)

points from the Sun to the Earth. Equation 2 also includes the magnitudes of the vectors, which can be calculated as follows, for the case of the vector r12:

(4)

Here x1, y1 and x2, y2 are the coordinates of the Earth and the Sun respectively.

Writing equations of motions in `x` and `y`

Equation 2 contains three equations of motion. In order to use the equations in our program we need to write each equation in terms of x and y coordinates. This gives six equations

(5)

Note the we got rid of the masses on the left-hand sides by dividing both sides by them. The equations look intimidating. However, these are not meant to be used by humans. It is much easier to write these equations in code, since they contain a lot of repetitions. But before we do this, we need to convert the equation into a computer readable form.

Converting the equations to first order

Equation 5 is a system of six second order differential equations. In order to be solved numerically, we need to convert the equations into twelve first order ones. This reduction of order is done by first introducing twelve new variables u:

(6)

Now we can use the new variables and turn Equation 5 into the following system of first-order differential equations that describe the motion of the three bodies:

(7)

Again, this looks horrific, but in the program this turns into a nice loop that takes care of repetitions.

Programming the equations of motion

We are finally done with algebra and will turn our equations into code. The first thing we need to do is to declare an array that will store that values of those twelve u variables:

// Current state of the system
var state = {
  // State variables used in the differential equations
  // First two elements are x and y positions,
  // and second two are x and y components of velocity
  // repeated for three bodies.
  u: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
}

Next, as promised, we turn the long Equation 7 into a much shorter code:

// Calculate the derivatives of the system of ODEs that describe equation of motion of the bodies
function derivative() {
  var du = new Array(initialConditions.bodies * 4);

  // Loop through the bodies
  for (var iBody = 0; iBody < initialConditions.bodies; iBody++) {
    // Starting index for current body in the u array
    var bodyStart = iBody * 4;

    du[bodyStart + 0] = state.u[bodyStart + 0 + 2]; // Velocity x
    du[bodyStart + 1] = state.u[bodyStart + 0 + 3]; // Velocity y
    du[bodyStart + 2] = acceleration(iBody, 0); // Acceleration x
    du[bodyStart + 3] = acceleration(iBody, 1); // Acceleration y
  }

  return du;
}

The function derivative calculates the derivatives of the twelve u variables using Equation 7. For simplicity, the right-hand sides of equation that calculate accelerations, are coded as a separate function:

// Calculates the acceleration of the body 'iFromBody'
// due to gravity from other bodies,
// using Newton's law of gravitation.
//   iFromBody: the index of body. 0 is first body, 1 is second body.
//   coordinate: 0 for x coordinate, 1 for y coordinate
function acceleration(iFromBody, coordinate) {
  var result = 0;
  // Starting index for the body in the u array
  var iFromBodyStart = iFromBody * 4;

  // Loop through the bodies
  for (var iToBody = 0; iToBody < initialConditions.bodies; iToBody++) {
    if (iFromBody === iToBody) { continue; }
    // Starting index for the body in the u array
    var iToBodyStart = iToBody * 4;

    // Distance between the two bodies
    var distanceX = state.u[iToBodyStart + 0] -
      state.u[iFromBodyStart + 0];

    var distanceY = state.u[iToBodyStart + 1] -
      state.u[iFromBodyStart + 1];

    var distance = Math.sqrt(Math.pow(distanceX, 2) +
      Math.pow(distanceY, 2));

    result += constants.gravitationalConstant *
      initialConditions.masses[iToBody] *
      (state.u[iToBodyStart + coordinate] -
        state.u[iFromBodyStart + coordinate]) /
      (Math.pow(distance, 3));
  }

  return result;
}

There are a lot of arrays and indices in this function, and I’ve made a lot of mistakes when I first coded this. But eventually, all bugs were found, removed and carefully released into the wild.

Solving the equations of motion numerically

Next, we need to solve the Equation 7 numerically. In order to do this, we use a popular numerical method called Runge-Kutta. At each frame of our animation, we call the rungeKutta.calculate function and it updates our variables u with new positions and velocities of the three bodies.

// The main function that is called on every animation frame.
// It calculates and updates the current positions of the bodies
function updatePosition(timestep) {
  rungeKutta.calculate(timestep, state.u, derivative);
}

Before the first run, however, we need to choose some initial positions and velocities of the Sun, Earth and Jupiter and store them in the u array.

Drawing the bodies on screen

At each frame of the animation, we calculate new positions of the three bodies in the u array. These position are turned into coordinates of the bodies on computer screen. Here we use the same drawing techniques that we discussed in the harmonic oscillator tutorial.

📚📖✨

If you are into science fiction, The Three-Body Problem novel by Liu Cixin and the other two books of the trilogy could be worth your time.

Credits

This work is based on code and lectures by Dr Rosemary Mardling from Monash University.
“The Blue Marble” image: NASA/Apollo 17 crew; taken by either Harrison Schmitt or Ron Evans, source, source.
“The Sun photographed at 304 angstroms” image: NASA/SDO (AIA), source, source.
“Jupiter’s South Pole” image: NASA/JPL-Caltech/SwRI/MSSS/Betsy Asher Hall/Gervasio Robles, source.
Figure eight orbit: Moore, C. 1993, Phys. Rev. Lett., 70, 3675.
Kepler-16 system: Doyle, L. R., Carter, J. A., Fabrycky, D. C., et al. 2011, Science, 333, 1602.

References

The complete source code of the three-body problem simulation.

Programming a two-body problem simulator in JavaScript

Fri, 17 Aug 2018 00:00:00 +0000

Please use a newer browser to see the simulation.

Mass ratio: 0.10

Eccentricity: 0.10

In this tutorial we will program a simulation of motion of two celestial bodies in HTML/JavaScript. This work is mostly based on what I learned from Dr Rosemary Mardling, who is an astrophysicist at Monash University. In addition, this code uses techniques we developed in harmonic oscillator tutorial, which would be a good starting place for those who are new to this topic. Please feel free to use the full source code of this simulation for any purpose.

Our approach

We have already done a simulation of motion of two bodies in the Earth orbit simulator tutorial. There we derived equations of motion from the Lagrangian and used them to move the planet around the Sun. For simplicity, we choose the center of mass of two bodies to be at the center of the Sun, which stayed stationary at the origin of our coordinate system. Here we will use a different approach and allow two bodies to move around a common center of mass.

Our coordinate system

A surprising fact about the motion of two bodies is that their common center of mass remains still (or moves at constant velocity). We can take advantage of this fact and place the origin of the coordinate system at the center of mass (Fig. 1).

Figure 1: A coordinate system with the origin at the common center of mass of the two bodies.

Newton’s law of gravitation

The main equation used in our simulation is the Newton’s law of universal gravitation (Eq. 1). It says that the force of gravitational attraction between two bodies is proportional to the product of their masses and inversely proportional to the square of the distance between them.

(1)

Equation of motion

After a series of algebraic manipulations and removing dimensions, we can turn Eq. 1 into an equation of motion of two bodies shown in Eq. 2. Here vector r describes the position of second body relative to the first one. This vector is shown as blue arrow on Fig. 1.

(2)

The variable q in Eq. 2 is the mass ratio of the bodies (i.e. mass of the Earth divided by Sun’s mass). The two dots above vector r mean the second time derivative.

Equations of motion for x and y

Next, we write Eq. 2 in terms of x and y coordinates, which gives a system of two second-order non-linear differential equations:

(3)

Reducing the order of ODEs

We will solve Eq. 3 numerically. In order to do this, we need to translate it into a system of first-order ODEs by making the following substitutions:

(4)

We will store the values of these four variables in the state.u array of the physics object:

var state = {
  // Four variables used in the differential equations
  // First two elements are x and y positions, and second two are x and y components of velocity
  u: [0, 0, 0, 0]
}

Using the new variables we can now translate two second-order differential equations (Eq. 4) into four first-order ones:

(5)

We can now write a function that returns the derivatives of the four variables:

// Calculate the derivatives of the system of ODEs that describe equation of motion of two bodies
function derivative() {
  var du = new Array(state.u.length);

  // x and y coordinates
  var r = state.u.slice(0,2);

  // Distance between bodies
  var rr = Math.sqrt( Math.pow(r[0],2) + Math.pow(r[1],2) );

  for (var i = 0; i < 2; i++) {
    du[i] = state.u[i + 2];
    du[i + 2] = -(1 + state.masses.q) * r[i] / (Math.pow(rr,3));
  }

  return du;
}

Solve ODEs numerically

Now we can use a numerical method to solve the ODEs. In Earth orbit simulator we used Euler’s method, but here we will try another popular method called Runge-Kutta:

var timestep = 0.15;
rungeKutta.calculate(timestep, state.u, derivative);

We will run this code at each frame of the animation and it will save the new values of positions and velocities in state.u. The first two elements of this array are the x and y positions of the r vector from Fig. 1.

Drawing two bodies on the screen

We are almost done. We have found the vector r, which describes the position of Earth relative to the Sun. We will now use this vector to calculate the positions of two bodies on screen. The trick here is to use the mass-distance relation shown in Fig. 2.

Figure 2: A relation between masses of two bodies and distances to the common center of mass.

With this knowledge, we can finally calculate the positions of the two bodies. The positions are saved in the state.positions array and then used to show the two bodies on screen.

function calculateNewPosition() {
    r = 1; // Distance between two bodies
    // m12 is the sum of two massses
    var a1 = (state.masses.m2 / state.masses.m12) * r;
    var a2 = (state.masses.m1 / state.masses.m12) * r;

    state.positions[0].x = -a2 * state.u[0];
    state.positions[0].y = -a2 * state.u[1];

    state.positions[1].x = a1 * state.u[0];
    state.positions[1].y = a1 * state.u[1];
}

Credits

This work is based on code and lectures by Dr Rosemary Mardling from Monash University.
“The Blue Marble” image: NASA/Apollo 17 crew; taken by either Harrison Schmitt or Ron Evans, source, source.
“The Sun photographed at 304 angstroms” image: NASA/SDO (AIA), source, source.

References

The complete source code of the two-body problem simulation.

When things don't fall apart

Mon, 05 Feb 2018 00:00:00 +0000

In his book Enlightenment Now Steven Pinker makes a point that I found interesting and brilliantly obvious.

When we see a poor person we tend to blame something or someone for his misfortune. We blame this person, government, God, Jews, Muslims, corporations, immigrants, socialists, gays, guns, video games, drugs. Insert your favorite root of all evil here. It is probably a natural tendency of our brains to search for causes even when there aren’t any.

But in most cases the explanation for bad stuff is just bad luck. Or in other words, it is the 2nd law of thermodynamics. It is all about probability.

There are infinitely more bad outcomes than good ones. In other words, a probability of a bad result is very large, while a good result is improbable.

From this perspective, there is no cause of poverty. Or rather, there is no simple or single cause of poverty. Instead, there are infinitely many interacting factors that are much more likely to result in poverty than in prosperity. Poverty is just a natural state of equilibrium, because things normally fall apart.

What is surprising is when things don’t fall apart. What is remarkable is that we sometimes see good stuff: prosperity, decline in violence and mortality, improvements in health, human rights, animal rights and so on.

And if we go out and look around we may find many good things happening right now.

How to reduce your energy consumption

Tue, 27 Jun 2017 00:00:00 +0000

The following is a list of things each of us can do to reduce our energy consumption. It’s based mostly on excellent lectures The Science of Energy: Resources and Power Explained by Professor Michael E. Wysession and The Great Courses.

In general

Recycle. It takes less energy to reuse materials than to make them from scratch.
Avoid disposable items and low quality products that don’t last long.
Purchase local food/products. Local products require less energy for transportation.
Eat less packaged food. It takes energy to make packaging.
Reduce amount of food you throw away. 40% of food is lost in the US during different stages from production to consumption.
Turn off electronic devices completely when they are not in use instead of leaving them in standby or sleep mode. 75% of electricity from electronics is consumed when they are not on.
Buy energy efficient house appliances (fridge, washing machine).

Water

Heating water requires enormous amount of energy.

Heat just enough water to fill your cup when making a hot drink. Heating extra water is wasteful.
Use lower temperature setting in your washing machine. Your clothes will also last longer.
Reduce time spent in the shower.

House

Use electricity provider that gets energy from renewable sources.
In summer, stick reflective film to your windows. Blinds and curtains don’t prevent heat from getting into your house.
Use thermally efficient windows with vacuum between multiple glass panes.
Generate your own energy with solar panels and store extra energy in batteries.
Improve insulation of your house: windows, doors, walls.
Plant trees around your house. Trees cool your house during summer and prevent winds from stealing away the heat in winter.

Lights

Use natural light whenever possible.
Turn off the lights when you leave the room.
Use LED light bulbs.
Install lighting dimmers.
Install solar powered street lights that point down.
Install motion sensors that turn lights off in offices and other public places.

Cooling/heating

Use heat pump technology for both heating and cooling instead of electrical/gas heating.
Set thermostat to lower temperature in winter and higher temperature in summer.
Consider putting on warmer clothes instead of heating entire room.
Keep doors/windows shut when cooling/heating is on.
Change air filters of cooling/heating equipment regularly.

Transportation

Reduce amount of flying.
Work remotely and teleconference for meetings instead of commuting.
Bicycle whenever possible.
Use public transportation. Electric public transport is most efficient.
Transport goods by water or train instead of truck/air.

Driving

Use electric car.
Use smaller/lighter car.
Reduce unnecessary acceleration and braking.
Avoid driving alone. Having more passengers is more efficient.
Keep your car tuned up: replace air filters, keep tires fully inflated etc.

I did not know that…

Flying in an airplane is one of the most energy intensive things you can do. Boeing 747 consumes 140 megawatts, which is equal to the power input of one hundred thousand (100 000) US homes. During a 12-hour flight you will consume as much energy one US household uses over one year (in electricity).
The total distance humans drive in two years is about the same as the distance to the nearest star, Proxima Centauri.
Electric cars are four to six times more efficient than gas-powered cars.
Bicycling is one of the most energy efficient ways of traveling.
Energy efficiency of walking depends on the food you eat. For example, beef requires a lot of energy to produce (to feed the cows). If you eat a lot of beef then walking is as energy inefficient as driving alone in the car.

Ideas for the future

Install electricity meter that displays the cost of your current energy use and place the meter somewhere in your house where everyone can see it.
Show the cost of current fuel consumption in your car.
Using virtual reality equipment for teleconferencing can make business meeting more realistic and can make commute/flying unnecessary.
Design new homes with energy savings in mind: insulation, air flow, orientation, tilt of windows, solar panels on rooftops.

Why should I save energy in the first place?

It reduces pollution.
It reduces greenhouse gas emission.
It reduces human impact on ecosystems, maintains biodiversity and prevents extinction of species.
It leaves the planet in better condition for future generations.
It saves you money.

References

“The Science of Energy: Resources and Power Explained” by Professor Michael E. Wysession and The Great Courses. Formats: audio, video.
Wasted: How America Is Losing Up to 40 Percent of Its Food from Farm to Fork to Landfill.

Disabling Swift 3 @objc inference in Xcode 9

Tue, 06 Jun 2017 00:00:00 +0000

Today I installed Xcode 9 and converted my projects to Swift 4.0. Surprisingly, very few changes were necessary to make my code compatible with the new Swift. However, one warning showed up after the build:

The use of Swift 3 @objc inference in Swift 4 mode is deprecated. Please address deprecated @objc inference warnings, test your code with “Use of deprecated Swift 3 @objc inference” logging enabled, and disable Swift 3 @objc inference.

Here is how I got rid of that warning:

Click on your project in the Project Navigator.
Select your target.
Click Build Settings.
In the search bar type “inference” to quickly find the settings.
Finally, change the “Swift 3 @objc Inference” settings to “Default” and rebuild the project.

What does “Swift 3 @objc Inference” setting do?

Before Swift 4, the compiler made some Swift declarations automatically available to Objective-C. For example, if one subclassed from NSObject, the compiler created Objective-C entry points for all methods in such classes. The mechanism is called @objc inference.

In Swift 4, such automatic @objc inference is deprecated because it is costly to generate all those Objective-C entry points. When “Swift 3 @objc Inference” setting is set to “On”, it allows the old code to work. However, it will show deprecation warnings that need to be addressed. It is recommended to “fix” these warnings and switch the setting to “Default”, which is the default for new Swift projects.

Example 1: before Swift 4

This code worked before Swift 4, since method foo was automatically exposed to Objective-C:

class MyClass: NSObject {
  func foo() {}

  func test() {
    var cl: AnyObject
    cl = MyClass()
    cl.foo?() // No problem before Swift 4
  }
}

Example 2: since Swift 4

Let’s try running the same code in Swift 4:

class MyClass: NSObject {
  func foo() {}

  func test() {
    var cl: AnyObject
    cl = MyClass()
    cl.foo?() // Error: Value of type 'AnyObject' has no member 'foo'
  }
}

Now the compiler shows an error, since foo method is no longer available from Objective-C. For convenience, the Swift 4 code migration sets “Swift 3 @objc Inference” setting to “On”, which makes our code compile with the following warning:

Reference to instance method ‘foo()’ of ‘MyClass’ depends on ‘@objc’ attribute inference deprecated in Swift 4.

Make class members available to Objective-C

If we want declarations to be accessible from Objective-C we can mark individual members with the @objc annotation:

class MyClass : NSObject {
  @objc func foo() { } // This method is available to Objective-C
  func bar() { } // But not this method
}

Alternatively, if we want all members of our class to be exposed to Objective-C, we can mark the class with @objcMembers annotation:

@objcMembers // All class members will be exposed to Objective-C
class MyClass : NSObject {
  func foo() { }
  func bar() { }
}

References

Limiting @objc inference Swift proposal.
An answer on Stack Overflow.

Quagga: combine code files into an LLM prompt

Making a JavaScript simulation of two interacting galaxies

What’s this about?

Who made this possible?

The main idea

A spherical cow

Downloading the code

Exploring the code

HTML code

CSS code

JavaScript code

Run the simulation locally

Option 1: running a web server with Python

Option 2: running a web server with Node.js

How the simulation works?

Counting the stars

Positioning stars in a galaxy

Calculating initial speeds of the stars

Changing units of length, mass and time

Calculating initial positions of stars in one galaxy

Calculating star’s position

To be continued…

Thanks 👍

The logistic function

How infection spreads?

What happens when we run out of healthy people? Logistic function happens.

What does the logistic function look like?

Modelling real data

Links

Tarpan: plots and summaries for cmdstanpy library

Four stages of the early Universe

Universe at one second after the Big Bang

Universe at 340 seconds

Helium abundance is 25%

Universe at 60,000 years

Universe at 350,000 years and the cosmic microwave background

References

Programming a three-body problem in JavaScript

Three-body simulations

Figure eight

Sun, Earth and Jupiter

Lagrange point L5

Kepler-16

Chaotic

The coordinate system

The equations of motion

Writing equations of motions in x and y

Converting the equations to first order

Programming the equations of motion

Solving the equations of motion numerically

Drawing the bodies on screen

📚📖✨

Credits

References

Programming a two-body problem simulator in JavaScript

Our approach

Our coordinate system

Newton’s law of gravitation

Equation of motion

Equations of motion for x and y

Reducing the order of ODEs

Solve ODEs numerically

Drawing two bodies on the screen

Credits

References

When things don't fall apart

How to reduce your energy consumption

In general

Water

House

Lights

Cooling/heating

Transportation

Driving

I did not know that…

Ideas for the future

Why should I save energy in the first place?

References

Disabling Swift 3 @objc inference in Xcode 9

What does “Swift 3 @objc Inference” setting do?

Writing equations of motions in `x` and `y`