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 exhibitionStap 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.
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.
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.
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.
At ANITA, I saw Who is that behinnd the
decks? with photographs and a short interview of:
Aramazd,
Property,
Remma, and
Leen.
At Concordia (Oude Markt), I had my picture taken while standing in the
elevator. I saw that on the third floor you could colour a figure which
was then scanned and added to an animation.
At Concordia (Langestraat), I saw eight paintings by Maarten Dalstra: repetitie I, percussie,
optreden, repetitie VI, harp en klarinet,
repetitie III, dirigent en klarinet, and repetitie X.
I also had a second look at the exhibition Stap in! Mijn cultuur
where I listened to some lullabies from various cultures and languages.
There were also many pillows with the text of lullabies written on them.
On of them was using Arabic script and the handwriting looked rather nice.
At PlanetArt, I saw two persons VJing with video mixers where one was using a modular synth as input.
At TETEM art space, I saw the
introduction video of the installation In Search of Ghost Effects by Laura A Dima. (There was a
queue of people waiting and I understand that you have to experience the
installation with someone else.) I played a bit with the drum installation
by Quentin Thomas-Oliver.
At AKI, I had my picture taken by
Laurin. It was taken
against a light background and printed in black and white. I also had
a look at the AKI show situated in the staircase. I bought the
Five of Pentacles from the Blue Ivy Tarot Deck by Minka Holtrap.
At De Museumfabriek, I saw the 35 long carpet by Amber Hyacinth about the relationship between slavery and the
province of Overijssel.
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.
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.
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.
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:
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.
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.
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.