$Total$</th>	$Blue$</th>	$Red$</th></tr></thead>
$21$</td>	$15$</td>	$6$</td></tr>
$120$</td>	$85$</td>	$35$</td></tr>
$697$</td>	$493$</td>	$204$</td></tr>
$4060$</td>	$2871$</td>	$1189$</td></tr>
$23661$</td>	$16731$</td>	$6930$</td></tr>
$137904$</td>	$97513$</td>	$40391$</td></tr>
$803761$</td>	$568345$</td>	$235416$</td></tr>
$4684660$</td>	$3312555$</td>	$1372105$</td></tr> </tbody></table> It turns out that $b$ follows a known sequence (A011900</a>):</p> $ a(n) = 6\cdot a(n-1) - a(n-2) - 2 $, with $ a(0) = 1 $ and $ a(1) = 3 $</p> Similarly, $r$ is a triangular number (A001109</a>):</p> $ a(n) = 6\cdot a(n-1) - a(n-2) $, with $ a(0) = 0 $ and $ a(1) = 1 $</p> It takes less than 20 iterations to find the first solution which exceeds $10^{12}$.</p> Project Euler #429: Sum of squares of unitary divisors Unknown — Thu, 23 Sep 2021 00:00:00 +0000 A unitary divisor $d$ of a number $n$ is a divisor of $n$ that has the property $gcd(d, \frac n d) = 1$.</p> The unitary divisors of $4! = 24$ are $1, 3, 8$ and $24$.</p> The sum of their squares is $12 + 32 + 82 + 242 = 650$.</p> Let $S(n)$ represent the sum of the squares of the unitary divisors of $n$. Thus $S(4!)=650$.</p> Find $S(100 000 000!) \mod 1 000 000 009$.</p> </blockquote> For clarity, let’s denote $n=10^8$ and $N=n!=10^8!$</p> Observation #1 🔗</a></h3> $N$ is huge. It has ~$750$ million digits. Computing it is out of the question.</p> Observation #2 🔗</a></h3> We are looking for coprime divisors of some integer $N$. This means they are not allowed to have any prime factors in common. Moreover, their product is $N$ so together they must share exactly all factors of $N$.</p> If $d$ and $\frac N d$ are two such divisors, and $N$ can be factorized as $\prod p_i^{a_i}$, then every $p_i^{a_i}$ must belong to either $d$ or $\frac N d$. It can not be subdivided as that would imply $gcd(d, \frac N d)$ is at least $p_i$.</p> $N$ contains every prime factor in the interval $[2, n]$. There are $\pi(n) = 5761455$ such primes (A000720</a>). Each of them can belong to either $d$ or $\frac n d$ so we can generate $2^{5761455}$ such pairs of divisors. Again, not feasible.</p> Observation #3 🔗</a></h3> The sum of $k$-th powers of unitary divisors</a> of $n$ is denoted by $\sigma^_k(n)$. Wikipedia doesn’t help much but MathWorld</a> has a useful formula for generating this function:</p> $\sigma^_k(\prod p_i^{a_i}) = \prod (1+p_i^ {k \cdot a_i}) $ </p> Using this notation, the answer is $\sigma^_2(N)$, which can be computed in $O(\pi(n))$ – completely reasonable.</p> So we need a few things:</p> All primes up to $n$.</li> The factorization of $N$ using said primes. Since $N=n!$, we can compute the factorization of every integer up to $n$ and merge the results.</li> The computation of $\sigma^_2(N)$ using said factorization.</li> </ul> A final implementation detail: the intermediate results can become significantly large. It is important to compute them modulo $ 10^9+9 $. Since the exponents $a_i$ can get fairly large too (on the same order of magnitude as $n$), it doesn’t hurt to use fast exponentiation</a> too.</p> This solution runs in ~1.5min on my machine: 14s generating primes, 70s performing the factorization and <1s computing $\sigma^_2(N)$.</p> Favorite CLI tools (and some GUIs too) Unknown — Wed, 17 Mar 2021 00:00:00 +0000 My first contact with Linux happened around 2008, back when Canonical was still distributing Ubuntu in the form of free CDs. The program was discontinued</a> in 2011. And yes, my official copy of Ubuntu 10.04 LTS has been lost in time:</p> </p> I’ve accumulated many tools and scripts over the years. Some of them made my life easier, some ended up costing more time [xkcd]</a></sup> to implement or figure out than they saved in the long run. This is a collection of those that I got the most use out of.</p> </p> ARandR 🔗</a></h2> ARandR</a> is a GUI for XRandR</a>, the monitor configuration utility for X. The latter provides powerful but inconvenient controls. For example, this is how I can set up my external monitor to extend on top of my laptop screen:</p> $</span> xrandr</span> --output</span> eDP1</span> --mode</span> 1920x1080</span> --rotate</span> normal</span> --primary </span>\ </span> --output</span> HDMI1</span> --mode</span> 2560x1440</span> --rotate</span> normal</span> --above</span> eDP1 </span></code></pre> For any other non-trivial setup, the command gets messy. You might end up setting absolute positions (--pos</code>), changing refresh rates (--rate</code>) or writing your custom scripts depending on several setups you cycle between (laptop only / home / office).</p> ARandR simplifies this by allowing graphical control. The same xrandr</code> command from above is equivalent to the following layout. Except now you don’t have to remember any display names, supported resolutions or refresh rates.</p> `</p> </div>`Mons🔗</a></h2> Mons</a> is another monitor management tool. It also uses xrandr</code> under the hood and exposes the most common use-cases as simple commands. This is especially useful when paired with a window manager which doesn’t handle monitor management natively.</p> The most common commands for me:</p> $</span> mons</span> -o </span># use only primary display </span>$</span> mons</span> -e</span> (top,left,right,bottom) </span># extend the primary display on a particular side </span>$</span> mons</span> -a </span># switch to a single display automatically if the external monitor is disconnected </span></code></pre> exa🔗</a></h2> exa</a> is a modern replacement for ls</code></em>. It’s fast, comes with better defaults (color output, human-readable sizes, etc) and expands on the features of ls</code>. I’ve switched to it years ago: alias ls 'exa -lg'</code>.</p> Examples:</p> $</span> exa</span> -s</span> new </span># sort by newest </span>$</span> exa</span> -T </span># show a tree </span>$</span> exa</span> -l --git </span># show git information </span></code></pre> Taskwarrior🔗</a></h2> Taskwarrior</a> is a CLI tool for managing your TODO list. It is often paired with the GTD methodology</a> which I’ve applied on and off for the past couple of years.</p> My usual workflow looks like this:</p> $ task proj:work.ml add "write design doc" due:3d </span>Created task 64. </span>The project 'work.ml' has changed. </span>Project 'work.ml' is 91% complete (15 of 170 tasks remaining). </span> </span>$ task annotate 64 "to be reviewed by X and Y" </span>Annotating task 64 'write design doc'. </span>Annotated 1 task. </span>Project 'work.ml' is 91% complete (15 of 170 tasks remaining). </span> </span>$ task ls project:work.ml </span>ID D Project Tags Due Description </span>64 work.ml 2d write design doc </span> 2021-03-14 to be reviewed by X and Y </span>25 work.ml someday 1mo enforce lowercase asset names </span>23 work.ml 2020Q4#3 add whackamole jobs to annealing </span>53 work.ml.router create blade targets for main router </span>54 D work.ml 2020Q4#4 4mo implement config watcher </span>55 work.ml 2020Q4#5 4mo write one-pager about aliasing consistency </span>26 work.ml obsolete move partition into model metadata </span></code></pre> I have different projects depending on what I’m working on. I usually set rough deadlines and dependencies between tasks and collect any helpful data (links to bugs, code changes, documentation, etc.</em>) as annotations. The brain behind Taskwarrior sorts existing tasks using a metric called urgency</strong>. For example, blocked tasks are less urgent than non-blocked ones. Tasks with upcoming deadlines are more urgent than tasks scheduled far into the future.</p> Once my work is added and classified properly, I go through to</code> (overdue tasks) and tt</code> (tasks which are due today):</p> alias </span>t </span>'task' </span>alias </span>ta </span>'task active' </span>alias </span>tn </span>'task next' </span>alias </span>to </span>'task overdue' </span>alias </span>ts </span>'task sync' </span>alias </span>tt </span>'task due:today' </span>alias </span>whatdididothisweek </span>'task completed end.after:(date +%Y-%m-%d)-7d' </span>alias </span>whatdididotoday </span>'task completed end.after:(date +%Y-%m-%d)' </span></code></pre> Crossing an item off a list sometimes feels more rewarding than doing the actual work. I found this process helpful in keeping momentum when working on boring parts of my projects. It also helped when I was feeling a complete lack of progress. Instead of staying blocked, I could usually split my work into almost trivially-sized chunks and process them one at a time. The graphical reports are a nice bonus feature too:</p> </p> On top of this, Taskwarrior can be deployed as a server. I’ve done this in order to have data consistency between all my clients:</p> personal laptop</li> work laptop</li> remote workstation</li> android phone (app</a>)</li> </ul> as well as daily backups on Google Drive.</p> Mosh🔗</a></h2> This is one I’ve known about since highschool (thanks to Marius</a>) but only got around to using very recently.</p> In short, mosh</a> is a replacement for SSH. From the surface, it looks and behaves extremely similarly. However, it has some smart features</a> which make it more resilient to intermittent connectivity.</p> The result is a remote connection which feels like a local terminal session. You can put your machine to sleep, come back to it a week later and resume instantly from where you left off.</p> Makes for a powerful workspace when combined with tmux</code>.</p> Alacritty🔗</a></h2> My terminal emulator of choice</a>. It’s implemented in Rust, it’s fast (GPU accelerated), easy to configure (YAML) and feels modern to use.</p> Some features such as scrolling or splitting tabs are excluded in the name of simplicity. While this can present a turn-off, I haven’t noticed any drawbacks since tmux</code> has already been fulfilling these needs for me.</p> Spongebob🔗</a></h2> This is a script</a> I wrote a while ago to aid me in using the mocking Spongebob</a> meme. Doesn’t rank that high on the utility spectrum but it’s fun enough.</p> ❱ echo</span> "you can't just automate yourself out of a job" \|</span> spongebob</span> YoU CaN'T jUsT AuToMAte YoUrSeLf oUt Of A JoB </code></pre> ss</code>🔗</a></h2> Another script</a>. This one uses scrot</a> to take a screenshot of an area, save it to ~/Pictures</code> and copy it to clipboard.</p> switch_sink</code>🔗</a></h2> This one</a> comes in handy when there are multiple audio outputs (sinks) configured in PulseAudio</a>. For example, as shown in pavucontrol</code>:</p> </p> </div> switch_sink</code> picks a random sink, sets it as default and moves all active streams to it. On my machine, it’s mapped to the XF86Tools</code></a> key. This lets me cycle all audio between the built-in laptop speakers, my external audio monitors and my bluetooth headphones at the press of a button.</p> dslr_webcam.sh</code>🔗</a></h2> For the past year I’ve been using my friend’s DSLR camera as a webcam for video calls. I found a solution in the form of gphoto2</a> which can create a virtual video device</em>, also known as a V4L2 loopback device. The script</a> uses gphoto2</code> and ffmpeg</code> to encode the stream.</p> The camera I’m using has an old (maybe proprietary?) connector and is very limited in terms of bandwidth. As such, it can only go up to ~480p 24fps. Still, the picture quality is much better and I can make use of my camera tripod and lenses. On top of this, I don’t have to open my laptop in order to use the built-in webcam.</p> xclip</code>🔗</a></h2> xclip</a> is a command line interface to X selections (clipboard). I use it for copying the output of certain commands to my clipboard. For example:</p> $</span> cat /etc/hosts </span>\| </span>xclip -selection</span> clipboard </span></code></pre> It also works with images (see ss</code></a>).</p> watch</code>🔗</a></h2> watch</a> repeats a command every N seconds and updates the output in-place.</p> For example, monitoring CPU temperature:</p> $</span> watch</span> -n</span> 1 </span>'sensors \| grep "Core"' </span></code></pre> Every 1.0s: sensors \| grep "Core" </span>Core 0: +44.0°C (high = +100.0°C, crit = +100.0°C) </span>Core 1: +45.0°C (high = +100.0°C, crit = +100.0°C) </span></code></pre> Ranger🔗</a></h2> Ranger</a> is a text-based file explorer based on curses. It has been an essential tool for navigating and exploring remote machines.</p> One of the most common non-trivial use cases is cleaning up large files. Ranger’s vi keybindings make this easy: vdcv</code> (inv</strong>ert selection, d</strong>isplay c</strong>ummulative sizes, inv</strong>ert again), followed by os</code> (o</strong>rder by s</strong>ize). Then go through the results, Space</code> to select and :delete</code> as needed.</p> Conclusion🔗</a></h2> As with most things, I’ve barely scratched the surface of what some of these tools are capable of. My usual strategy relies on (1) discovering features organically, as needed and (2) occasionally doing a quick refresh of a particular tool. Most of the time this is as simple as scanning the docs or man page to see that else the tool can do. Sometimes it’s a more systematic approach, for example picking a random chapter of Practical Vim</a> and using that as a way to fill knowledge gaps.</p> Preserving Terminal Colors On The Web Unknown — Sat, 27 Feb 2021 00:00:00 +0000 There are a few different ways of adding code blocks to text-based web content, such as this blog post. I wanted to explore the available options in hope of finding a method that lets me preserve colors exactly as they are in the original text.</p> Markdown🔗</a></h2> This post is mostly written in markdown. The built-in construct for a fenced code block (triple backticks) allows setting a language for syntax highlighting. For example:</p> ```rust pub fn is_drive_document(&self) -> bool { self.drive_file .as_ref() .and_then(\|f\| f.mime_type.clone()) .map(\|t\| EXTENSIONS.contains_key::(&t)) == Some(true) } ``` </code></pre> Which renders as:</p> pub fn </span>is_drive_document</span>(</span>&</span>self</span>) -> </span>bool </span>{ </span> </span>self</span>.drive_file </span> .</span>as_ref</span>() </span> .</span>and_then</span>(\|</span>f</span>\| f.mime_type.</span>clone</span>()) </span> .</span>map</span>(\|</span>t</span>\| </span>EXTENSIONS</span>.contains_key::<</span>str</span>>(</span>&</span>t)) </span> </span>== </span>Some</span>(</span>true</span>) </span>} </span></code></pre> The actual list of supported languages depends on the syntax highlighting engine. Zola supports over 100</a> languages. GitHub uses linguist</a> which has over 500</a> language definitions.</p> This works fantastically well when writing code blocks in any of these predefined languages. The drawbacks are few and fairly minor: edge cases such as incorrect highlighting when using newer features of some languages or having custom prompts/commands when writing console snippets.</p> HTML + JavaScript🔗</a></h2> There are many libraries for highlighting code on the web. The usual workflow involves:</p> Linking in a CSS and JS file, either locally or using a CDN.</li> Including a short script which triggers the highlighting logic.</li> Marking the HTML code elements with a certain class such that the highlighting library can identify them.</li> </ul> One such library is highlight.js</a>. I included it in this page using a CDN and triggered the highlighter with a custom script. Since I’m not using highlight.js everywhere, I want to be able to enable it explicitly on certain elements.</p> <link rel=</span>"stylesheet" </span>href=</span>"//cdnjs.cloudflare.com/ajax/libs/highlight.js/10.5.0/styles/default.min.css"</span>> </span><script src=</span>"//cdnjs.cloudflare.com/ajax/libs/highlight.js/10.5.0/highlight.min.js"</span>></script> </span></code></pre> // Only after the page has loaded. </span>document</span>.</span>addEventListener</span>(</span>"DOMContentLoaded"</span>, </span>function</span>() { </span> </span>// Highlight all <code class="highlightjs"> elements </span> </span>document</span>.</span>querySelectorAll</span>(</span>'code.highlightjs'</span>).</span>forEach</span>(</span>block </span>=> </span>{ </span> </span>hljs</span>.</span>highlightBlock</span>(</span>block</span>); </span> }); </span>}); </span></code></pre> The same Rust snippet can then be included like this:</p> <</span>pre</span>> </span> </span><</span>code class</span>=</span>"highlightjs"</span> class</span>=</span>"rust"</span>> </span> </span>// [...] </span> </span></</span>code</span>> </span></</span>pre</span>> </span></code></pre> Which results in:</p> pub fn is_drive_document(&self) -> bool { self.drive_file .as_ref() .and_then(\|f\| f.mime_type.clone()) .map(\|t\| EXTENSIONS.contains_key::(&t)) == Some(true) </code></pre> One advantage of this approach is the ability of customizing the library. You can choose to include only the languages that you care about. This reduces the payload and can make your web page load faster (compared to linking the complete library) as a result.</p> </p> Changing the colorscheme also becomes trivial. Just pick a different CSS from the available styles</a>.</p> If highlight.js falls short in some way, there are many other alternatives to experiment with:</p> SHJS</a></li> Rainbow</a></li> Prism</a></li> microlight.js</a></li> EnlighterJS</a></li> </ul> ANSI escapes🔗</a></h2> Previous solutions rely on the assumption that the highlightable content is written in a recognized, well-defined language and does not contain errors. This is not always true. In the past, I found myself in situations where I wanted to capture the output of a terminal session without losing any color information. It is possible to programmatically highlight console sessions</a> but it fails more often than not. This is increasingly problematic since many CLI tools benefit from color output nowadays. In most cases, colors increase readability and improve the user experience.</p> But there are many different tools which use colors and the output can be virtually anything. No predefined structure which lends itself to easy color matching.</p> In this case, you have to dig one layer deeper and access the ANSI escape codes</a>. These are binary sequences embedded into text which dictate how it should be displayed in terms of color, styling and other variables. The name comes from the first character in such a code which is usually an ASCII escape character. ANSI codes are used extensively by terminal emulators.</p> However, they are for the most part not human readable. For example, the following mess converts into a nicely colored sentence:</p> ^[[1;34mthis ^[[33mis ^[[31mcolored^[[32m text </span></code></pre> this </span>is </span>colored</span> text </span></pre> In order to get this working, two things must be done:</p> Capturing ANSI information🔗</a></h3> Copying and pasting colored text from a terminal emulator will most likely lose any color information. Redirecting all output to a file will likely do the same. This can be explained by an excerpt taken from the ls</code> manpage</a>:</p> Using color to distinguish file types is disabled both by default and with --color</b>=never</i>. With --color</b>=auto</i>, ls emits color codes only when standard output is connected to a terminal. The LS_COLORS</b> environment variable can change the settings. Use the dircolors command to set it.</pre> One workaround is to set --color=always</code> and redirect the output to a file. Of course, this solution only works for commands which have such a flag. It also gets messy when working with interactive programs, since it essentially separates away all user input. Instead of having a single interactive session, you end up with a blank terminal used only for input and another one for tail</code>-ing the output file. Not a great experience.</p> Luckily, we have script</a>. This tool creates a log of a terminal session and saves it to disk:</p> ~ ❱ script </span>Script started, output log file is 'typescript'. </span>~ ❱ exa -l /srv </span>dr-xr-xr-x - root 19 Jan 2:32 ftp </span>drwxrwxr-x - sergiu 20 Feb 14:25 ghost </span>drwxr-xr-x - sergiu 17 Feb 12:47 sergiu.org </span>drwxr-xr-x - root 19 Jan 2:32 http </span>drwxr-xr-x - http 10 Feb 14:57 manythanks </span>~ ❱ exit </span>Script done. </span></code></pre> The result is a binary file which will show exactly the same terminal information when cat</code>. For what it’s worth, here’s what a hexdump</a> of it looks like.</p> Fun fact: if script</code> is executed with timing information (-T, --log-timing file</code>) it can be replayed at a later time using script-replay</code>. This essentially simulates your shell interaction in real time.</p> Converting ANSI to HTML🔗</a></h3> The captured logfile is not useful on its own. It needs to be converted to HTML tags which convey the same information in a human readable form. I found a few tools for doing this. The ones I tried are ansi2html</a> and aha</a>. In my limited testing, aha</code> provided better results and required less cleanup overall so I’m going to use it to illustrate this step.</p> $</span> aha</span> -f</span> typescript</span> --no-header </span>></span> render.html </span></code></pre> The generated HTML is included below and looks much better than plaintext:</p> ~</span> ❱ exa</span> -l /srv</span> </span></span>d</span>r</span>-</span>x</span>r</span>-</span>x</span>r</span>-</span>x</span> -</span> root 19 Jan 2:32</span> ftp</span> d</span>r</span>w</span>x</span>r</span>w</span>x</span>r</span>-</span>x</span> -</span> sergiu</span> 20 Feb 14:25</span> ghost</span> d</span>r</span>w</span>x</span>r</span>-</span>x</span>r</span>-</span>x</span> -</span> sergiu</span> 17 Feb 12:47</span> sergiu.org</span> d</span>r</span>w</span>x</span>r</span>-</span>x</span>r</span>-</span>x</span> -</span> root 19 Jan 2:32</span> http</span> d</span>r</span>w</span>x</span>r</span>-</span>x</span>r</span>-</span>x</span> -</span> http 10 Feb 14:57</span> manythanks</span> ~</span> ❱ exit</span> </code></pre> The tool is not perfect. In my personal setup, I use the fish</a> shell with many autocomplete plugins. Some of them output ANSII escape codes in real time as I’m typing. This messes up the log file so I have to manually go in and do some cleanup afterwards. Most of it boils down to carriage returns (^M</code>) and other unparsed garbage (special characters, partial autocomplete snippets, etc). I’ve tried the same exercise on bash with a blank .bashrc</code> and had much better results. There’s certainly room for improvement and refinements to be done.</p> Conclusion🔗</a></h2> For the most part, I think the simple Markdown code blocks work best. But for anything terminal-related I would like to find a better workflow around ANSI codes and tools like aha</code>. Either fix the bad interaction with fish (possibly by turning off autocomplete suggestions temporarily) or maybe switch to bash altogether when recording terminal interaction snippets.</p> Building This Blog With Zola Unknown — Wed, 10 Feb 2021 00:00:00 +0000 While looking for options of reviving my old blog, I initially wanted to use the same platform as before – Ghost</a>. After assessing the state of Ghost on Arch, I decided it’s probably not worth the effort so I did some research on HN</a>. Some solutions came up repeatedly:</p> Bear</a> – this would have been my first choice but it does not currently support self hosting.</li> Micro.blog</a> – I want a free solution, especially as I am hosting it on my own server.</li> Blot</a> – same.</li> Medium</a> – there are no words for how much I hate paywalls and gated content. It’s also one of the reasons I stopped reading Quora</a> years ago. If your website is going to ask me to (1) disable my adbocker, (2) create a “free” account or (3) sign up for a paid subscription, I will just close it and move on with my life. On the same note, I have some resistance towards the whole concept of a centralized Internet. I don’t like big social networks. The Internet was more fun when it consisted of a bunch of personal websites that people hosted themselves. If this resonates with you, it’s also worth reading about POSSE</a>.</li> </ul> I eventually landed on Zola</a>, which I used to generate this website. I chose this engine for a few reasons:</p> it generates a simple site. I don’t like complex/over-engineered services and bloated websites. I want a clean and simple landing page which is easy to navigate. This website is mostly a collection of Markdown files with some CSS thrown on top.</p> </li> it’s implemented in Rust. I like Rust and have become familiar with it. As such, some concepts already come across more naturally. For example, Zola’s config is written in toml</a> which is already the de-facto standard</a> for Rust.</p> </li> it’s easy to set up. The Arch User Repository</a> already includes zola</a> as a community package.</p> </li> it’s a simple tool. To emphasize this point, just take a look at what the arch package contains:</p> ~</span> ❱ trizen</span> -Ql zola</span> zola</span> /usr/ zola</span> /usr/bin/ zola</span> /usr/bin/zola zola</span> /usr/share/ zola</span> /usr/share/licenses/ zola</span> /usr/share/licenses/zola/ zola</span> /usr/share/licenses/zola/LICENSE </code></pre> Just one binary and a LICENSE file. That’s it.</p> </li> it has a built-in web server for local development. Although I now use nginx</a> to serve the static files, this was extremely useful in the beginning for just trying stuff out.</p> </li> </ul> Setup and initial configuration🔗</a></h2> Installing Zola on Arch is straightforward. Note:</em> I use trizen</a> instead of pacman</a>.</p> ~</span> ❱ trizen</span> -S zola</span> </span>::</span> Pacman command: </span>/usr/bin/sudo /usr/bin/pacman -S</span> resolving dependencies... looking for conflicting packages... Packages (1)</span> zola-0.13.0-1 Total Download Size: </span> 5.91 MiB Total Installed Size:</span> 20.14 MiB ::</span> Proceed with installation? [Y/n] </span>y ::</span> Retrieving packages...</span> zola-0.13.0-1-x86_64 5.9 MiB 4.11 MiB/s 00:01 [#############################] 100% (1/1) checking keys in keyring [#############################] 100% (1/1) checking package integrity [#############################] 100% (1/1) loading package files [#############################] 100% (1/1) checking for file conflicts [#############################] 100% (1/1) checking available disk space [#############################] 100% ::</span> Processing package changes... </span>(1/1) installing zola [#############################] 100% ::</span> Running post-transaction hooks... </span>(1/1) Arming ConditionNeedsUpdate... </code></pre> The zola</code> binary exposes the init</code> command for initializing a blank website. I decided to create mine under /srv/sergiu.org</code> alongside some of the other web services I host:</p> ~</span> ❱ sudo</span> mkdir /srv/sergiu.org</span> ~</span> ❱ sudo</span> chown sergiu:users /srv/sergiu.org</span> ~</span> ❱ cd</span> /srv</span> /srv</span> ❱ zola</span> init sergiu.org</span> Welcome to Zola!</span> Please answer a few questions to get started quickly.</span> Any choices made can be changed by modifying the `config.toml` file later.</span> > What is the URL of your site? (https://example.com): https://sergiu.org > Do you want to enable Sass compilation? [Y/n]: y > Do you want to enable syntax highlighting? [y/N]: y > Do you want to build a search index of the content? [y/N]: y </span>Done! Your site was created in /srv/sergiu.org</span> Get started by moving into the directory and using the built-in server: `zola serve`</span> Visit https://www.getzola.org for the full documentation. </code></pre> This creates the following skeleton:</p> /srv/sergiu.org</span> ❱ tree</span> . ├── config.toml ├── content ├── sass ├── static ├── templates └── themes 5 directories, 1 file </code></pre> Built-in web server🔗</a></h2> You can preview the website quickly using zola serve</code>. I’m using 0.0.0.0</code> instead of 127.0.0.1</code> in order to be able to access the server from outside the network.</p> /srv/sergiu.org</span> ❱ zola</span> serve -u 0.0.0.0 -i 0.0.0.0</span> Building site...</span> -> Creating 0 pages (0 orphan), 0 sections, and processing 0 images </span>Done in 5ms. </span> Web server is available at http://0.0.0.0:1111 Listening for changes in /srv/sergiu.org{config.toml, content, sass, static, templates} Press Ctrl+C to stop </code></pre> Which results in this:</p> </p> Now, the official documentation suggests a certain content structure</a> which is fairly intuitive. What I found more useful is this list of examples</a>, many of them having the source code publicly available. I personally like the design and structure used by Vincent Prouillet</a> (Zola’s creator) which I’ve adopted as a starting point for my website.</p> All in all, this is the current file structure of this site:</p> /srv/sergiu.org</span> ❱ tree</span> -I public</span> # exclude the auto-generated "public" dir</span> . ├── config.toml ├── content │ └── blog │ ├── _index.md │ ├── building-this-blog-with-zola │ │ ├── index.md │ │ ├── medium-login-wall.png │ │ ├── welcome-to-zola.png │ │ └── zola-welcome.png │ └── state-of-ghost-on-arch │ └── index.md ├── sass │ ├── _base.scss │ ├── _blog.scss │ ├── _layout.scss │ ├── _normalize.scss │ └── site.scss ├── static │ ├── Rubik-Regular.ttf │ └── thesis.pdf ├── templates │ ├── base.html │ ├── blog.html │ ├── index.html │ └── page.html └── themes 8 directories, 18 files </code></pre> Editing🔗</a></h2> Since most content is in the form of Markdown files, I can just ssh</code> into the server and write new content using a text editor.</p> The content can be updated using zola build</code>. This renders the pages and exports everything as static files in the public</code> dir.</p> I’ve added this line to my .vimrc</code> to rebuild the site every time I hit \zb</code>:</p> nnoremap </span><Leader></span>zb :!cd </span>/srv/</span>sergiu</span>.</span>org; </span>zola</span> build</span><CR> </span></code></pre> This means there’s no “save draft” option. All changes I make while writing a post show up incrementally as I’m making progress. This is good enough for now, but in the long term I want to improve the workflow. A better approach would be to have a separate server which is protected against the outside world and only accessible by me. Once I finish writing a post and I’m happy with the result, I can push the changes to the live server. Storing the files on git is also a common practice with static websites. This is all future work though so I’m not going to throw myself completely down the rabbit hole quite yet.</p> Deployment🔗</a></h2> As mentioned above, the static site is served by nginx:</p> http </span>{ </span> [...] </span> server </span>{ </span> </span>listen </span>80</span>; </span> </span>server_name </span>sergiu</span>.</span>org; </span> </span> </span>root </span>/</span>srv</span>/</span>sergiu</span>.</span>org/public</span>; </span> index</span> index</span>.</span>html; </span> </span>error_page </span>404 404</span>.</span>html; </span> </span> location /</span> { </span> </span>try_files </span>$uri $uri</span>/ =</span>404</span>; </span> } </span> } </span> [...] </span>} </span></code></pre> Putting the Fun in Function Optimization Unknown — Wed, 02 May 2018 00:00:00 +0000 The problem of finding the maximum (or minimum) of a real function is often encountered in real-life problems. This is especially true when the function describes how close a solution is to some pre-established aim.</p> We as humans have the natural instinct of searching for better ways to do things:</p> finding a shorter route to work</li> earning a higher grade while studying less</li> finding a balance between all areas of our lives which leads to highest level of happiness</li> and the list goes on</li> </ul> Naturally, not all of these targets are easily quantifiable or achievable, but constructing an appropriate model for such a complex problem is the first step towards solving it.</p> The textbook way🔗</a></h2> There are many known methods</a> of finding the maximum (or minimum) of a real function.</p> Some of the more popular ones - Gradient Descent</a>, for instance</em> - became known in the mainstream CS community due to their applicability in Machine Learning</a> and their simplicity of implementation:</p> function </span>[</span>theta</span>, </span>J_history</span>] = </span> </span>gradientDescent</span>(</span>X</span>, </span>y</span>, </span>theta</span>, </span>alpha</span>, </span>num_iters</span>) </span> </span>% GRADIENTDESCENT Performs gradient descent to learn theta </span>% theta = GRADIENTDESENT(X, y, theta, alpha, num_iters) </span>% updates theta by taking num_iters gradient steps with </span>% learning rate alpha </span> </span>m</span> = length</span>(y); </span>% number of training examples </span>J_history</span> = zeros</span>(num_iters, </span>1</span>); </span> </span>for </span>iter</span> = </span>1</span>:</span>num_iters </span> rsum_0</span> = </span>0</span>; </span> rsum_1</span> = </span>0</span>; </span> </span> </span>for </span>i</span>=</span>1</span>:</span>m, </span> rsum_0</span> += </span>(X(</span>i</span>,</span>:</span>)</span> </span>theta</span> - </span>y(</span>i</span>))</span> * </span>X(</span>i</span>, </span>1</span>); </span> rsum_1</span> += </span>(X(</span>i</span>,</span>:</span>)</span> * </span>theta</span> - </span>y(</span>i</span>))</span> * </span>X(</span>i</span>, </span>2</span>); </span> </span>end </span> </span> theta</span> = </span>[theta(</span>1</span>)</span> - </span>(</span>alpha</span> / </span>m)</span> * </span>rsum_0; </span> theta(</span>2</span>)</span> - </span>(</span>alpha</span> / </span>m)</span> * </span>rsum_1]; </span> </span> </span>% Save the cost J in every iteration </span> J_history(iter)</span> = </span>computeCost(X, y, theta); </span>end </span></code></pre> The problem with such methods is their mathematical complexity. It is considerably more difficult to understand the inner workings and intuition behind gradient descent than it is to actually implement it.</p> Coming up with the algorithm from first principles requires a strong mathematical background. Just opening the Wikipedia article</a> is enough to scare most programmers away, when they encounter this:</p> </p> A more intuitive way🔗</a></h2> Luckily, there is a class of heuristic-based optimization techniques which perform on-par with the mathematically proven™</strong> methods, when tuned properly. Most of these algorithms are heavily inspired from natural phenomena, ranging from the movement of bees in a colony</a>, to Darwin</a>’s theory of evolution by natural selection</a>.</p> Particle Swarm Optimization🔗</a></h3> This particular technique was initially designed as a model to represent the movement of flocks of birds or groups of fish. Later analysis showed that the algorithm was performing optimization.</p> Assume that we want to minimize a $2$-dimensional real function (this method also works for $n$-dimensional functions). The main idea behind PSO can be described as follows:</p> A particle represents a potential solution (i.e.</em> a pair $(x, y)$). From this point forward, we will be refering to this pair as the position</strong> of the particle.</li> Additionally, each particle is assigned a velocity</strong> (i.e.</em> a pair $(dx, dy)$).</li> Initially, a swarm of N randomly placed (or uniformly distributed) particles is generated in the function domain.</li> The fitness</strong> of each particle (i.e.</em> how well it performs as a solution) is computed; this is equivalent to the actual value of the given function at the position of each particle. Our aim is to minimize this fitness.</li> Each particle keeps track of its best previously encountered position. In addition, we also keep track of the best position ever encountered by any particle in the swarm.</li> </ul> The optimization takes place over the span of multiple iterations. Every iteration works like this:</p> Each particle moves to a new position, by adding its velocity to the current position.</p> </li> The velocity is then recomputed as a weighted average of three factors:</p> current velocity (weight $\omega$))</li> the best position of the particle (weight $\phi_{p_{i}}$)</li> the best position of the entire swarm (weight $\phi_{G}$)</li> </ul> # p and g are randomly generated in [-1.0, 1.0] </span># they act as mutations </span> </span>def </span>updateVelocity</span>(</span>self</span>, </span>i</span>, </span>p</span>, </span>g</span>): </span> deltaParticle </span>= </span>self</span>.bestPos[i] </span>- </span>self</span>.pos[i] </span> deltaSwarm </span>= </span>self</span>.swarm.bestPos[i] </span>- </span>self</span>.pos[i] </span> </span> newComponent </span>= </span>omega </span>* </span>self</span>.velocity[i] \ </span> </span>+ </span>phiP </span>* </span>p </span>* </span>deltaParticle \ </span> </span>+ </span>phiG </span>* </span>g </span>* </span>deltaSwarm </span> </span> </span>if </span>i </span>== </span>0</span>: </span> </span>self</span>.velocity </span>= </span>(newComponent, </span>self</span>.velocity[</span>1</span>]) </span> </span>else</span>: </span> </span>self</span>.velocity </span>= </span>(</span>self</span>.velocity[</span>0</span>], newComponent) </span></code></pre> </li> The best position for each particle and for the colony are updated.</p> </li> </ul> There is a bit of work involved in choosing appropriate values for $\omega$, $\phi_{p_{i}}$ and $\phi_{G}$, but this job becomes considerably less difficult after understanding how each of these parameters affects the colony.</p> This set of rules leads to a tremendously organic behaviour. There is no magic behind the scenes; it’s just particles that explore the problem domain while learning from their past experience and from each other.</p> Testing🔗</a></h2> Wikipedia provides a list of functions</a> designed specifically for evaluating the performance of optimization algorithms. These are the results I obtained on a subset of them:</p> McCormick🔗</a></h3> Formula: $f(x, y) = sin(x+y) + (x-y)^2 - 1.5x + 2.5y + 1$</p> Global minimum: $ f(-0.54719, -1.54719) = -1.9133 $</p> Best solution found: $ f(-0.54710, -1.54724) = -1.913223 $</p> Plot:</p> </div> Your browser does not support the video tag. </video> Notes:</p> There is a noticeable cluster of particles that gravitate around a local minimum, also visible in the function plot.</li> A set of $100$ particles and approximately $200$ iterations suffice for finding the global minimum with a precision of $ 10^{-3} $; further improvements require additional iterations.</li> </ul> Eggholder🔗</a></h3> Formula: $ f(x, y) = -(y+47) * sin \sqrt {\left \| \frac{x}{2} + (y+47) \right \|} - x * sin \sqrt{\left \| x - (y+47) \right \|} $</p> Global minimum: $ f(512, 404.2319) = -959.6407 $</p> Best solution found: $ f(482.03561, 432.59104) = -956.879905 $</p> Plot:</p> </div> Your browser does not support the video tag. </video> Notes:</p> Because of the numerous local minima of this function, we need to start with a larger set of particles ($500$), such that there is a higher chance of at least one particle being on the right track</em> straight from the beginning.</li> Same as before, most particles tend to form clusters corresponding to local minima. This is a common problem encountered by Hill climbing</a> algorithms.</li> </ul> Rastrigin🔗</a></h3> Formula: $ f(x) = An + \sum_{i=1}^{n} \left [ x_{i}^{2} - A cos \left ( 2 \pi x_{i} \right )\right ] $ where $A = 10$ and $x$ is an $n$-dimensional vector ($n=2$).</p> Global minimum: $ f(0, 0) = 0 $</p> Best solution found: $ f(0.00181, 0.00083) = 0.000785 $</p> Plot:</p> </div> Contour:</p> </p> Your browser does not support the video tag. </video> Notes:</p> There are a couple of noticeable direction changes in the entire swarm (starting at iteration $40$ and $170$). This behavior illustrates the concept of swarm intelligence</strong>: as soon as a particle finds a new best solution for the colony, all other particles start to follow it.</li> The final placement of the swarm resembles the grid-like pattern shown in the contour plot.</li> </ul> Easom🔗</a></h3> Formula: $ f(x,y) = -cos \left ( x \right ) cos \left ( y \right ) exp \left ( -\left ( \left ( x - \pi \right )^{2} + \left ( y - \pi \right )^{2} \right ) \right ) $</p> Global minimum: $ f(\pi, \pi) = -1 $</p> Best solution found: $ f(3.14158, 3.14163) = -1.000000 $</p> Plot:</p> </div> Your browser does not support the video tag. </video> Notes:</p> Nice method for approximating the value of $\pi$. :)</li></li> In this simulation, I used a relatively large value for $\omega$. As a result, each particle tends to stick more to its current direction, which makes the particles’ paths more distinctive.</li> </ul> Cross-in-tray🔗</a></h3> Formula: $ f(x, y) = -(10^{-4}) \left [ \left \| sin\left ( x \right ) sin\left ( y \right ) exp \left ( \left \| 100 - \frac{\sqrt{x^{2}+y^{2}}}{\pi} \right \| \right ) \right \| + 1 \right ]^{0.1} $</p> Global minimum: $ f(\pm1.34941, \pm1.34941) = -2.06261 $</p> Best solution found: $ f(1.34830, 1.34880) = -2.062612 $</p> Plot:</p> </div> Your browser does not support the video tag. </video> Notes:</p> All 4 global minima are discovered.</li> Similar to the Rastrigin</a> function, the entire swarm changes direction once a better solution is found.</li> </ul> Conclusion🔗</a></h2> Optimization techniques usually behave really well on real functions, but they are not limited to this scope. I chose this application because it can provide insightful data visualization more easily than other use cases.</p> The code can be found on GitHub</a>.</p>

sergiu.org

Things I want to 3D print

Unknown — Thu, 06 Jan 2022 00:00:00 +0000

In no particular order:

Project Euler #213: Flea Circus

Unknown — Wed, 06 Oct 2021 00:00:00 +0000

A $30 \times 30$ grid of squares contains 900 fleas, initially one flea per square. When a bell is rung, each flea jumps to an adjacent square at random (usually 4 possibilities, except for fleas on the edge of the grid or at the corners).
What is the expected number of unoccupied squares after 50 rings of the bell? Give your answer rounded to six decimal places. </blockquote>
The problem statement looks deceivingly simple but also doesn’t give away any approach towards finding a solution. The entire process can be simulated using the Monte Carlo method</a>:

place one flea in each cell of an $ n \times n $ grid ($ n = 30 $)</li>
simulate $ k = 50 $ bell rings

during each bell ring, move all $ 900 $ fleas to a randomly selected neighboring cell</li> </ul> </li>
count the number of empty cells at the end</li>
repeat the whole process as many times as possible and average the results</li> </ul>
This can give a reasonable approximation of the final result but is in no way feasible considering the required precision. A straight-forward implementation can simulate one experiment in $ O(n^2 \cdot k) $, which is already a non-trivial complexity. My C++ implementation needs almost a minute to simulate the experiment $ 10^5 $ times. The precision is not great: at most one significant figure, and only some of the time. Increasing the iteration count to $ 10^6 $ does not necessarily perform better. There is still a high variance between runs.
But at least we have a better idea of what the answer looks like:
</iframe> </center>
Expected value 🔗</a></h2>
The expected number of unoccupied cells is, simply put, the average that would be obtained by repeating the simulation infinitely many times. Mathematically, it is a weighted arithmetic mean of the possible outcomes (i.e. number of unoccupied cells) and the probabilities of obtaining them.
If we denote the discrete random variable $ X $ to represent the number of unoccupied cells after 50 bell rings, then:
$$ E(X) = \sum x_i p_i $$
where the values $ x_i $ are the possible outcomes $ X $.
In practice, we know what these outcomes are. The two extremes are $ x_{min} = 1 $ (all fleas end up in exactly the same cell) and $ x_{max} = 900 $ (all fleas end up in distinct cells, exactly like the beginning). Every value in between is also plausible.
Probabilities 🔗</a></h2>
Now we need a way to compute any given probability $ p_i $ of ending up with exactly $ i $ unoccupied cells. We can draw some intuitive conclusions right away: it’s highly likely that $ p $ follows a bell curve. Moreover, it might be more likely for border and corner cells to be empty. They have fewer neighbors where fleas can enter from, and border fleas can only stay for so long before the randomness pulls them closer to the center. I have no proof for either of these claims but it might be fun to plot some graphs and verify them.
In any case, the probability is tricky to compute. Since this looks a lot like a counting problem, maybe a dynamic programming approach can work. I tried to come up with a useful definition, going through several iterations depending on the information that was needed:

$ dp(i,j,k) = $ the probability of having cell $(i, j)$ occupied after $k$ bells.</li>
Initial state: $ dp(i,j,0) = 1 $. Every cell is occupied in the beginning.</li>
Recurrence: hard to tell. Since all fleas which are in cell $ (i, j) $ after $ k-1 $ bells will jump away, none of them will be there anymore after $ k $ bells. Instead, all fleas from the (up to) 4 neighboring cells have a chance of entering cell $ (i,j) $.</li>
Problems: this $ dp $ table doesn’t tell us anything about the number of fleas. A neighbor cell with 20 fleas has more chances of having some of them jump to the current cell than a neighbor with only 3 fleas. We don’t have enough information to compute an exact probability.</li> </ul>
Maybe introduce another dimension:

$ dp(i,j,x,k) = $ the probability of having exactly $ x $ fleas in cell $(i, j)$ after $k$ bells.</li>
Initial state: $ dp(i, j, 1, 0) = 1 $. Every cell has exactly one flea in the beginning.</li>
Recurrence: calculable but computationally expensive.</li> </ul>
Assuming we want to compute the current state $ dp(i, j, x, k) $, what previous states could we have come from?
We know the fleas came from (up to) 4 neighbors. Those neighbors could have had any number of fleas themselves after $ k-1 $ bells, ranging from $0$ all the way to $900$. So the possible previous states are:
$$ dp(i_t, j_t, x_t, k-1), 1 \le t \le 4; 0 \le x_t \le 900 $$
Moreover, the $x$ fleas we have obtained in cell $(i,j)$ could have come in any combination from these neighbors. Essentially, we must try all configurations of $ x = \sum x_t’$, where $ 0 \le x_t’ \le x_t $.
With a bit more gymnastics we can compute the probability of having exactly $x_t’$ out of $x_t$ fleas jump in exactly the direction they need to in order to reach the current cell. The whole recurrence starts to take form but ends up looking extremely unwieldy. I will not attempt to write it here in full (or at all really).
Perspective shift 🔗</a></h2>
This unlocked the problem for me. What if, instead of tracking cells and the fleas contained within, we track the journey of individual fleas? This proves to be useful, despite adding a new dimension to the $dp$ table:

$ dp(i, j, x, y, k) = $ the probability of the flea who started in cell $(i, j)$ to reach cell $(x,y)$ after exactly $k$ bells.</li>
Initial state: $dp(i,j,i,j,0)=1$. Every flea has reached its own cell in the beginning.</li>
Recurrence: the flea must have come from one of the (up to) 4 neighboring cells. Each neighbor $(x_t, y_t)$ has a probability of containing this particular flea after the previous bell (basically $ dp(i, j, x_t, y_t, k-1) $). In turn, the neighbor can have $ b_t $ neighbors of its own ($ 2 \le b_t \le 4 $). All of them are equally likely to be chosen as the jump destination but only one of them is our current cell. So we have a clear relation:</li> </ul>
$$ dp(i, j, x, y, k) = \sum_{t=1}^4 \frac 1 b_t \cdot dp(i, j, x_t, y_t, k-1) $$
Of course, only valid neighbors are considered.
Putting it all together 🔗</a></h2>
Now we know for every flea how likely it is to end up in any cell of the grid after 50 bell rings. How is this useful?
We can treat cells individually. A cell $(x, y)$ will be unoccupied at the end only if all fleas land somewhere else. If we denote this probability as $p(x, y)$, then:
$$ p(x,y) = \prod (1-dp(i, j, x, y, k)) $$
As it turns out, this probability shows exactly by how much cell $(x, y)$ contributes to the expected number of unoccupied cells. The final answer is:
$$ E(X) = \sum p(x, y) $$
Complexity: $O(n^4 \cdot k)$. Execution time less than 2 seconds.

Project Euler #100: Arranged probability

Unknown — Fri, 24 Sep 2021 00:00:00 +0000

If a box contains twenty-one coloured discs, composed of fifteen blue discs and six red discs, and two discs were taken at random, it can be seen that the probability of taking two blue discs, $P(BB) = \frac {15} {21} \times \frac {14} {20} = \frac 1 2$.
The next such arrangement, for which there is exactly 50% chance of taking two blue discs at random, is a box containing eighty-five blue discs and thirty-five red discs.
By finding the first arrangement to contain over $10^{12} = 1,000,000,000,000$ discs in total, determine the number of blue discs that the box would contain. </blockquote>
This is a fun problem that seems out of reach initially but can be reduced to something more simple.
Compute the probability 🔗</a></h2>
Assuming there are $b$ blue discs and $r$ red discs, the probability of choosing one blue disc at random is $P_1 = \frac {b} {b+r}$. The probability of choosing another blue disc from the remaining set is $P_2 = \frac {b-1} {b+r-1}$.
So the probability of choosing 2 blue discs is $P(BB) = P_1 \cdot P_2 = \frac {b} {b+r} \cdot \frac {b-1} {b+r-1}$
We need to find the smallest solution of:
$$ \begin{cases} \frac {b} {b+r} \cdot \frac {b-1} {b+r-1} = \frac 1 2 \newline b + r > 10^{12} \end{cases} $$
If we consider $b$ to be a constant, the first equation can be rewritten to express $r$ as a function of $b$. In short:
$$ r^2 + (2b-1) \cdot r + (b-b^2) = 0 $$
Which has at most two natural roots:
$$ r_{1,2} = \frac {1 - 2b \pm \sqrt {(2b-1)^2 - 4(b-b^2)} } 2 $$
We can now compute the corresponding $r$ for every possible $b$, if it exists. Assuming that $b$ and $r$ are on the same order of magnitude, this approach should find the answer after ~$10^{12}$ iterations.
Finding patterns 🔗</a></h2>
The previous approach finds several solutions quickly:
$Total$</th> $Blue$</th> $Red$</th></tr></thead>

$21$</td> $15$</td> $6$</td></tr>
$120$</td> $85$</td> $35$</td></tr>
$697$</td> $493$</td> $204$</td></tr>
$4060$</td> $2871$</td> $1189$</td></tr>
$23661$</td> $16731$</td> $6930$</td></tr>
$137904$</td> $97513$</td> $40391$</td></tr>
$803761$</td> $568345$</td> $235416$</td></tr>
$4684660$</td> $3312555$</td> $1372105$</td></tr> </tbody></table>
It turns out that $b$ follows a known sequence (A011900</a>):
$ a(n) = 6\cdot a(n-1) - a(n-2) - 2 $, with $ a(0) = 1 $ and $ a(1) = 3 $
Similarly, $r$ is a triangular number (A001109</a>):
$ a(n) = 6\cdot a(n-1) - a(n-2) $, with $ a(0) = 0 $ and $ a(1) = 1 $
It takes less than 20 iterations to find the first solution which exceeds $10^{12}$.

Project Euler #429: Sum of squares of unitary divisors

Unknown — Thu, 23 Sep 2021 00:00:00 +0000

A unitary divisor $d$ of a number $n$ is a divisor of $n$ that has the property $gcd(d, \frac n d) = 1$.
The unitary divisors of $4! = 24$ are $1, 3, 8$ and $24$.
The sum of their squares is $12 + 32 + 82 + 242 = 650$.
Let $S(n)$ represent the sum of the squares of the unitary divisors of $n$. Thus $S(4!)=650$.
Find $S(100 000 000!) \mod 1 000 000 009$. </blockquote>
For clarity, let’s denote $n=10^8$ and $N=n!=10^8!$
Observation #1 🔗</a></h3>
$N$ is huge. It has ~$750$ million digits. Computing it is out of the question.
Observation #2 🔗</a></h3>
We are looking for coprime divisors of some integer $N$. This means they are not allowed to have any prime factors in common. Moreover, their product is $N$ so together they must share exactly all factors of $N$.
If $d$ and $\frac N d$ are two such divisors, and $N$ can be factorized as $\prod p_i^{a_i}$, then every $p_i^{a_i}$ must belong to either $d$ or $\frac N d$. It can not be subdivided as that would imply $gcd(d, \frac N d)$ is at least $p_i$.
$N$ contains every prime factor in the interval $[2, n]$. There are $\pi(n) = 5761455$ such primes (A000720</a>). Each of them can belong to either $d$ or $\frac n d$ so we can generate $2^{5761455}$ such pairs of divisors. Again, not feasible.
Observation #3 🔗</a></h3>
The sum of $k$-th powers of unitary divisors</a> of $n$ is denoted by $\sigma^*_k(n)$. Wikipedia doesn’t help much but MathWorld</a> has a useful formula for generating this function:
$\sigma^*_k(\prod p_i^{a_i}) = \prod (1+p_i^ {k \cdot a_i}) $ 
Using this notation, the answer is $\sigma^*_2(N)$, which can be computed in $O(\pi(n))$ – completely reasonable.
So we need a few things:

All primes up to $n$.</li>
The factorization of $N$ using said primes. Since $N=n!$, we can compute the factorization of every integer up to $n$ and merge the results.</li>
The computation of $\sigma^*_2(N)$ using said factorization.</li> </ul>
A final implementation detail: the intermediate results can become significantly large. It is important to compute them modulo $ 10^9+9 $. Since the exponents $a_i$ can get fairly large too (on the same order of magnitude as $n$), it doesn’t hurt to use fast exponentiation</a> too.
This solution runs in ~1.5min on my machine: 14s generating primes, 70s performing the factorization and <1s computing $\sigma^*_2(N)$.

Favorite CLI tools (and some GUIs too)

Unknown — Wed, 17 Mar 2021 00:00:00 +0000

My first contact with Linux happened around 2008, back when Canonical was still distributing Ubuntu in the form of free CDs. The program was discontinued</a> in 2011. And yes, my official copy of Ubuntu 10.04 LTS has been lost in time:

I’ve accumulated many tools and scripts over the years. Some of them made my life easier, some ended up costing more time [xkcd]</a> to implement or figure out than they saved in the long run. This is a collection of those that I got the most use out of.

ARandR 🔗</a></h2>
ARandR</a> is a GUI for XRandR</a>, the monitor configuration utility for X. The latter provides powerful but inconvenient controls. For example, this is how I can set up my external monitor to extend on top of my laptop screen:
$ xrandr --output eDP1 --mode 1920x1080 --rotate normal --primary \ --output HDMI1 --mode 2560x1440 --rotate normal --above eDP1 </code></pre> For any other non-trivial setup, the command gets messy. You might end up setting absolute positions (--pos</code>), changing refresh rates (--rate</code>) or writing your custom scripts depending on several setups you cycle between (laptop only / home / office). ARandR simplifies this by allowing graphical control. The same xrandr</code> command from above is equivalent to the following layout. Except now you don’t have to remember any display names, supported resolutions or refresh rates.
 </div>Mons🔗</a></h2> Mons</a> is another monitor management tool. It also uses xrandr</code> under the hood and exposes the most common use-cases as simple commands. This is especially useful when paired with a window manager which doesn’t handle monitor management natively. The most common commands for me: $ mons -o # use only primary display $ mons -e (top,left,right,bottom) # extend the primary display on a particular side $ mons -a # switch to a single display automatically if the external monitor is disconnected </code></pre> exa🔗</a></h2> exa</a> is a modern replacement for ls</code>. It’s fast, comes with better defaults (color output, human-readable sizes, etc) and expands on the features of ls</code>. I’ve switched to it years ago: alias ls 'exa -lg'</code>. Examples: $ exa -s new # sort by newest $ exa -T # show a tree $ exa -l --git # show git information </code></pre> Taskwarrior🔗</a></h2> Taskwarrior</a> is a CLI tool for managing your TODO list. It is often paired with the GTD methodology</a> which I’ve applied on and off for the past couple of years. My usual workflow looks like this: $ task proj:work.ml add "write design doc" due:3d Created task 64. The project 'work.ml' has changed. Project 'work.ml' is 91% complete (15 of 170 tasks remaining). $ task annotate 64 "to be reviewed by X and Y" Annotating task 64 'write design doc'. Annotated 1 task. Project 'work.ml' is 91% complete (15 of 170 tasks remaining). $ task ls project:work.ml ID D Project Tags Due Description 64 work.ml 2d write design doc 2021-03-14 to be reviewed by X and Y 25 work.ml someday 1mo enforce lowercase asset names 23 work.ml 2020Q4#3 add whackamole jobs to annealing 53 work.ml.router create blade targets for main router 54 D work.ml 2020Q4#4 4mo implement config watcher 55 work.ml 2020Q4#5 4mo write one-pager about aliasing consistency 26 work.ml obsolete move partition into model metadata </code></pre> I have different projects depending on what I’m working on. I usually set rough deadlines and dependencies between tasks and collect any helpful data (links to bugs, code changes, documentation, etc.) as annotations. The brain behind Taskwarrior sorts existing tasks using a metric called urgency. For example, blocked tasks are less urgent than non-blocked ones. Tasks with upcoming deadlines are more urgent than tasks scheduled far into the future. Once my work is added and classified properly, I go through to</code> (overdue tasks) and tt</code> (tasks which are due today): alias t 'task' alias ta 'task active' alias tn 'task next' alias to 'task overdue' alias ts 'task sync' alias tt 'task due:today' alias whatdididothisweek 'task completed end.after:(date +%Y-%m-%d)-7d' alias whatdididotoday 'task completed end.after:(date +%Y-%m-%d)' </code></pre> Crossing an item off a list sometimes feels more rewarding than doing the actual work. I found this process helpful in keeping momentum when working on boring parts of my projects. It also helped when I was feeling a complete lack of progress. Instead of staying blocked, I could usually split my work into almost trivially-sized chunks and process them one at a time. The graphical reports are a nice bonus feature too: On top of this, Taskwarrior can be deployed as a server. I’ve done this in order to have data consistency between all my clients: personal laptop</li> work laptop</li> remote workstation</li> android phone (app</a>)</li> </ul> as well as daily backups on Google Drive. Mosh🔗</a></h2> This is one I’ve known about since highschool (thanks to Marius</a>) but only got around to using very recently. In short, mosh</a> is a replacement for SSH. From the surface, it looks and behaves extremely similarly. However, it has some smart features</a> which make it more resilient to intermittent connectivity. The result is a remote connection which feels like a local terminal session. You can put your machine to sleep, come back to it a week later and resume instantly from where you left off. Makes for a powerful workspace when combined with tmux</code>. Alacritty🔗</a></h2> My terminal emulator of choice</a>. It’s implemented in Rust, it’s fast (GPU accelerated), easy to configure (YAML) and feels modern to use. Some features such as scrolling or splitting tabs are excluded in the name of simplicity. While this can present a turn-off, I haven’t noticed any drawbacks since tmux</code> has already been fulfilling these needs for me. Spongebob🔗</a></h2> This is a script</a> I wrote a while ago to aid me in using the mocking Spongebob</a> meme. Doesn’t rank that high on the utility spectrum but it’s fun enough. ❱ echo "you can't just automate yourself out of a job" | spongebob YoU CaN'T jUsT AuToMAte YoUrSeLf oUt Of A JoB </code></pre> ss</code>🔗</a></h2> Another script</a>. This one uses scrot</a> to take a screenshot of an area, save it to ~/Pictures</code> and copy it to clipboard. switch_sink</code>🔗</a></h2> This one</a> comes in handy when there are multiple audio outputs (sinks) configured in PulseAudio</a>. For example, as shown in pavucontrol</code>: </div> switch_sink</code> picks a random sink, sets it as default and moves all active streams to it. On my machine, it’s mapped to the XF86Tools</code></a> key. This lets me cycle all audio between the built-in laptop speakers, my external audio monitors and my bluetooth headphones at the press of a button. dslr_webcam.sh</code>🔗</a></h2> For the past year I’ve been using my friend’s DSLR camera as a webcam for video calls. I found a solution in the form of gphoto2</a> which can create a virtual video device, also known as a V4L2 loopback device. The script</a> uses gphoto2</code> and ffmpeg</code> to encode the stream. The camera I’m using has an old (maybe proprietary?) connector and is very limited in terms of bandwidth. As such, it can only go up to ~480p 24fps. Still, the picture quality is much better and I can make use of my camera tripod and lenses. On top of this, I don’t have to open my laptop in order to use the built-in webcam. xclip</code>🔗</a></h2> xclip</a> is a command line interface to X selections (clipboard). I use it for copying the output of certain commands to my clipboard. For example: $ cat /etc/hosts | xclip -selection clipboard </code></pre> It also works with images (see ss</code></a>). watch</code>🔗</a></h2> watch</a> repeats a command every N seconds and updates the output in-place. For example, monitoring CPU temperature: $ watch -n 1 'sensors | grep "Core"' </code></pre> Every 1.0s: sensors | grep "Core" Core 0: +44.0°C (high = +100.0°C, crit = +100.0°C) Core 1: +45.0°C (high = +100.0°C, crit = +100.0°C) </code></pre> Ranger🔗</a></h2> Ranger</a> is a text-based file explorer based on curses. It has been an essential tool for navigating and exploring remote machines. One of the most common non-trivial use cases is cleaning up large files. Ranger’s vi keybindings make this easy: vdcv</code> (invert selection, display cummulative sizes, invert again), followed by os</code> (order by size). Then go through the results, Space</code> to select and :delete</code> as needed. Conclusion🔗</a></h2> As with most things, I’ve barely scratched the surface of what some of these tools are capable of. My usual strategy relies on (1) discovering features organically, as needed and (2) occasionally doing a quick refresh of a particular tool. Most of the time this is as simple as scanning the docs or man page to see that else the tool can do. Sometimes it’s a more systematic approach, for example picking a random chapter of Practical Vim</a> and using that as a way to fill knowledge gaps.
Preserving Terminal Colors On The Web Unknown — Sat, 27 Feb 2021 00:00:00 +0000 There are a few different ways of adding code blocks to text-based web content, such as this blog post. I wanted to explore the available options in hope of finding a method that lets me preserve colors exactly as they are in the original text. Markdown🔗</a></h2> This post is mostly written in markdown. The built-in construct for a fenced code block (triple backticks) allows setting a language for syntax highlighting. For example: ```rust pub fn is_drive_document(&self) -> bool { self.drive_file .as_ref() .and_then(|f| f.mime_type.clone()) .map(|t| EXTENSIONS.contains_key::(&t)) == Some(true) } ``` </code></pre> Which renders as: pub fn is_drive_document(&self) -> bool { self.drive_file .as_ref() .and_then(|f| f.mime_type.clone()) .map(|t| EXTENSIONS.contains_key::<str>(&t)) == Some(true) } </code></pre> The actual list of supported languages depends on the syntax highlighting engine. Zola supports over 100</a> languages. GitHub uses linguist</a> which has over 500</a> language definitions. This works fantastically well when writing code blocks in any of these predefined languages. The drawbacks are few and fairly minor: edge cases such as incorrect highlighting when using newer features of some languages or having custom prompts/commands when writing console snippets. HTML + JavaScript🔗</a></h2> There are many libraries for highlighting code on the web. The usual workflow involves: Linking in a CSS and JS file, either locally or using a CDN.</li> Including a short script which triggers the highlighting logic.</li> Marking the HTML code elements with a certain class such that the highlighting library can identify them.</li> </ul> One such library is highlight.js</a>. I included it in this page using a CDN and triggered the highlighter with a custom script. Since I’m not using highlight.js everywhere, I want to be able to enable it explicitly on certain elements. <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/highlight.js/10.5.0/styles/default.min.css"> <script src="//cdnjs.cloudflare.com/ajax/libs/highlight.js/10.5.0/highlight.min.js"></script> </code></pre> // Only after the page has loaded. document.addEventListener("DOMContentLoaded", function() { // Highlight all <code class="highlightjs"> elements document.querySelectorAll('code.highlightjs').forEach(block => { hljs.highlightBlock(block); }); }); </code></pre> The same Rust snippet can then be included like this: <pre> <code class="highlightjs" class="rust"> // [...] </code> </pre> </code></pre> Which results in: pub fn is_drive_document(&self) -> bool { self.drive_file .as_ref() .and_then(|f| f.mime_type.clone()) .map(|t| EXTENSIONS.contains_key::(&t)) == Some(true) </code></pre> One advantage of this approach is the ability of customizing the library. You can choose to include only the languages that you care about. This reduces the payload and can make your web page load faster (compared to linking the complete library) as a result. Changing the colorscheme also becomes trivial. Just pick a different CSS from the available styles</a>. If highlight.js falls short in some way, there are many other alternatives to experiment with: SHJS</a></li> Rainbow</a></li> Prism</a></li> microlight.js</a></li> EnlighterJS</a></li> </ul> ANSI escapes🔗</a></h2> Previous solutions rely on the assumption that the highlightable content is written in a recognized, well-defined language and does not contain errors. This is not always true. In the past, I found myself in situations where I wanted to capture the output of a terminal session without losing any color information. It is possible to programmatically highlight console sessions</a> but it fails more often than not. This is increasingly problematic since many CLI tools benefit from color output nowadays. In most cases, colors increase readability and improve the user experience. But there are many different tools which use colors and the output can be virtually anything. No predefined structure which lends itself to easy color matching. In this case, you have to dig one layer deeper and access the ANSI escape codes</a>. These are binary sequences embedded into text which dictate how it should be displayed in terms of color, styling and other variables. The name comes from the first character in such a code which is usually an ASCII escape character. ANSI codes are used extensively by terminal emulators. However, they are for the most part not human readable. For example, the following mess converts into a nicely colored sentence: ^[[1;34mthis ^[[33mis ^[[31mcolored^[[32m text </code></pre> this is colored text </pre> In order to get this working, two things must be done: Capturing ANSI information🔗</a></h3> Copying and pasting colored text from a terminal emulator will most likely lose any color information. Redirecting all output to a file will likely do the same. This can be explained by an excerpt taken from the ls</code> manpage</a>: Using color to distinguish file types is disabled both by default and with --color=never. With --color=auto, ls emits color codes only when standard output is connected to a terminal. The LS_COLORS environment variable can change the settings. Use the dircolors command to set it.</pre> One workaround is to set --color=always</code> and redirect the output to a file. Of course, this solution only works for commands which have such a flag. It also gets messy when working with interactive programs, since it essentially separates away all user input. Instead of having a single interactive session, you end up with a blank terminal used only for input and another one for tail</code>-ing the output file. Not a great experience. Luckily, we have script</a>. This tool creates a log of a terminal session and saves it to disk: ~ ❱ script Script started, output log file is 'typescript'. ~ ❱ exa -l /srv dr-xr-xr-x - root 19 Jan 2:32 ftp drwxrwxr-x - sergiu 20 Feb 14:25 ghost drwxr-xr-x - sergiu 17 Feb 12:47 sergiu.org drwxr-xr-x - root 19 Jan 2:32 http drwxr-xr-x - http 10 Feb 14:57 manythanks ~ ❱ exit Script done. </code></pre> The result is a binary file which will show exactly the same terminal information when cat</code>. For what it’s worth, here’s what a hexdump</a> of it looks like. Fun fact: if script</code> is executed with timing information (-T, --log-timing file</code>) it can be replayed at a later time using script-replay</code>. This essentially simulates your shell interaction in real time. Converting ANSI to HTML🔗</a></h3> The captured logfile is not useful on its own. It needs to be converted to HTML tags which convey the same information in a human readable form. I found a few tools for doing this. The ones I tried are ansi2html</a> and aha</a>. In my limited testing, aha</code> provided better results and required less cleanup overall so I’m going to use it to illustrate this step. $ aha -f typescript --no-header > render.html </code></pre> The generated HTML is included below and looks much better than plaintext: ~ ❱ exa -l /srv dr-xr-xr-x - root 19 Jan 2:32 ftp drwxrwxr-x - sergiu 20 Feb 14:25 ghost drwxr-xr-x - sergiu 17 Feb 12:47 sergiu.org drwxr-xr-x - root 19 Jan 2:32 http drwxr-xr-x - http 10 Feb 14:57 manythanks ~ ❱ exit </code></pre> The tool is not perfect. In my personal setup, I use the fish</a> shell with many autocomplete plugins. Some of them output ANSII escape codes in real time as I’m typing. This messes up the log file so I have to manually go in and do some cleanup afterwards. Most of it boils down to carriage returns (^M</code>) and other unparsed garbage (special characters, partial autocomplete snippets, etc). I’ve tried the same exercise on bash with a blank .bashrc</code> and had much better results. There’s certainly room for improvement and refinements to be done. Conclusion🔗</a></h2> For the most part, I think the simple Markdown code blocks work best. But for anything terminal-related I would like to find a better workflow around ANSI codes and tools like aha</code>. Either fix the bad interaction with fish (possibly by turning off autocomplete suggestions temporarily) or maybe switch to bash altogether when recording terminal interaction snippets. Building This Blog With Zola Unknown — Wed, 10 Feb 2021 00:00:00 +0000 While looking for options of reviving my old blog, I initially wanted to use the same platform as before – Ghost</a>. After assessing the state of Ghost on Arch, I decided it’s probably not worth the effort so I did some research on HN</a>. Some solutions came up repeatedly: Bear</a> – this would have been my first choice but it does not currently support self hosting.</li> Micro.blog</a> – I want a free solution, especially as I am hosting it on my own server.</li> Blot</a> – same.</li> Medium</a> – there are no words for how much I hate paywalls and gated content. It’s also one of the reasons I stopped reading Quora</a> years ago. If your website is going to ask me to (1) disable my adbocker, (2) create a “free” account or (3) sign up for a paid subscription, I will just close it and move on with my life. On the same note, I have some resistance towards the whole concept of a centralized Internet. I don’t like big social networks. The Internet was more fun when it consisted of a bunch of personal websites that people hosted themselves. If this resonates with you, it’s also worth reading about POSSE</a>.</li> </ul> I eventually landed on Zola</a>, which I used to generate this website. I chose this engine for a few reasons: it generates a simple site. I don’t like complex/over-engineered services and bloated websites. I want a clean and simple landing page which is easy to navigate. This website is mostly a collection of Markdown files with some CSS thrown on top. </li> it’s implemented in Rust. I like Rust and have become familiar with it. As such, some concepts already come across more naturally. For example, Zola’s config is written in toml</a> which is already the de-facto standard</a> for Rust. </li> it’s easy to set up. The Arch User Repository</a> already includes zola</a> as a community package. </li> it’s a simple tool. To emphasize this point, just take a look at what the arch package contains: ~ ❱ trizen -Ql zola zola /usr/ zola /usr/bin/ zola /usr/bin/zola zola /usr/share/ zola /usr/share/licenses/ zola /usr/share/licenses/zola/ zola /usr/share/licenses/zola/LICENSE </code></pre> Just one binary and a LICENSE file. That’s it. </li> it has a built-in web server for local development. Although I now use nginx</a> to serve the static files, this was extremely useful in the beginning for just trying stuff out. </li> </ul> Setup and initial configuration🔗</a></h2> Installing Zola on Arch is straightforward. Note: I use trizen</a> instead of pacman</a>. ~ ❱ trizen -S zola :: Pacman command: /usr/bin/sudo /usr/bin/pacman -S resolving dependencies... looking for conflicting packages... Packages (1) zola-0.13.0-1 Total Download Size: 5.91 MiB Total Installed Size: 20.14 MiB :: Proceed with installation? [Y/n] y :: Retrieving packages... zola-0.13.0-1-x86_64 5.9 MiB 4.11 MiB/s 00:01 [#############################] 100% (1/1) checking keys in keyring [#############################] 100% (1/1) checking package integrity [#############################] 100% (1/1) loading package files [#############################] 100% (1/1) checking for file conflicts [#############################] 100% (1/1) checking available disk space [#############################] 100% :: Processing package changes... (1/1) installing zola [#############################] 100% :: Running post-transaction hooks... (1/1) Arming ConditionNeedsUpdate... </code></pre> The zola</code> binary exposes the init</code> command for initializing a blank website. I decided to create mine under /srv/sergiu.org</code> alongside some of the other web services I host: ~ ❱ sudo mkdir /srv/sergiu.org ~ ❱ sudo chown sergiu:users /srv/sergiu.org ~ ❱ cd /srv /srv ❱ zola init sergiu.org Welcome to Zola! Please answer a few questions to get started quickly. Any choices made can be changed by modifying the `config.toml` file later. > What is the URL of your site? (https://example.com): https://sergiu.org > Do you want to enable Sass compilation? [Y/n]: y > Do you want to enable syntax highlighting? [y/N]: y > Do you want to build a search index of the content? [y/N]: y Done! Your site was created in /srv/sergiu.org Get started by moving into the directory and using the built-in server: `zola serve` Visit https://www.getzola.org for the full documentation. </code></pre> This creates the following skeleton: /srv/sergiu.org ❱ tree . ├── config.toml ├── content ├── sass ├── static ├── templates └── themes 5 directories, 1 file </code></pre> Built-in web server🔗</a></h2> You can preview the website quickly using zola serve</code>. I’m using 0.0.0.0</code> instead of 127.0.0.1</code> in order to be able to access the server from outside the network. /srv/sergiu.org ❱ zola serve -u 0.0.0.0 -i 0.0.0.0 Building site... -> Creating 0 pages (0 orphan), 0 sections, and processing 0 images Done in 5ms. Web server is available at http://0.0.0.0:1111 Listening for changes in /srv/sergiu.org{config.toml, content, sass, static, templates} Press Ctrl+C to stop </code></pre> Which results in this: Now, the official documentation suggests a certain content structure</a> which is fairly intuitive. What I found more useful is this list of examples</a>, many of them having the source code publicly available. I personally like the design and structure used by Vincent Prouillet</a> (Zola’s creator) which I’ve adopted as a starting point for my website. All in all, this is the current file structure of this site: /srv/sergiu.org ❱ tree -I public # exclude the auto-generated "public" dir . ├── config.toml ├── content │ └── blog │ ├── _index.md │ ├── building-this-blog-with-zola │ │ ├── index.md │ │ ├── medium-login-wall.png │ │ ├── welcome-to-zola.png │ │ └── zola-welcome.png │ └── state-of-ghost-on-arch │ └── index.md ├── sass │ ├── _base.scss │ ├── _blog.scss │ ├── _layout.scss │ ├── _normalize.scss │ └── site.scss ├── static │ ├── Rubik-Regular.ttf │ └── thesis.pdf ├── templates │ ├── base.html │ ├── blog.html │ ├── index.html │ └── page.html └── themes 8 directories, 18 files </code></pre> Editing🔗</a></h2> Since most content is in the form of Markdown files, I can just ssh</code> into the server and write new content using a text editor. The content can be updated using zola build</code>. This renders the pages and exports everything as static files in the public</code> dir. I’ve added this line to my .vimrc</code> to rebuild the site every time I hit \zb</code>: nnoremap <Leader>zb :!cd /srv/sergiu.org; zola build<CR> </code></pre> This means there’s no “save draft” option. All changes I make while writing a post show up incrementally as I’m making progress. This is good enough for now, but in the long term I want to improve the workflow. A better approach would be to have a separate server which is protected against the outside world and only accessible by me. Once I finish writing a post and I’m happy with the result, I can push the changes to the live server. Storing the files on git is also a common practice with static websites. This is all future work though so I’m not going to throw myself completely down the rabbit hole quite yet. Deployment🔗</a></h2> As mentioned above, the static site is served by nginx: http { [...] server { listen 80; server_name sergiu.org; root /srv/sergiu.org/public; index index.html; error_page 404 404.html; location / { try_files $uri $uri/ =404; } } [...] } </code></pre> Putting the Fun in Function Optimization Unknown — Wed, 02 May 2018 00:00:00 +0000 The problem of finding the maximum (or minimum) of a real function is often encountered in real-life problems. This is especially true when the function describes how close a solution is to some pre-established aim. We as humans have the natural instinct of searching for better ways to do things: finding a shorter route to work</li> earning a higher grade while studying less</li> finding a balance between all areas of our lives which leads to highest level of happiness</li> and the list goes on</li> </ul> Naturally, not all of these targets are easily quantifiable or achievable, but constructing an appropriate model for such a complex problem is the first step towards solving it. The textbook way🔗</a></h2> There are many known methods</a> of finding the maximum (or minimum) of a real function. Some of the more popular ones - Gradient Descent</a>, for instance - became known in the mainstream CS community due to their applicability in Machine Learning</a> and their simplicity of implementation: function [theta, J_history] = gradientDescent(X, y, theta, alpha, num_iters) % GRADIENTDESCENT Performs gradient descent to learn theta % theta = GRADIENTDESENT(X, y, theta, alpha, num_iters) % updates theta by taking num_iters gradient steps with % learning rate alpha m = length(y); % number of training examples J_history = zeros(num_iters, 1); for iter = 1:num_iters rsum_0 = 0; rsum_1 = 0; for i=1:m, rsum_0 += (X(i,:) * theta - y(i)) * X(i, 1); rsum_1 += (X(i,:) * theta - y(i)) * X(i, 2); end theta = [theta(1) - (alpha / m) * rsum_0; theta(2) - (alpha / m) * rsum_1]; % Save the cost J in every iteration J_history(iter) = computeCost(X, y, theta); end </code></pre> The problem with such methods is their mathematical complexity. It is considerably more difficult to understand the inner workings and intuition behind gradient descent than it is to actually implement it. Coming up with the algorithm from first principles requires a strong mathematical background. Just opening the Wikipedia article</a> is enough to scare most programmers away, when they encounter this: A more intuitive way🔗</a></h2> Luckily, there is a class of heuristic-based optimization techniques which perform on-par with the mathematically proven™ methods, when tuned properly. Most of these algorithms are heavily inspired from natural phenomena, ranging from the movement of bees in a colony</a>, to Darwin</a>’s theory of evolution by natural selection</a>. Particle Swarm Optimization🔗</a></h3> This particular technique was initially designed as a model to represent the movement of flocks of birds or groups of fish. Later analysis showed that the algorithm was performing optimization. Assume that we want to minimize a $2$-dimensional real function (this method also works for $n$-dimensional functions). The main idea behind PSO can be described as follows: A particle represents a potential solution (i.e. a pair $(x, y)$). From this point forward, we will be refering to this pair as the position of the particle.</li> Additionally, each particle is assigned a velocity (i.e. a pair $(dx, dy)$).</li> Initially, a swarm of N randomly placed (or uniformly distributed) particles is generated in the function domain.</li> The fitness of each particle (i.e. how well it performs as a solution) is computed; this is equivalent to the actual value of the given function at the position of each particle. Our aim is to minimize this fitness.</li> Each particle keeps track of its best previously encountered position. In addition, we also keep track of the best position ever encountered by any particle in the swarm.</li> </ul> The optimization takes place over the span of multiple iterations. Every iteration works like this: Each particle moves to a new position, by adding its velocity to the current position. </li> The velocity is then recomputed as a weighted average of three factors: current velocity (weight $\omega$))</li> the best position of the particle (weight $\phi_{p_{i}}$)</li> the best position of the entire swarm (weight $\phi_{G}$)</li> </ul> # p and g are randomly generated in [-1.0, 1.0] # they act as mutations def updateVelocity(self, i, p, g): deltaParticle = self.bestPos[i] - self.pos[i] deltaSwarm = self.swarm.bestPos[i] - self.pos[i] newComponent = omega * self.velocity[i] \ + phiP * p * deltaParticle \ + phiG * g * deltaSwarm if i == 0: self.velocity = (newComponent, self.velocity[1]) else: self.velocity = (self.velocity[0], newComponent) </code></pre> </li> The best position for each particle and for the colony are updated. </li> </ul> There is a bit of work involved in choosing appropriate values for $\omega$, $\phi_{p_{i}}$ and $\phi_{G}$, but this job becomes considerably less difficult after understanding how each of these parameters affects the colony. This set of rules leads to a tremendously organic behaviour. There is no magic behind the scenes; it’s just particles that explore the problem domain while learning from their past experience and from each other. Testing🔗</a></h2> Wikipedia provides a list of functions</a> designed specifically for evaluating the performance of optimization algorithms. These are the results I obtained on a subset of them: McCormick🔗</a></h3> Formula: $f(x, y) = sin(x+y) + (x-y)^2 - 1.5x + 2.5y + 1$ Global minimum: $ f(-0.54719, -1.54719) = -1.9133 $ Best solution found: $ f(-0.54710, -1.54724) = -1.913223 $ Plot: </div> Your browser does not support the video tag. </video> Notes: There is a noticeable cluster of particles that gravitate around a local minimum, also visible in the function plot.</li> A set of $100$ particles and approximately $200$ iterations suffice for finding the global minimum with a precision of $ 10^{-3} $; further improvements require additional iterations.</li> </ul> Eggholder🔗</a></h3> Formula: $ f(x, y) = -(y+47) * sin \sqrt {\left | \frac{x}{2} + (y+47) \right |} - x * sin \sqrt{\left | x - (y+47) \right |} $ Global minimum: $ f(512, 404.2319) = -959.6407 $ Best solution found: $ f(482.03561, 432.59104) = -956.879905 $ Plot: </div> Your browser does not support the video tag. </video> Notes: Because of the numerous local minima of this function, we need to start with a larger set of particles ($500$), such that there is a higher chance of at least one particle being on the right track straight from the beginning.</li> Same as before, most particles tend to form clusters corresponding to local minima. This is a common problem encountered by Hill climbing</a> algorithms.</li> </ul> Rastrigin🔗</a></h3> Formula: $ f(x) = A*n + \sum_{i=1}^{n} \left [ x_{i}^{2} - A * cos \left ( 2 \pi x_{i} \right )\right ] $ where $A = 10$ and $x$ is an $n$-dimensional vector ($n=2$). Global minimum: $ f(0, 0) = 0 $ Best solution found: $ f(0.00181, 0.00083) = 0.000785 $ Plot: </div> Contour: Your browser does not support the video tag. </video> Notes: There are a couple of noticeable direction changes in the entire swarm (starting at iteration $40$ and $170$). This behavior illustrates the concept of swarm intelligence: as soon as a particle finds a new best solution for the colony, all other particles start to follow it.</li> The final placement of the swarm resembles the grid-like pattern shown in the contour plot.</li> </ul> Easom🔗</a></h3> Formula: $ f(x,y) = -cos \left ( x \right ) cos \left ( y \right ) exp \left ( -\left ( \left ( x - \pi \right )^{2} + \left ( y - \pi \right )^{2} \right ) \right ) $ Global minimum: $ f(\pi, \pi) = -1 $ Best solution found: $ f(3.14158, 3.14163) = -1.000000 $ Plot: </div> Your browser does not support the video tag. </video> Notes: Nice method for approximating the value of $\pi$. :)</li></li> In this simulation, I used a relatively large value for $\omega$. As a result, each particle tends to stick more to its current direction, which makes the particles’ paths more distinctive.</li> </ul> Cross-in-tray🔗</a></h3> Formula: $ f(x, y) = -(10^{-4}) \left [ \left | sin\left ( x \right ) sin\left ( y \right ) exp \left ( \left | 100 - \frac{\sqrt{x^{2}+y^{2}}}{\pi} \right | \right ) \right | + 1 \right ]^{0.1} $ Global minimum: $ f(\pm1.34941, \pm1.34941) = -2.06261 $ Best solution found: $ f(1.34830, 1.34880) = -2.062612 $ Plot: </div> Your browser does not support the video tag. </video> Notes: All 4 global minima are discovered.</li> Similar to the Rastrigin</a> function, the entire swarm changes direction once a better solution is found.</li> </ul> Conclusion🔗</a></h2> Optimization techniques usually behave really well on real functions, but they are not limited to this scope. I chose this application because it can provide insightful data visualization more easily than other use cases. The code can be found on GitHub</a>.

sergiu.org

Things I want to 3D print

Project Euler #213: Flea Circus

Project Euler #100: Arranged probability

Project Euler #429: Sum of squares of unitary divisors

Favorite CLI tools (and some GUIs too)

Preserving Terminal Colors On The Web

HTML + JavaScript🔗</a></h2> There are many libraries for highlighting code on the web. The usual workflow involves:</p> Linking in a CSS and JS file, either locally or using a CDN.</li> Including a short script which triggers the highlighting logic.</li>

Building This Blog With Zola

Putting the Fun in Function Optimization

Testing🔗</a></h2> Wikipedia provides a list of functions</a> designed specifically for evaluating the performance of optimization algorithms. These are the results I obtained on a subset of them:</p>

Testing🔗</a></h2>
Wikipedia provides a list of functions</a> designed specifically for evaluating the performance of optimization algorithms. These are the results I obtained on a subset of them:</p>