Zola2026-02-11T00:00:00+00:00https://6ai6.com/atom.xmlAdding audio to your blog2026-02-11T00:00:00+00:002026-02-11T00:00:00+00:00
Thomas Weitzel
https://6ai6.com/blog/audio-player-shortcode/<p>There are two practical ways to add audio to a blog: use the native <code><audio></code> element or render a custom player with JavaScript.
The <a rel="external" href="https://www.getzola.org/">Zola</a> theme <a rel="external" href="https://github.com/thomasweitzel/zolarwind">Zolarwind</a> provides two shortcodes that map to those choices: <code>audio_simple</code> uses the native element, <code>audio</code> uses a custom player.
Both are usable as-is, and the choice comes down to how much control you want over the player UI.</p>
<h2 id="the-baseline-native-audio">The baseline native <code><audio></code></h2>
<p>You get built-in controls and good accessibility.
If you are fine with browser-native styling, this is the fastest path.</p>
<pre class="giallo z-code"><code data-lang="html"><span class="giallo-l"><span class="z-punctuation z-definition z-tag z-begin"><</span><span class="z-entity z-name z-tag">audio</span><span class="z-entity z-entity z-other z-attribute-name"> controls</span><span class="z-punctuation z-definition z-tag z-end">></span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-tag z-begin"> <</span><span class="z-entity z-name z-tag">source</span><span class="z-entity z-entity z-other z-attribute-name"> src</span><span class="z-punctuation z-separator">=</span><span class="z-string">"</span><span class="z-string">audio.mp3</span><span class="z-string">"</span><span class="z-entity z-entity z-other z-attribute-name"> type</span><span class="z-punctuation z-separator">=</span><span class="z-string">"</span><span class="z-string">audio/mpeg</span><span class="z-string">"</span><span class="z-punctuation z-definition z-tag z-end">></span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-tag z-begin"></</span><span class="z-entity z-name z-tag">audio</span><span class="z-punctuation z-definition z-tag z-end">></span></span></code></pre><audio controls>
<source src="audio.mp3" type="audio/mpeg">
</audio>
<p>The tradeoff is consistency. Browsers style the element differently, and you get limited control over the UI.</p>
<h2 id="audio-simple-shortcode"><code>audio_simple</code> shortcode</h2>
<p>This wraps the native element and keeps the setup small.
It uses no JavaScript, like the baseline audio element, but adds a small amount of CSS for layout.</p>
<pre class="giallo z-code"><code data-lang="ini"><span class="giallo-l"><span>{{ audio_simple(</span></span>
<span class="giallo-l"><span class="z-keyword"> src</span><span class="z-punctuation z-separator">=</span><span class="z-string">"</span><span class="z-string">audio.mp3</span><span class="z-string">"</span><span>,</span></span>
<span class="giallo-l"><span class="z-keyword"> title</span><span class="z-punctuation z-separator">=</span><span class="z-string">"</span><span class="z-string">Audio in your blog</span><span class="z-string">"</span><span>,</span></span>
<span class="giallo-l"><span class="z-keyword"> year</span><span class="z-punctuation z-separator">=</span><span class="z-string">"</span><span class="z-string">2026</span><span class="z-string">"</span><span>,</span></span>
<span class="giallo-l"><span class="z-keyword"> artist</span><span class="z-punctuation z-separator">=</span><span class="z-string">"</span><span class="z-string">Female Speaker</span><span class="z-string">"</span><span>,</span></span>
<span class="giallo-l"><span class="z-keyword"> label</span><span class="z-punctuation z-separator">=</span><span class="z-string">"</span><span class="z-string">Blog of Thomas Weitzel</span><span class="z-string">"</span><span>)</span></span>
<span class="giallo-l"><span>) }}</span></span></code></pre><div class="container max-w-md my-6 py-6 px-6 text-black dark:text-black bg-gradient-to-tr from-ok-600 to-primary-800 rounded-2xl overflow-hidden">
<div class="text-center relative">
<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="h-16 w-16 inline-block">
<path stroke-linecap="round" stroke-linejoin="round" d="M12 18.75a6 6 0 006-6v-1.5m-6 7.5a6 6 0 01-6-6v-1.5m6 7.5v3.75m-3.75 0h7.5M12 15.75a3 3 0 01-3-3V4.5a3 3 0 116 0v8.25a3 3 0 01-3 3z" />
</svg>
</div>
<div class="mb-6 text-center relative">
<h2 class="inline-block font-medium">Audio in your blog</h2>
<p class="inline-block font-medium text-sm">Female Speaker | Blog of Thomas Weitzel | 2026</p>
</div>
<audio controls src="audio.mp3" style="width: 100%">Your browser does not support the audio element.</audio>
</div>
<h2 id="custom-player">Custom player</h2>
<p>If you want a consistent player UI across browsers, the <code>audio</code> shortcode renders a custom player with JavaScript.
The native <code><audio></code> controls are not used; the UI is fully custom.</p>
<pre class="giallo z-code"><code data-lang="ini"><span class="giallo-l"><span>{{ audio(</span></span>
<span class="giallo-l"><span class="z-keyword"> src</span><span class="z-punctuation z-separator">=</span><span class="z-string">"</span><span class="z-string">audio.mp3</span><span class="z-string">"</span><span>,</span></span>
<span class="giallo-l"><span class="z-keyword"> length</span><span class="z-punctuation z-separator">=</span><span class="z-string">"</span><span class="z-string">0:48</span><span class="z-string">"</span><span>,</span></span>
<span class="giallo-l"><span class="z-keyword"> title</span><span class="z-punctuation z-separator">=</span><span class="z-string">"</span><span class="z-string">Audio in your blog</span><span class="z-string">"</span><span>,</span></span>
<span class="giallo-l"><span class="z-keyword"> year</span><span class="z-punctuation z-separator">=</span><span class="z-string">"</span><span class="z-string">2026</span><span class="z-string">"</span><span>,</span></span>
<span class="giallo-l"><span class="z-keyword"> artist</span><span class="z-punctuation z-separator">=</span><span class="z-string">"</span><span class="z-string">Female Speaker</span><span class="z-string">"</span><span>,</span></span>
<span class="giallo-l"><span class="z-keyword"> label</span><span class="z-punctuation z-separator">=</span><span class="z-string">"</span><span class="z-string">Blog of Thomas Weitzel</span><span class="z-string">"</span><span>)</span></span>
<span class="giallo-l"><span>) }}</span></span></code></pre><div
class="container max-w-md my-6 py-6 px-6 text-black dark:text-black bg-gradient-to-tr from-primary-600 to-warn-800 rounded-2xl overflow-hidden"
data-audio-id="1"
data-audio-src="audio.mp3"
>
<div class="text-center relative">
<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="h-16 w-16 inline-block">
<path stroke-linecap="round" stroke-linejoin="round" d="M12 18.75a6 6 0 006-6v-1.5m-6 7.5a6 6 0 01-6-6v-1.5m6 7.5v3.75m-3.75 0h7.5M12 15.75a3 3 0 01-3-3V4.5a3 3 0 116 0v8.25a3 3 0 01-3 3z" />
</svg>
</div>
<div class="mb-6 text-center relative">
<h2 class="inline-block font-medium">Audio in your blog</h2>
<p class="inline-block font-medium text-sm">Female Speaker | Blog of Thomas Weitzel | 2026</p>
</div>
<div class="audio-controls1 flex space-x-1">
<div class="play-div1 flex-none hover:text-fail-600">Loading ...</div>
<div class="time-div1 flex-none pr-2">00:00 | 0:48</div>
<div class="flex-auto cursor-pointer select-none mt-2">
<div class="progress-container1 w-full bg-primary-700 rounded-full h-2 dark:bg-neutral-200">
<div class="progress-bar1 bg-neutral-800 h-2 rounded-full hover:bg-fail-600" style="width: 0%"></div>
</div>
</div>
<div class="speaker-div1 flex-none pl-2 hover:text-fail-600"></div>
</div><script src="https://6ai6.com/js/audio/howler.js" integrity="sha384-B3AhJtVepaXjzRprLH6ZMkrOI+XDduqXmwhe4m+RDATUkM8o1I2STFsig6dra4XF"></script>
<script src="https://6ai6.com/js/audio/audio-player.js" integrity="sha384-uM+RjXS/SiYym8NXLgoHFdNXVU0dZFjg9FyWhppQgkb0RJd1dnp7H+Pom5azyaMI"></script>
<script src="https://6ai6.com/js/audio/audio-init.js" integrity="sha384-MxFc2CYeIiCM4XDzrORmIy9R06BD/FQLTHq71ZIlTY/tJCqi3Isa8/o+yKSFg1Vc"></script></div>
<p>I prefer the <code>audio</code> shortcode, because I want a stable player UI across browsers.
<code>audio_simple</code> stays in the toolbox because it keeps the setup small and uses no extra JavaScript.</p>
<h2 id="notes">Notes</h2>
<ul>
<li>The shortcodes expect local assets, not remote URLs.</li>
<li><code>zola serve</code> does not support range requests as of 0.22.1, so Chrome cannot seek properly. Use a static server for testing.</li>
</ul>
Search2026-01-14T00:00:00+00:002026-01-14T00:00:00+00:00
Thomas Weitzel
https://6ai6.com/pages/search/Diagrams with Mermaid2023-10-29T00:00:00+00:002023-10-29T00:00:00+00:00
Thomas Weitzel
https://6ai6.com/blog/mermaid/<h2 id="what-are-mermaid-diagrams">What are Mermaid diagrams?</h2>
<p><a rel="external" href="https://mermaid.js.org">Mermaid</a> is a syntax similar to Markdown where you can use text to describe and automatically generate diagrams.
With Mermaid, you can generate
<a rel="external" href="https://mermaid.js.org/syntax/flowchart.html">Flow charts</a>,
<a rel="external" href="https://mermaid.js.org/syntax/classDiagram.html">UML diagrams</a>,
<a rel="external" href="https://mermaid.js.org/syntax/pie.html">Pie charts</a>,
<a rel="external" href="https://mermaid.js.org/syntax/gantt.html">Gantt diagrams</a>,
<a rel="external" href="https://mermaid.js.org/syntax/entityRelationshipDiagram.html">Entity Relationship diagrams</a>,
and more.</p>
<h2 id="an-entity-relationship-diagram-example">An Entity Relationship diagram example</h2>
<pre class="mermaid">
%%{ init: {'theme': 'forest'} }%%
erDiagram
CUSTOMER ||--o{ ORDER : places
ORDER ||--|{ LINEITEM : contains
PRODUCT ||--o{ LINEITEM : is_listed_in
CUSTOMER {
string Name
string Email
string Address
}
PRODUCT {
string ProductName
float Price
}
ORDER {
date DateOrdered
string Status
}
LINEITEM {
int Quantity
}
</pre>
<h2 id="using-mermaid-in-your-blog-post">Using Mermaid in your blog post</h2>
<p>The diagram shortcode allows you to easily embed Mermaid diagrams in your blog posts, with an option to configure its appearance.</p>
<h3 id="basic-usage">Basic Usage</h3>
<p>To use the shortcode in your blog post, you would use the following format:</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-meta z-block">{</span><span class="z-keyword z-keyword z-operator">%</span><span class="z-entity z-name z-function"> diagram</span><span class="z-meta z-block">(</span><span class="z-meta z-block">)</span><span class="z-keyword z-keyword z-operator"> %</span><span class="z-meta z-block">}</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable">Your</span><span class="z-variable z-other z-variable"> Mermaid</span><span class="z-variable z-other z-variable"> diagram</span><span class="z-variable z-other z-variable"> code</span><span class="z-variable z-other z-variable"> here</span></span>
<span class="giallo-l"><span class="z-meta z-block">{</span><span class="z-keyword z-keyword z-operator">%</span><span class="z-variable z-other z-variable"> end</span><span class="z-keyword z-keyword z-operator"> %</span><span class="z-meta z-block">}</span></span></code></pre>
<p>Replace <em>Your Mermaid diagram code here</em> with your actual Mermaid diagram code.</p>
<p>To load the necessary JavaScript to render the Mermaid diagram, you need to enable it in the front matter of your blog post by setting the value for <code>extra.diagram</code> to <code>true</code>:</p>
<pre class="giallo z-code"><code data-lang="ini"><span class="giallo-l"><span>+++</span></span>
<span class="giallo-l"><span class="z-entity z-name">[</span><span class="z-entity z-name">extra</span><span class="z-entity z-name">]</span></span>
<span class="giallo-l"><span class="z-keyword">diagram</span><span class="z-punctuation z-separator"> =</span><span> true</span></span>
<span class="giallo-l"><span>+++</span></span></code></pre><h3 id="configuring-the-appearance">Configuring the Appearance</h3>
<p>The shortcode supports an optional <code>init</code> parameter that allows you to specify configuration options for Mermaid,
particularly changing the appearance of the diagrams through the theme.</p>
<p>For example, to apply the <code>forest</code> theme:</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-meta z-block">{</span><span class="z-keyword z-keyword z-operator">%</span><span class="z-entity z-name z-function"> diagram</span><span class="z-meta z-block">(</span><span class="z-variable z-other z-variable">init</span><span class="z-keyword z-keyword z-operator">=</span><span class="z-string">"</span><span class="z-string">{'theme': 'forest'}</span><span class="z-string">"</span><span class="z-meta z-block">)</span><span class="z-keyword z-keyword z-operator"> %</span><span class="z-meta z-block">}</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable">Your</span><span class="z-variable z-other z-variable"> Mermaid</span><span class="z-variable z-other z-variable"> diagram</span><span class="z-variable z-other z-variable"> code</span><span class="z-variable z-other z-variable"> here</span></span>
<span class="giallo-l"><span class="z-meta z-block">{</span><span class="z-keyword z-keyword z-operator">%</span><span class="z-variable z-other z-variable"> end</span><span class="z-keyword z-keyword z-operator"> %</span><span class="z-meta z-block">}</span></span></code></pre><h3 id="providing-init-configuration">Providing init Configuration</h3>
<p>When using the <code>init</code> parameter, the configuration should be a string wrapped in double quotes.
Inside this string, use single quotes for keys and values.</p>
<p>Here's a more advanced example with multiple configuration options:</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-meta z-block">{</span><span class="z-keyword z-keyword z-operator">%</span><span class="z-entity z-name z-function"> diagram</span><span class="z-meta z-block">(</span><span class="z-variable z-other z-variable">init</span><span class="z-keyword z-keyword z-operator">=</span><span class="z-string">"</span><span class="z-string">{'theme': 'forest', 'themeVariables': {'primaryColor': '#FF0000'}}</span><span class="z-string">"</span><span class="z-meta z-block">)</span><span class="z-keyword z-keyword z-operator"> %</span><span class="z-meta z-block">}</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable">Your</span><span class="z-variable z-other z-variable"> Mermaid</span><span class="z-variable z-other z-variable"> diagram</span><span class="z-variable z-other z-variable"> code</span><span class="z-variable z-other z-variable"> here</span></span>
<span class="giallo-l"><span class="z-meta z-block">{</span><span class="z-keyword z-keyword z-operator">%</span><span class="z-variable z-other z-variable"> end</span><span class="z-keyword z-keyword z-operator"> %</span><span class="z-meta z-block">}</span></span></code></pre>
<p>In this example, we're using the <code>forest</code> theme and changing the primary color to red (<code>#FF0000</code>).</p>
<p><strong>Note</strong>: Ensure that you use single quotes inside the double quotes for the configuration to work correctly.</p>
<h3 id="putting-it-all-together">Putting it all together</h3>
<p>Use the shortcode by enclosing your Mermaid diagram code with it.
To change the look of the Mermaid theme, provide values for the <code>init</code> parameter.
Always enclose the <code>init</code> value with double quotes, and use single quotes inside the configuration string.
With this shortcode in place, integrating and customizing Mermaid diagrams in your blog posts becomes easy.</p>
<h2 id="explaining-mermaid-diagram-code">Explaining Mermaid diagram code</h2>
<p>Here is how the diagram rendered above is embedded in this blog post as a code block.
Because it is the same code as the diagram above, extra care has to be taken to prevent Mermaid from rendering it as a diagram.
Use Zola’s <a rel="external" href="https://www.getzola.org/documentation/content/shortcodes/#shortcodes-without-body">ignored shortcode syntax</a> in the code block, so the code stays visible but is not executed.
For example, use <code>{%/*</code> for displaying <code>{%</code>, and <code>*/%}</code> for displaying <code>%}</code>.</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-meta z-block">{</span><span class="z-keyword z-keyword z-operator">%</span><span class="z-entity z-name z-function"> diagram</span><span class="z-meta z-block">(</span><span class="z-variable z-other z-variable">init</span><span class="z-keyword z-keyword z-operator">=</span><span class="z-string">"</span><span class="z-string">{'theme': 'forest'}</span><span class="z-string">"</span><span class="z-meta z-block">)</span><span class="z-keyword z-keyword z-operator"> %</span><span class="z-meta z-block">}</span></span>
<span class="giallo-l"><span class="z-variable z-other z-constant z-variable"> CUSTOMER</span><span class="z-keyword z-keyword z-operator"> ||</span><span class="z-keyword z-keyword z-operator">--</span><span class="z-variable z-other z-variable">o</span><span class="z-meta z-block">{</span><span class="z-entity z-name"> ORDER</span><span class="z-meta z-block z-punctuation z-separator"> :</span><span class="z-variable z-other z-variable"> places</span></span>
<span class="giallo-l"><span class="z-variable z-other z-constant z-variable"> ORDER</span><span class="z-keyword z-keyword z-operator"> ||</span><span class="z-keyword z-keyword z-operator">--</span><span class="z-keyword z-keyword z-operator">|</span><span class="z-meta z-block">{</span><span class="z-entity z-name"> LINEITEM</span><span class="z-meta z-block z-punctuation z-separator"> :</span><span class="z-variable z-other z-variable"> contains</span></span>
<span class="giallo-l"><span class="z-variable z-other z-constant z-variable"> PRODUCT</span><span class="z-keyword z-keyword z-operator"> ||</span><span class="z-keyword z-keyword z-operator">--</span><span class="z-variable z-other z-variable">o</span><span class="z-meta z-block">{</span><span class="z-entity z-name"> LINEITEM</span><span class="z-meta z-block z-punctuation z-separator"> :</span><span class="z-variable z-other z-variable"> is_listed_in</span></span>
<span class="giallo-l"><span class="z-variable z-other z-constant z-variable"> CUSTOMER</span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable"> string</span><span class="z-variable z-other z-variable"> Name</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable"> string</span><span class="z-variable z-other z-variable"> Email</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable"> string</span><span class="z-variable z-other z-variable"> Address</span></span>
<span class="giallo-l"><span class="z-meta z-block"> }</span></span>
<span class="giallo-l"><span class="z-variable z-other z-constant z-variable"> PRODUCT</span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable"> string</span><span class="z-variable z-other z-variable"> ProductName</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable"> float</span><span class="z-variable z-other z-variable"> Price</span></span>
<span class="giallo-l"><span class="z-meta z-block"> }</span></span>
<span class="giallo-l"><span class="z-variable z-other z-constant z-variable"> ORDER</span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable"> date</span><span class="z-variable z-other z-variable"> DateOrdered</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable"> string</span><span class="z-variable z-other z-variable"> Status</span></span>
<span class="giallo-l"><span class="z-meta z-block"> }</span></span>
<span class="giallo-l"><span class="z-variable z-other z-constant z-variable"> LINEITEM</span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable"> int</span><span class="z-variable z-other z-variable"> Quantity</span></span>
<span class="giallo-l"><span class="z-meta z-block"> }</span></span>
<span class="giallo-l"><span class="z-meta z-block">{</span><span class="z-keyword z-keyword z-operator">%</span><span class="z-variable z-other z-variable"> end</span><span class="z-keyword z-keyword z-operator"> %</span><span class="z-meta z-block">}</span></span></code></pre>Internal rate of return calculation2023-07-29T00:00:00+00:002023-07-29T00:00:00+00:00
Thomas Weitzel
https://6ai6.com/blog/calculating-internal-interest-rate/<p>The internal rate of return (IRR) is a potent financial measure used in financial analysis, accounting, and portfolio management to gauge the profitability of investments.
It's like the heartbeat of an investment - an indicator of health, the higher it is, the better the investment.
This powerful tool can help investors compare different investment options, assisting in making informed decisions about where to allocate their capital.
Especially when cash flows are irregular, as often is the case in real-world scenarios, IRR becomes invaluable.
This article will first explain the concept and calculations behind IRR and then demonstrate how to implement an IRR algorithm in Rust.</p>
<h2 id="irr-vs-xirr-terminology">IRR vs. XIRR terminology</h2>
<p>The IRR is the rate of return that makes the net present value (NPV) of all cash flows (both positive and negative) from a particular investment equal to zero.
It's sometimes used for cash flows at regular, usually annual, intervals.
I will not make this assumption in this article.
While Microsoft uses the name XIRR for its Excel function, I will use the term IRR throughout this article, even though the cash flows do not occur at regular intervals.</p>
<h2 id="example-data-and-validation">Example data and validation</h2>
<p>A crucial part of implementing a financial algorithm like IRR is validation. That is, making sure that your algorithm is producing correct and expected results.
One effective way to validate your implementation is by comparing its outputs to those of <a rel="external" href="https://support.microsoft.com/en-gb/office/xirr-function-de1242ec-6477-445b-b11b-a303ad9adc9d">Microsoft Excel's XIRR function</a>.
I will use the data from the Excel example.
Using Excel's XIRR function to compute the internal rate of return for this specific data set yields a result of
<span class="math math-inline">$37.34\%$</span>
.</p>
<table><thead><tr><th style="text-align: right">$\textbf{i}$</th><th>ISO Date $\textbf{d}$</th><th style="text-align: right">Years since first cash flow $\textbf{y}$</th><th style="text-align: right">Payment $\textbf{p}$</th></tr></thead><tbody>
<tr><td style="text-align: right">1</td><td>2008-01-01</td><td style="text-align: right">0.0000</td><td style="text-align: right">-10,000</td></tr>
<tr><td style="text-align: right">2</td><td>2008-03-01</td><td style="text-align: right">0.1644</td><td style="text-align: right">2,750</td></tr>
<tr><td style="text-align: right">3</td><td>2008-10-30</td><td style="text-align: right">0.8301</td><td style="text-align: right">4,250</td></tr>
<tr><td style="text-align: right">4</td><td>2009-02-15</td><td style="text-align: right">1.1260</td><td style="text-align: right">3,250</td></tr>
<tr><td style="text-align: right">5</td><td>2009-04-01</td><td style="text-align: right">1.2493</td><td style="text-align: right">2,750</td></tr>
</tbody></table>
<h2 id="how-irr-works">How IRR works</h2>
<p>The IRR is calculated by finding the rate of return that would make the net present value (NPV) of an investment equal to zero.
The NPV is the sum of the present values of all future cash flows from an investment.
The derivative of the NPV is used to find the IRR.
The derivative of the NPV is the rate of change of the NPV with respect to the interest rate.</p>
<p>The IRR algorithm is an instance of the <a rel="external" href="https://en.wikipedia.org/wiki/Newton%27s_method">Newton-Raphson method</a>,
which is a root-finding algorithm that produces successively better approximations to the roots (or zeroes) of a real-valued function.
To calculate the IRR, you need an array with pairs of data: one is the date of a cash flow, and the other is its payment amount.
You also need an initial guess for the IRR rate, which is often set as
<span class="math math-inline">$10\%$</span>
or $0.1$.</p>
<p>Here's the general process of the algorithm:</p>
<ol>
<li><strong>Compute the net present value (NPV)</strong>: The NPV is calculated by summing the present values of the individual cash flows.</li>
<li><strong>Compute the derivative of the NPV</strong>: The derivative of the NPV with respect to the rate is created by differentiating the NPV formula and summing these values.</li>
<li><strong>Update the guess</strong>: The next guess for the rate is calculated by subtracting the ratio of the NPV to its derivative from the current guess.</li>
<li><strong>Iterate until convergence</strong>: These steps are repeated until the change in guesses is below a certain tolerance or until a maximum number of iterations is reached.
At this point, the guess for the rate is considered to be the IRR.</li>
</ol>
<h2 id="compute-the-net-present-value-npv">Compute the net present value (NPV)</h2>
<p>Here, $y_i$ represents the number of years that have passed since the first cash flow,
calculated as the difference in days between the date of the $i$-th cash flow $d_i$ and the date of the first cash flow $d_1$,
divided by 365 (days in one year).
I have pre-calculated it in the table above:</p>
<p>$$y_i = \frac{d_i - d_1}{365}$$</p>
<p>The NPV is the sum of all payments, where the correct interest rate $irr$ is applied.
Its value is 0 after all transactions have been concluded:</p>
<p>$$\mathit{NPV} = \sum_{i = 1}^{m} \frac{p_i}{(1 + irr)^{y_i}}$$</p>
<p>When you <a rel="external" href="https://www.wolframalpha.com/input?i=plot+-10000*%281%2F%281+%2B+x%29%5E%280.0000%29%29+%2B+2750*%281%2F%281+%2B+x%29%5E%280.1644%29%29+%2B+4250*%281%2F%281+%2B+x%29%5E%280.8301%29%29+%2B+3250*%281%2F%281+%2B+x%29%5E%281.1260%29%29+%2B+2750*%281%2F%281+%2B+x%29%5E%281.2493%29%29+from+x%3D-0.1+to+0.9">plot</a> the NPV function as a function of $irr$,
you are essentially varying the interest rate and observing how it affects the NPV.
Here's what you see on the graph below, which plots the NPV as a function of the rate with the values from the table above:</p>
<ul>
<li><strong>X-axis</strong>: The x-axis represents the interest rate $irr$.
It typically ranges from
<span class="math math-inline">$0\%$</span>
to a reasonable upper limit, depending on the context of your problem.</li>
<li><strong>Y-axis</strong>: The y-axis represents the net present value NPV.
It's the cumulative sum of the discounted cash flows according to the given formula.</li>
<li><strong>Shape of the curve</strong>: The curve of the NPV function will generally be downward-sloping.
This is because as you increase the interest rate $irr$, the present value of future cash flows decreases.
Higher interest rates mean that future cash flows are being discounted more heavily, which reduces their present value.</li>
<li><strong>Break-even point</strong>: There will be a point on the graph where the NPV curve intersects the x-axis.
It's where our $irr$ satisfies the condition $\mathit{NPV} = 0$.
For our data, it is somewhere between $0.35$ and $0.40$, or
<span class="math math-inline">$35\%$</span>
and
<span class="math math-inline">$40\%$</span>
.</li>
</ul>
<figure class="mt-4"><span class="light-dark-image inline-block">
<img class="block image-shortcode" src="https://6ai6.com/blog/calculating-internal-interest-rate/irr-npv-function-light.webp" alt="Plot of the NPV as a function of the rate with the values from the table" width="560" height="360" loading="lazy" decoding="async">
<img class="block image-shortcode" src="https://6ai6.com/blog/calculating-internal-interest-rate/irr-npv-function-dark.webp" alt="Plot of the NPV as a function of the rate with the values from the table" width="560" height="360" loading="lazy" decoding="async">
</span>
<figcaption class="italic">Downward-sloping NPV curve</figcaption>
</figure>
<p>The above formula is a sum of function terms.
Applying the <a rel="external" href="https://en.wikipedia.org/wiki/Superposition_principle">superposition principle</a>,
we can split the sum into individual function terms, which look all the same.
For each cash flow, we have a function term, which is the present value of the cash flow.
The important part is that we can apply this principle to the NPV function <strong>and</strong> the derivative of the NPV function.</p>
<p>With $irr$ written as $x$, each function term looks like this, where $p_i$ and $y_i$ are just constants.
$f_i(x)$ represents the NPV for a single cash flow, the $i$-th one:</p>
<p>$$f_i(x) = \frac{p_i}{(1 + x)^{y_i}}$$</p>
<p>The amount $p_i$ is discounted in the NPV calculation to reflect the time value of money. Here's an explanation for why that's done:</p>
<ul>
<li><strong>Time value of money</strong>: Money available today is worth more than the same amount in the future because of its potential earning capacity.
This core principle of finance holds that, provided money can earn interest, any amount of money is worth more the sooner it is received.</li>
<li><strong>Discounting future cash flows</strong>: In the context of the internal rate of return (IRR) and net present value (NPV), this principle is applied to future cash flows.
The $p_i$ represents a payment (cash flow) at some future date. To compare this future value to present values,
it needs to be discounted back to its value in today's terms.</li>
<li><strong>The discount factor</strong>: The expression $\frac{1}{(1 + x)^{y_i}}$ serves as a discount factor, where $x$ is the internal rate of return, and $y_i$ is the number of years that have passed since the first cash flow.
This factor is derived from the formula for compounding interest in reverse (discounting rather than compounding).</li>
<li><strong>Sum of discounted payments</strong>: The NPV is the sum of these discounted payments. By discounting each future cash flow back to its present value,
the NPV provides a consistent basis for comparing the value of cash flows across different time periods.</li>
<li><strong>Understanding the equation</strong>: The equation $f_i(x) = \frac{p_i}{(1 + x)^{y_i}}$ represents the present value of the $i$-th cash flow.
It shows how each cash flow is discounted back to present value terms using the discount factor.</li>
</ul>
<p>Discounting the $p_i$ in the NPV calculation allows for a proper comparison of cash flows across different time periods,
taking into account the time value of money and the specific internal rate of return (IRR) required from the investment.
It ensures that future cash flows are appropriately weighed against the potential earning capacity of money in the present.</p>
<h3 id="but-what-happens-if">But what happens if ...</h3>
<p>The expression $(1 + x)^{y_i}$ can become a problem if $x < -1$ (less than
<span class="math math-inline">$-100\%$</span>
), because raising a negative number to a non-integer power will result in a complex number.
Within the realm of real numbers, this operation is undefined.
For example, consider a case where $x = -1.1$ and $y_i$ is a floating point number like $0.4$.
Then, $(1 + x)$ will be negative, and raising it to the $y_i$ power <a rel="external" href="https://www.wolframalpha.com/input?i=%281+-+1.1%29%5E%280.4%29">produces a complex value</a>:
${(1 - 1.1)}^{0.4} \approx 0.12 + 0.38 i$</p>
<p>In the context of finance and the calculation of IRR, it doesn't make sense to have complex numbers as they don't have a practical interpretation in terms of cash flows or discount rates.
Therefore, you would typically ensure that the rate $x$ stays within the range where the calculation remains within the realm of real numbers.
If you're working with cash flows and discount rates, you may want to either avoid or handle situations where $x < -1$ by constraining the value of $x$ within a reasonable range or taking some other specific action if $x$ falls outside that range.</p>
<p>In practice, it's rare that you would come across this scenario.</p>
<h2 id="compute-the-derivative-of-the-npv">Compute the derivative of the NPV</h2>
<p>We can now apply the <a rel="external" href="https://www.wolframalpha.com/input?i=derivative+of+a+%2F+%28%281+%2B+x%29%5Eb%29">basic differentiation rules</a> to get the derivative of $f_i(x)$.
It represents the derivative of the NPV for a single cash flow, also the $i$-th one:</p>
<p>$$f_i^\prime(x) = \frac{-y_i \cdot p_i}{(1 + x)^{y_i + 1}}$$</p>
<h2 id="update-the-guess">Update the guess</h2>
<p>The <a rel="external" href="https://en.wikipedia.org/wiki/Newton%27s_method">Newton-Raphson method</a> is an iterative process used to locate the roots of a differentiable function, i.e. a solution for $x$ where $f(x) = 0$.
The method begins with an initial estimate $x_n$, which is then refined into a more accurate guess, $x_{n+1}$.
This stage is where the NPV and its derivative come into play.
Instead of solely employing $f_i(x_n)$ and $f_i^\prime(x_n)$ for a single cash flow, we incorporate all the cash flows by adding up the NPV terms and derivative terms respectively:</p>
<p>$$x_{n+1} = x_{n} - \frac{\sum_{i = 1}^{m} f_i(x_n)}{\sum_{i = 1}^{m} f_i^\prime(x_n)} $$</p>
<h2 id="iterate-until-convergence">Iterate until convergence</h2>
<p>Instead of improving the result indefinitely, you stop when the difference between $x_n$ and $x_{n+1}$ is smaller than or equal to a given $\epsilon$, i.e. $\left| x_n - x_{n+1} \right| \le \epsilon$.
It's usually a tiny number, like $0.000001$ ($1.0 e^{-6}$).
This is the value used in Microsoft Excel's XIRR function.</p>
<p>It's also worth noting that despite using the exact derivative, the IRR algorithm is still an approximation method.
It may not always converge to a solution, especially for cash flow series that have multiple changes in sign.
In these cases, it may be necessary to provide a good initial guess for the rate or to use a different method to compute the internal rate of return.</p>
<h2 id="implementation-in-rust">Implementation in Rust</h2>
<p>Let's move towards translating our theoretical understanding into a concrete implementation using Rust.
We'll focus on implementing the IRR calculation algorithm by applying the findings and formulas mentioned in the previous sections.
The final output should be close to Excel's XIRR function result within an acceptable tolerance range.</p>
<pre class="giallo z-code"><code data-lang="rust"><span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> We use the chrono crate for date handling: https://docs.rs/chrono/latest/chrono</span></span>
<span class="giallo-l"><span class="z-keyword">use</span><span class="z-entity z-name"> chrono</span><span class="z-keyword z-keyword z-operator">::</span><span class="z-entity z-name">prelude</span><span class="z-keyword z-keyword z-operator">::</span><span class="z-keyword z-keyword z-operator">*</span><span>;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> Function to calculate the number of days between two dates</span></span>
<span class="giallo-l"><span class="z-keyword">fn</span><span class="z-entity z-name z-function"> days_between</span><span>(</span><span class="z-variable z-other z-variable">start_date</span><span class="z-keyword z-keyword z-operator">:</span><span class="z-entity z-name"> NaiveDate</span><span>,</span><span class="z-variable z-other z-variable"> end_date</span><span class="z-keyword z-keyword z-operator">:</span><span class="z-entity z-name"> NaiveDate</span><span>)</span><span class="z-keyword z-keyword z-operator"> -></span><span class="z-entity z-name"> i64</span><span> {</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Calculate the duration between the two dates</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> let</span><span class="z-variable z-other z-variable"> duration</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> end_date</span><span class="z-keyword z-keyword z-operator">.</span><span class="z-entity z-name z-function">signed_duration_since</span><span>(</span><span class="z-variable z-other z-variable">start_date</span><span>)</span><span>;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Return the duration in days</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable"> duration</span><span class="z-keyword z-keyword z-operator">.</span><span class="z-entity z-name z-function">num_days</span><span>(</span><span>)</span></span>
<span class="giallo-l"><span>}</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> Main function to calculate the internal rate of return</span></span>
<span class="giallo-l"><span class="z-keyword">fn</span><span class="z-entity z-name z-function"> calculate_irr</span><span>(</span><span class="z-variable z-other z-variable">transactions</span><span class="z-keyword z-keyword z-operator">:</span><span class="z-keyword z-keyword z-operator"> &</span><span>[</span><span>(</span><span class="z-entity z-name">f64</span><span>,</span><span class="z-entity z-name"> f64</span><span>)</span><span>]</span><span>,</span><span class="z-variable z-other z-variable"> initial_guess</span><span class="z-keyword z-keyword z-operator">:</span><span class="z-entity z-name"> f64</span><span>)</span><span class="z-keyword z-keyword z-operator"> -></span><span class="z-entity z-name"> f64</span><span> {</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Start with initial guess for the IRR</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> let</span><span class="z-storage"> mut</span><span class="z-variable z-other z-variable"> x</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> initial_guess</span><span>;</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> const</span><span class="z-constant z-constant z-other"> MAX_TRIES</span><span class="z-keyword z-keyword z-operator">:</span><span class="z-entity z-name"> usize</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 100</span><span>;</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> const</span><span class="z-constant z-constant z-other"> EPSILON</span><span class="z-keyword z-keyword z-operator">:</span><span class="z-entity z-name"> f64</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-constant z-punctuation z-separator">.</span><span class="z-constant z-constant z-numeric">0</span><span class="z-keyword z-keyword z-operator">e</span><span class="z-keyword z-keyword z-operator">-</span><span class="z-constant z-constant z-numeric">6</span><span>;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Loop until a maximum number of iterations is reached</span></span>
<span class="giallo-l"><span class="z-keyword"> for</span><span class="z-variable z-other z-variable"> _</span><span class="z-keyword"> in</span><span class="z-constant z-constant z-numeric"> 0</span><span class="z-keyword z-keyword z-operator">..</span><span class="z-constant z-constant z-other">MAX_TRIES</span><span> {</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Calculate NPV and its derivative for each cash flow and sum them up</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> let</span><span> (</span><span class="z-variable z-other z-variable">fx</span><span>,</span><span class="z-variable z-other z-variable"> dfx</span><span>)</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> transactions</span><span class="z-keyword z-keyword z-operator">.</span><span class="z-entity z-name z-function">iter</span><span>(</span><span>)</span></span>
<span class="giallo-l"><span class="z-keyword z-keyword z-operator"> .</span><span class="z-entity z-name z-function">map</span><span>(</span><span class="z-keyword z-keyword z-operator">|</span><span>(</span><span class="z-variable z-other z-variable">years</span><span>,</span><span class="z-variable z-other z-variable"> amount</span><span>)</span><span class="z-keyword z-keyword z-operator">|</span><span> {</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> let</span><span class="z-variable z-other z-variable"> fx</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> amount</span><span class="z-keyword z-keyword z-operator"> /</span><span> (</span><span class="z-constant z-constant z-numeric">1_</span><span class="z-entity z-name">f64</span><span class="z-keyword z-keyword z-operator"> +</span><span class="z-variable z-other z-variable"> x</span><span>)</span><span class="z-keyword z-keyword z-operator">.</span><span class="z-entity z-name z-function">powf</span><span>(</span><span class="z-keyword z-keyword z-operator">*</span><span class="z-variable z-other z-variable">years</span><span>)</span><span>;</span><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> NPV of the cash flow</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> let</span><span class="z-variable z-other z-variable"> dfx</span><span class="z-keyword z-keyword z-operator"> =</span><span> (</span><span class="z-keyword z-keyword z-operator">-</span><span class="z-variable z-other z-variable">years</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-variable z-other z-variable"> amount</span><span>)</span><span class="z-keyword z-keyword z-operator"> /</span><span> (</span><span class="z-constant z-constant z-numeric">1_</span><span class="z-entity z-name">f64</span><span class="z-keyword z-keyword z-operator"> +</span><span class="z-variable z-other z-variable"> x</span><span>)</span><span class="z-keyword z-keyword z-operator">.</span><span class="z-entity z-name z-function">powf</span><span>(</span><span class="z-variable z-other z-variable">years</span><span class="z-keyword z-keyword z-operator"> +</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-constant z-punctuation z-separator">.</span><span class="z-constant z-constant z-numeric">0</span><span>)</span><span>;</span><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Derivative of NPV</span></span>
<span class="giallo-l"><span> (</span><span class="z-variable z-other z-variable">fx</span><span>,</span><span class="z-variable z-other z-variable"> dfx</span><span>)</span><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Return both values for a single cash flow</span></span>
<span class="giallo-l"><span> }</span><span>)</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Sum up all NPVs and derivatives for all cash flows (reduce to a tuple of two sums)</span></span>
<span class="giallo-l"><span class="z-keyword z-keyword z-operator"> .</span><span class="z-entity z-name z-function">fold</span><span>(</span><span>(</span><span class="z-constant z-constant z-numeric">0_</span><span class="z-entity z-name">f64</span><span>,</span><span class="z-constant z-constant z-numeric"> 0_</span><span class="z-entity z-name">f64</span><span>)</span><span>,</span><span class="z-keyword z-keyword z-operator"> |</span><span>(</span><span class="z-variable z-other z-variable">fx_acc</span><span>,</span><span class="z-variable z-other z-variable"> dfx_acc</span><span>)</span><span>,</span><span> (</span><span class="z-variable z-other z-variable">fx</span><span>,</span><span class="z-variable z-other z-variable"> dfx</span><span>)</span><span class="z-keyword z-keyword z-operator">|</span><span> (</span><span class="z-variable z-other z-variable">fx_acc</span><span class="z-keyword z-keyword z-operator"> +</span><span class="z-variable z-other z-variable"> fx</span><span>,</span><span class="z-variable z-other z-variable"> dfx_acc</span><span class="z-keyword z-keyword z-operator"> +</span><span class="z-variable z-other z-variable"> dfx</span><span>)</span><span>)</span><span>;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Calculate the new guess</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> let</span><span class="z-variable z-other z-variable"> new_x</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> x</span><span class="z-keyword z-keyword z-operator"> -</span><span class="z-variable z-other z-variable"> fx</span><span class="z-keyword z-keyword z-operator"> /</span><span class="z-variable z-other z-variable"> dfx</span><span>;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Calculate the difference between the new and the old guess</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> let</span><span class="z-variable z-other z-variable"> epsilon</span><span class="z-keyword z-keyword z-operator"> =</span><span> (</span><span class="z-variable z-other z-variable">new_x</span><span class="z-keyword z-keyword z-operator"> -</span><span class="z-variable z-other z-variable"> x</span><span>)</span><span class="z-keyword z-keyword z-operator">.</span><span class="z-entity z-name z-function">abs</span><span>(</span><span>)</span><span>;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> If the difference is smaller than or equal to the tolerance, we are done</span></span>
<span class="giallo-l"><span class="z-keyword"> if</span><span class="z-variable z-other z-variable"> epsilon</span><span class="z-keyword z-keyword z-operator"> <=</span><span class="z-constant z-constant z-other"> EPSILON</span><span> {</span></span>
<span class="giallo-l"><span class="z-keyword"> return</span><span class="z-variable z-other z-variable"> x</span><span>;</span></span>
<span class="giallo-l"><span> }</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Continue the loop with the new guess</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable"> x</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> new_x</span><span>;</span></span>
<span class="giallo-l"><span> }</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Return a non-number if the algorithm didn't converge (see "Iterate until convergence" in article)</span></span>
<span class="giallo-l"><span class="z-entity z-name"> f64</span><span class="z-keyword z-keyword z-operator">::</span><span class="z-constant z-constant z-other">NAN</span></span>
<span class="giallo-l"><span>}</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> Define the main function and our example transactions</span></span>
<span class="giallo-l"><span class="z-keyword">fn</span><span class="z-entity z-name z-function"> main</span><span>(</span><span>)</span><span> {</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Example from Microsoft Excel documentation:</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> https://support.microsoft.com/en-gb/office/xirr-function-de1242ec-6477-445b-b11b-a303ad9adc9d</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> The internal rate of return is 0.373362535 or 37.34%</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> let</span><span class="z-variable z-other z-variable"> cashflows</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-entity z-name z-function"> vec!</span><span>[</span></span>
<span class="giallo-l"><span> (</span><span class="z-entity z-name">NaiveDate</span><span class="z-keyword z-keyword z-operator">::</span><span class="z-entity z-name z-function">from_ymd_opt</span><span>(</span><span class="z-constant z-constant z-numeric">2008</span><span>,</span><span class="z-constant z-constant z-numeric"> 1</span><span>,</span><span class="z-constant z-constant z-numeric"> 1</span><span>)</span><span class="z-keyword z-keyword z-operator">.</span><span class="z-entity z-name z-function">unwrap</span><span>(</span><span>)</span><span>,</span><span class="z-keyword z-keyword z-operator"> -</span><span class="z-constant z-constant z-numeric">10_000</span><span class="z-constant z-punctuation z-separator">.</span><span class="z-constant z-constant z-numeric">00</span><span>)</span><span>,</span></span>
<span class="giallo-l"><span> (</span><span class="z-entity z-name">NaiveDate</span><span class="z-keyword z-keyword z-operator">::</span><span class="z-entity z-name z-function">from_ymd_opt</span><span>(</span><span class="z-constant z-constant z-numeric">2008</span><span>,</span><span class="z-constant z-constant z-numeric"> 3</span><span>,</span><span class="z-constant z-constant z-numeric"> 1</span><span>)</span><span class="z-keyword z-keyword z-operator">.</span><span class="z-entity z-name z-function">unwrap</span><span>(</span><span>)</span><span>,</span><span class="z-constant z-constant z-numeric"> 2_750</span><span class="z-constant z-punctuation z-separator">.</span><span class="z-constant z-constant z-numeric">00</span><span>)</span><span>,</span></span>
<span class="giallo-l"><span> (</span><span class="z-entity z-name">NaiveDate</span><span class="z-keyword z-keyword z-operator">::</span><span class="z-entity z-name z-function">from_ymd_opt</span><span>(</span><span class="z-constant z-constant z-numeric">2008</span><span>,</span><span class="z-constant z-constant z-numeric"> 10</span><span>,</span><span class="z-constant z-constant z-numeric"> 30</span><span>)</span><span class="z-keyword z-keyword z-operator">.</span><span class="z-entity z-name z-function">unwrap</span><span>(</span><span>)</span><span>,</span><span class="z-constant z-constant z-numeric"> 4_250</span><span class="z-constant z-punctuation z-separator">.</span><span class="z-constant z-constant z-numeric">00</span><span>)</span><span>,</span></span>
<span class="giallo-l"><span> (</span><span class="z-entity z-name">NaiveDate</span><span class="z-keyword z-keyword z-operator">::</span><span class="z-entity z-name z-function">from_ymd_opt</span><span>(</span><span class="z-constant z-constant z-numeric">2009</span><span>,</span><span class="z-constant z-constant z-numeric"> 2</span><span>,</span><span class="z-constant z-constant z-numeric"> 15</span><span>)</span><span class="z-keyword z-keyword z-operator">.</span><span class="z-entity z-name z-function">unwrap</span><span>(</span><span>)</span><span>,</span><span class="z-constant z-constant z-numeric"> 3_250</span><span class="z-constant z-punctuation z-separator">.</span><span class="z-constant z-constant z-numeric">00</span><span>)</span><span>,</span></span>
<span class="giallo-l"><span> (</span><span class="z-entity z-name">NaiveDate</span><span class="z-keyword z-keyword z-operator">::</span><span class="z-entity z-name z-function">from_ymd_opt</span><span>(</span><span class="z-constant z-constant z-numeric">2009</span><span>,</span><span class="z-constant z-constant z-numeric"> 4</span><span>,</span><span class="z-constant z-constant z-numeric"> 1</span><span>)</span><span class="z-keyword z-keyword z-operator">.</span><span class="z-entity z-name z-function">unwrap</span><span>(</span><span>)</span><span>,</span><span class="z-constant z-constant z-numeric"> 2_750</span><span class="z-constant z-punctuation z-separator">.</span><span class="z-constant z-constant z-numeric">00</span><span>)</span><span>,</span></span>
<span class="giallo-l"><span> ]</span><span>;</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Pre-calculate the years since first cash flow for each cash flow</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> let</span><span class="z-variable z-other z-variable"> transactions</span><span class="z-keyword z-keyword z-operator">:</span><span class="z-entity z-name"> Vec</span><span><</span><span>(</span><span class="z-entity z-name">f64</span><span>,</span><span class="z-entity z-name"> f64</span><span>)</span><span>></span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> cashflows</span><span class="z-keyword z-keyword z-operator">.</span><span class="z-entity z-name z-function">iter</span><span>(</span><span>)</span></span>
<span class="giallo-l"><span class="z-keyword z-keyword z-operator"> .</span><span class="z-entity z-name z-function">map</span><span>(</span><span class="z-keyword z-keyword z-operator">|</span><span>(</span><span class="z-variable z-other z-variable">date</span><span>,</span><span class="z-variable z-other z-variable"> amount</span><span>)</span><span class="z-keyword z-keyword z-operator">|</span><span> (</span><span class="z-entity z-name z-function">days_between</span><span>(</span><span class="z-variable z-other z-variable">cashflows</span><span>[</span><span class="z-constant z-constant z-numeric">0</span><span>]</span><span class="z-keyword z-keyword z-operator">.</span><span class="z-constant z-constant z-numeric">0</span><span>,</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-variable z-other z-variable">date</span><span>)</span><span class="z-keyword"> as</span><span class="z-entity z-name"> f64</span><span class="z-keyword z-keyword z-operator"> /</span><span class="z-constant z-constant z-numeric"> 365</span><span class="z-constant z-punctuation z-separator">.</span><span class="z-constant z-constant z-numeric">0</span><span>,</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-variable z-other z-variable">amount</span><span>)</span><span>)</span></span>
<span class="giallo-l"><span class="z-keyword z-keyword z-operator"> .</span><span class="z-entity z-name z-function">collect</span><span>(</span><span>)</span><span>;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Call our IRR calculation function and print the result</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Expected result is 37.34%</span></span>
<span class="giallo-l"><span class="z-entity z-name z-function"> println!</span><span>(</span><span class="z-string">"</span><span class="z-string">IRR with Newton-Raphson: </span><span class="z-string">{</span><span class="z-string">:.2</span><span class="z-string">}</span><span class="z-string">%</span><span class="z-string">"</span><span>,</span><span class="z-entity z-name z-function"> calculate_irr</span><span>(</span><span class="z-keyword z-keyword z-operator">&</span><span class="z-variable z-other z-variable">transactions</span><span>,</span><span class="z-constant z-constant z-numeric"> 0</span><span class="z-constant z-punctuation z-separator">.</span><span class="z-constant z-constant z-numeric">1</span><span>)</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-constant z-constant z-numeric"> 100</span><span class="z-constant z-punctuation z-separator">.</span><span class="z-constant z-constant z-numeric">0</span><span>)</span><span>;</span></span>
<span class="giallo-l"><span>}</span></span></code></pre>
<p>The <code>calculate_irr</code> function is where the heart of our IRR calculation lives.
It starts by defining the initial guess for the IRR, then enters a loop that calculates the new guess, checks for convergence, and continues the loop if not converged.
Finally, if the algorithm fails to converge, it returns a non-number.
The main function uses an example transaction set and calls our <code>calculate_irr</code> function.</p>
<h2 id="bonus-implementation-in-javascript">Bonus: implementation in JavaScript</h2>
<p>JavaScript runs natively in all modern browsers and is the <em>lingua franca</em> of the web.
By translating the Rust code into JavaScript, the IRR calculation will be easily usable on virtually any device, regardless of operating system or hardware.
This way, it should be possible to use it in a web application or even in a mobile app using a framework like <a rel="external" href="https://reactnative.dev">React Native</a>.
Maybe you want to write a financial app that runs on iOS, Android, and the web?</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> Function to calculate the number of days between two dates</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage z-type z-function">function</span><span class="z-entity z-name z-function"> daysBetween</span><span>(</span><span class="z-variable z-variable z-parameter">start</span><span class="z-punctuation z-separator">,</span><span class="z-variable z-variable z-parameter"> end</span><span>)</span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> const</span><span class="z-variable z-other z-constant z-variable"> millisecondsPerDay</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 1000</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-constant z-constant z-numeric"> 60</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-constant z-constant z-numeric"> 60</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-constant z-constant z-numeric"> 24</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> const</span><span class="z-variable z-other z-constant z-variable"> millisBetween</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> end</span><span class="z-meta z-block z-punctuation z-accessor">.</span><span class="z-entity z-name z-function">getTime</span><span class="z-meta z-block">(</span><span class="z-meta z-block">)</span><span class="z-keyword z-keyword z-operator"> -</span><span class="z-variable z-other z-variable"> start</span><span class="z-meta z-block z-punctuation z-accessor">.</span><span class="z-entity z-name z-function">getTime</span><span class="z-meta z-block">(</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-keyword"> return</span><span class="z-variable z-other z-variable"> millisBetween</span><span class="z-keyword z-keyword z-operator"> /</span><span class="z-variable z-other z-variable"> millisecondsPerDay</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-meta z-block">}</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> Main function to calculate the internal rate of return</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage z-type z-function">function</span><span class="z-entity z-name z-function"> calculateIRR</span><span>(</span><span class="z-variable z-variable z-parameter">transactions</span><span class="z-punctuation z-separator">,</span><span class="z-variable z-variable z-parameter"> initialGuess</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 0</span><span class="z-constant z-constant z-numeric">.</span><span class="z-constant z-constant z-numeric">1</span><span>)</span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Start with initial guess for the IRR</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> let</span><span class="z-variable z-other z-variable"> x</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> initialGuess</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> const</span><span class="z-variable z-other z-constant z-variable"> MAX_TRIES</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 100</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> const</span><span class="z-variable z-other z-constant z-variable"> EPSILON</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-constant z-constant z-numeric">.</span><span class="z-constant z-constant z-numeric">0e-6</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Loop until a maximum number of iterations is reached</span></span>
<span class="giallo-l"><span class="z-keyword"> for</span><span class="z-meta z-block"> (</span><span class="z-storage z-type z-storage">let</span><span class="z-variable z-other z-variable"> tries</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 0</span><span class="z-meta z-block z-punctuation z-terminator">;</span><span class="z-variable z-other z-variable"> tries</span><span class="z-keyword z-keyword z-operator"> <</span><span class="z-variable z-other z-constant z-variable"> MAX_TRIES</span><span class="z-meta z-block z-punctuation z-terminator">;</span><span class="z-variable z-other z-variable"> tries</span><span class="z-keyword z-keyword z-operator"> +=</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block">)</span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Calculate NPV and its derivative for each cash flow and sum them up</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> const</span><span class="z-meta z-block"> {</span><span class="z-variable z-other z-constant z-variable"> fxs</span><span class="z-meta z-block z-punctuation z-separator">,</span><span class="z-variable z-other z-constant z-variable"> dfxs</span><span class="z-meta z-block"> }</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> transactions</span></span>
<span class="giallo-l"><span class="z-meta z-block z-punctuation z-accessor"> .</span><span class="z-entity z-name z-function">map</span><span class="z-meta z-block">(</span><span class="z-meta z-block">(</span><span class="z-variable z-variable z-parameter">tx</span><span class="z-meta z-block">)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> const</span><span class="z-variable z-other z-constant z-variable"> fx</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> tx</span><span class="z-meta z-block z-punctuation z-accessor">.</span><span class="z-variable z-other z-variable">amount</span><span class="z-keyword z-keyword z-operator"> /</span><span class="z-meta z-block"> (</span><span class="z-meta z-block">(</span><span class="z-constant z-constant z-numeric">1</span><span class="z-constant z-constant z-numeric">.</span><span class="z-constant z-constant z-numeric">0</span><span class="z-keyword z-keyword z-operator"> +</span><span class="z-variable z-other z-variable"> x</span><span class="z-meta z-block">)</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-keyword z-keyword z-operator">*</span><span class="z-variable z-other z-variable"> tx</span><span class="z-meta z-block z-punctuation z-accessor">.</span><span class="z-variable z-other z-variable">years</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-terminator">;</span><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> NPV of the cash flow</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> const</span><span class="z-variable z-other z-constant z-variable"> dfx</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-meta z-block"> (</span><span class="z-keyword z-keyword z-operator">-</span><span class="z-variable z-other z-variable">tx</span><span class="z-meta z-block z-punctuation z-accessor">.</span><span class="z-variable z-other z-variable">years</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-variable z-other z-variable"> tx</span><span class="z-meta z-block z-punctuation z-accessor">.</span><span class="z-variable z-other z-variable">amount</span><span class="z-meta z-block">)</span><span class="z-keyword z-keyword z-operator"> /</span><span class="z-meta z-block"> (</span><span class="z-meta z-block">(</span><span class="z-constant z-constant z-numeric">1</span><span class="z-constant z-constant z-numeric">.</span><span class="z-constant z-constant z-numeric">0</span><span class="z-keyword z-keyword z-operator"> +</span><span class="z-variable z-other z-variable"> x</span><span class="z-meta z-block">)</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-keyword z-keyword z-operator">*</span><span class="z-meta z-block"> (</span><span class="z-variable z-other z-variable">tx</span><span class="z-meta z-block z-punctuation z-accessor">.</span><span class="z-variable z-other z-variable">years</span><span class="z-keyword z-keyword z-operator"> +</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block">)</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-terminator">;</span><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Derivative of NPV</span></span>
<span class="giallo-l"><span class="z-keyword"> return</span><span class="z-meta z-block"> {</span><span class="z-variable z-other z-variable"> fx</span><span class="z-meta z-block z-punctuation z-separator">,</span><span class="z-variable z-other z-variable"> dfx</span><span class="z-meta z-block"> }</span><span class="z-meta z-block z-punctuation z-terminator">;</span><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Return both values for a single cash flow</span></span>
<span class="giallo-l"><span class="z-meta z-block"> }</span><span class="z-meta z-block">)</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Sum up all NPVs and derivatives for all cash flows (reduce to an object with two sums)</span></span>
<span class="giallo-l"><span class="z-meta z-block z-punctuation z-accessor"> .</span><span class="z-entity z-name z-function">reduce</span><span class="z-meta z-block">(</span><span class="z-meta z-block">(</span><span class="z-variable z-variable z-parameter">acc</span><span class="z-meta z-block z-punctuation z-separator">,</span><span class="z-variable z-variable z-parameter"> obj</span><span class="z-meta z-block">)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-meta z-block"> (</span><span class="z-meta z-block">{</span><span class="z-meta z-object z-member"> fxs</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-variable z-other z-variable"> acc</span><span class="z-meta z-object z-member z-punctuation z-accessor">.</span><span class="z-variable z-other z-variable">fxs</span><span class="z-keyword z-keyword z-operator"> +</span><span class="z-variable z-other z-variable"> obj</span><span class="z-meta z-object z-member z-punctuation z-accessor">.</span><span class="z-variable z-other z-variable">fx</span><span class="z-meta z-block z-punctuation z-separator">,</span><span class="z-meta z-object z-member"> dfxs</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-variable z-other z-variable"> acc</span><span class="z-meta z-object z-member z-punctuation z-accessor">.</span><span class="z-variable z-other z-variable">dfxs</span><span class="z-keyword z-keyword z-operator"> +</span><span class="z-variable z-other z-variable"> obj</span><span class="z-meta z-object z-member z-punctuation z-accessor">.</span><span class="z-variable z-other z-variable">dfx</span><span class="z-meta z-block"> }</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-separator">,</span><span class="z-meta z-block"> {</span><span class="z-meta z-object z-member"> fxs</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-constant z-constant z-numeric"> 0</span><span class="z-meta z-block z-punctuation z-separator">,</span><span class="z-meta z-object z-member"> dfxs</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-constant z-constant z-numeric"> 0</span><span class="z-meta z-block"> }</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Calculate the new guess</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> const</span><span class="z-variable z-other z-constant z-variable"> xNew</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> x</span><span class="z-keyword z-keyword z-operator"> -</span><span class="z-variable z-other z-variable"> fxs</span><span class="z-keyword z-keyword z-operator"> /</span><span class="z-variable z-other z-variable"> dfxs</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Calculate the difference between the new and the old guess</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> const</span><span class="z-variable z-other z-constant z-variable"> epsilon</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> Math</span><span class="z-meta z-block z-punctuation z-accessor">.</span><span class="z-entity z-name z-function">abs</span><span class="z-meta z-block">(</span><span class="z-variable z-other z-variable">xNew</span><span class="z-keyword z-keyword z-operator"> -</span><span class="z-variable z-other z-variable"> x</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> If the difference is smaller than or equal to the tolerance, we are done</span></span>
<span class="giallo-l"><span class="z-keyword"> if</span><span class="z-meta z-block"> (</span><span class="z-variable z-other z-variable">epsilon</span><span class="z-keyword z-keyword z-operator"> <=</span><span class="z-variable z-other z-constant z-variable"> EPSILON</span><span class="z-meta z-block">)</span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-keyword"> return</span><span class="z-variable z-other z-variable"> x</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-meta z-block"> }</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Continue the loop with the new guess</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable"> x</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> xNew</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-meta z-block"> }</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment"> //</span><span class="z-comment"> Return a non-number if the algorithm didn't converge</span></span>
<span class="giallo-l"><span class="z-keyword"> return</span><span class="z-constant z-constant z-language"> NaN</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-meta z-block">}</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> Example from Microsoft Excel documentation:</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> https://support.microsoft.com/en-gb/office/xirr-function-de1242ec-6477-445b-b11b-a303ad9adc9d</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> The internal rate of return is 0.373362535 or 37.34%</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage">const</span><span class="z-variable z-other z-constant z-variable"> cashflows</span><span class="z-keyword z-keyword z-operator"> =</span><span> [</span></span>
<span class="giallo-l"><span> {</span><span class="z-meta z-object z-member"> date</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-keyword z-keyword z-operator"> new</span><span class="z-entity z-name z-function"> Date</span><span class="z-meta z-object z-member">(</span><span class="z-string">'</span><span class="z-string">2008-01-01</span><span class="z-string">'</span><span class="z-meta z-object z-member">)</span><span class="z-punctuation z-separator">,</span><span class="z-meta z-object z-member"> amount</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-keyword z-keyword z-operator"> -</span><span class="z-constant z-constant z-numeric">10000</span><span class="z-constant z-constant z-numeric">.</span><span class="z-constant z-constant z-numeric">00</span><span> }</span><span class="z-punctuation z-separator">,</span></span>
<span class="giallo-l"><span> {</span><span class="z-meta z-object z-member"> date</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-keyword z-keyword z-operator"> new</span><span class="z-entity z-name z-function"> Date</span><span class="z-meta z-object z-member">(</span><span class="z-string">'</span><span class="z-string">2008-03-01</span><span class="z-string">'</span><span class="z-meta z-object z-member">)</span><span class="z-punctuation z-separator">,</span><span class="z-meta z-object z-member"> amount</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-constant z-constant z-numeric"> 2750</span><span class="z-constant z-constant z-numeric">.</span><span class="z-constant z-constant z-numeric">00</span><span> }</span><span class="z-punctuation z-separator">,</span></span>
<span class="giallo-l"><span> {</span><span class="z-meta z-object z-member"> date</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-keyword z-keyword z-operator"> new</span><span class="z-entity z-name z-function"> Date</span><span class="z-meta z-object z-member">(</span><span class="z-string">'</span><span class="z-string">2008-10-30</span><span class="z-string">'</span><span class="z-meta z-object z-member">)</span><span class="z-punctuation z-separator">,</span><span class="z-meta z-object z-member"> amount</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-constant z-constant z-numeric"> 4250</span><span class="z-constant z-constant z-numeric">.</span><span class="z-constant z-constant z-numeric">00</span><span> }</span><span class="z-punctuation z-separator">,</span></span>
<span class="giallo-l"><span> {</span><span class="z-meta z-object z-member"> date</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-keyword z-keyword z-operator"> new</span><span class="z-entity z-name z-function"> Date</span><span class="z-meta z-object z-member">(</span><span class="z-string">'</span><span class="z-string">2009-02-15</span><span class="z-string">'</span><span class="z-meta z-object z-member">)</span><span class="z-punctuation z-separator">,</span><span class="z-meta z-object z-member"> amount</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-constant z-constant z-numeric"> 3250</span><span class="z-constant z-constant z-numeric">.</span><span class="z-constant z-constant z-numeric">00</span><span> }</span><span class="z-punctuation z-separator">,</span></span>
<span class="giallo-l"><span> {</span><span class="z-meta z-object z-member"> date</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-keyword z-keyword z-operator"> new</span><span class="z-entity z-name z-function"> Date</span><span class="z-meta z-object z-member">(</span><span class="z-string">'</span><span class="z-string">2009-04-01</span><span class="z-string">'</span><span class="z-meta z-object z-member">)</span><span class="z-punctuation z-separator">,</span><span class="z-meta z-object z-member"> amount</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-constant z-constant z-numeric"> 2750</span><span class="z-constant z-constant z-numeric">.</span><span class="z-constant z-constant z-numeric">00</span><span> }</span></span>
<span class="giallo-l"><span>]</span><span class="z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> Pre-calculate the years since first cash flow for each cash flow</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage">const</span><span class="z-variable z-other z-constant z-variable"> transactions</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-other z-variable"> cashflows</span></span>
<span class="giallo-l"><span class="z-punctuation z-accessor"> .</span><span class="z-entity z-name z-function">map</span><span>(</span><span>(</span><span class="z-variable z-variable z-parameter">cf</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span> (</span><span>{</span><span class="z-meta z-object z-member"> years</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-entity z-name z-function"> daysBetween</span><span class="z-meta z-object z-member">(</span><span class="z-variable z-other z-variable">cashflows</span><span class="z-meta z-object z-member">[</span><span class="z-constant z-constant z-numeric">0</span><span class="z-meta z-object z-member">]</span><span class="z-meta z-object z-member z-punctuation z-accessor">.</span><span class="z-variable z-other z-variable">date</span><span class="z-meta z-object z-member z-punctuation z-separator">,</span><span class="z-variable z-other z-variable"> cf</span><span class="z-meta z-object z-member z-punctuation z-accessor">.</span><span class="z-variable z-other z-variable">date</span><span class="z-meta z-object z-member">)</span><span class="z-keyword z-keyword z-operator"> /</span><span class="z-constant z-constant z-numeric"> 365</span><span class="z-punctuation z-separator">,</span><span class="z-meta z-object z-member"> amount</span><span class="z-meta z-object z-member z-punctuation z-separator">:</span><span class="z-variable z-other z-variable"> cf</span><span class="z-meta z-object z-member z-punctuation z-accessor">.</span><span class="z-variable z-other z-variable">amount</span><span> }</span><span>)</span><span>)</span><span class="z-punctuation z-terminator">;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> Call our IRR calculation function and print the result</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> Expected result is 37.34%</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable">console</span><span class="z-punctuation z-accessor">.</span><span class="z-entity z-name z-function">log</span><span>(</span><span class="z-string">`</span><span class="z-string">IRR with Newton-Raphson: </span><span class="z-string z-punctuation z-definition z-template-expression">${</span><span class="z-string z-meta z-embedded">(</span><span class="z-entity z-name z-function">calculateIRR</span><span class="z-string z-meta z-embedded">(</span><span class="z-variable z-other z-variable">transactions</span><span class="z-string z-meta z-embedded">)</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-constant z-constant z-numeric"> 100</span><span class="z-string z-meta z-embedded">)</span><span class="z-string z-punctuation z-accessor">.</span><span class="z-entity z-name z-function">toFixed</span><span class="z-string z-meta z-embedded">(</span><span class="z-constant z-constant z-numeric">2</span><span class="z-string z-meta z-embedded">)</span><span class="z-string z-punctuation z-definition z-template-expression">}</span><span class="z-string">%</span><span class="z-string">`</span><span>)</span><span class="z-punctuation z-terminator">;</span></span></code></pre><h2 id="conclusion">Conclusion</h2>
<p>The internal rate of return (IRR) is an instrumental financial measure that helps investors compare and decide between different investment opportunities.
Calculating it can get complex due to irregular cash flows, making a detailed understanding of the underlying algorithm crucial.
This article dived into the mathematics behind IRR calculation and provided a concrete implementation using the Rust programming language.
Remember, IRR is not just a number but an insight into the potential of an investment, assisting you in making informed financial decisions.</p>
<p>If you have any questions, need further clarification, or want to give feedback: please let me know.</p>
Attributions2021-06-04T00:00:00+00:002021-06-04T00:00:00+00:00
Unknown
https://6ai6.com/pages/attributions/<h2 id="content-management-system">Content management system</h2>
<p><a rel="external" href="https://www.getzola.org/">Zola</a> is my choice for managing content and creating a static website from it.
It is your one-stop static site engine.</p>
<h2 id="cascading-style-sheets">Cascading style sheets</h2>
<p>For styling, I use the <a rel="external" href="https://tailwindcss.com">Tailwind CSS</a> framework by Adam Wathan.</p>
<h2 id="artwork">Artwork</h2>
<p>I use free artwork on this site:</p>
<ul>
<li>Free icons (MIT License) from
<ul>
<li><a rel="external" href="https://github.com/refactoringui/heroicons">Heroicons</a> by Refactoring UI Inc.</li>
</ul>
</li>
<li>Free images under the <a rel="external" href="https://unsplash.com/license">Unsplash License</a> from
<ul>
<li><a rel="external" href="https://unsplash.com/@zgc1993">冬城</a></li>
<li><a rel="external" href="https://unsplash.com/@cuatrobel">Abel Pérez</a></li>
<li><a rel="external" href="https://unsplash.com/@alexander_ant">Alexander Ant</a></li>
<li><a rel="external" href="https://unsplash.com/@sharonmccutcheon">Alexander Grey</a></li>
<li>Andrew Buchanan</li>
<li><a rel="external" href="https://unsplash.com/@drwmrk">Andrew Stutesman</a></li>
<li><a rel="external" href="https://unsplash.com/@brett_jordan">Brett Jordan</a></li>
<li><a rel="external" href="https://unsplash.com/@woodpecker65">Christian Stahl</a></li>
<li><a rel="external" href="https://unsplash.com/@clintadair">Clint Adair</a></li>
<li><a rel="external" href="https://unsplash.com/@danielcgold">Dan Gold</a></li>
<li><a rel="external" href="https://unsplash.com/@davelowephoto">Dave Lowe</a></li>
<li><a rel="external" href="https://unsplash.com/@davidclode">David Clode</a></li>
<li><a rel="external" href="https://unsplash.com/@hasanalmasi">Hasan Almasi</a></li>
<li><a rel="external" href="https://unsplash.com/@jasonrosewell">Jason Rosewell</a></li>
<li><a rel="external" href="https://unsplash.com/@jaysung">Jehyun Sung</a></li>
<li><a rel="external" href="https://unsplash.com/@kathhh">Katherine Fleitas</a></li>
<li><a rel="external" href="https://unsplash.com/@lionel28">Lionel Hesry</a></li>
<li><a rel="external" href="https://unsplash.com/@mmmarq">Marcelo Marques</a></li>
<li>Marian Kroell</li>
<li><a rel="external" href="https://unsplash.com/@kerber">Marko Blažević</a></li>
<li><a rel="external" href="https://unsplash.com/@markusspiske">Markus Spiske</a></li>
<li><a rel="external" href="https://unsplash.com/@markuswinkler">Markus Winkler</a></li>
<li><a rel="external" href="https://unsplash.com/@max_williams">Max Williams</a></li>
<li>Mohammad Ali Berenji</li>
<li><a rel="external" href="https://unsplash.com/@nhulz">Nathan Hulsey</a></li>
<li><a rel="external" href="https://unsplash.com/@jannerboy62">Nick Fewings</a></li>
<li><a rel="external" href="https://unsplash.com/@olav_tvedt">Olav Tvedt</a></li>
<li>Omar Flores</li>
<li><a rel="external" href="https://unsplash.com/@pawel_czerwinski">Pawel Czerwinski</a></li>
<li><a rel="external" href="https://unsplash.com/@theshubhamdhage">Shubham Dhage</a></li>
<li>Sophie Vinetlouis</li>
<li><a rel="external" href="https://unsplash.com/@steve_j">Steve Johnson</a></li>
<li><a rel="external" href="https://unsplash.com/@srz">Sydney Rae</a></li>
<li><a rel="external" href="https://unsplash.com/@timmarshall">Tim Marshall</a></li>
<li><a rel="external" href="https://unsplash.com/@timmossholder">Tim Mossholder</a></li>
<li><a rel="external" href="https://unsplash.com/@karton55">Vitalik Vynarchyk</a></li>
<li><a rel="external" href="https://unsplash.com/@vivaantrivedii">Vivaan Trivedii</a></li>
</ul>
</li>
</ul>
<p>Some Unsplash profiles are no longer available.</p>
<h2 id="libraries-and-assets">Libraries and assets</h2>
<ul>
<li><a rel="external" href="https://katex.org/">KaTeX</a> (MIT License) for math rendering.</li>
<li><a rel="external" href="https://mermaid.js.org/">Mermaid</a> (MIT License) for diagrams.</li>
<li><a rel="external" href="https://howlerjs.com/">Howler.js</a> (MIT License) for the custom audio player.</li>
<li><a rel="external" href="https://lucaong.github.io/minisearch/">MiniSearch</a> (MIT License) for client-side search.</li>
<li><a rel="external" href="https://artalk.js.org/">Artalk</a> (MIT License) for optional comments.</li>
<li><a rel="external" href="https://github.com/getzola/giallo">Giallo</a> (EUPL-1.2 License) for syntax highlighting.</li>
</ul>
The Game of Fifteen2020-06-11T00:00:00+00:002020-06-11T00:00:00+00:00
Thomas Weitzel
https://6ai6.com/blog/game-of-fifteen/<p>The Game of Fifteen is a sliding puzzle that consists of a square with tiles numbered from 1 to 15 in random order with one tile missing.
To solve the puzzle, you must place the tiles in order by moving tiles to the empty space.</p>
<h2 id="how-to-play">How to play</h2>
<p>Play the game online by clicking/tapping on the tile you want to move.
Only tiles neighboring the empty space can be moved.
Once you solve the puzzle, the tiles will not move anymore.
Just play a new game by clicking the button.
I can guarantee you that every game presented here is solvable.
Read below for an explanation.</p>
<p>Hint: if your browser doesn't display the board correctly, try clearing your browser cache and try again.</p>
<div id="board">
<div class="m-4 grid grid-flow-row grid-cols-4 grid-rows-4 h-64 w-64 gap-1">
<div id="f0" class=""></div>
<div id="f1" class=""></div>
<div id="f2" class=""></div>
<div id="f3" class=""></div>
<div id="f4" class=""></div>
<div id="f5" class=""></div>
<div id="f6" class=""></div>
<div id="f7" class=""></div>
<div id="f8" class=""></div>
<div id="f9" class=""></div>
<div id="f10" class=""></div>
<div id="f11" class=""></div>
<div id="f12" class=""></div>
<div id="f13" class=""></div>
<div id="f14" class=""></div>
<div id="f15" class=""></div>
</div>
</div>
<div class="mt-4">
<button id="playButton" class="py-2 px-4 border border-transparent text-sm leading-5 font-medium rounded-md text-neutral-950 bg-primary-300 shadow-sm hover:bg-primary-500 focus:outline-none focus:ring-2 focus:ring-primary-500 focus:ring-offset-2 focus:ring-offset-neutral-950 active:bg-primary-600 transition duration-150 ease-in-out">
new game
</button>
</div>
<h2 id="parity-of-a-permutation">Parity of a permutation</h2>
<p>For the Game of Fifteen, a permutation of the numbers 1 to 15 is a state of the game if read line by line - like a book.
Some smart people have figured out, that an even parity (is dividable by 2, like 42) is an invariant of a solvable permutation of the Game of Fifteen.
In computer science, an invariant is a condition that is always true, i.e. doesn't change for a section of code.</p>
<p>The parity of a permutation is simply the number of inversions.
An inversion happens when an element with a lower index has a higher value than a value at a higher index.</p>
<p>Examples:</p>
<ul>
<li><code>1, 2, 3</code> has no inversions, all elements are in order</li>
<li><code>2, 3, 1</code> has two inversions, because <code>2</code> is greater than <code>1</code> and <code>3</code> is greater than <code>1</code></li>
<li><code>1, 3, 2</code> has only one inversion, <code>3</code> is greater than <code>2</code></li>
</ul>
<p>There are about 1.3 Trillion (Billion for us people in Central Europe) possible permutations of the numbers 1 to 15.
Only half of them have an even parity.
When we calculate a random permutation for the start of a game, it then makes sense to filter out all the permutations with an odd parity.
Because we do not want to present an unsolvable game.</p>
<p>Here is a fragment of source code that calculates the parity and checks if it's even for the examples from above.</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> for (let i = 0; i < limit; i += 1) {...} vs</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> range0(limit).forEach((i) => {...})</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage">const</span><span class="z-entity z-name z-function"> range0</span><span class="z-keyword z-keyword z-operator"> =</span><span> (</span><span class="z-variable z-variable z-parameter">limit</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span> [</span><span class="z-keyword z-keyword z-operator">...</span><span class="z-entity z-name z-function">Array</span><span>(</span><span class="z-variable z-other z-variable">limit</span><span>)</span><span class="z-punctuation z-accessor">.</span><span class="z-entity z-name z-function">keys</span><span>(</span><span>)</span><span>]</span><span class="z-punctuation z-terminator">;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-storage z-type z-storage">const</span><span class="z-entity z-name z-function"> isEvenPermutation</span><span class="z-keyword z-keyword z-operator"> =</span><span> (</span><span class="z-variable z-variable z-parameter">p</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-entity z-name z-function"> parity</span><span>(</span><span class="z-variable z-other z-variable">p</span><span>)</span><span class="z-keyword z-keyword z-operator"> %</span><span class="z-constant z-constant z-numeric"> 2</span><span class="z-keyword z-keyword z-operator"> ===</span><span class="z-constant z-constant z-numeric"> 0</span><span class="z-punctuation z-terminator">;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-storage z-type z-storage">const</span><span class="z-entity z-name z-function"> parity</span><span class="z-keyword z-keyword z-operator"> =</span><span> (</span><span class="z-variable z-variable z-parameter">p</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-entity z-name z-function"> range0</span><span>(</span><span class="z-variable z-other z-variable">p</span><span class="z-punctuation z-accessor">.</span><span class="z-support z-variable">length</span><span>)</span></span>
<span class="giallo-l"><span class="z-punctuation z-accessor"> .</span><span class="z-entity z-name z-function">map</span><span>(</span><span>(</span><span class="z-variable z-variable z-parameter">i</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-entity z-name z-function"> range0</span><span>(</span><span class="z-variable z-other z-variable">p</span><span class="z-punctuation z-accessor">.</span><span class="z-support z-variable">length</span><span>)</span></span>
<span class="giallo-l"><span class="z-punctuation z-accessor"> .</span><span class="z-entity z-name z-function">filter</span><span>(</span><span>(</span><span class="z-variable z-variable z-parameter">j</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-variable z-other z-variable"> i</span><span class="z-keyword z-keyword z-operator"> <</span><span class="z-variable z-other z-variable"> j</span><span class="z-keyword z-keyword z-operator"> &&</span><span class="z-variable z-other z-variable"> p</span><span>[</span><span class="z-variable z-other z-variable">i</span><span>]</span><span class="z-keyword z-keyword z-operator"> ></span><span class="z-variable z-other z-variable"> p</span><span>[</span><span class="z-variable z-other z-variable">j</span><span>]</span><span>)</span></span>
<span class="giallo-l"><span class="z-punctuation z-accessor"> .</span><span class="z-support z-variable">length</span></span>
<span class="giallo-l"><span> )</span></span>
<span class="giallo-l"><span class="z-punctuation z-accessor"> .</span><span class="z-entity z-name z-function">reduce</span><span>(</span><span>(</span><span class="z-variable z-variable z-parameter">agg</span><span class="z-punctuation z-separator">,</span><span class="z-variable z-variable z-parameter"> v</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-variable z-other z-variable"> agg</span><span class="z-keyword z-keyword z-operator"> +</span><span class="z-variable z-other z-variable"> v</span><span class="z-punctuation z-separator">,</span><span class="z-constant z-constant z-numeric"> 0</span><span>)</span><span class="z-punctuation z-terminator">;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> true, 0 inversions</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable">console</span><span class="z-punctuation z-accessor">.</span><span class="z-entity z-name z-function">log</span><span>(</span><span class="z-entity z-name z-function">isEvenPermutation</span><span>(</span><span>[</span><span class="z-constant z-constant z-numeric">1</span><span class="z-punctuation z-separator">,</span><span class="z-constant z-constant z-numeric"> 2</span><span class="z-punctuation z-separator">,</span><span class="z-constant z-constant z-numeric"> 3</span><span>]</span><span>)</span><span>)</span><span class="z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> true, 2 inversions</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable">console</span><span class="z-punctuation z-accessor">.</span><span class="z-entity z-name z-function">log</span><span>(</span><span class="z-entity z-name z-function">isEvenPermutation</span><span>(</span><span>[</span><span class="z-constant z-constant z-numeric">2</span><span class="z-punctuation z-separator">,</span><span class="z-constant z-constant z-numeric"> 3</span><span class="z-punctuation z-separator">,</span><span class="z-constant z-constant z-numeric"> 1</span><span>]</span><span>)</span><span>)</span><span class="z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> false, 1 inversion</span></span>
<span class="giallo-l"><span class="z-variable z-other z-variable">console</span><span class="z-punctuation z-accessor">.</span><span class="z-entity z-name z-function">log</span><span>(</span><span class="z-entity z-name z-function">isEvenPermutation</span><span>(</span><span>[</span><span class="z-constant z-constant z-numeric">1</span><span class="z-punctuation z-separator">,</span><span class="z-constant z-constant z-numeric"> 3</span><span class="z-punctuation z-separator">,</span><span class="z-constant z-constant z-numeric"> 2</span><span>]</span><span>)</span><span>)</span><span class="z-punctuation z-terminator">;</span></span></code></pre><h2 id="source-code">Source code</h2>
<p>I have created this <a rel="external" href="https://gist.github.com/thomasweitzel/3fd3197616f0299a2935972edd68bd4a">GitHub Gist</a> with the complete HTML page including the JavaScript source code.
It runs in the browser and uses just <a rel="external" href="https://tailwindcss.com">Tailwind CSS</a> for styling and plain ES6-style JavaScript.
The source code can be used for all square board sizes, not only 4 by 4.
You have to adjust the boards GUI or dynamically generate it - it's easy.</p>
<div class="hidden bg-primary-300 bg-primary-500 bg-primary-600 bg-primary-800 bg-primary-950 bg-warn-700 text-neutral-950 text-fail-200 border-primary-700 border-warn-600 border-transparent focus:ring-primary-500 focus:ring-offset-neutral-950"></div>
<script src="game-of-fifteen.js" integrity="sha384-JxrdBI5c+wPKQv/3jeIZHhvFK5u658hFW/SaEFvVQZkE3Obo6boo+t3mu8dXS/ts"></script>
Terms2020-01-08T00:00:00+00:002020-01-08T00:00:00+00:00
Thomas Weitzel
https://6ai6.com/pages/terms/<p><em>Last updated: February 9, 2026</em></p>
<h2 id="general-character-of-the-website">General character of the website</h2>
<p>This website is a <strong>private, non-commercial blog</strong> with mostly informational content. It can be used <strong>without registration</strong>
and <strong>without providing personal data</strong>.</p>
<p>The following notes are for transparency and clarity. They are <strong>not general terms and conditions</strong> and <strong>not a contract</strong>
in a legal sense.</p>
<h2 id="content-and-opinions">Content and opinions</h2>
<p>The content published on this website reflects <strong>my personal views and experiences</strong>. It is <strong>not professional advice</strong>,
in particular not legal, tax, medical, or financial advice.</p>
<p>I aim to provide correct and current information but make <strong>no warranties</strong> regarding accuracy, completeness, or suitability
for a specific purpose.</p>
<h2 id="liability">Liability</h2>
<p>Liability for damages resulting from the use or non-use of the information provided on this website is excluded,
<strong>unless caused by intent or gross negligence</strong>.</p>
<p>Mandatory statutory liability remains unaffected, especially for injury to life, body, or health.</p>
<h2 id="external-links">External links</h2>
<p>This website may contain links to external websites of third parties. I have no influence on their content.</p>
<p>The provider or operator of the linked pages is always responsible. At the time of linking, no illegal content was apparent.
If legal violations become known, the links will be removed promptly.</p>
<h2 id="copyright-and-use-of-content">Copyright and use of content</h2>
<p>The content and works published on this website are subject to German copyright law.</p>
<p>Unless stated otherwise, <strong>copying and redistribution</strong> are permitted <strong>as long as the author's attribution notice remains</strong> and the use is not commercial.</p>
<p>Any further use requires my prior consent.</p>
<h2 id="privacy">Privacy</h2>
<p>Information about the processing of personal data and browser storage can be found in the
<a href="https://6ai6.com/pages/privacy/">privacy policy</a>.</p>
<h2 id="applicable-law">Applicable law</h2>
<p>These notes and the use of this website are governed by the laws of the Federal Republic of Germany.</p>
<h2 id="closing-note">Closing note</h2>
<p>If any part of these notes is or becomes invalid, the remaining content remains effective.</p>
Tail recursion with trampoline2019-03-16T00:00:00+00:002019-03-16T00:00:00+00:00
Thomas Weitzel
https://6ai6.com/blog/tail-recursion-with-trampoline/<p>In case your platform lacks support for proper tail call optimization and you want to do functional programming, you might run into stack space problems.
This can be mitigated, but you have to find a way yourself to make it work.
The specific platform I'm writing about here is <a rel="external" href="https://nodejs.org/en/about">Node.js</a>.
After a little introduction, I show one well-known solution to the problem.</p>
<p>In functional programming, recursion is a fundamental concept for handling mutability.
Pure functional languages like Haskell do not allow mutation of variables, so you have to come up with a different solution to the problem.
What you do is called <a rel="external" href="https://alvinalexander.com/scala/functional-programming-simplified-book">update as you copy</a>.
You create new variables by calculating their values from the values of existing ones.
But you never assign a new value to a variable that already has one.</p>
<h2 id="recursion">Recursion</h2>
<p>To simplify the reasoning, I will assume that a function does not rely on or modify external state, i.e. values of variables outside of its body.
Math is organized this way: <code>1 + 2 = 3</code> independently of e.g. the current weather outside.
It's always true, no matter what.</p>
<p>In order to write a useful recursive function, you have to make sure that it:</p>
<ul>
<li>eventually returns with a value (terminates)</li>
<li>calls itself</li>
</ul>
<p>By using these criteria for a recursive function, you can see that it has to either call itself or terminate.
When it terminates, it's done and you have a value.
Otherwise it will call itself, and you get another stack frame with this call.
Depending on the number of calls this function makes to itself, the used stack space grows and you might eventually run out of stack space.
This is not a good thing!</p>
<h2 id="tail-recursion">Tail recursion</h2>
<p>What if you do not need the current stack frame anymore, once you make your recursive call?
You could immediately forget it, throw it away, or reuse it, thereby saving stack space.
But you have to make sure that you need no information from this stack frame once you have made your next call.
This can be accomplished by returning the recursive call alone, not adding to it or modifying it once it returns, so the return value can be directly passed on.
Now you have what's called a tail-recursive function.</p>
<h2 id="tail-call-optimization">Tail call optimization</h2>
<p>Once you have made sure that your function is tail-recursive, your runtime environment or compiler can optimize the calls in such a way,
that the existing stack frame is reused by the next call.
The stack thereby never grows and you have eliminated the potential for a stack overflow.
But it's not enough that it can be optimized, it has to be actually done.
That's where the problem starts.</p>
<p>Not every runtime environment or compiler performs tail call optimization.
As of this writing two of the platforms that I use do not support tail call optimization out-of-the-box:</p>
<ul>
<li><a rel="external" href="https://nodejs.org/en">Node.js</a></li>
<li>Java Virtual Machine (JVM) with <a rel="external" href="https://openjdk.java.net/projects/jdk8u">Java 8</a></li>
</ul>
<p>The JVM does support tail call optimization when used with Kotlin or Scala though.</p>
<p>Not all is lost: where tail call optimization is not directly supported you can implement a workaround that is straightforward.
It's effective in saving you from stack overflow errors.
The rest of this article shows you how to implement it.
It's known under the name <a rel="external" href="https://en.wikipedia.org/wiki/Tail_call#Through_trampolining">trampoline device</a>.</p>
<p>I use the factorial function and implement it in different ways, starting with a loop that mutates values.
Factorial is defined for natural numbers without the 0 (1, 2, 3, ...).
<code>Factorial(n)</code> calculates the product of all numbers between <code>1</code> and <code>n</code>.
It serves as an example that I chose because it's easy to understand.
I'll then transform it to a recursive function and show you how to make this function tail-recursive.
Afterwards I introduce the trampoline device and apply it to a function that is the modified tail-recursive function.
Let's start.</p>
<h2 id="loop">Loop</h2>
<p>If you're an <a rel="external" href="https://en.wikipedia.org/wiki/Imperative_programming">imperative programmer</a>, you would implement the factorial function with a loop.
You start with a variable <code>result</code> that has the value <code>1</code> and then have a for-loop that starts at <code>2</code> and goes up to <code>n</code>.
In the body of the for-loop you modify <code>result</code> and set it to a value that was its previous value multiplied by whatever value your loop-variable has.
If you are done with the loop you return the <code>result</code>.</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-storage z-type z-storage">const</span><span class="z-entity z-name z-function"> loopFactorial</span><span class="z-keyword z-keyword z-operator"> =</span><span> (</span><span class="z-variable z-variable z-parameter">n</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> let</span><span class="z-variable z-other z-variable"> result</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-keyword"> for</span><span class="z-meta z-block"> (</span><span class="z-storage z-type z-storage">let</span><span class="z-variable z-other z-variable"> i</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 2</span><span class="z-meta z-block z-punctuation z-terminator">;</span><span class="z-variable z-other z-variable"> i</span><span class="z-keyword z-keyword z-operator"> <=</span><span class="z-variable z-other z-variable"> n</span><span class="z-meta z-block z-punctuation z-terminator">;</span><span class="z-variable z-other z-variable"> i</span><span class="z-keyword z-keyword z-operator"> +=</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block">)</span><span class="z-variable z-other z-variable"> result</span><span class="z-keyword z-keyword z-operator"> *=</span><span class="z-variable z-other z-variable"> i</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-keyword"> return</span><span class="z-variable z-other z-variable"> result</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-meta z-block">}</span><span class="z-punctuation z-terminator">;</span></span></code></pre>
<p>Something to note here is that your <code>result</code> variable does not contain the result.
It holds the result only when the execution reaches the return statement.
How do you effectively name a variable that has different meanings during its life cycle?</p>
<h2 id="recursive-with-info-left-on-the-stack">Recursive with info left on the stack</h2>
<p>How do you slice a carrot?
Although there are many possible ways to do it, one would be to cut off one slice from one end and then repeat the procedure with the rest of the carrot, until there's nothing left.
You do the same with whatever is left until you reach the terminating condition.
It's a recursive definition.
And it's essentially what you do to calculate the factorial in a recursive way.</p>
<p>To calculate the factorial of <code>n</code> you multiply <code>n</code> with the factorial of <code>n - 1</code>.
You now have to calculate the factorial of <code>n - 1</code>.
And so on.</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-storage z-type z-storage">const</span><span class="z-entity z-name z-function"> stackFactorial</span><span class="z-keyword z-keyword z-operator"> =</span><span> (</span><span class="z-variable z-variable z-parameter">n</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-keyword"> if</span><span class="z-meta z-block"> (</span><span class="z-variable z-other z-variable">n</span><span class="z-keyword z-keyword z-operator"> ></span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block">)</span><span class="z-keyword"> return</span><span class="z-variable z-other z-variable"> n</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-entity z-name z-function"> stackFactorial</span><span class="z-meta z-block">(</span><span class="z-variable z-other z-variable">n</span><span class="z-keyword z-keyword z-operator"> -</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-keyword"> return</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-meta z-block">}</span><span class="z-punctuation z-terminator">;</span></span></code></pre>
<p>You need the result of <code>stackFactorial(n - 1)</code> before you can return from the function call, because you have to multiply it with <code>n</code> before that can happen.
What <code>n</code> actually is, is stored in the context of your <strong>current</strong> stack frame.
The next call will have another stack frame, where <code>n</code> has another value.
Because you cannot forget the <code>n</code> of the current call, the current stack frame has to stay around.</p>
<p>With large <code>n</code> this can lead to a situation where you get an error and the entire process stops: <code>RangeError: Maximum call stack size exceeded</code>.</p>
<h2 id="recursive-without-info-left-on-the-stack">Recursive without info left on the stack</h2>
<p>What can be done about it?
As a first step, you can eliminate the need for the current stack frame once you made the next call.
But you somehow have to preserve information that's needed.
The solution is to pass all required information on to the next recursive call.</p>
<p>An extra parameter is needed to hold this information.
It's commonly called an aggregator, or <code>agg</code> for short.
For multiplication you start at <code>1</code> (identity, <code>n * 1 === n</code> and <code>1 * n === n</code>).
Along the way, you multiply the aggregator with the current value of <code>n</code>, thereby keeping track of how far you've come with the product.
The aggregator will look like this over time:</p>
<ul>
<li><code>1</code></li>
<li><code>1 * n</code></li>
<li><code>1 * n * (n - 1)</code></li>
<li><code>1 * n * (n - 1) * (n - 2)</code></li>
<li>etc.</li>
</ul>
<p>When you finally hit <code>1</code> for <code>n</code>, you simply return the aggregator, because it already contains the correct result.</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-storage z-type z-storage">const</span><span class="z-entity z-name z-function"> tailFactorial</span><span class="z-keyword z-keyword z-operator"> =</span><span> (</span><span class="z-variable z-variable z-parameter">n</span><span class="z-punctuation z-separator">,</span><span class="z-variable z-variable z-parameter"> agg</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 1</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-keyword"> if</span><span class="z-meta z-block"> (</span><span class="z-variable z-other z-variable">n</span><span class="z-keyword z-keyword z-operator"> ></span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block">)</span><span class="z-keyword"> return</span><span class="z-entity z-name z-function"> tailFactorial</span><span class="z-meta z-block">(</span><span class="z-variable z-other z-variable">n</span><span class="z-keyword z-keyword z-operator"> -</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block z-punctuation z-separator">,</span><span class="z-variable z-other z-variable"> agg</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-variable z-other z-variable"> n</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-keyword"> return</span><span class="z-variable z-other z-variable"> agg</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-meta z-block">}</span><span class="z-punctuation z-terminator">;</span></span></code></pre>
<p>As you can see, the call <code>tailFactorial(...)</code> is directly returned, no information from the current stack frame is required anymore.</p>
<h2 id="alternative-function-signature">Alternative function signature</h2>
<p>Even though you invoke <code>tailFactorial(5)</code>, the definition has two parameters, <code>n</code> and <code>agg</code>.
The aggregator has a default value, so you need not provide it.
But since it's exposed in the function's interface, someone can call <code>tailFactorial(5, 0)</code> and get a wrong result.
Because nobody should mess with <code>agg</code>, it's better to hide it.</p>
<p>Wrap it with a function that only allows the parameter <code>n</code> and make it an inner function of that wrapper function.
Within that wrapper function, pass the call on to the inner function.</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> Alternative way (not exposing the aggregator)</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage">const</span><span class="z-entity z-name z-function"> tailFactorialAlt</span><span class="z-keyword z-keyword z-operator"> =</span><span> (</span><span class="z-variable z-variable z-parameter">n</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> const</span><span class="z-entity z-name z-function"> innerTailFactorial</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-meta z-block"> (</span><span class="z-variable z-variable z-parameter">x</span><span class="z-meta z-block z-punctuation z-separator">,</span><span class="z-variable z-variable z-parameter"> agg</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block">)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-keyword"> if</span><span class="z-meta z-block"> (</span><span class="z-variable z-other z-variable">x</span><span class="z-keyword z-keyword z-operator"> ></span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block">)</span><span class="z-keyword"> return</span><span class="z-entity z-name z-function"> innerTailFactorial</span><span class="z-meta z-block">(</span><span class="z-variable z-other z-variable">x</span><span class="z-keyword z-keyword z-operator"> -</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block z-punctuation z-separator">,</span><span class="z-variable z-other z-variable"> agg</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-variable z-other z-variable"> x</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-keyword"> return</span><span class="z-variable z-other z-variable"> agg</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-meta z-block"> }</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-keyword"> return</span><span class="z-entity z-name z-function"> innerTailFactorial</span><span class="z-meta z-block">(</span><span class="z-variable z-other z-variable">n</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-meta z-block">}</span><span class="z-punctuation z-terminator">;</span></span></code></pre>
<p>I will not use this alternative function signature, because it's too verbose and not helping me make my point.
Still, I highly recommend that you do not expose parameters in your function interface that are neither needed nor intended for public access.</p>
<h2 id="returning-a-function-without-calling-it">Returning a function without calling it</h2>
<p>Instead of having the tail-recursive function make the tail call itself, it returns a function (with no arguments) that can call the recursive function with all arguments already in place.
This is called a <a rel="external" href="https://en.wikipedia.org/wiki/Thunk#Functional_programming">thunk</a>.
You then simply have someone to call that thunk, because the tail call is no longer made by the function.
If it returns another function, you call it again. And again.
Until the final value is returned.</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-storage z-type z-storage">const</span><span class="z-entity z-name z-function"> thunkFactorial</span><span class="z-keyword z-keyword z-operator"> =</span><span> (</span><span class="z-variable z-variable z-parameter">n</span><span class="z-punctuation z-separator">,</span><span class="z-variable z-variable z-parameter"> agg</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 1</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-keyword"> if</span><span class="z-meta z-block"> (</span><span class="z-variable z-other z-variable">n</span><span class="z-keyword z-keyword z-operator"> ></span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block">)</span><span class="z-keyword"> return</span><span class="z-meta z-block"> (</span><span class="z-meta z-block">)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-entity z-name z-function"> thunkFactorial</span><span class="z-meta z-block">(</span><span class="z-variable z-other z-variable">n</span><span class="z-keyword z-keyword z-operator"> -</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block z-punctuation z-separator">,</span><span class="z-variable z-other z-variable"> agg</span><span class="z-keyword z-keyword z-operator"> *</span><span class="z-variable z-other z-variable"> n</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-keyword"> return</span><span class="z-variable z-other z-variable"> agg</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-meta z-block">}</span><span class="z-punctuation z-terminator">;</span></span></code></pre>
<p>Since the function returns either a value or another function without calling it, it is neither recursive nor tail-recursive anymore.
The stack cannot grow and you will not run out of it.
But if your first call does not give you the final result, you end up with just another function and not with the result.</p>
<h2 id="device-for-pulling-out-functions-and-calling-them">Device for pulling out functions and calling them</h2>
<p>Since you simply pull functions/thunks out of your factorial function until the final value is returned (instead of yet another function), you have to set up a device that's doing just that.
The device is called a trampoline and it is handed a function that returns either thunks or a final value.
If a call to that function results in another function, it is called for as long as the returned type is a function.
Otherwise it returns the final result.</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-storage z-type z-storage">const</span><span class="z-entity z-name z-function"> trampoline</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-variable z-variable z-parameter"> fn</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span> (</span><span class="z-keyword z-keyword z-operator">...</span><span class="z-variable z-variable z-parameter">args</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-storage z-type z-storage"> let</span><span class="z-variable z-other z-variable"> res</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-entity z-name z-function"> fn</span><span class="z-meta z-block">(</span><span class="z-keyword z-keyword z-operator">...</span><span class="z-variable z-other z-variable">args</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-keyword"> while</span><span class="z-meta z-block"> (</span><span class="z-variable z-other z-variable">res</span><span class="z-keyword z-keyword z-operator"> instanceof</span><span class="z-entity z-name"> Function</span><span class="z-meta z-block">)</span><span class="z-variable z-other z-variable"> res</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-entity z-name z-function"> res</span><span class="z-meta z-block">(</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-keyword"> return</span><span class="z-variable z-other z-variable"> res</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-meta z-block">}</span><span class="z-punctuation z-terminator">;</span></span></code></pre><h2 id="putting-it-into-action">Putting it into action</h2>
<p>You have two things right now, a function that is returning thunks and another function that can call these thunks for as long as needed, i.e. the final result is returned.
The last thing that's left to do is to join these two functions together.</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-storage z-type z-storage">const</span><span class="z-variable z-other z-constant z-variable"> trampolineFactorial</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-entity z-name z-function"> trampoline</span><span>(</span><span class="z-variable z-other z-variable">thunkFactorial</span><span>)</span><span class="z-punctuation z-terminator">;</span></span>
<span class="giallo-l"></span>
<span class="giallo-l"><span class="z-punctuation z-definition z-comment z-comment">//</span><span class="z-comment"> Example call</span></span>
<span class="giallo-l"><span class="z-entity z-name z-function">trampolineFactorial</span><span>(</span><span class="z-constant z-constant z-numeric">5</span><span>)</span><span class="z-punctuation z-terminator">;</span></span></code></pre>
<p>All this is for Node.js and JavaScript.</p>
<h2 id="tail-recursive-fibonacci-numbers">Tail recursive Fibonacci numbers</h2>
<p>The Fibonacci sequence is defined like this: <code>F(0) = 0</code> and <code>F(1) = 1</code>.
For all <code>n > 1</code> you calculate them with <code>F(n) = F(n - 1) + F(n - 2)</code>.
This is a recursive definition.</p>
<p>What is different from the factorial example used above?
You need two independent information, the two previous values of the function.
When you want to solve the problem with tail recursion, instead of one aggregator parameter, you need to pass two aggregator parameters to the function: the two previous values.
As a rule, you need an additional parameter for every additional information that you need in the body of your function.</p>
<p>Interestingly, <code>n</code> is used as a counter, going down to <code>1</code>, but the function works its way up to the higher values.
For each call, the <code>previous</code> value becomes the <code>current</code> value from the previous call, while the <code>current</code> value is set to <code>current + previous</code>.
Until the function terminates for <code>n === 1</code>.</p>
<pre class="giallo z-code"><code data-lang="javascript"><span class="giallo-l"><span class="z-storage z-type z-storage">const</span><span class="z-entity z-name z-function"> F</span><span class="z-keyword z-keyword z-operator"> =</span><span> (</span><span class="z-variable z-variable z-parameter">n</span><span class="z-punctuation z-separator">,</span><span class="z-variable z-variable z-parameter"> previous</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 0</span><span class="z-punctuation z-separator">,</span><span class="z-variable z-variable z-parameter"> current</span><span class="z-keyword z-keyword z-operator"> =</span><span class="z-constant z-constant z-numeric"> 1</span><span>)</span><span class="z-storage z-type z-storage z-type z-function"> =></span><span class="z-meta z-block"> {</span></span>
<span class="giallo-l"><span class="z-keyword"> if</span><span class="z-meta z-block"> (</span><span class="z-variable z-other z-variable">n</span><span class="z-keyword z-keyword z-operator"> ===</span><span class="z-constant z-constant z-numeric"> 0</span><span class="z-meta z-block">)</span><span class="z-keyword"> return</span><span class="z-variable z-other z-variable"> previous</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-keyword"> if</span><span class="z-meta z-block"> (</span><span class="z-variable z-other z-variable">n</span><span class="z-keyword z-keyword z-operator"> ===</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block">)</span><span class="z-keyword"> return</span><span class="z-variable z-other z-variable"> current</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-keyword"> return</span><span class="z-entity z-name z-function"> F</span><span class="z-meta z-block">(</span><span class="z-variable z-other z-variable">n</span><span class="z-keyword z-keyword z-operator"> -</span><span class="z-constant z-constant z-numeric"> 1</span><span class="z-meta z-block z-punctuation z-separator">,</span><span class="z-variable z-other z-variable"> current</span><span class="z-meta z-block z-punctuation z-separator">,</span><span class="z-variable z-other z-variable"> current</span><span class="z-keyword z-keyword z-operator"> +</span><span class="z-variable z-other z-variable"> previous</span><span class="z-meta z-block">)</span><span class="z-meta z-block z-punctuation z-terminator">;</span></span>
<span class="giallo-l"><span class="z-meta z-block">}</span><span class="z-punctuation z-terminator">;</span></span></code></pre>
<p>You can wrap it in a function with only one parameter for <code>n</code>, which hides the aggregators <code>current</code> and <code>next</code> if you want.
Like in the example above, the original function becomes an inner function of the wrapper function.</p>
<p>As I recently found out, Fibonacci numbers also have a <a rel="external" href="https://en.wikipedia.org/wiki/Fibonacci_number#Matrix_form">closed-form expression</a>:</p>
<div class="math math-display">$$F_{n}={\cfrac {1}{\sqrt {5}}}\left({\cfrac {1+{\sqrt {5}}}{2}}\right)^{n}-{\cfrac {1}{\sqrt {5}}}\left({\cfrac {1-{\sqrt {5}}}{2}}\right)^{n}$$</div>
<p>As an aside: we were <a rel="external" href="https://www.mountaingoatsoftware.com/agile/planning-poker">estimating story points</a> during a sprint planing.
Story points roughly follow the Fibonacci numbers, so it's natural that the topic pops up from time to time.
Someone was asking if there was a closed-form expression for Fibonacci numbers, so we searched for an answer. And voilà ...</p>
<p>Using the trampoline device together with the modified tail-recursive Fibonacci function is left as an exercise for the reader.
Hint: you have to modify the tail-recursive Fibonacci function to return a function/thunk instead of returning the result of a recursive function call.</p>
<h2 id="final-thoughts">Final thoughts</h2>
<p>I use the trampoline device because Node.js does not support tail call optimization (TCO).
At one point I thought that Node.js would eventually support TCO through its use of Google's V8 engine. Google was actively working on supporting TCO in V8.
But it turned out that Google is <a rel="external" href="https://www.chromestatus.com/feature/5516876633341952">no longer pursuing</a> this path.
Since tail-recursive functions are particularly useful in functional programming, it's extremely frustrating to see so little progress.</p>
About2019-03-11T00:00:00+00:002019-03-11T00:00:00+00:00
6AI6
https://6ai6.com/pages/about/<h2 id="what-s-the-topic">What's the topic?</h2>
<p>This blog covers my findings while exploring various aspects of AI in general, with a special focus on Deep Learning, LLM and AIGC.</p>
<h2 id="the-motivation">The motivation?</h2>
<p>Why do people climb mountains?
British mountaineer George Mallory famously answered: <em>Because they're there</em>.
They want to reach the top faster, in a more efficient or elegant way, differently from anybody else, or even at all.
That's how you approach problem-solving in programming.</p>
<h2 id="do-or-not-do-there-is-no-try-yoda"><em>Do, or not do. There is no try</em>. -- Yoda</h2>
<p>The decision is not between doing something or not.
It's that <em>trying</em> is something more than just any attempt.</p>
Imprint2019-03-11T00:00:00+00:002019-03-11T00:00:00+00:00
Thomas Weitzel
https://6ai6.com/pages/imprint/<!-- Add two spaces after each line to enforce line break -->
<blockquote>
<p><em>Thomas Weitzel</em><br />
<em>Theodor-Heuss-Str. 21</em><br />
<em>63225 Langen</em><br />
<em>Germany</em></p>
</blockquote>
<p>Copyright Thomas Weitzel.</p>
<h2 id="liability-for-content">Liability for content</h2>
<p>As a service provider, I am responsible under the general laws (DDG) for my own content on these pages.
However, I am not obliged to monitor transmitted or stored third-party information or to investigate circumstances that indicate illegal activity.
Obligations to remove or block the use of information under the general laws remain unaffected.
Liability is only possible from the time of knowledge of a specific infringement.
If I become aware of violations, I will remove the content immediately.</p>
<h2 id="liability-for-links">Liability for links</h2>
<p>This website contains links to external websites of third parties. I have no influence on their content.
The provider or operator of the linked pages is always responsible.
At the time of linking, no illegal content was apparent.
Permanent monitoring of the content of the linked pages is not reasonable without concrete evidence of an infringement.
If I become aware of violations, I will remove such links immediately.</p>
<h2 id="copyright">Copyright</h2>
<p>The content and works created by me on these pages are subject to German copyright law.
Reproduction, editing, distribution, and any kind of use outside the limits of copyright law require my written consent.
Downloads and copies of this page are permitted only for private, non-commercial use.
If the content on this page was not created by me, the copyrights of third parties are respected and such content is marked.
If you notice a copyright infringement, please inform me. If violations become known, I will remove such content immediately.</p>
<p>Attributions for third-party assets used on this site are listed <a href="https://6ai6.com/pages/attributions/">here</a>.</p>
Privacy Policy2019-03-11T00:00:00+00:002019-03-11T00:00:00+00:00
Thomas Weitzel
https://6ai6.com/pages/privacy/<h2 id="general-notes">General notes</h2>
<p>Protecting your personal data matters. This website is a <strong>static information site</strong> and can be used <strong>without providing personal data</strong>.</p>
<p>I do <strong>not</strong> actively collect personal data unless optional features are used, in particular:</p>
<ul>
<li>no contact forms</li>
<li>no tracking</li>
<li>no analytics or marketing services</li>
<li>no comments or user accounts without explicit consent</li>
</ul>
<h2 id="responsible-controller">Responsible controller</h2>
<p>The responsible controller for data processing on this website is the person named in the <a href="https://6ai6.com/pages/imprint/">imprint</a>.</p>
<h2 id="hosting">Hosting</h2>
<p>This website is hosted by <strong>an internet hosting provider</strong>.</p>
<p>The web server stores information in its log files, some of which your browser transmits:</p>
<ul>
<li>IP address</li>
<li>date and time of the request</li>
<li>requested page</li>
<li>HTTP status code</li>
<li>referrer URL</li>
<li>browser and operating system information</li>
</ul>
<p>This data is used only for <strong>technical operation</strong>, <strong>security</strong>, and <strong>error analysis</strong>.</p>
<p><strong>Legal basis:</strong> Art. 6(1)(f) GDPR <br />
<strong>Legitimate interest:</strong> secure and stable operation of the website</p>
<p>The log data are stored separately and not used for profiling.</p>
<h2 id="data-processing">Data processing</h2>
<p>I have signed a data processing agreement with the hosting provider under Art. 28 GDPR.</p>
<h2 id="cookies">Cookies and browser data storage</h2>
<p>This website does not use cookies.</p>
<p>Browser storage is used in these cases:</p>
<ul>
<li>After an <strong>active click on the theme toggle</strong>, to store the display setting (<code>light</code> or <code>dark</code>) for this session in
the browser (<code>sessionStorage</code>). Legal basis: Section 25(2) No. 2 TDDDG.</li>
<li>When using the comment function, to store user-provided data and technical session information for later
comments in the browser, e.g. username/nickname, email address, optional website (<code>localStorage</code>). Legal basis:
Section 25(1) TDDDG and Art. 7 GDPR.</li>
</ul>
<p>The data storage takes place exclusively locally in the browser. Entries can be deleted there at any time.</p>
<h2 id="external-content-and-services">External content and services</h2>
<p>This website does <strong>not</strong> embed external content (e.g., YouTube, Google Fonts, tracking scripts).
All resources (scripts, images, etc.) are served locally.</p>
<h2 id="ssl-tls-encryption">SSL/TLS encryption</h2>
<p>This website uses SSL/TLS encryption. Data transmitted during a page request cannot be read by third parties.</p>
<h2 id="rights-of-data-subjects">Rights of data subjects</h2>
<p>You have the right to:</p>
<ul>
<li>access to stored personal data</li>
<li>correction or deletion</li>
<li>data portability where applicable</li>
<li>restriction of processing</li>
<li>objection to processing</li>
</ul>
<p>These rights mainly apply to technically necessary server log data. If you use the comment function, the data you enter
(e.g. name/nickname, email address, optional website) and the comment content may also be processed. In that case, the
same rights apply. On request, a comment can be deleted or anonymized unless statutory retention obligations prevent this.</p>
<p>Requests can be sent via the contact address in the imprint.</p>
<h2 id="supervisory-authority-and-right-to-file-a-complaint">Supervisory authority and right to file a complaint</h2>
<p>You have the right to file a complaint with a data protection supervisory authority. The competent authority is the
authority of your federal state of residence or the seat of the responsible controller.</p>