Previous Up No next

Diary, November 2026



Sun Mon Tue Wed Thu Fri Sat
  1   2   3   4   5   6   7
  8   9  10  11  12  13  14
 15  16  17  18  19  20  21
 22  23  24  25  26  27  28
 29  30


Sunday, November 1, 2026

65 years

I was born on Wednesday, November 1, 1961 at 9:45 in the morning (CET). That means that today, I will be 65 years according to the calendar and 23376 days old. But how old am I really? The tropical year, the time that it takes for the seasons to return, is said to be 365 days, 5 hours, 48 minutes, and 45.19 seconds. Today, around 3:33:57 in the night, it was 65 tropical years since I was born. But the tropical year is shorter than the sidereal year, the time taken by the Earth to orbit the Sun once with respect to the fixed stars, namely 365 days, 6 hours, 9 minutes, and 9.76 seconds. That means that, tomorrow nigth around 1:40:34 it will be 65 sidereal years after I was born. The average anomalistic year, the time taken for the Earth to complete one revolution with respect to its apsides, is 365 days, 6 hours, 13 minutes, and 52.6 seconds. That means that, tomorrow around 6:46:59 it will be 65 average anomalistic years since I was born.

I have reached the age at which people used to retire in the Netherlands, till almost fourteen years ago, when the age was increased. Now I will official retire on February 1, 2029.

I went into the city and shortly visited the exhibition Stap in! Mijn cultuur with works by from local women from various cultural backgrounds.

I met with some of my family in the cafe Het Bolwerk, the oldest cafe in Enschede, known for being the local pub of Willem Wilmink. The band BlankPaint was performing during our stay. As presents, I got some green tea '宜興茗茶' from Yixing, some cinema vouchers, jar of cherry jam, and a 'tie' with the number 65 as can be seen in the picture below. After a short walk through the city center we enjoyed and Indonesian rijsttafel at Nyonya Meneer. Everybody enjoyed the dinner.


(©Pieter)


Tuesday, November 4, 2026

Endive and red chicory hotchpotch

Tonight's dinner: endive and red chicory (radicchio) hotchpotch, served with pork belly slices and seasoned with a touch of curry powder. A successful combination. The endive, the red chicory and the potatoes are from the harvest of the Herenboeren Usseler Es cooperative.

Walking simulator games

I saw the video Custom Engine Forest Showcase and was bit surprised by how realistic it looks. I do not know whether it is completely procedural generated. Some days ago, I came across the video 44 km Through a 10 Trillion km Procedural World from the Infinitra Project which has much variation but is less realistic. A few days before I saw the video Procedural Planet, which has nice animation of ths sky, while the trees are very simplified, but it is planet sized. I have enjoyed adventure games. It has very varied terrain but no buildings and or roads. Some others that I came across are: I like adventure games where you can walk around. I like the exploration type more than the ones where you have to puzzle to make progress (especially if the puzzling requires you to quickly walk from one location to another) or where there is a lot of narrative. I think what I prefer are so-called Walking simulator games. I wonder whether the best parts of the above could be combined and serve as a starting point for a walking simulator game. Lately, I have been thinking about a type that is kind of a labyrinth, a city on multiple levels, where you can see 'roads' but where it is not immediately clear how to get somewhere. I game that would require good navigation and orientating skills. On itch.io there are many free games for Linux tagged Walking simulator. Just one of them is Wave Function Collapse.


Friday, November 6, 2026

Linear interpolation with integers

Linear interpolation is about finding points on a line defined by two points. Usually it is a (non-vertical) line in the XY-plane or a function defined in time going from one value to another between two points in time. Without loss of generality we could asume that the first point is on the origin and the other point at xy-coordinates (A, B) where A is larger than zero. The y-coordinate of the points on the line can be calculated with (x*B)/A. Now when integers are used, as can be seen in the graph below, you get points that are on or below the line. This is due to the fact that integer division, rounds towards zero. A simple method for implementing rounding, is to add half of A before the division, resulting in using the formula (x*b+A/2)/A, as can be seen with the second option in the animation below. Now the points appear above and below the line and the average error is smaller. The end point can be dragged around with the mouse. In mircocontrollers division is usually a slow operations and especially when one has to calculate many interpolated points, it might be a good idea to avoid the division. Because the B/A remains constant, one possiblity is to introduce factor for that and use that as a multiplication factor. Multiplications are usually more efficient (because it can be parallelized while this is not so easy for a division). However, this does not work very well when B is not much larger than A. Divisions with a power of two can be efficiently implemented in a microcontroller to use a right arithmetic shift operation. The idea is to multiply the factor with a power of two and use a right arithmetic shift in the calculation of a point. This method is a type of fixed-point arithmetic. In the fourth option below, this technique is used. As can be seen the points appear on or below the line. When the end point is moved to the bottom right corner, the points often appear far below the line. The correction that was used in the second option, adding half of the the multiplication factor, does not solve the problem. One solution, given in the sixth option, is to use a much higher factor. This seems to work much beter, but still when it is compared in with the second option, it has difference, which can be visualized with clicking the 'Show differences with best' checkbox. An obvious solution seems be to increase the factor even furhter. However, for some cases this might lead to an overflow during the multiplication, which would result in very large errors as is shown in the last option where the integer values are limited to 16-bits and the value of f is truncated whenever the B value becomes to high. (High values of A do not cause truncation problems.) The additional multiplication factor should be selected careful with respect to the maximum y value and the maximum integer value.

y = (B * x) / A
y = (B * x + A/2) / A
f = B / A, y = f * x
f = (8 * B) / A, y = (f * x) / 8
f = (8 * B) / A, y = (f * x + 4) / 8
f = (256 * B) / A, y = (f * x + 128) / 256
f = (2048 * B) / A, y = (f * x + 1024) / 2048 with 16 bits
Show differences with best


Saturday, November 7, 2026

Museumnacht

This evening, I went to the Museumnacht (Museum night) in Enschede. I visited a number of the locations that joined this year.


Tuesday, November 10, 2026

Linear interpolation with integers (2)

Last Friday, when writing about the problem with doing linear interpolation with integers, I made a remark that seems to imply that high values for A are not a problem. But of course there are problems. In the graph below the x-scale of the graph can be multiplied with 10, 100, and 1000. The higher the scale get, the worse the result gets. One way to deal with this is to devided the x-coordinate with a power of 2 (which can be done with an arithmetic right shift) and multiply the f factor with the same amount. This can be enabled with the last option where 32 is used. The best choice depends on the range of the A and B values.

f = (1024 * B) / A, y = (f * x + 512) / 1024 with 16 bits
x-scale: ×10, f = (1024 * B) / A, y = (f * x + 512) / 1024 with 16 bits
x-scale: ×100, f = (1024 * B) / A, y = (f * x + 512) / 1024 with 16 bits
x-scale: ×1000, f = (1024 * B) / A, y = (f * x + 512) / 1024 with 16 bits
x-scale: ×1000, f = (32 * B) / A, y = (f * (x/32) + 512) / 1024 with 16 bits
Show differences with best


Thursday, November 12, 2026

Book

At 15:16, I bought the book De tweede helft gedocumenteerd written by Ad de Visser in Dutch and published by SUN in 2002, ISBN:9789058750563, from Het Goed for € 10.80. I already have the book 'De tweede helft: beeldende kunst na 1945' for which this book the the accompanying book is.


Friday, November 13, 2026

Mushroom in the garden

I noticed a mushroom in our garden at the back of the house. It is some time ago I have seen such a big mushroom in the garden. The last time I posted a picture of mushrooms in the garden was on Tuesday, January 24, 2023. On Sunday, November 10, 2013, I posted a picture of a similar mushroo (in size and shape). I have no idea what type of mushroom it is, but it could be a Clitocybe nebularis.

Linear interpolation on the ESP32-S3

When you are optimizing a certain calculation, it is always a good idea to look at the actual machine code that is generated by the compiler you are using. A nice tool for such analysis is the Compiler Explorer. It is also important to look at the number of clock cycles that are needed to execute each instruction. In the past week, I have been studying linear interpolation with integer operations. The ESP32-S3 has two Xtensa LX7 cores which do have instructions for multiplying and dividing 32-bit integers, but limited support for 64-bit integers and 32-bit float numbers. Division of float takes about 20 to 25 clock cycles as I understand from the paper (Fixed-Point Integer Approximations for Square Root and Division on ESP32: A Benchmark-Driven Analysis by Lucas Lima Freitag. Division of two 32-bit integers takes about 3 or 4 clock cycles, which is less than I had expected. For the simplest form of linear interpolation, multiplying a step with a constant ratio from the origin and using integer arithmetic the ratio has to be expressed with an integer numerator and a integer divider. To accurately approximate the ratio it is usually required to use large values for the numerator and the divider, especially when the divider has to be a power of two in case one wants to use an arithmetic right shift operator. To implement rounding, one has to add half of the divider to the multiplication of the step and the numerator. To implement this with a division, the following expression can be used (where div2 is half the value of div):
(step * num + div2) / div
When selecting the 'Xtensa ESP32 gcc 14.2.0' compiler, this results in the following seven instruction instructions (with added comments by me) that takes at most eleven clock cycles:
        l32i    a9, a7, 0      // load 'step'
        l32i    a8, a7, 4      // load 'num'
        mull    a9, a9, a8     // multiply
        l32i    a8, a7, 12     // load 'div2'
        add.n   a9, a9, a8     // add
        l32i    a8, a7, 8      // load 'div'
        quos    a8, a9, a8     // divide
If, for example, the value 2 to the power 11 is selected as divider the expression becomes:
(step * num + 1024) >> 11
When compiled, this results in the following five instructions that takes at most six clock cycles:
        l32i    a9, a7, 0      // laod 'step'
        l32i    a8, a7, 4      // load 'num'
        mull    a8, a9, a8     // multiply
        addmi   a8, a8, 0x4000 // add 1024
        srai    a8, a8, 15     // divide by 2048
In many cases this leads to a worse approximation compared to exact solution than the code with the division instruction. One has to carefully evaluate whether the improvement in speed outweighs the loss of accuracy.


Thursday, November 19, 2026

Souvenir: The complete trilogy

This evening, I went to see Souvenir; The complete trilogy by Thom Floris at Villa De Bank. I found his three animatronic theater plays rather impressive knowing that he build and programmed everything by himself.

At 20:50:30, I bought the book In & Out of Amsterdam written by Christophe Cherix and Rini Dippel in English published by The Museum of Modern Art in 2009, ISBN:9780870707537, from bookshop Broekhuis for € 21.95.


Friday, November 20, 2026

Levent Alpöge

Levent Alpöge is a Turkish-American mathematician who today published a remark and Lean proof for the Riemann hypothesis, which has been open math problem for over 150 years and is one of the seven Millennium Prize Problems. Together with Tristan Buckmaster he also published the paper Finite-time blow-up for the Navier–Stokes equations for the unforced case together with a proof in Lean. This too is one of the Millenium Prize Problesm. Earlier this year, OpenAI already had provided a proof for the force case. The Clay Mathematics Institure is getting busy with verifying the results. One problem with Lean proofs that are generated with AI agents is that they tend to get large and that there are often ways to simplify them. The Lean proof for the Rieman hypothesis can be downloaded with the following Bash script:
mkdir -p riemann_proof && cd riemann_proof
for i in {01..14}; do
  curl -fSL -o lean.tar.gz.part$i https://alpo.ge/lean.tar.gz.part$i || { echo "failed: part$i"; break; }
done
cat lean.tar.gz.part{01..14} | tar xzf -
This results in a lean directory with 178,804 files and a size of about 1.1GB. The files and work on verifying the files with Lean can be found in the repository Deicyde/riemann-hypothesis. The results are published on separate page by Andrew Sutherland. There is also a community driven attempt to verify the proof.

And then came the hurried announcement by Ravi Vakil with a 940 page document The Music of the Primes by Alessandro Maria Masullo claiming to have solved the Generalized Riemann hypothesis without the help of AI agents. I guess it does not come with Lean formalization, so there is no easy way to verify the result (when assuming that the Lean prover is without errors). The Lean community started working on a formalization. Proof progress.


This months interesting links


Home | October 2026