+
diff --git a/content/posts/20230618_classify_blood_cells_using_neural_networks.md b/content/posts/20230618_classify_blood_cells_using_neural_networks.md
index 3c07e34..ef9c791 100755
--- a/content/posts/20230618_classify_blood_cells_using_neural_networks.md
+++ b/content/posts/20230618_classify_blood_cells_using_neural_networks.md
@@ -7,6 +7,7 @@ slug: classify-blood-cells-using-neural-networks
author: Samuel Ortion
Summary: Machine Learning is widely used for image recognition. Here, we tried to perform blood cell classification using Convolutional Neural Networks.
lang: en
+draft: true
---
## Introduction
diff --git a/content/posts/20240114_unixfu.org b/content/posts/20240114_unixfu.org
index 076431e..0c57662 100755
--- a/content/posts/20240114_unixfu.org
+++ b/content/posts/20240114_unixfu.org
@@ -2,7 +2,7 @@
#+date: <2024-01-14 Sun>
#+category: linux
-A bin for some useful UNIX command.
+A bean for some useful UNIX command snippets.
* Add two hours
diff --git a/content/posts/20240309_pseudocode_in_hugo.md b/content/posts/20240309_pseudocode_in_hugo.md
index 9e33996..429fd7a 100644
--- a/content/posts/20240309_pseudocode_in_hugo.md
+++ b/content/posts/20240309_pseudocode_in_hugo.md
@@ -13,19 +13,9 @@ Here is what I did to make this working on my blog.
In your theme files, you will first need to add link to the library CDN.
```html
-
-
diff --git a/content/posts/20240313_eulerian_path_Hierholzer.md b/content/posts/20240313_eulerian_path_Hierholzer.md
new file mode 100644
index 0000000..e2ac5de
--- /dev/null
+++ b/content/posts/20240313_eulerian_path_Hierholzer.md
@@ -0,0 +1,135 @@
+---
+title: Find an Eulerian Path with the Hierholzer Algorithm
+date: 2024-03-13
+pseudocode: true
+slug: hierholzer-algorithm
+draft: true
+---
+An Eulerian path of a graph is a path that passes once on every edge of the graph.
+
+The Hierholzer algorithm allows to find this path.
+
+The algorithm proceeds as follows:
+1. Choose any vertex $v_0$ of the graph $G = (V, E)$. Starting from $v_0$, build a path $c$ that passes only once per edge until it reaches $v_0$ again.
+2. If $c$ is an Eulerian cycle, we have found the Eulerian path, else
+ - Ignore all edges from $c$.
+ - For the first vertex $u$ from $c$ whose degree is not null, build an other cycle $c'$ that passes only once per edges, and does not pass in the previously visited edges.
+ - Insert $c'$ in $c$ by replacing the starting node $u$.
+ - Repeat the second step until we have an Eulerian path.
+
+
+## Pseudocode
+
+\begin{algorithm}
+\caption{Hierholzer algorithm for Eulerian path finding}
+\begin{algorithmic}
+\Function{EulerianPath}{$G: (V, E)$}
+\State $c \gets$ an empty Doubly Linked List
+\State $E' \gets E$
+\State $v_0$ becomes the first vertex from $V$
+\State $u \gets v_0$
+\State \Comment{Find the first cycle}
+\While{$\exists (u, v) \in E'$}
+ \State $c$.insert($u$)
+ \State $u \gets v$
+ \State $E' \gets E' \setminus \{(u, v)\}$
+ \If {$u = v_0$}
+ \Break
+ \EndIf
+\EndWhile
+\State \Comment{Add the other cycles}
+\While {$c$.length $< |E|$}
+\State \Comment{Find the next vertex with non null degree}
+\State $v_0 \gets c$.value
+\While {$\nexists (v_0, v) \in E'$}
+\State $c \gets c$.next
+\State $v_0 \gets c$.value
+\State $u \gets v_0$
+\EndWhile
+\State \Comment{Insert the next cycle in $c$}
+\State $c$.delete() \Comment{Ensure $v_0$ is not present twice there}
+\While {$\exists (u, v) \in E'$}
+ \State $c$.insert($u$)
+ \State $u \gets v$
+ \State $E' \gets E' \setminus \{(u, v)\}$
+ \If {$u = v_0$}
+ \Break
+ \EndIf
+\EndWhile
+\EndWhile
+\EndFunction
+\end{algorithmic}
+\end{algorithm}
+
+
+## Rust implantation
+
+```rust
+use std::collections::{HashMap, LinkedList};
+use std::io::Error;
+
+/// Eulerian path
+///
+/// Warning: this assumes the graph is Eulerian
+fn eulerian_path(graph: HashMap
+ \begin{algorithm}
+ \caption{Mixed-radix generation}
+ \begin{algorithmic}
+ \State \textbf{M1.} [Initialize.] Set $a_j \gets 0$ for $0 \leq j \leq n$, and set $m_0 \gets 2$.
+ \State \textbf{M2.} [Visit.] Visit the \(n\)-tuple $(a_1, ..., a_n)$ (The program that wants to examine all $n$-tuples now does its thing.)
+ \State \textbf{M3.} [Prepare to add one.] Set $j \gets n$.
+ \State \textbf{M4.} [Carry if necessary.] If $a_j = m_j - 1$, set $a_j \gets 0$, $j \gets j - 1$ and repeat this step.
+ \State \textbf{M5.} [Increase, unless done.] If $j = 0$, terminate the algorithm. Otherwise set $a_j \gets a_j + 1$ and go back to step M2.
+ \end{algorithmic}
+ \end{algorithm}
+
+
+## References
+
+
+
+
diff --git a/content/sigmulus.png b/content/sigmulus.png
deleted file mode 100755
index 67d9242..0000000
Binary files a/content/sigmulus.png and /dev/null differ
diff --git a/go.mod b/go.mod
deleted file mode 100755
index 0436c2e..0000000
--- a/go.mod
+++ /dev/null
@@ -1,5 +0,0 @@
-module forge.s1gm4.eu/sortion/org-blog
-
-go 1.21.5
-
-require github.com/Mitrichius/hugo-theme-anubis v0.0.0-20231204175953-57eb2998cf2e // indirect
diff --git a/go.sum b/go.sum
deleted file mode 100755
index 0b4d568..0000000
--- a/go.sum
+++ /dev/null
@@ -1,2 +0,0 @@
-github.com/Mitrichius/hugo-theme-anubis v0.0.0-20231204175953-57eb2998cf2e h1:oCnqB3lB2ZwWA8lDsCPWHrArSGx+/g4lqR1rX33hm/E=
-github.com/Mitrichius/hugo-theme-anubis v0.0.0-20231204175953-57eb2998cf2e/go.mod h1:FKD3NbdsQzL+cXsC3x99XD/t/Rd5EyhDlNBAxQhULbo=
diff --git a/org/taocp/20240415_permutations.org b/org/taocp/20240415_permutations.org
new file mode 100644
index 0000000..1544d14
--- /dev/null
+++ b/org/taocp/20240415_permutations.org
@@ -0,0 +1,71 @@
+#+title: Mixed-radix generation - TAOCP
+#+date: <2024-04-15 Mon>
+#+category: taocp
+#+pseudocode: true
+#+bibliography: references.bib
+#+slug: taocp/permutations
+#+hugo_draft: true
+
+#+hugo_front_matter_format: yaml
+#+hugo_base_dir: ../../
+#+hugo_custom_front_matter: :pseudocode true
+
+In his draft on Generating all $n$ tuples, of The Art of Computer Programming, Knuth presents the following algorithm for the generation of $n$-tuples [cite:@knuthDraftSectionGenerating2002].
+#+begin_export html
+
+ \begin{algorithm}
+ \caption{Mixed-radix generation}
+ \begin{algorithmic}
+ \State \textbf{M1.} [Initialize.] Set $a_j \gets 0$ for $0 \leq j \leq n$, and set $m_0 \gets 2$.
+ \State \textbf{M2.} [Visit.] Visit the \(n\)-tuple $(a_1, ..., a_n)$ (The program that wants to examine all $n$-tuples now does its thing.)
+ \State \textbf{M3.} [Prepare to add one.] Set $j \gets n$.
+ \State \textbf{M4.} [Carry if necessary.] If $a_j = m_j - 1$, set $a_j \gets 0$, $j \gets j - 1$ and repeat this step.
+ \State \textbf{M5.} [Increase, unless done.] If $j = 0$, terminate the algorithm. Otherwise set $a_j \gets a_j + 1$ and go back to step M2.
+ \end{algorithmic}
+ \end{algorithm}
+
+#+end_export
+
+In this document, I try to implement this algorithm in C.
+
+
+#+begin_src C
+#include