From d73c2fc1e8347eae196749671ab4fa2ac56ed1be Mon Sep 17 00:00:00 2001
From: yoh <kawasaki.liamg@gmail.com>
Date: Thu, 11 Jul 2024 19:10:41 +0900
Subject: [PATCH] linalg: refine BLAS1 functions (#1233)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Markdownリストレイアウト崩れ修正
- 一部に内部リンク付与
- 例示コードのハイライト指定
---
 reference/linalg/apply_givens_rotation.md     |  5 +++--
 reference/linalg/copy.md                      |  4 +++-
 reference/linalg/dot.md                       |  8 +++----
 reference/linalg/dotc.md                      | 12 +++++-----
 reference/linalg/matrix_frob_norm.md          | 18 +++++++--------
 reference/linalg/matrix_inf_norm.md           | 16 +++++++-------
 reference/linalg/matrix_one_norm.md           | 16 +++++++-------
 reference/linalg/setup_givens_rotation.md     | 11 ++++++----
 .../linalg/setup_givens_rotation_result.md    |  4 +++-
 reference/linalg/swap_elements.md             |  2 ++
 reference/linalg/vector_abs_sum.md            | 20 ++++++++---------
 reference/linalg/vector_idx_abs_max.md        | 22 ++++++++++---------
 reference/linalg/vector_sum_of_squares.md     | 15 ++++++++-----
 reference/linalg/vector_two_norm.md           | 18 +++++++--------
 14 files changed, 93 insertions(+), 78 deletions(-)

diff --git a/reference/linalg/apply_givens_rotation.md b/reference/linalg/apply_givens_rotation.md
index 11ff401f7..1e8d4ed20 100644
--- a/reference/linalg/apply_givens_rotation.md
+++ b/reference/linalg/apply_givens_rotation.md
@@ -50,6 +50,7 @@ namespace std::linalg {
     complex<Real> s); // (4)
 }
 ```
+* complex[link /reference/complex/complex.md]
 
 
 ## 概要
@@ -73,8 +74,8 @@ $$
 
 ## 適格要件
 - 共通:
-  + `Real`が`complex<Real>`を規定できる型であること
-  + [`compatible-static-extents`](/reference/linalg/compatible-static-extents.md)`<InOutVec1, InOutVec2>(0,0) == true`
+    + `Real`が[`complex`](/reference/complex/complex.md)`<Real>`を規定できる型であること
+    + [`compatible-static-extents`](/reference/linalg/compatible-static-extents.md)`<InOutVec1, InOutVec2>(0,0) == true`
 - (2), (4): [`is_execution_policy`](/reference/execution/is_execution_policy.md)`<ExecutionPolicy>::value`が`true`
 
 
diff --git a/reference/linalg/copy.md b/reference/linalg/copy.md
index 586373809..668b6ff2c 100644
--- a/reference/linalg/copy.md
+++ b/reference/linalg/copy.md
@@ -30,15 +30,17 @@ namespace std::linalg {
 
 ## テンプレートパラメータ制約
 `x`と`y`の次元が等しくなければならない。
+
 - `x.rank() == y.rank()`
 
 
 ## 適格要件
-- (1), (2): 0以上`x.rank()`未満の整数rに対して、[`compatible-static-extents`](/reference/linalg/compatible-static-extents.md)`<InVec, OutVec>(r,r)`が`true`
+- (1), (2): 0以上[`x.rank()`](/reference/mdspan/mdspan/rank.md)未満の整数`r`に対して、[`compatible-static-extents`](/reference/linalg/compatible-static-extents.md)`<InVec, OutVec>(r,r)`が`true`
 - (2): [`is_execution_policy`](/reference/execution/is_execution_policy.md)`<ExecutionPolicy>::value`が`true`
 
 ## 事前条件
 `x`と`y`の各次元の要素数が等しくなければならない。
+
 - `x.extents() == y.extents()`
 
 
diff --git a/reference/linalg/dot.md b/reference/linalg/dot.md
index 8dea51686..95bf0a5c3 100644
--- a/reference/linalg/dot.md
+++ b/reference/linalg/dot.md
@@ -45,7 +45,7 @@ namespace std::linalg {
 
 ## 適格要件
 - 共通:
-  + [`compatible-static-extents`](compatible-static-extents.md)`<InVec1, InVec2>(0, 0)`が`true` (2つのベクトルの静的な要素数が同じ)
+    + [`compatible-static-extents`](compatible-static-extents.md)`<InVec1, InVec2>(0, 0)`が`true` (2つのベクトルの静的な要素数が同じ)
 - (2), (4): [`is_execution_policy`](/reference/execution/is_execution_policy.md)`<ExecutionPolicy>::value`が`true`
 
 
@@ -58,8 +58,8 @@ namespace std::linalg {
 ## 効果
 - (1), (2): なし
 - (3), (4): `T`を各ベクトルの値型の積の型`decltype(declval<typename InVec1::value_type>() * declval<typename InVec2::value_type>())`とする。
-  + (3): `dot(v1, v2, T{})`を返す。
-  + (4): `dot(std::forward<ExecutionPolicy>(exec), v1, v2, T{})`を返す。
+    + (3): `dot(v1, v2, T{})`を返す。
+    + (4): `dot(std::forward<ExecutionPolicy>(exec), v1, v2, T{})`を返す。
 
 
 ## 戻り値
@@ -77,7 +77,7 @@ $$
 
 
 ## 備考
-- (1), (2): もし`InVec1::value_type`、`InVec2::value_type`、`Scalar`が全て浮動小数点数型または`std::complex`の特殊化で、`Scalar`が`InVec1::value_type`と`InVec2::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
+- (1), (2): もし`InVec1::value_type`、`InVec2::value_type`、`Scalar`が全て浮動小数点数型または[`std::complex`](/reference/complex/complex.md)の特殊化で、`Scalar`が`InVec1::value_type`と`InVec2::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
 
 
 ## 例
diff --git a/reference/linalg/dotc.md b/reference/linalg/dotc.md
index 1349e6d16..a8dd35350 100644
--- a/reference/linalg/dotc.md
+++ b/reference/linalg/dotc.md
@@ -45,7 +45,7 @@ namespace std::linalg {
 
 ## 適格要件
 - 共通:
-  + [`compatible-static-extents`](compatible-static-extents.md)`<InVec1, InVec2>(0, 0)`が`true` (2つのベクトルの静的な要素数が同じ)
+    + [`compatible-static-extents`](compatible-static-extents.md)`<InVec1, InVec2>(0, 0)`が`true` (2つのベクトルの静的な要素数が同じ)
 - (2), (4): [`is_execution_policy`](/reference/execution/is_execution_policy.md)`<ExecutionPolicy>::value`が`true`
 
 
@@ -57,10 +57,10 @@ namespace std::linalg {
 
 ## 効果
 - (1): [`dot`](dot.md)`(`[`conjugated`](conjugated.md)`(v1), v2, init)`を返す。
-- (2): `dot(std::forward<ExecutionPolicy>(exec), conjugated(v1), v2, init)`を返す。
-- (3), (4): `T`を各ベクトルの値型の積の型`decltype(conj-if-needed(declval<typename InVec1::value_type>()) * declval<typename InVec2::value_type>())`とする。
-  + (3): `dotc(v1, v2, T{})`を返す。
-  + (4): `dotc(std::forward<ExecutionPolicy>(exec), v1, v2, T{})`を返す。
+- (2): [`dot`](dot.md)`(std::forward<ExecutionPolicy>(exec),` [`conjugated`](conjugated.md)`(v1), v2, init)`を返す。
+- (3), (4): `T`を各ベクトルの値型の積の型`decltype(`[`conj-if-needed`](conj-if-needed.md)`(declval<typename InVec1::value_type>()) * declval<typename InVec2::value_type>())`とする。
+    + (3): `dotc(v1, v2, T{})`を返す。
+    + (4): `dotc(std::forward<ExecutionPolicy>(exec), v1, v2, T{})`を返す。
 
 
 ## 戻り値
@@ -114,7 +114,7 @@ int main()
   return 0;
 }
 ```
-
+* std::linalg::dotc[color ff0000]
 
 ### 出力
 ```
diff --git a/reference/linalg/matrix_frob_norm.md b/reference/linalg/matrix_frob_norm.md
index 544a175ec..44a97bd11 100644
--- a/reference/linalg/matrix_frob_norm.md
+++ b/reference/linalg/matrix_frob_norm.md
@@ -38,13 +38,13 @@ namespace std::linalg {
 
 
 ## 適格要件
-- (1), (2): `decltype(init + `[`abs-if-needed`](abs-if-needed.md)`(declval<typename InMat::value_type>()) * abs-if-needed(declval<typename InMat::value_type>()))`が`Scalar`に変換可能。
+- (1), (2): `decltype(init +` [`abs-if-needed`](abs-if-needed.md)`(declval<typename InMat::value_type>()) * abs-if-needed(declval<typename InMat::value_type>()))`が`Scalar`に変換可能。
 - (2), (4): [`is_execution_policy`](/reference/execution/is_execution_policy.md)`<ExecutionPolicy>::value`が`true`
 
 ## 効果
-- (3), (4): `T`を`decltype(abs-if-needed(declval<typename InMat::value_type>()) * abs-if-needed(declval<typename InMat::value_type>()))`とすると、
-  + (3): `matrix_frob_norm(A, T{})`を返す。
-  + (4): `matrix_frob_norm(std::forward<ExecutionPolicy>(exec), A, T{})`を返す。
+- (3), (4): `T`を`decltype(`[`abs-if-needed`](abs-if-needed.md)`(declval<typename InMat::value_type>()) * abs-if-needed(declval<typename InMat::value_type>()))`とすると、
+    + (3): `matrix_frob_norm(A, T{})`を返す。
+    + (4): `matrix_frob_norm(std::forward<ExecutionPolicy>(exec), A, T{})`を返す。
 
 
 ## 戻り値
@@ -54,13 +54,13 @@ $$
 \sqrt{\sum_{i = 0}^{m - 1} \sum_{j = 0}^{n - 1} |\verb|A[|i, j\verb|]||^2 + \verb|init|^2}
 $$
 
-- (3), (4): `T`を`decltype(abs-if-needed(declval<typename InMat::value_type>()) * abs-if-needed(declval<typename InMat::value_type>()))`とすると、
-  + (3): `matrix_frob_norm(A, T{})`を返す。
-  + (4): `matrix_frob_norm(std::forward<ExecutionPolicy>(exec), A, T{})`を返す。
+- (3), (4): `T`を`decltype(`[`abs-if-needed`](abs-if-needed.md)`(declval<typename InMat::value_type>()) * abs-if-needed(declval<typename InMat::value_type>()))`とすると、
+    + (3): `matrix_frob_norm(A, T{})`を返す。
+    + (4): `matrix_frob_norm(std::forward<ExecutionPolicy>(exec), A, T{})`を返す。
 
 
 ## 備考
-- (1), (2): もし`InMat::value_type`と`Scalar`がどちらも浮動小数点数型または`std::complex`の特殊化で、`Scalar`が`InMat::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
+- (1), (2): もし`InMat::value_type`と`Scalar`がどちらも浮動小数点数型または[`std::complex`](/reference/complex/complex.md)の特殊化で、`Scalar`が`InMat::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
 
 
 ## 例
@@ -97,7 +97,7 @@ int main()
   return 0;
 }
 ```
-
+* std::linalg::matrix_frob_norm[color ff0000]
 
 ### 出力
 ```
diff --git a/reference/linalg/matrix_inf_norm.md b/reference/linalg/matrix_inf_norm.md
index 76844e853..f11272888 100644
--- a/reference/linalg/matrix_inf_norm.md
+++ b/reference/linalg/matrix_inf_norm.md
@@ -43,9 +43,9 @@ namespace std::linalg {
 
 
 ## 効果
-- (3), (4): `T`を`decltype(abs-if-needed(declval<typename InMat::value_type>()))`とすると、
-  + (3): `matrix_inf_norm(A, T{})`を返す。
-  + (4): `matrix_inf_norm(std::forward<ExecutionPolicy>(exec), A, T{})`を返す。
+- (3), (4): `T`を`decltype(`[`abs-if-needed`](abs-if-needed.md)`(declval<typename InMat::value_type>()))`とすると、
+    + (3): `matrix_inf_norm(A, T{})`を返す。
+    + (4): `matrix_inf_norm(std::forward<ExecutionPolicy>(exec), A, T{})`を返す。
 
 
 ## 戻り値
@@ -57,13 +57,13 @@ $$
 \verb|init| + \max_{i = 0, \dots ,m - 1}\sum_{j = 0}^{n - 1} |\verb|A[|i, j\verb|]||
 $$
 
-- (3), (4): `T`を`decltype(abs-if-needed(declval<typename InMat::value_type>()))`とすると、
-  + (3): `matrix_inf_norm(A, T{})`を返す。
-  + (4): `matrix_inf_norm(std::forward<ExecutionPolicy>(exec), A, T{})`を返す。
+- (3), (4): `T`を`decltype(`[`abs-if-needed`](abs-if-needed.md)`(declval<typename InMat::value_type>()))`とすると、
+    + (3): `matrix_inf_norm(A, T{})`を返す。
+    + (4): `matrix_inf_norm(std::forward<ExecutionPolicy>(exec), A, T{})`を返す。
 
 
 ## 備考
-- (1), (2): もし`InMat::value_type`と`Scalar`がどちらも浮動小数点数型または`std::complex`の特殊化で、`Scalar`が`InMat::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
+- (1), (2): もし`InMat::value_type`と`Scalar`がどちらも浮動小数点数型または[`std::complex`](/reference/complex/complex.md)の特殊化で、`Scalar`が`InMat::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
 
 
 ## 例
@@ -100,7 +100,7 @@ int main()
   return 0;
 }
 ```
-
+* std::linalg::matrix_inf_norm[color ff0000]
 
 ### 出力
 ```
diff --git a/reference/linalg/matrix_one_norm.md b/reference/linalg/matrix_one_norm.md
index a0cd520e9..f736b56f9 100644
--- a/reference/linalg/matrix_one_norm.md
+++ b/reference/linalg/matrix_one_norm.md
@@ -43,9 +43,9 @@ namespace std::linalg {
 
 
 ## 効果
-- (3), (4): `T`を`decltype(abs-if-needed(declval<typename InMat::value_type>()))`とすると、
-  + (3): `matrix_one_norm(A, T{})`を返す。
-  + (4): `matrix_one_norm(std::forward<ExecutionPolicy>(exec), A, T{})`を返す。
+- (3), (4): `T`を`decltype(`[`abs-if-needed`](abs-if-needed.md)`(declval<typename InMat::value_type>()))`とすると、
+    + (3): `matrix_one_norm(A, T{})`を返す。
+    + (4): `matrix_one_norm(std::forward<ExecutionPolicy>(exec), A, T{})`を返す。
 
 
 ## 戻り値
@@ -57,13 +57,13 @@ $$
 \verb|init| + \max_{j = 0, \dots ,n - 1}\sum_{i = 0}^{m - 1} |\verb|A[|i, j\verb|]||
 $$
 
-- (3), (4): `T`を`decltype(abs-if-needed(declval<typename InMat::value_type>()))`とすると、
-  + (3): `matrix_one_norm(A, T{})`を返す。
-  + (4): `matrix_one_norm(std::forward<ExecutionPolicy>(exec), A, T{})`を返す。
+- (3), (4): `T`を`decltype(`[`abs-if-needed`](abs-if-needed.md)`(declval<typename InMat::value_type>()))`とすると、
+    + (3): `matrix_one_norm(A, T{})`を返す。
+    + (4): `matrix_one_norm(std::forward<ExecutionPolicy>(exec), A, T{})`を返す。
 
 
 ## 備考
-- (1), (2): もし`InMat::value_type`と`Scalar`がどちらも浮動小数点数型または`std::complex`の特殊化で、`Scalar`が`InMat::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
+- (1), (2): もし`InMat::value_type`と`Scalar`がどちらも浮動小数点数型または[`std::complex`](/reference/complex/complex.md)の特殊化で、`Scalar`が`InMat::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
 
 
 ## 例
@@ -100,7 +100,7 @@ int main()
   return 0;
 }
 ```
-
+* std::linalg::matrix_one_norm[color ff0000]
 
 ### 出力
 ```
diff --git a/reference/linalg/setup_givens_rotation.md b/reference/linalg/setup_givens_rotation.md
index 18c9bb4ac..f91e11574 100644
--- a/reference/linalg/setup_givens_rotation.md
+++ b/reference/linalg/setup_givens_rotation.md
@@ -9,13 +9,16 @@
 ```cpp
 namespace std::linalg {
   template<class Real>
-  setup_givens_rotation_result<Real> setup_givens_rotation(Real a, Real b) noexcept; // (1)
+  setup_givens_rotation_result<Real>
+    setup_givens_rotation(Real a, Real b) noexcept; // (1)
 
   template<class Real>
-  setup_givens_rotation_result<complex<Real>> setup_givens_rotation(complex<Real> a, complex<Real> b) noexcept; // (2)
+  setup_givens_rotation_result<complex<Real>>
+    setup_givens_rotation(complex<Real> a, complex<Real> b) noexcept; // (2)
 }
 ```
-
+* setup_givens_rotation_result[link setup_givens_rotation_result.md]
+* complex[link /reference/complex/complex.md]
 
 ## 概要
 ギブンス回転を計算する。すなわち、以下の式が成り立つような、`Real`型の値`c`と `s`, `r`を計算する。
@@ -53,7 +56,7 @@ $$
 
 
 ## 適格要件
-- `Real`は`complex<Real>`が規定できる型であること。
+- `Real`は[`complex`](/reference/complex/complex.md)`<Real>`が規定できる型であること。
 
 
 ## 戻り値
diff --git a/reference/linalg/setup_givens_rotation_result.md b/reference/linalg/setup_givens_rotation_result.md
index b38e24b36..5cd720420 100644
--- a/reference/linalg/setup_givens_rotation_result.md
+++ b/reference/linalg/setup_givens_rotation_result.md
@@ -21,13 +21,15 @@ namespace std::linalg {
   };
 }
 ```
+* complex[link /reference/complex/complex.md]
+
 
 ## 概要
 ギブンス回転の結果を表すクラス。詳しくは、[`setup_givens_rotation`](setup_givens_rotation.md)にて。
 
 
 ## 適格要件
-- `Real`は`complex<Real>`が規定できる型であること。
+- `Real`は[`complex`](/reference/complex/complex.md)`<Real>`が規定できる型であること。
 
 
 ## 例
diff --git a/reference/linalg/swap_elements.md b/reference/linalg/swap_elements.md
index 4fc87ae70..a8be2a486 100644
--- a/reference/linalg/swap_elements.md
+++ b/reference/linalg/swap_elements.md
@@ -30,6 +30,7 @@ namespace std::linalg {
 
 ## テンプレートパラメータ制約
 `x`と`y`の次元が等しくなければならない。
+
 - `x.rank() == y.rank()`
 
 
@@ -40,6 +41,7 @@ namespace std::linalg {
 
 ## 事前条件
 `x`と`y`の各次元の要素数が等しくなければならない。
+
 - `x.extents() == y.extents()`
 
 
diff --git a/reference/linalg/vector_abs_sum.md b/reference/linalg/vector_abs_sum.md
index 837a36833..774fb08c2 100644
--- a/reference/linalg/vector_abs_sum.md
+++ b/reference/linalg/vector_abs_sum.md
@@ -37,25 +37,25 @@ namespace std::linalg {
 
 
 ## 適格要件
-- (1), (2): `decltype(init + `[`abs-if-needed`](abs-if-needed.md)`(`[`real-if-needed`](real-if-needed.md)`(declval<typename InVec::value_type>())) + abs-if-needed(`[`imag-if-needed`](imag-if-needed.md)`(declval<typename InVec::value_type>())))`が`Scalar`に変換可能。
+- (1), (2): `decltype(init +` [`abs-if-needed`](abs-if-needed.md)`(`[`real-if-needed`](real-if-needed.md)`(declval<typename InVec::value_type>())) + abs-if-needed(`[`imag-if-needed`](imag-if-needed.md)`(declval<typename InVec::value_type>())))`が`Scalar`に変換可能。
 - (2), (4): [`is_execution_policy`](/reference/execution/is_execution_policy.md)`<ExecutionPolicy>::value`が`true`
 
 ## 効果
 - (3), (4): `T`を`typename InVec::value_type`とすると、
-  + (3): `vector_abs_sum(v, T{})`を返す。
-  + (4): `vector_abs_sum(std::forward<ExecutionPolicy>(exec), v, T{})`を返す。
+    + (3): `vector_abs_sum(v, T{})`を返す。
+    + (4): `vector_abs_sum(std::forward<ExecutionPolicy>(exec), v, T{})`を返す。
 
 
 ## 戻り値
 - (1), (2): `N`を`v`の次元`v.extent(0)`とすると、以下を返す。
-  1. もし`N`が0なら`init`
-  2. そうでない場合、もし`InVec::value_type`が算術型なら以下の式の値
+    - もし`N`が0なら`init`
+    - そうでない場合、もし`InVec::value_type`が算術型なら以下の式の値
 
 $$
 \sum_{i = 0}^{N - 1} |\verb|v[|i\verb|]|| + \verb|init|
 $$
 
-  3. そうでない場合、以下の式の値
+    - そうでない場合、以下の式の値
 
 $$
 \sum_{i = 0}^{N - 1} \left\{|\mathrm{Re}(\verb|v[|i\verb|]|)| + |\mathrm{Im}(\verb|v[|i\verb|]|)|\right\} + \verb|init|
@@ -63,12 +63,12 @@ $$
 
 
 - (3), (4): `T`を`typename InVec::value_type`とすると、
-  + (3): `vector_abs_sum(v, T{})`を返す。
-  + (4): `vector_abs_sum(std::forward<ExecutionPolicy>(exec), v, T{})`を返す。
+    + (3): `vector_abs_sum(v, T{})`を返す。
+    + (4): `vector_abs_sum(std::forward<ExecutionPolicy>(exec), v, T{})`を返す。
 
 
 ## 備考
-- (1), (2): もし`InVec::value_type`と`Scalar`がどちらも浮動小数点数型または`std::complex`の特殊化で、`Scalar`が`InVec::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
+- (1), (2): もし`InVec::value_type`と`Scalar`がどちらも浮動小数点数型または[`std::complex`](/reference/complex/complex.md)の特殊化で、`Scalar`が`InVec::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
 
 
 ## 例
@@ -102,7 +102,7 @@ int main()
   return 0;
 }
 ```
-
+* std::linalg::vector_abs_sum[color ff0000]
 
 ### 出力
 ```
diff --git a/reference/linalg/vector_idx_abs_max.md b/reference/linalg/vector_idx_abs_max.md
index 63d50f909..85b4e234d 100644
--- a/reference/linalg/vector_idx_abs_max.md
+++ b/reference/linalg/vector_idx_abs_max.md
@@ -32,16 +32,18 @@ namespace std::linalg {
 
 ## 戻り値
 - (1), (2): `N`を`v`の次元`v.extent(0)`とすると、以下を返す。
-  1. もし`N`が0なら`std::numeric_limits<typename InVec::size_type>::max()`
-  2. そうでない場合、もし`InVec::value_type`が算術型なら絶対値が最大の最初の`v`の成分のインデックス。つまり、
-  $$
-  \argmax_{i = 0, \dots, N - 1} |\verb|v[|i\verb|]||
-  $$
-  3. そうでない場合、
+    + もし`N`が0なら[`std::numeric_limits`](/reference/limits/numeric_limits.md)`<typename InVec::size_type>::max()`
+    + そうでない場合、もし`InVec::value_type`が算術型なら絶対値が最大の最初の`v`の成分のインデックス。つまり、
 
-  $$
-  \argmax_{i = 0, \dots, N - 1}\left\{|\mathrm{Re}(\verb|v[|i\verb|]|)| + |\mathrm{Im}(\verb|v[|i\verb|]|)|\right\}
-  $$
+$$
+\argmax_{i = 0, \dots, N - 1} |\verb|v[|i\verb|]||
+$$
+
+    + そうでない場合、
+
+$$
+\argmax_{i = 0, \dots, N - 1}\left\{|\mathrm{Re}(\verb|v[|i\verb|]|)| + |\mathrm{Im}(\verb|v[|i\verb|]|)|\right\}
+$$
 
 
 ## 例
@@ -73,7 +75,7 @@ int main()
   return 0;
 }
 ```
-
+* std::linalg::vector_idx_abs_max[color ff0000]
 
 ### 出力
 ```
diff --git a/reference/linalg/vector_sum_of_squares.md b/reference/linalg/vector_sum_of_squares.md
index 98ed9076e..be29e69b5 100644
--- a/reference/linalg/vector_sum_of_squares.md
+++ b/reference/linalg/vector_sum_of_squares.md
@@ -22,6 +22,7 @@ namespace std::linalg {
     sum_of_squares_result<Scalar> init); // (2)
 }
 ```
+* sum_of_squares_result[link sum_of_squares_result.md]
 
 
 ## 概要
@@ -33,6 +34,7 @@ namespace std::linalg {
     return std::pow(result.scaling_factor, 2) * result.scaled_sum_of_squares;
   }
 ```
+* sum_of_squares_result[link sum_of_squares_result.md]
 
 を定義すると、以下の式が成り立つように計算する。
 
@@ -49,19 +51,19 @@ $$
 
 
 ## 効果
-- (1): 以下の条件を満たす`sum_of_squares_result<Scalar>`型の値`result`を返す。
-  + `result.scaling_factor`が`init.scaling_factor`と$\max_{i = 0, \dots, n - 1}|\verb|v[|i\verb|]||$の最大値。ただし、`n`は`v`の次元である。
-  + 概要に記載した式を満たす。
+- (1): 以下の条件を満たす[`sum_of_squares_result`](sum_of_squares_result.md)`<Scalar>`型の値`result`を返す。
+    + `result.scaling_factor`が`init.scaling_factor`と$\max_{i = 0, \dots, n - 1}|\verb|v[|i\verb|]||$の最大値。ただし、`n`は`v`の次元である。
+    + 概要に記載した式を満たす。
 - (2): (1)の並列アルゴリズム版。
 
 
 ## 戻り値
-`sum_of_squares_result<Scalar>`
+[`sum_of_squares_result`](sum_of_squares_result.md)`<Scalar>`
 
 
 ## 備考
 - `init.scaled_sum_of_squares`は0以上でなければならない。
-- もし`InVec::value_type`と`Scalar`がどちらも浮動小数点数型または`std::complex`の特殊化で、`Scalar`が`InVec::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
+- もし`InVec::value_type`と`Scalar`がどちらも浮動小数点数型または[`std::complex`](/reference/complex/complex.md)の特殊化で、`Scalar`が`InVec::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
 
 
 ## 例
@@ -109,7 +111,8 @@ int main()
   return 0;
 }
 ```
-
+* std::linalg::vector_sum_of_squares[color ff0000]
+* std::linalg::sum_of_squares_result[link sum_of_squares_result.md]
 
 ### 出力
 ```
diff --git a/reference/linalg/vector_two_norm.md b/reference/linalg/vector_two_norm.md
index 1178dc20c..46ce843d5 100644
--- a/reference/linalg/vector_two_norm.md
+++ b/reference/linalg/vector_two_norm.md
@@ -37,14 +37,14 @@ namespace std::linalg {
 
 
 ## 適格要件
-- (1), (2): `decltype(init + `[`abs-if-needed`](abs-if-needed.md)`(declval<typename InVec::value_type>()) * abs-if-needed(declval<typename InVec::value_type>()))`が`Scalar`に変換可能。
+- (1), (2): `decltype(init +` [`abs-if-needed`](abs-if-needed.md)`(declval<typename InVec::value_type>()) * abs-if-needed(declval<typename InVec::value_type>()))`が`Scalar`に変換可能。
 - (2), (4): [`is_execution_policy`](/reference/execution/is_execution_policy.md)`<ExecutionPolicy>::value`が`true`
 
 
 ## 効果
-- (3), (4): `T`を`decltype(abs-if-needed(declval<typename InVec::value_type>()) * abs-if-needed(declval<typename InVec::value_type>()))`とすると、
-  + (3): `vector_two_norm(v, T{})`を返す。
-  + (4): `vector_two_norm(std::forward<ExecutionPolicy>(exec), v, T{})`を返す。
+- (3), (4): `T`を`decltype(`[`abs-if-needed`](abs-if-needed.md)`(declval<typename InVec::value_type>()) * abs-if-needed(declval<typename InVec::value_type>()))`とすると、
+    + (3): `vector_two_norm(v, T{})`を返す。
+    + (4): `vector_two_norm(std::forward<ExecutionPolicy>(exec), v, T{})`を返す。
 
 
 ## 戻り値
@@ -55,13 +55,13 @@ $$
 $$
 
 
-- (3), (4): `T`を`decltype(abs-if-needed(declval<typename InVec::value_type>()) * abs-if-needed(declval<typename InVec::value_type>()))`とすると、
-  + (3): `vector_two_norm(v, T{})`を返す。
-  + (4): `vector_two_norm(std::forward<ExecutionPolicy>(exec), v, T{})`を返す。
+- (3), (4): `T`を`decltype(`[`abs-if-needed`](abs-if-needed.md)`(declval<typename InVec::value_type>()) * abs-if-needed(declval<typename InVec::value_type>()))`とすると、
+    + (3): `vector_two_norm(v, T{})`を返す。
+    + (4): `vector_two_norm(std::forward<ExecutionPolicy>(exec), v, T{})`を返す。
 
 
 ## 備考
-- (1), (2): もし`InVec::value_type`と`Scalar`がどちらも浮動小数点数型または`std::complex`の特殊化で、`Scalar`が`InVec::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
+- (1), (2): もし`InVec::value_type`と`Scalar`がどちらも浮動小数点数型または[`std::complex`](/reference/complex/complex.md)の特殊化で、`Scalar`が`InVec::value_type`より精度が高い場合、和の各項は`Scalar`またはより高い精度の型が使われる。
 
 
 ## 例
@@ -95,7 +95,7 @@ int main()
   return 0;
 }
 ```
-
+* std::linalg::vector_two_norm[color ff0000]
 
 ### 出力
 ```