fix baseurl links

jakobkogler · jakobkogler · commit d996e09fb03b · 2021-08-14T13:30:39.000+02:00
diff --git a/build/build.py b/build/build.py
@@ -1,7 +1,6 @@
 """Converter of the e-maxx-eng project into HTML
 
 Todos:
-- fix absolute links
 - fix header links (e.g. in the Segmented Tree page)
 - add CSS
 - add code highlighting
@@ -16,7 +15,6 @@
 from contextlib import redirect_stderr
 import io
 
-
 import markdown  # type: ignore
 from tqdm import tqdm  # type: ignore
 
@@ -43,6 +41,11 @@ def parse_arguments(args=None):
         required=True,
         help="path to the template file"
     )
+    arg_parser.add_argument(
+        "--baseurl",
+        default=None,
+        help="Base-URL of the website"
+    )
     arg_parser.add_argument(
         "--show-progress",
         const=True,
@@ -58,6 +61,7 @@ class MarkdownConverter(markdown.Markdown):
     def __init__(self, **kwargs):
         template_path = kwargs.pop("template_path")
         self.template = template_path.read_text()
+        self.baseurl = kwargs.pop("baseurl")
 
         super().__init__(**kwargs)
 
@@ -95,6 +99,7 @@ def convert(self, md_content: str) -> str:
             self.template
             .replace("&title&", title)
             .replace("&year&", str(datetime.now().year))
+            .replace("&baseurl&", self.baseurl)
             .replace("&text&", html_content)
         )
 
@@ -110,13 +115,16 @@ def main():
         "markdown_math_escape",  # support for math formula
         "mdx_linkify",  # convert text that looks like links into links
     ]
+    baseurl = args.baseurl or f"{args.output_dir}/"
     md = MarkdownConverter(
         extensions=extensions,
-        template_path=args.template_path
+        template_path=args.template_path,
+        baseurl=baseurl
     )
 
     input_paths = list(args.input_dir.glob("**/*.md"))
     for input_path in tqdm(input_paths, disable=not args.show_progress):
+        relative_path = input_path.relative_to(args.input_dir)
         # read
         md_content = input_path.read_text()
 
@@ -125,11 +133,10 @@ def main():
         with redirect_stderr(f):
             html_content = md.convert(md_content)
         if f.getvalue():
-            print(input_path.relative_to(args.input_dir))
+            print(relative_path)
             print(f.getvalue())
 
         # write
-        relative_path = input_path.relative_to(args.input_dir)
         output_path = args.output_dir / relative_path.with_suffix(".html")
         output_path.parent.mkdir(parents=True, exist_ok=True)
         output_path.write_text(html_content)
diff --git a/src/_templates/default.html b/src/_templates/default.html
@@ -27,7 +27,7 @@
 <div id="container">
     <div id="navbar">
         <span id="title">
-            <a href="./">CP-Algorithms</a>
+            <a href="./index.html">CP-Algorithms</a>
         </span>
         <span id="menu">
             <a href="&history&" title="Changes History">Page Authors</a>
diff --git a/src/algebra/extended-euclid-algorithm.md b/src/algebra/extended-euclid-algorithm.md
@@ -1,7 +1,7 @@
 <!--?title Extended Euclidean Algorithm  -->
 # Extended Euclidean Algorithm
 
-While the [Euclidean algorithm](../algebra/euclid-algorithm.html) calculates only the greatest common divisor (GCD) of two integers $a$ and $b$, the extended version also finds a way to represent GCD in terms of $a$ and $b$, i.e. coefficients $x$ and $y$ for which:
+While the [Euclidean algorithm](./algebra/euclid-algorithm.html) calculates only the greatest common divisor (GCD) of two integers $a$ and $b$, the extended version also finds a way to represent GCD in terms of $a$ and $b$, i.e. coefficients $x$ and $y$ for which:
 
 $$a \cdot x + b \cdot y = \gcd(a, b)$$
 
diff --git a/src/algebra/phi-function.md b/src/algebra/phi-function.md
@@ -23,7 +23,7 @@ The following properties of Euler totient function are sufficient to calculate i
 
   - If $a$ and $b$ are relatively prime, then:
     $$\phi(a b) = \phi(a) \cdot \phi(b).$$
-    This relation is not trivial to see. It follows from the [Chinese remainder theorem](../algebra/chinese-remainder-theorem.html). The Chinese remainder theorem guarantees, that for each $0 \le x < a$ and each $0 \le y < b$, there exists a unique $0 \le z < a b$ with $z \equiv x \pmod{a}$ and $z \equiv y \pmod{b}$. It's not hard to show that $z$ is coprime to $a b$ if and only if $x$ is coprime to $a$ and $y$ is coprime to $b$. Therefore the amount of integers coprime to $a b$ is equal to product of the amounts of $a$ and $b$.
+    This relation is not trivial to see. It follows from the [Chinese remainder theorem](./algebra/chinese-remainder-theorem.html). The Chinese remainder theorem guarantees, that for each $0 \le x < a$ and each $0 \le y < b$, there exists a unique $0 \le z < a b$ with $z \equiv x \pmod{a}$ and $z \equiv y \pmod{b}$. It's not hard to show that $z$ is coprime to $a b$ if and only if $x$ is coprime to $a$ and $y$ is coprime to $b$. Therefore the amount of integers coprime to $a b$ is equal to product of the amounts of $a$ and $b$.
 
   - In general, for not coprime $a$ and $b$, the equation $$\phi(ab) = \phi(a) \cdot \phi(b) \cdot \dfrac{d}{\phi(d)}$$ with $d = \gcd(a, b)$ holds.
 
@@ -121,7 +121,7 @@ $$a^{\phi(m)} \equiv 1 \pmod m$$ if $a$ and $m$ are relatively prime.
 In the particular case when $m$ is prime, Euler's theorem turns into **Fermat's little theorem**:
 $$a^{m - 1} \equiv 1 \pmod m$$
 
-Euler's theorem and Euler's totient function occur quite often in practical applications, for example both are used to compute the [modular multiplicative inverse](../algebra/module-inverse.html).
+Euler's theorem and Euler's totient function occur quite often in practical applications, for example both are used to compute the [modular multiplicative inverse](./algebra/module-inverse.html).
 
 As immediate consequence we also get the equivalence:
 $$a^n \equiv a^{n \bmod \phi(m)} \pmod m$$
diff --git a/src/algebra/primality_tests.md b/src/algebra/primality_tests.md
@@ -32,7 +32,7 @@ Multiple such optimizations are described in the article about [integer factoriz
 
 This is a probabilistic test.
 
-Fermat's little theorem (see also [Euler's totient function](https://cp-algorithms.com/algebra/phi-function.html)) states, that for a prime number $p$ and a coprime integer $a$ the following equation holds:
+Fermat's little theorem (see also [Euler's totient function](./algebra/phi-function.html)) states, that for a prime number $p$ and a coprime integer $a$ the following equation holds:
 
 $$a^{p-1} \equiv 1 \bmod p$$
 
diff --git a/src/sequences/rmq.md b/src/sequences/rmq.md
@@ -5,7 +5,7 @@
 You are given an array $A[1..N]$.
 You have to answer incoming queries of the form $(L, R)$, which ask to find the minimum element in array $A$ between positions $L$ and $R$ inclusive.
 
-RMQ can appear in problems directly or can be applied in some other tasks, e.g. the [Lowest Common Ancestor](../graph/lca.html) problem.
+RMQ can appear in problems directly or can be applied in some other tasks, e.g. the [Lowest Common Ancestor](./graph/lca.html) problem.
 
 ## Solution
 
@@ -15,20 +15,20 @@ The ones that are explained on this site are listed below.
 
 First the approaches that allow modifications to the array between answering queries.
 
-- [Sqrt-decomposition](../data_structures/sqrt_decomposition.html) - answers each query in $O(\sqrt{N})$, preprocessing done in $O(N)$.
+- [Sqrt-decomposition](./data_structures/sqrt_decomposition.html) - answers each query in $O(\sqrt{N})$, preprocessing done in $O(N)$.
   Pros: a very simple data structure. Cons: worse complexity.
-- [Segment tree](../data_structures/segment_tree.html) - answers each query in $O(\log N)$, preprocessing done in $O(N)$.
+- [Segment tree](./data_structures/segment_tree.html) - answers each query in $O(\log N)$, preprocessing done in $O(N)$.
   Pros: good time complexity. Cons: larger amount of code compared to the other data structures.
-- [Fenwick tree](../data_structures/fenwick.html) - answers each query in $O(\log N)$, preprocessing done in $O(N \log N)$.
+- [Fenwick tree](./data_structures/fenwick.html) - answers each query in $O(\log N)$, preprocessing done in $O(N \log N)$.
   Pros: the shortest code, good time complexity. Cons: Fenwick tree can only be used for queries with $L = 1$, so it is not applicable to many problems.
 
 And here are the approaches that only work on static arrays, i.e. it is not possible to change a value in the array without recomputing the complete data structure.
 
-- [Sparse Table](../data_structures/sparse-table.html) - answers each query in $O(1)$, preprocessing done in $O(N \log N)$.
+- [Sparse Table](./data_structures/sparse-table.html) - answers each query in $O(1)$, preprocessing done in $O(N \log N)$.
   Pros: simple data structure, excellent time complexity.
-- [Sqrt Tree](../data_structures/sqrt-tree.html) - answers queries in $O(1)$, preprocessing done in $O(N \log \log N)$. Pros: fast. Cons: Complicated to implement.
-- [Disjoint Set Union / Arpa's Trick](../data_structures/disjoint_set_union.html#arpa) - answers queries in $O(1)$, preprocessing in $O(n)$. Pros: short, fast. Cons: only works if all queries are known in advance, i.e. only supports off-line processing of the queries.
-- [Cartesian Tree](../graph/rmq_linear.html) and [Farach-Colton and Bender algorithm](../graph/lca_farachcoltonbender.html) - answers queries in $O(1)$, preprocessing in $O(n)$. Pros: optimal complexity. Cons: large amount of code.
+- [Sqrt Tree](./data_structures/sqrt-tree.html) - answers queries in $O(1)$, preprocessing done in $O(N \log \log N)$. Pros: fast. Cons: Complicated to implement.
+- [Disjoint Set Union / Arpa's Trick](./data_structures/disjoint_set_union.html#arpa) - answers queries in $O(1)$, preprocessing in $O(n)$. Pros: short, fast. Cons: only works if all queries are known in advance, i.e. only supports off-line processing of the queries.
+- [Cartesian Tree](./graph/rmq_linear.html) and [Farach-Colton and Bender algorithm](./graph/lca_farachcoltonbender.html) - answers queries in $O(1)$, preprocessing in $O(n)$. Pros: optimal complexity. Cons: large amount of code.
 
 Note: Preprocessing is the preliminary processing of the given array by building the corresponding data structure for it.
 
