diff --git a/.nojekyll b/.nojekyll index 16073fc..a5876f5 100644 --- a/.nojekyll +++ b/.nojekyll @@ -1 +1 @@ -1b2c487f \ No newline at end of file +94d3304a \ No newline at end of file diff --git a/pages/gauss/solve.html b/pages/gauss/solve.html index b78f284..4e2c10d 100644 --- a/pages/gauss/solve.html +++ b/pages/gauss/solve.html @@ -564,67 +564,71 @@

bit::solve — Solver

A must be square, and b must be the same size as the number of rows in A. -

The [std::optional] return value can be safely dereferenced as a bit-vector if everything goes well. That bit-vector will be a solution \(x\) to the system \(A \cdot x = b\). The solution may or may not be unique.

+

The std::optional return value can be safely dereferenced as a bit-vector if everything goes well. That bit-vector will be a solution \(x\) to the system \(A \cdot x = b\). The solution may or may not be unique.

If there is a problem, the return value will be a std::nullopt. This happens if the system of equations has no solution. It will also be the case if A is not square or if the size of b is not the same as the number of rows in A.

-The idea is to get one solution for a system of equations with the least possible fuss. + Over \(\mathbb{F}_2\), any free variable can take on one of the values 0 and 1. Hence, if the system is consistent and has \(f\) free variables, it will have \(2^f\) possible solutions. So, a consistent system will have a unique solution only if \(A\) has full-rank. The gauss::operator(i) method iterates through potentially non-unique solutions if that is required. +We wan to get one solution for a system of equations with very little fuss.
+Over \(\mathbb{F}_2\), any free variable can take on one of the values 0 and 1. Hence, if the system is consistent and has \(f\) free variables, it will have \(2^f\) possible solutions. So, a consistent system will have a unique solution only if \(A\) has full-rank. The gauss::operator(i) method iterates through potentially non-unique solutions if that is required.

Example

#include <bit/bit.h>
-int
-main()
-{
-    std::size_t m = 12;
-
-    auto A = bit::matrix<>::random(m);
-    auto b = bit::vector<>::random(m);
-    auto x = bit::solve(A, b);
-
-    if(x) {
-        // Check that x is indeed a solution by computing A.x and comparing that to b
-        auto Ax = bit::dot(A, *x);
-        std::cout << "bit::matrix A, solution vector x, product A.x, and right hand side b\n";
+int main()
+{
+    std::size_t m = 12;
+
+    auto A = bit::matrix<>::random(m);
+    auto b = bit::vector<>::random(m);
+    auto x = bit::solve(A, b);
+
+    if (x) {
+        // Check that x is indeed a solution by computing A.x and comparing that to b
+        auto Ax = bit::dot(A, *x);
+        std::cout << "bit::matrix A, solution vector x, product A.x, and right hand side b:\n";
+        std::cout << "      A         x      A.x      b\n";
         bit::print(A, *x, Ax, b);
         std::cout << "So A.x == b? " << (Ax == b ? "YES" : "NO") << '\n';
     }
     else {
-        std::cout << "System A.x = b has NO solutions for A and b as follows\n";
-        bit::print(A, b);
-    }
-}
-

Output for a consistent system (details depend on the values of the random inputs)

-
bit::matrix A, solution vector x, product A.x, and right hand side b
-011000011001    0       0       0
-000100011010    0       0       0
-100001011010    0       0       0
-111111010000    1       1       1
-101011100101    1       1       1
-100001111100    1       0       0
-111100111110    0       0       0
-101111011010    0       0       0
-111100010110    1       1       1
-011011010000    0       0       0
-010011100101    0       1       1
-000111101001    1       1       1
-So A.x == b? YES
-

Output for an inconsistent system (details depend on the values of the random inputs)

-
System A.x = b has NO solutions for A and b as follows
-110000000111    0
-011111100001    1
-011111000101    0
-110110111011    1
-100111001101    0
-000010010010    1
-001110011110    0
-100010000001    0
-110001110110    1
-000100100010    0
-001101100010    0
-000000110000    0
+ std::cout << "System A.x = b has NO solutions for A and b as follows:\n"; + std::cout << " A x\n"; + bit::print(A, b); + } +} +

Output for a consistent system (varies on each run)

+
bit::matrix A, solution vector x, product A.x, and right hand side b:
+      A         x      A.x      b
+001110110111    0       0       0
+100011110000    0       1       1
+110010110000    0       0       0
+011101011001    0       0       0
+011001111001    1       0       0
+011010011110    1       0       0
+110110110101    0       0       0
+100000010101    1       1       1
+010101000101    1       1       1
+110000011111    1       0       0
+001010000011    0       0       0
+110111110111    1       1       1
+So A.x == b? YES
+

Output for an inconsistent system (varies on each run)

+
System A.x = b has NO solutions for A and b as follows:
+      A         x
+010100100011    1
+000010010000    1
+000111111011    1
+000111111011    1
+001101110011    1
+111001110111    1
+010001010111    1
+101011000001    0
+110101110111    0
+111000010000    0
+011011010100    1
+011001110010    0

See Also

gauss::operator()
diff --git a/pages/notes/gf2.html b/pages/notes/gf2.html index 074caf7..b6b78e8 100644 --- a/pages/notes/gf2.html +++ b/pages/notes/gf2.html @@ -615,7 +615,7 @@

Some things are si

Gaussian Elimination in \(\mathbb{F}_2\)

Suppose that \(A\) is an \(n \times n\) matrix over \(\mathbb{F}_2\) and \(b\) is a compatibly sized bit-vector where we are interested in finding an \(x\) satisfying \(A \cdot x = b\). Then the pseudocode for Gaussian elimination looks like:

-
+
\begin{algorithm} \caption{Gaussian Elimination in $F_2$} \begin{algorithmic} \Procedure{Solve}{$A, b, n$} \For {$j = 0$ \To $n - 1$} \State $s = j$ \While {$A(s,j) = 0$} \State $s = s + 1$ \EndWhile \If {$s > n$} \Continue \EndIf \If {$ s \ne j$} \State swap rows $s$ and $j$ in the matrix $A$ \State swap elements $s$ and $j$ in the vector $b$ \EndIf \For {$i = j+1$ \To $n$} \If {$A(i,j) == 1$} \State replace row $i$ in $A$ with the sum of rows $i$ and $j$ \State replace element $i$ in $b$ with the sum of elements $i$ and $j$ \EndIf \EndFor \EndFor \EndProcedure \end{algorithmic} \end{algorithm}
diff --git a/pages/notes/reduction.html b/pages/notes/reduction.html index 07d865c..07a531c 100644 --- a/pages/notes/reduction.html +++ b/pages/notes/reduction.html @@ -681,7 +681,7 @@

With those in place we can proceed as follows (this is just a sketch):

-
+
\begin{algorithm} \caption{Modular Reduction of $x^N$} \begin{algorithmic} \Require $\mathbf{p}$, a bit-vector of size $n$, where $P(x) = x^n + p(x)$ and $\mathbf{p} \sim p(x)$. Unchanged on output. \Require $\mathbf{r}$, a destination bit-vector of size $n$. On output $\mathbf{r} \sim r(x) = x^N \mid P(x)$. \Procedure{reduce}{$N$, $\mathbf{p}$} \State $\mathbf{r} \gets \mathbf{0}$ \State $r_1 = 1$ \While{$N > 0$} \If{$N \text{ mod } 2 = 1$} \State \Call{MultiplyStep}{$\mathbf{r}$} \EndIf \State \Call{SquareStep}{$\mathbf{r}$} \State $N \gets N \gg 1$ \EndWhile \EndProcedure \end{algorithmic} \end{algorithm}
@@ -694,7 +694,7 @@

The Multiply Step

\] then the following procedure performs the step \[ q(x) \gets x q(x) \mod P(x), \] where \(q(x)\) is represented by the bit-vector of its \(n\) coefficients \(\bold{q} = [q_0, q_1, \ldots, q_{n-1}]\).

-
+
\begin{algorithm} \caption{The step: $q(x) \gets x q(x) \mid P(x)$.} \begin{algorithmic} \Require $\mathbf{p} \sim p(x)$ is a known bit-vector of size $n$, where $P(x) = x^n + p(x)$. \Require $\mathbf{q}$ is a bit-vector of size $n > 0$. \Procedure{MultiplyStep}{$\mathbf{q}$} \State $tmp \gets q_{n-1}$ \State $\mathbf{q} \gets \mathbf{q} \gg 1$ \If {$tmp$} \State $\mathbf{q} \gets \mathbf{q} \wedge \mathbf{p}$ \EndIf \EndProcedure \end{algorithmic} \end{algorithm}
@@ -732,7 +732,7 @@

The Square Step

\bold{x}^0 = \bold{p}. \] With that starting point, we can easily fill in bit vectors \(\bold{x}^i\) for \(i = 1, \ldots, n-1\) by using Algorithm 2.

The squaring step looks like the following:

-
+
\begin{algorithm} \caption{The step: $q(x) \gets q(x)^2 \mid P(x)$.} \begin{algorithmic} \Require $\mathbf{p} \sim p(x)$ is a known bit-vector of size $n$, where $P(x) = x^n + p(x)$. \Require $\mathbf{x}^i$ are known bit-vectors, where $\mathbf{x}^i \sim x^{n+i} \mid P(x)$. \Require $\mathbf{s}, \mathbf{l}$ and $\mathbf{h}$ are available workspace bit-vectors. \Require $\mathbf{q}$ is a bit-vector of size $n > 0$. \Procedure{SquareStep}{$\mathbf{q}$} \State // \textit{Riffle $\mathbf{q}$ into $\mathbf{s}$.} \State \Call{riffle}{$\mathbf{q}$, $\mathbf{s}$} \State // \textit{Fill $\mathbf{l}$ with a copy of the first $n$ elements from $\mathbf{s}$ and $\mathbf{h}$ with the rest.} \State \Call{split}{$\mathbf{s}$, $n$, $\mathbf{l}$, $\mathbf{h}$} \State $\mathbf{q} \gets \mathbf{l}$ \For {$i \gets 0, n-1$} \If{$h_i$} \State $\mathbf{q} \gets \mathbf{q} \wedge \mathbf{x}^i$ \EndIf \EndFor \EndProcedure \end{algorithmic} \end{algorithm}
diff --git a/search.json b/search.json index e2e6840..38fce3d 100644 --- a/search.json +++ b/search.json @@ -1264,7 +1264,7 @@ "href": "pages/gauss/solve.html", "title": "bit::solve — Solver", "section": "", - "text": "We supply a standalone non-member function that attempts to solve the system of linear equations \\(A \\cdot x = b\\) over \\(\\mathbb{F}_2\\).\nstd::optional<bit::vector>\n1bit::solve(const bit::matrix &A, const bit::vector &b)\n\n1\n\nA must be square, and b must be the same size as the number of rows in A.\n\n\nThe [std::optional] return value can be safely dereferenced as a bit-vector if everything goes well. That bit-vector will be a solution \\(x\\) to the system \\(A \\cdot x = b\\). The solution may or may not be unique.\nIf there is a problem, the return value will be a std::nullopt. This happens if the system of equations has no solution. It will also be the case if A is not square or if the size of b is not the same as the number of rows in A.\n\n \n \n \n \nThe idea is to get one solution for a system of equations with the least possible fuss. + Over \\(\\mathbb{F}_2\\), any free variable can take on one of the values 0 and 1. Hence, if the system is consistent and has \\(f\\) free variables, it will have \\(2^f\\) possible solutions. So, a consistent system will have a unique solution only if \\(A\\) has full-rank. The gauss::operator(i) method iterates through potentially non-unique solutions if that is required.\n\nExample\n#include <bit/bit.h>\nint\nmain()\n{\n std::size_t m = 12;\n\n auto A = bit::matrix<>::random(m);\n auto b = bit::vector<>::random(m);\n auto x = bit::solve(A, b);\n\n if(x) {\n // Check that x is indeed a solution by computing A.x and comparing that to b\n auto Ax = bit::dot(A, *x);\n std::cout << \"bit::matrix A, solution vector x, product A.x, and right hand side b\\n\";\n bit::print(A, *x, Ax, b);\n std::cout << \"So A.x == b? \" << (Ax == b ? \"YES\" : \"NO\") << '\\n';\n }\n else {\n std::cout << \"System A.x = b has NO solutions for A and b as follows\\n\";\n bit::print(A, b);\n }\n}\nOutput for a consistent system (details depend on the values of the random inputs)\nbit::matrix A, solution vector x, product A.x, and right hand side b\n011000011001 0 0 0\n000100011010 0 0 0\n100001011010 0 0 0\n111111010000 1 1 1\n101011100101 1 1 1\n100001111100 1 0 0\n111100111110 0 0 0\n101111011010 0 0 0\n111100010110 1 1 1\n011011010000 0 0 0\n010011100101 0 1 1\n000111101001 1 1 1\nSo A.x == b? YES\nOutput for an inconsistent system (details depend on the values of the random inputs)\nSystem A.x = b has NO solutions for A and b as follows\n110000000111 0\n011111100001 1\n011111000101 0\n110110111011 1\n100111001101 0\n000010010010 1\n001110011110 0\n100010000001 0\n110001110110 1\n000100100010 0\n001101100010 0\n000000110000 0\n\nSee Also\ngauss::operator()\ngauss::operator(i)\n\n\n\n\n Back to top" + "text": "We supply a standalone non-member function that attempts to solve the system of linear equations \\(A \\cdot x = b\\) over \\(\\mathbb{F}_2\\).\nstd::optional<bit::vector>\n1bit::solve(const bit::matrix &A, const bit::vector &b)\n\n1\n\nA must be square, and b must be the same size as the number of rows in A.\n\n\nThe std::optional return value can be safely dereferenced as a bit-vector if everything goes well. That bit-vector will be a solution \\(x\\) to the system \\(A \\cdot x = b\\). The solution may or may not be unique.\nIf there is a problem, the return value will be a std::nullopt. This happens if the system of equations has no solution. It will also be the case if A is not square or if the size of b is not the same as the number of rows in A.\n\n \n \n \n \nWe wan to get one solution for a system of equations with very little fuss.\nOver \\(\\mathbb{F}_2\\), any free variable can take on one of the values 0 and 1. Hence, if the system is consistent and has \\(f\\) free variables, it will have \\(2^f\\) possible solutions. So, a consistent system will have a unique solution only if \\(A\\) has full-rank. The gauss::operator(i) method iterates through potentially non-unique solutions if that is required.\n\nExample\n#include <bit/bit.h>\nint main()\n{\n std::size_t m = 12;\n\n auto A = bit::matrix<>::random(m);\n auto b = bit::vector<>::random(m);\n auto x = bit::solve(A, b);\n\n if (x) {\n // Check that x is indeed a solution by computing A.x and comparing that to b\n auto Ax = bit::dot(A, *x);\n std::cout << \"bit::matrix A, solution vector x, product A.x, and right hand side b:\\n\";\n std::cout << \" A x A.x b\\n\";\n bit::print(A, *x, Ax, b);\n std::cout << \"So A.x == b? \" << (Ax == b ? \"YES\" : \"NO\") << '\\n';\n }\n else {\n std::cout << \"System A.x = b has NO solutions for A and b as follows:\\n\";\n std::cout << \" A x\\n\";\n bit::print(A, b);\n }\n}\nOutput for a consistent system (varies on each run)\nbit::matrix A, solution vector x, product A.x, and right hand side b:\n A x A.x b\n001110110111 0 0 0\n100011110000 0 1 1\n110010110000 0 0 0\n011101011001 0 0 0\n011001111001 1 0 0\n011010011110 1 0 0\n110110110101 0 0 0\n100000010101 1 1 1\n010101000101 1 1 1\n110000011111 1 0 0\n001010000011 0 0 0\n110111110111 1 1 1\nSo A.x == b? YES\nOutput for an inconsistent system (varies on each run)\nSystem A.x = b has NO solutions for A and b as follows:\n A x\n010100100011 1\n000010010000 1\n000111111011 1\n000111111011 1\n001101110011 1\n111001110111 1\n010001010111 1\n101011000001 0\n110101110111 0\n111000010000 0\n011011010100 1\n011001110010 0\n\nSee Also\ngauss::operator()\ngauss::operator(i)\n\n\n\n\n Back to top" }, { "objectID": "pages/gauss/constructors.html", diff --git a/sitemap.xml b/sitemap.xml index d848544..a8a70c5 100644 --- a/sitemap.xml +++ b/sitemap.xml @@ -2,502 +2,502 @@ https://nessan.github.io/bit/pages/matrix/constructors.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/logical-op-eq.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/random.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/add-pop.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/invert.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/resize.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/triangle.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/matrix/from.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/capacity.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/transpose.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/pow.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/sub.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/shrink_to_fit.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/size.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/is_special.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/to_vector.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/dot.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/all.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/stream.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/logical-op.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/vector/join.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/constructors.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/logical-op-eq.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/index.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/import_bits.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/riffled.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/vector/set_if.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/vector/resize.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/replace.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/from.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/to_string.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/vector/swap_elements.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/vector/formatter.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/trimmed.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/vector/specials.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/vector/if_set_call.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/indices.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/blocks.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/push-pop.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/all.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/stream.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/lu/constructors.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/lu/invert.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/lu/queries.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/lu/functor.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/gauss/index.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/gauss/queries.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/gauss/functor.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/notes/index.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/notes/danilevsky.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/notes/gf2.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/constructors.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/index.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/special.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/monic.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/degree.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/formatter.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/evaluation.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/shrink_to_fit.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/power.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/split.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/times_x.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/index.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/polynomial/stream.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/access.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/size.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/count.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/sub.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/reduce.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/to_string.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/reference.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/random.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/squared.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/polynomial/arithmetic.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/verify/index.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/notes/reduction.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/notes/design.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/faq/index.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/gauss/access.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/gauss/solve.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/gauss/constructors.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/lu/access.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/lu/permute.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/lu/index.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/vector/logical-op.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/shift.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/vector/access.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/dot.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/clear.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/size.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/vector/count.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/sub.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/vector/set.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/vector/swap.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/vector/capacity.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/diff.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/export_bits.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/reference.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/append.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/description.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/random.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/first_set.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/convolution.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/reserve.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.038Z https://nessan.github.io/bit/pages/vector/unit_floor.html - 2024-08-26T10:00:06.167Z + 2024-08-26T12:04:25.042Z https://nessan.github.io/bit/pages/index.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/companion.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/shift.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/access.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/clear.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/characteristic_polynomial.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/probability.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/count.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/specials.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/set.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/formatter.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/swap.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/to_string.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/echelon.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/replace.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/append.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/set_if.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/description.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/index.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z https://nessan.github.io/bit/pages/matrix/print.html - 2024-08-26T10:00:06.163Z + 2024-08-26T12:04:25.034Z