Ciro Santilli @cirosantilli 37 

An efficient algorithm to calculate the discrete Fourier transform.

feathers-chat-react Updated 2025-07-16

github.com/feathersjs-ecosystem/feathers-chat-react

Last updated 2018 as of 2021, but still just worked.

Also uses webpack which is fantastic.

Gotta run github.com/feathersjs/feathers-chat first: github.com/feathersjs-ecosystem/feathers-chat-react/issues/5, then it worked:

git clone https://github.com/feathersjs/feathers-chat
cd feathers-chat
git checkout fd729a47c57f9e6170cc1fa23cee0c84a004feb5
npm install
npm start

and on the other terminal:

git clone https://github.com/feathersjs-ecosystem/feathers-chat-react
cd feathers-chat-react
git checkout 36d56cbe80bbd5596f6a108b1de9db343b33dac3
npm install
npm start

then visit localhost:3000/ and you can create an account and login, tested on Ubuntu 20.10. Data is stored on persistently.

TODO how to merge those two repos into a single repo.

If you disable JavaScript on Chromium, it stops working completely. There is a section on how to solve that at: docs.feathersjs.com/cookbook/express/view-engine.html but it does not cover React specifically. Codaisseur/feathersjs-react-redux-ssr might be good to look into.

FEniCS Project Updated 2025-07-16

TODO heat equation hello world.

fenicsproject.org/

One big advantage over FreeFem is that it uses plain old Python to describe the problems instead of a domain-specific language. Matplotlib is used for plotting by default, so we get full Python power out of the box!

Also uses variational formulation of a partial differential equation like FreeFem which is a pain.

One downside is that its documentation is a Springer published PDF link.springer.com/content/pdf/10.1007%2F978-3-319-52462-7.pdf which is several years out-of-date (tested with FEnics 2016.2. Newbs. This causes problems e.g.: stackoverflow.com/questions/53730427/fenics-did-not-show-figure-nameerror-name-interactive-is-not-defined/57390687#57390687

system of partial differential equations are mentioned at: link.springer.com/content/pdf/10.1007%2F978-3-319-52462-7.pdf 3.5 "A system of advection–diffusion–reaction equations". You don't need to manually iterate between the equations.

On Ubuntu 20.04 as per fenicsproject.org/download/

sudo apt-get install software-properties-common
sudo add-apt-repository ppa:fenics-packages/fenics
sudo apt-get update
sudo apt-get install --no-install-recommends fenics
sudo apt install fenics
python3 -m pip install -u matplotlib

Before 2020-06, it was failing with:

E: The repository 'http://ppa.launchpad.net/fenics-packages/fenics/ubuntu focal Release' does not have a Release file.

but they seem to have created the Ubuntu 20.04 package as of 2020-06, so it now worked! askubuntu.com/questions/866901/what-can-i-do-if-a-repository-ppa-does-not-have-a-release-file

FFmpeg Updated 2025-07-16

FFmpeg is the assembler of audio and video.

As a result, Ciro Santilli who likes "lower level stuff", has had many many hours if image manipulation fun with this software, see e.g.:

the "Media" section of the best articles by Ciro Articles.
Figure "Ciro knows how to convert videos to GIFs"

As older Ciro grows, the more he notices that FFmpeg can do basically any lower level audio video task. It is just an amazing piece of software, the immediate go-to for any low level operation.

FFmpeg was created by Fabrice Bellard, which Ciro deeply respects.

Resize a video: superuser.com/questions/624563/how-to-resize-a-video-to-make-it-smaller-with-ffmpeg:

ffmpeg -i input.avi -filter:v scale=720:-1 -c:a copy output.mkv

Unlike every other convention under the sun, the height in scale is the first number.

FFmpeg filter graph Updated 2025-07-16

Filter graphs are a thing of great beauty. What an amazingly obscure domain-specific language, but which can produce striking results with very little!!!

A quick example from stackoverflow.com/questions/59551013/how-to-generate-stereo-sine-wave-using-ffmpeg-with-different-frequencies-for-eac/77730492#77730492 illustrates some of the fundamentals:

ffplay -autoexit -nodisp -f lavfi -i '
sine=frequency=500[a];
sine=frequency=1000[b];
[a][b]amerge, atrim=end=2
'

which creates a graph:

                              +--------+
[sine=frequency=500]--->[a]-->|        |
                              | amerge |-->[atrim]-->[output]
[sine=frequency=1000]-->[b]-->|        |
                              +--------+

and plays 500 Hz on the left channel and 1000 Hz on the right channel for 2 seconds.

So we see the following syntax patterns:

sine, amerge and atrim are filters
sine=frequency=500: the first = says "araguments follow"
- frequency=500 sets the frequency argument of the sine filter
- for multiple arguments the syntax is to separate arguments with colons e.g. sine=frequency=500:duration=2
;: separates statements
[a], [b]: sets the name of an edge
,: creates unnamed edge between filters that have one input and one output

A list of all filters can be obtained ith:

ffmpeg -filters

and parameters for a single filter can be obtained with:

ffmpeg --help filter=sine

TODO dump graph to ASCII art? trac.ffmpeg.org/wiki/FilteringGuide#Visualizingfilters mentions a -dumpgraph option, but haven't managed to use it yet.

Bibliography:

ffmpeg.org/ffmpeg-filters.html official documentation
trac.ffmpeg.org/wiki/FilteringGuide some handy tips from the FFMpeg Wiki

FFmpeg video synthesis Updated 2025-07-16

Video with a solid color:

2 second white video:

ffplay -autoexit -f lavfi -i 'color=white:640x480:d=3,format=rgb24,trim=end=2'

Also add some audio:

ffmpeg -lavfi "color=white:640x480:d=3,format=rgb24,trim=end=2[v];sine=f=1000:d=2[a]" -map '[a]' -map '[v]' out.mkv

TODO how to ffplay the video + audio directly? -map does not seem to work unfortunately.

2 second white followed by 2 second black video:

ffplay -autoexit -f lavfi -i 'color=white:640x480:d=3,format=rgb24,trim=end=2[a];color=black:640x480:d=3,format=rgb24,trim=end=2[b];[a][b]concat=n=2:v=1:a=0'

bibliography:
- superuser.com/questions/1153930/how-to-generate-a-pure-white-background-video-with-ffmpeg

Display count in seconds on the video:

black text on white background. Start from 0 and count up to 2:

ffplay -autoexit -f lavfi -i "
color=white:480x480:d=3,
format=rgb24,
drawtext=
  fontcolor=black:
  fontsize=600:
  text='%{eif\:t\:d}':
  x=(w-text_w)/2:
  y=(h-text_h)/2
"

count 0 to 2 with one different sine wave per count:

ffmpeg -lavfi "
color=white:480x480:d=3,
format=rgb24,
drawtext=
fontcolor=black:
fontsize=600:
text='%{eif\:t\:d}':
x=(w-text_w)/2:
y=(h-text_h)/2[v];
sine=f=500:d=1[a1];
sine=f=1000:d=1[a2];
sine=f=2000:d=1[a3];
[a1][a2][a3]concat=n=3:v=0:a=1[a];
" -map '[v]' -map '[a]' count.mkv

bibliography:

Bibliography:

ffmpeg.org//ffmpeg-filters.html#Video-Sources main section of the documentation listing various video generators
stackoverflow.com/questions/11640458/how-can-i-generate-a-video-file-directly-from-an-ffmpeg-filter-with-no-actual-in generically asking how to generate the video without an input video

Fiat currency Updated 2025-07-16

A useless piece of paper (or digital version of it) that you can pay taxes with :)

As opposed to:

2020 cryptocurrencies, while governments still don't accept them for taxes, as well as other assets that are also not accepted for taxes (i.e. most assets)
physical currencies that have intrinsic material value, e.g. gold coins

Field-programmable gate array Updated 2025-07-16

It basically replaces a bunch of discrete digital components with a single chip. So you don't have to wire things manually.

Particularly fundamental if you would be putting those chips up a thousand cell towers for signal processing, and ever felt the need to reprogram them! Resoldering would be fun, would it? So you just do a over the wire update of everything.

Vs a microcontroller: same reason why you would want to use discrete components: speed. Especially when you want to do a bunch of things in parallel fast.

One limitation is that it only handles digital electronics: electronics.stackexchange.com/questions/25525/are-there-any-analog-fpgas There are some analog analogs, but they are much more restricted due to signal loss, which is exactly what digital electronics is very good at mitigating.

First FPGA experiences with a Digilent Cora Z7 Xilinx Zynq by Marco Reps (2018)

Source. Good video, actually gives some rationale of a use case that a microcontroller wouldn't handle because it is not fast enough.

Video 2.

FPGA Dev Board Tutorial by Ben Heck (2016)

Source.

Video 3.

The History of the FPGA by Asianometry (2022)

Source.

nodejs/sequelize/raw/parallel_update_async.js Updated 2025-07-16

../../../nodejs/sequelize/raw/parallel_update_worker_threads.js contains a base example that can be used to test what can happen when queries are being run in parallel. But it is broken due to a sqlite3 Node.js package bug: github.com/mapbox/node-sqlite3/issues/1381...

../../../nodejs/sequelize/raw/parallel_update_async.js is an async version of it. It should be just parallel enough to allow observing the same effects.

This is an example of a transaction where the SQL READ COMMITTED isolation level if sufficient.

These examples run queries of type:

UPDATE "MyInt" SET i = i + 1

Sample execution:

node --unhandled-rejections=strict ./parallel_update_async.js p 10 100

which does:

PostgreSQL, see other databases options at SQL example
10 threads
100 increments on each thread

The fear then is that of a classic read-modify-write failure.

But as www.postgresql.org/docs/14/transaction-iso.html page makes very clear, including with an explicit example of type UPDATE accounts SET balance = balance + 100.00 WHERE acctnum = 12345;, that the default isolation level, SQL READ COMMITTED isolation level, already prevents any problems with this, as the update always re-reads selected rows in case they were previously modified.

If the first updater commits, the second updater will ignore the row if the first updater deleted it, otherwise it will attempt to apply its operation to the updated version of the row

Since in PostgreSQL "Read uncommitted" appears to be effectively the same as "Read committed", we won't be able to observe any failures on that database system for this example.

nodejs/sequelize/raw/parallel_create_delete_empty_tag.js contains an example where things can actually blow up in read committed.

prime-number-theorem Updated 2025-07-16

Consider this is a study in failed computational number theory.

The

n / l n (n)

approximation converges really slowly, and we can't easy go far enough to see that the ration converges to 1 with only awk and primes:

sudo apt intsall bsdgames
cd prime-number-theorem
./main.py 100000000

Runs in 30 minutes tested on Ubuntu 22.10 and P51, producing:

Figure 1.
Linear $π (n)$ vs $n / l n (n)$ approximation plot
. $f (n) = n$ and $f (n) = l o g (n)$ are added to give a better sense of scale. $l o g (n)$ is too close to 0 and not visible, and the approximation almost overlaps entirely with $p i$ .

Figure 2.
$π (n) - n / l n (n)$
. It is clear that the difference diverges, albeit very slowly.

Figure 3.
$π (n) / (n / l n (n))$
. We just don't have enough points to clearly see that it is converging to 1.0, the convergence truly is very slow. The logarithm integral approximation is much much better, but we can't calculate it in awk, sadface.

But looking at: en.wikipedia.org/wiki/File:Prime_number_theorem_ratio_convergence.svg we see that it takes way longer to get closer to 1, even at

1 0^{24}

it is still not super close. Inspecting the code there we see:

(* Supplement with larger known PrimePi values that are too large for \
Mathematica to compute *)
LargePiPrime = {{10^13, 346065536839}, {10^14, 3204941750802}, {10^15,
     29844570422669}, {10^16, 279238341033925}, {10^17,
    2623557157654233}, {10^18, 24739954287740860}, {10^19,
    234057667276344607}, {10^20, 2220819602560918840}, {10^21,
    21127269486018731928}, {10^22, 201467286689315906290}, {10^23,
    1925320391606803968923}, {10^24, 18435599767349200867866}};

so OK, it is not something doable on a personal computer just like that.

python/sphinx/virtual_method Updated 2025-07-16

Polymorphism example:

python/typing_cheat/hello.py Updated 2025-07-16

The hello world!

qiskit/hello.py Updated 2025-07-16

Our example uses a Bell state circuit to illustrate all the fundamental Qiskit basics.

Sample program output, counts are randomized each time.

First we take the quantum state vector immediately after the

∣ 00 ⟩

input.

input:
state:
Statevector([1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j],
            dims=(2, 2))
probs:
[1. 0. 0. 0.]

We understand that the first element of Statevector is

∣ 00 ⟩

, and has probability of 1.0.

Next we take the state after a Hadamard gate on the first qubit:

h:
state:
Statevector([0.70710678+0.j, 0.70710678+0.j, 0.        +0.j,
             0.        +0.j],
            dims=(2, 2))
probs:
[0.5 0.5 0.  0. ]

We now understand that the second element of the Statevector is

∣ 01 ⟩

, and now we have a 50/50 propabability split for the first bit.

Then we apply the CNOT gate:

cx:
state:
Statevector([0.70710678+0.j, 0.        +0.j, 0.        +0.j,
             0.70710678+0.j],
            dims=(2, 2))
probs:
[0.5 0.  0.  0.5]

which leaves us with the final

\frac{∣ 00 ⟩ + ∣ 11 ⟩}{2}

Then we print the circuit a bit:

qc without measure:
     ┌───┐
q_0: ┤ H ├──■──
     └───┘┌─┴─┐
q_1: ─────┤ X ├
          └───┘
c: 2/══════════

qc with measure:
     ┌───┐     ┌─┐
q_0: ┤ H ├──■──┤M├───
     └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
          └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
                0  1
qasm:
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q[0];
cx q[0],q[1];
measure q[0] -> c[0];
measure q[1] -> c[1];

And finally we compile the circuit and do some sample measurements:

qct:
     ┌───┐     ┌─┐
q_0: ┤ H ├──■──┤M├───
     └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
          └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
                0  1
counts={'11': 484, '00': 516}
counts={'11': 493, '00': 507}

qiskit/qft.py Updated 2025-07-16

This is an example of the qiskit.circuit.library.QFT implementation of the Quantum Fourier transform function which is documented at: docs.quantum.ibm.com/api/qiskit/0.44/qiskit.circuit.library.QFT

Output:

init: [1, 0, 0, 0, 0, 0, 0, 0]
qc
     ┌──────────────────────────────┐┌──────┐
q_0: ┤0                             ├┤0     ├
     │                              ││      │
q_1: ┤1 Initialize(1,0,0,0,0,0,0,0) ├┤1 QFT ├
     │                              ││      │
q_2: ┤2                             ├┤2     ├
     └──────────────────────────────┘└──────┘
transpiled qc
     ┌──────────────────────────────┐                                     ┌───┐   
q_0: ┤0                             ├────────────────────■────────■───────┤ H ├─X─
     │                              │              ┌───┐ │        │P(π/2) └───┘ │ 
q_1: ┤1 Initialize(1,0,0,0,0,0,0,0) ├──────■───────┤ H ├─┼────────■─────────────┼─
     │                              │┌───┐ │P(π/2) └───┘ │P(π/4)                │ 
q_2: ┤2                             ├┤ H ├─■─────────────■──────────────────────X─
     └──────────────────────────────┘└───┘
Statevector([0.35355339+0.j, 0.35355339+0.j, 0.35355339+0.j,
             0.35355339+0.j, 0.35355339+0.j, 0.35355339+0.j,
             0.35355339+0.j, 0.35355339+0.j],
            dims=(2, 2, 2))

init: [0.0, 0.35355339059327373, 0.5, 0.3535533905932738, 6.123233995736766e-17, -0.35355339059327373, -0.5, -0.35355339059327384]
Statevector([ 7.71600526e-17+5.22650714e-17j,
              1.86749130e-16+7.07106781e-01j,
             -6.10667421e-18+6.10667421e-18j,
              1.13711443e-16-1.11022302e-16j,
              2.16489014e-17-8.96726857e-18j,
             -5.68557215e-17-1.11022302e-16j,
             -6.10667421e-18-4.94044770e-17j,
             -3.30200457e-16-7.07106781e-01j],
            dims=(2, 2, 2))

So this also serves as a more interesting example of quantum compilation, mapping the QFT gate to Qiskit Aer primitives.

If we don't transpile in this example, then running blows up with:

qiskit_aer.aererror.AerError: 'unknown instruction: QFT'

The second input is:

x_{i} = \frac{1}{2} s in (2 * π * i /8)

(1)

and the output of that approximately:

[0, 1j/sqrt(2), 0, 0, 0, 0, 0, 1j/sqrt(2)]

which can be defined simply as the normalized DFT of the input quantum state vector.

From this we see that the Quantum Fourier transform is equivalent to a direct discrete Fourier transform on the quantum state vector, related: physics.stackexchange.com/questions/110073/how-to-derive-quantum-fourier-transform-from-discrete-fourier-transform-dft

Film about artificial intelligence Updated 2025-07-16

And by artificial intelligence, read of course (non-human-identical) artificial general intelligence.

Today-2022, this is placed under the science fiction film category. But maybe this might change during Ciro Santilli's own lifetime?

The basic criteria of "is a film about artificial intelligence good or not" to Ciro Santilli is: does the AI inhabit humanoid, or fully human looking, bodies? Bodies is a bad sign due to:

the best science fiction works deeply explore the consequences of one single technology: efficient humanoid bodies are a second technological breakthrough besides AI itself. The first AI will obviously be a supercomputer without a body
it is hard to imagine that the AI wouldn't organize itself as one huge central computer and R&D/command center. Perhaps there will be need for a few separate ones to optimize usage of natural resources, and to have some redundance in case a nuke blows the region, but there would be very very few of the think tanks. But having big centers is fundamental, because you centralize all the flow of ideas and their combination leading to new better outcomes for the AI. The mobile robot actors controlled by this center, if any exist, would then be slaves with some degree of autonomy and infinitely less computational powerful than the think tank.

Finite field Updated 2025-07-16

A convenient notation for the elements of

GF (n)

of prime order is to use integers, e.g. for

GF (7)

we could write:

GR (7) = {- 3, - 2, - 1, 0, 1, 2, 3}

(1)

which makes it clear what is the additive inverse of each element, although sometimes a notation starting from 0 is also used:

GR (7) = {0, 1, 2, 3, 4, 5, 6}

(2)

For fields of prime order, regular modular arithmetic works as the field operation.

For non-prime order, we see that modular arithmetic does not work because the divisors have no inverse. E.g. at order 6, 2 and 3 have no inverse, e.g. for 2:

0 \times 2 = 01 \times 2 = 22 \times 2 = 43 \times 2 = 04 \times 2 = 25 \times 2 = 4

(3)

we see that things wrap around perfecly, and 1 is never reached.

For non-prime prime power orders however, we can find a way, see finite field of non-prime order.

Finite fields made easy by Randell Heyman (2015)

Source. Good introduction with examples

Finite general linear group Updated 2025-07-16

general linear group over a finite field of order

m

. Remember that due to the classification of finite fields, there is one single field for each prime power

m

Exactly as over the real numbers, you just put the finite field elements into a

n \times n

matrix, and then take the invertible ones.

Flash memory Updated 2025-07-16

The Engineering Puzzle of Storing Trillions of Bits in your Smartphone / SSD using Quantum Mechanics by Branch Education (2020)

Source. Nice animations show how quantum tunnelling is used to set bits in flash memory.

Flux qubit Updated 2025-07-16

In Ciro's ASCII art circuit diagram notation, it is a loop with three Josephson junctions:

+----X-----+
|          |
|          |
|          |
+--X----X--+

https://upload.wikimedia.org/wikipedia/en/0/04/Flux_Qubit_-_Holloway.jpg

Superconducting Qubit by NTT SCL (2015)

Source.

Offers an interesting interpretation of superposition in that type of device (TODO precise name, seems to be a flux qubit): current going clockwise or current going counter clockwise at the same time. youtu.be/xjlGL4Mvq7A?t=1348 clarifies that this is just one of the types of qubits, and that it was developed by Hans Mooij et. al., with a proposal in 1999 and experiments in 2000. The other type is dual to this one, and the superposition of the other type is between N and N + 1 copper pairs stored in a box.

Their circuit is a loop with three Josephson junctions, in Ciro's ASCII art circuit diagram notation:

+----X-----+
|          |
|          |
|          |
+--X----X--+

They name the clockwise and counter clockwise states

∣ L ⟩

and

∣ R ⟩

(named for Left and Right).

When half the magnetic flux quantum is applied as microwaves, this produces the ground state:

∣ 0 ⟩ = ∣ L ⟩ + ∣ R ⟩

(1)

where

L

and

R

cancel each other out. And the first excited state

∣ 1 ⟩

is:

∣ 0 ⟩ = ∣ L ⟩ - ∣ R ⟩

(2)

Then he mentions that:

to go from 0 to 1, they apply the difference in energy
if the duration is reduced by half, it creates a superposition of $∣ 0 ⟩ + ∣ 1 ⟩$ .

Form of government Updated 2025-07-16

en.wikipedia.org/wiki/List_of_forms_of_government

Rasselas Prince of Abyssinia CHAPTER VIII www.gutenberg.org/cache/epub/652/pg652-images.html:

Oppression is, in the Abyssinian dominions, neither frequent nor tolerated; but no form of government has been yet discovered by which cruelty can be wholly prevented. Subordination supposes power on one part and subjection on the other; and if power be in the hands of men it will sometimes be abused. The vigilance of the supreme magistrate may do much, but much will still remain undone. He can never know all the crimes that are committed, and can seldom punish all that he knows.