equivalentの訳語として、同等を等価に修正 #582

Author: faithandbrave

lang/cpp11/alias_templates.md

@@ -45,7 +45,7 @@ using FunctionPointerByDecltype = decltype(&f);
 
 ## 仕様
 - テンプレートによる型の別名付けは、`using`キーワードによるもののみを許可し、`typedef`キーワードに対しては許可しない
-- エイリアステンプレートによって付けられた型の別名と元の型は同等と見なされ、それらの間でオーバーロードはできない
+- エイリアステンプレートによって付けられた型の別名と元の型は等価と見なされ、それらの間でオーバーロードはできない
 
     ```cpp
     template <class T>

lang/cpp11/initializer_lists.md

@@ -240,7 +240,7 @@ int main()
     X x = {1, 2, 3};
     ```
 
-    実装は以下と同等の初期化を行う (実装が用意した`std::initializer_list`クラスがポインタの組を受け取れると仮定する)：
+    実装は以下と等価の初期化を行う (実装が用意した`std::initializer_list`クラスがポインタの組を受け取れると仮定する)：
 
     ```cpp
     double __a[3] = {double{1}, double{2}, double{3}};

lang/cpp11/scoped_enum.md

@@ -87,7 +87,7 @@ C++03は、C99の列挙型に対する改善は提供していたが、依然と
 - コードのわかりやすさ(明確さ)
 - コードの移植性
 
-ECMA規格になっているC++/CLIが、現在のスコープを持つ列挙型と同等の機能を持っていたために、その経験を標準C++に取り入れることとなった。
+ECMA規格になっているC++/CLIが、現在のスコープを持つ列挙型と等価の機能を持っていたために、その経験を標準C++に取り入れることとなった。
 
 
 ## 関連項目

lang/cpp20/allow_lambda_capture_equal_this.md

@@ -4,7 +4,7 @@
 ## 概要
 C++17まで、ラムダ式のキャプチャとして`[=, this]`は指定できなかった。これは、デフォルトコピーキャプチャ (`=`) に、`this`ポインタのコピーキャプチャが含まれるため、重複指定はできないというものである。
 
-C++20では、`[=, this]`のキャプチャ指定を許可する。これは、意味としては`[=]`と同等である。明示的に`this`ポインタをキャプチャして使用するという表明によって、可読性を向上させる目的に使える。
+C++20では、`[=, this]`のキャプチャ指定を許可する。これは、意味としては`[=]`と等価である。明示的に`this`ポインタをキャプチャして使用するという表明によって、可読性を向上させる目的に使える。
 
 
 ## 例
@@ -15,7 +15,7 @@ struct X {
   void f()
   {
     int value = 3;
-    auto x = [=, this] { // [=]キャプチャと同等
+    auto x = [=, this] { // [=]キャプチャと等価
       return value + g();
     };
     std::cout << x() << std::endl;

reference/algorithm.md

@@ -203,7 +203,7 @@ return distance(a, b);
 ### ソート済み構造に対する集合演算
 
 このセクションでは基本的なソート済み構造に対する集合演算を定義する。  
-これらの演算は、等価な要素を複数格納できる `multiset` であっても動作する。集合演算のセマンティクスは、等価な要素が複数あっても、一般化された標準的な方法で演算できるようになっている。  
+これらの演算は、等価なキーの要素を複数格納できる `multiset` であっても動作する。集合演算のセマンティクスは、等価なキーの要素が複数あっても、一般化された標準的な方法で演算できるようになっている。  
 例えば [`set_union()`](algorithm/set_union.md) ならそれぞれの要素の最大数を格納する、[`set_intersection()`](algorithm/set_intersection.md) なら最小数を格納するといったようになる。
 
 | 名前 | 説明 | 対応バージョン |

reference/algorithm/clamp.md

@@ -32,7 +32,7 @@ namespace std {
 
 
 ## 備考
-- `clamp(v, low, high)`は[`min`](min.md)`(`[`max`](max.md)`(v, low), high)`と同等
+- `clamp(v, low, high)`は[`min`](min.md)`(`[`max`](max.md)`(v, low), high)`と等価
 
 
 ## 例

reference/algorithm/lower_bound.md

@@ -66,8 +66,8 @@ namespace std {
 
 
 ## 備考
-- 本関数は、本質的に C++11 で追加された [`partition_point`](partition_point.md) と同等である。  
-	具体的には、[`partition_point`](partition_point.md)`(first, last, [value](const T& e) { return e < value; })`、あるいは、[`partition_point`](partition_point.md)`(first, last, [value, comp](const T& e) { return comp(e, value); })` とすることで同等の結果が得られる。
+- 本関数は、本質的に C++11 で追加された [`partition_point`](partition_point.md) と等価である。  
+	具体的には、[`partition_point`](partition_point.md)`(first, last, [value](const T& e) { return e < value; })`、あるいは、[`partition_point`](partition_point.md)`(first, last, [value, comp](const T& e) { return comp(e, value); })` とすることで等価の結果が得られる。
 - 本関数の要件は、上記の通り C++03 までの方が C++11 よりも厳しい。
 	しかし、本アルゴリズムの特性上、処理系が C++03 までにしか準拠していない場合でも、昇順に並んでいなくても正常に動作する可能性は高いものと思われる。
 

reference/algorithm/upper_bound.md

@@ -64,8 +64,8 @@ namespace std {
 
 
 ## 備考
-- 本関数は、本質的に C++11 で追加された [`partition_point`](partition_point.md) と同等である。  
-	具体的には、[`partition_point`](partition_point.md)`(first, last, [value](const T& e) { return !bool(value < e); })`、あるいは、[`partition_point`](partition_point.md)`(first, last, [value, comp](const T& e) { return !bool(comp(value, e)); })` とすることで同等の結果が得られる。
+- 本関数は、本質的に C++11 で追加された [`partition_point`](partition_point.md) と等価である。  
+	具体的には、[`partition_point`](partition_point.md)`(first, last, [value](const T& e) { return !bool(value < e); })`、あるいは、[`partition_point`](partition_point.md)`(first, last, [value, comp](const T& e) { return !bool(comp(value, e)); })` とすることで等価の結果が得られる。
 - 本関数の要件は、上記の通り C++03 までの方が C++11 よりも厳しい。  
 	しかし、本アルゴリズムの特性上、処理系が C++03 までにしか準拠していない場合でも、昇順に並んでいなくても正常に動作する可能性は高いものと思われる。
 

reference/any/any/op_assign.md

@@ -24,8 +24,8 @@ any& operator=(T&& rhs);            // (3)
 
 
 ## 効果
-- (1) : `any(rhs).`[`swap`](swap.md)`(*this)`と同等。この効果自体では例外を送出しない
-- (2) : `any(`[`std::move`](/reference/utility/move.md)`(rhs)).`[`swap`](swap.md)`(*this)`と同等。この効果自体では例外を送出しない。`*this`の状態は、この関数を呼び出す前の`rhs`と同等の状態となり、`rhs`は有効だが未規定の状態を持つようになる
+- (1) : `any(rhs).`[`swap`](swap.md)`(*this)`と等価。この効果自体では例外を送出しない
+- (2) : `any(`[`std::move`](/reference/utility/move.md)`(rhs)).`[`swap`](swap.md)`(*this)`と等価。この効果自体では例外を送出しない。`*this`の状態は、この関数を呼び出す前の`rhs`と等価の状態となり、`rhs`は有効だが未規定の状態を持つようになる
 - (3) : [`std::forward`](/reference/utility/forward.md)`<T>(value)`をコンストラクタ引数として、型[`std::decay_t<T>`](/reference/type_traits/decay.md)のオブジェクトを直接構築して保持する`any`オブジェクト`tmp`を構築し、`tmp.`[`swap`](swap.md)`(*this)`する。この効果自体では例外を送出しない
 
 

reference/any/any/op_constructor.md

@@ -39,7 +39,7 @@ explicit any(in_place_type_t<T>,
 
 
 ## 効果
-- (2) : `other.`[`has_value()`](has_value.md) `== false`である場合、値を保持しない`any`オブジェクトを構築する。そうでなければ、`any(`[`in_place`](/reference/utility/in_place_t.md)`<T>,` [`any_cast`](/reference/any/any_cast.md)`<const T&>(other))`と同等の効果をもつ
+- (2) : `other.`[`has_value()`](has_value.md) `== false`である場合、値を保持しない`any`オブジェクトを構築する。そうでなければ、`any(`[`in_place`](/reference/utility/in_place_t.md)`<T>,` [`any_cast`](/reference/any/any_cast.md)`<const T&>(other))`と等価の効果をもつ
 - (3) : `other.`[`has_value()`](has_value.md) `== false`である場合、値を保持しない`any`オブジェクトを構築する。そうでなければ、`other`が保持する値を`this`にムーブする
 - (4) : [`std::forward`](/reference/utility/forward.md)`<T>(value)`をコンストラクタ引数として、型[`std::decay_t<T>`](/reference/type_traits/decay.md)のオブジェクトを直接構築して保持する
 - (5) : [`std::forward`](/reference/utility/forward.md)`<Args>(value)...`をコンストラクタ引数として、型[`std::decay_t<T>`](/reference/type_traits/decay.md)のオブジェクトを直接構築して保持する

reference/any/any/op_destructor.md

@@ -14,7 +14,7 @@
 
 
 ## 効果
-[`reset()`](reset.md)を呼び出すことと同等。
+[`reset()`](reset.md)を呼び出すことと等価。
 
 
 ## バージョン

reference/any/make_any.md

@@ -19,15 +19,15 @@ namespace std {
 ## 概要
 `any`オブジェクトを生成するヘルパ関数。
 
-`any`のコンストラクタ呼び出しでこの関数と同等のことを行う場合、先頭の引数として[`std::in_place_type`](/reference/utility/in_place_type_t.md)タグを付加する必要があり冗長である。この関数は、その冗長さを回避するためにある。
+`any`のコンストラクタ呼び出しでこの関数と等価のことを行う場合、先頭の引数として[`std::in_place_type`](/reference/utility/in_place_type_t.md)タグを付加する必要があり冗長である。この関数は、その冗長さを回避するためにある。
 
 - (1) : 任意の型`T`のコンストラクタ引数`args...`をとり、この関数内部で`T`型オブジェクトを構築して保持する`any`オブジェクトを構築する
 - (2) : 任意の型`T`のコンストラクタ引数`il`と`args...`をとり、この関数内部で`T`型オブジェクトを構築して保持する`any`オブジェクトを構築する
 
 
 ## 効果
-- (1) : `return any(`[`in_place_type`](/reference/utility/in_place_type_t.md)`<T>,` [`std::forward`](/reference/utility/forward.md)`<Args>(args)...);`と同等
-- (2) : `return any(`[`in_place_type`](/reference/utility/in_place_type_t.md)`<T>, il,` [`std::forward`](/reference/utility/forward.md)`<Args>(args)...);`と同等
+- (1) : `return any(`[`in_place_type`](/reference/utility/in_place_type_t.md)`<T>,` [`std::forward`](/reference/utility/forward.md)`<Args>(args)...);`と等価
+- (2) : `return any(`[`in_place_type`](/reference/utility/in_place_type_t.md)`<T>, il,` [`std::forward`](/reference/utility/forward.md)`<Args>(args)...);`と等価
 
 
 ## 例

reference/atomic/atomic_thread_fence.md

@@ -17,7 +17,7 @@ namespace std {
 
 ## 効果
 この関数は、弱い[`memory_order`](memory_order.md)が指定されたアトミック操作の前後に指定することで、より強い`memory_order`を指定した場合と似たような振る舞いをさせる効果を持つ。
-たとえば、`a`を[`atomic`](atomic.md)`<int>`型の変数とするとき、下記2種類の処理はほぼ同等の振る舞いをする。
+たとえば、`a`を[`atomic`](atomic.md)`<int>`型の変数とするとき、下記2種類の処理はほぼ等価の振る舞いをする。
 
 ```cpp
 // relaxed操作 + releaseフェンス
@@ -31,7 +31,7 @@ a.store(42, std::memory_order_release);
 * a.store[link atomic/store.md]
 
 ただし、後者のほうがより効率的な機械語命令へとコンパイルされる可能性が高い。より詳しい議論については[N2176](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2176.html#integrated)などを参照のこと。
-同様に、下記2種類の処理はほぼ同等の振る舞いをする。
+同様に、下記2種類の処理はほぼ等価の振る舞いをする。
 
 ```cpp
 // relaxed操作 + acquireフェンス

reference/cfloat/dbl_dig.md

@@ -42,7 +42,7 @@ int main()
 {
   std::cout << DBL_DIG << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   double log10b = std::log10(FLT_RADIX);
   double intpart;
   if (std::modf(log10b, &intpart) == 0.0) {

reference/cfloat/dbl_epsilon.md

@@ -36,7 +36,7 @@ int main()
   std::cout << std::setprecision(DBL_DIG);
   std::cout << DBL_EPSILON << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   std::cout << std::pow(FLT_RADIX, 1 - DBL_MANT_DIG) << '\n';
 }
 ```

reference/cfloat/dbl_max.md

@@ -37,7 +37,7 @@ int main()
   std::cout << std::setprecision(DBL_DIG);
   std::cout << DBL_MAX << '\n';
 
-  // 以下の式と同等（std::pow(FLT_RADIX, DBL_MAX_EXP) は double の最大値を超えてしまうため、式を調整してある）
+  // 以下の式と等価（std::pow(FLT_RADIX, DBL_MAX_EXP) は double の最大値を超えてしまうため、式を調整してある）
   std::cout << (1 - std::pow(FLT_RADIX, -DBL_MANT_DIG)) * std::pow(FLT_RADIX, DBL_MAX_EXP - 1) * FLT_RADIX << '\n';
 }
 ```

reference/cfloat/dbl_max_10_exp.md

@@ -37,10 +37,10 @@ int main()
 {
   std::cout << DBL_MAX_10_EXP << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   std::cout << std::floor(std::log10(DBL_MAX)) << '\n';
 
-  // 以下の式とも同等（std::pow(FLT_RADIX, DBL_MAX_EXP) は double の最大値を超えてしまうため、式を調整してある）
+  // 以下の式とも等価（std::pow(FLT_RADIX, DBL_MAX_EXP) は double の最大値を超えてしまうため、式を調整してある）
   std::cout << std::floor(std::log10((1 - std::pow(FLT_RADIX, -DBL_MANT_DIG)) * std::pow(FLT_RADIX, DBL_MAX_EXP - 1) * FLT_RADIX)) << '\n';
 
   std::cout << std::boolalpha;

reference/cfloat/dbl_min.md

@@ -37,7 +37,7 @@ int main()
   std::cout << std::setprecision(DBL_DIG);
   std::cout << DBL_MIN << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   std::cout << std::pow(FLT_RADIX, DBL_MIN_EXP - 1) << '\n';
 }
 ```

reference/cfloat/dbl_min_10_exp.md

@@ -37,10 +37,10 @@ int main()
 {
   std::cout << DBL_MIN_10_EXP << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   std::cout << std::ceil(std::log10(DBL_MIN)) << '\n';
 
-  // 以下の式とも同等
+  // 以下の式とも等価
   std::cout << std::ceil(std::log10(std::pow(FLT_RADIX, DBL_MIN_EXP - 1))) << '\n';
 }
 ```

reference/cfloat/decimal_dig.md

@@ -45,7 +45,7 @@ int main()
 {
   std::cout << DECIMAL_DIG << '\n';
 
-  // 精度が一番高い浮動小数点型が long double の場合、以下の式と同等
+  // 精度が一番高い浮動小数点型が long double の場合、以下の式と等価
   long double log10b = std::log10(FLT_RADIX);
   long double intpart;
   if (std::modf(log10b, &intpart) == 0.0) {

reference/cfloat/flt_dig.md

@@ -42,7 +42,7 @@ int main()
 {
   std::cout << FLT_DIG << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   double log10b = std::log10(FLT_RADIX);
   double intpart;
   if (std::modf(log10b, &intpart) == 0.0) {

reference/cfloat/flt_epsilon.md

@@ -36,7 +36,7 @@ int main()
   std::cout << std::setprecision(FLT_DIG);
   std::cout << FLT_EPSILON << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   std::cout << std::pow(FLT_RADIX, 1 - FLT_MANT_DIG) << '\n';
 }
 ```

reference/cfloat/flt_max.md

@@ -37,7 +37,7 @@ int main()
   std::cout << std::setprecision(FLT_DIG);
   std::cout << FLT_MAX << '\n';
 
-  // 以下の式と同等（std::pow((float)FLT_RADIX, (float)FLT_MAX_EXP) は float の最大値を超えてしまうため、式を調整してある）
+  // 以下の式と等価（std::pow((float)FLT_RADIX, (float)FLT_MAX_EXP) は float の最大値を超えてしまうため、式を調整してある）
   std::cout << (1 - std::pow((float)FLT_RADIX, (float)-FLT_MANT_DIG)) * std::pow((float)FLT_RADIX, (float)(FLT_MAX_EXP - 1)) * FLT_RADIX << '\n';
 }
 ```

reference/cfloat/flt_max_10_exp.md

@@ -37,10 +37,10 @@ int main()
 {
   std::cout << FLT_MAX_10_EXP << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   std::cout << std::floor(std::log10(FLT_MAX)) << '\n';
 
-  // 以下の式とも同等（std::pow((float)FLT_RADIX, FLT_MAX_EXP) は float の最大値を超えてしまうため、式を調整してある）
+  // 以下の式とも等価（std::pow((float)FLT_RADIX, FLT_MAX_EXP) は float の最大値を超えてしまうため、式を調整してある）
   std::cout << std::floor(std::log10((1 - std::pow((float)FLT_RADIX, -FLT_MANT_DIG)) * std::pow((float)FLT_RADIX, FLT_MAX_EXP - 1) * FLT_RADIX)) << '\n';
 
   std::cout << std::boolalpha;

reference/cfloat/flt_min.md

@@ -37,7 +37,7 @@ int main()
   std::cout << std::setprecision(FLT_DIG);
   std::cout << FLT_MIN << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   std::cout << std::pow((float)FLT_RADIX, (float)(FLT_MIN_EXP - 1)) << '\n';
 }
 ```

reference/cfloat/flt_min_10_exp.md

@@ -37,10 +37,10 @@ int main()
 {
   std::cout << FLT_MIN_10_EXP << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   std::cout << std::ceil(std::log10(FLT_MIN)) << '\n';
 
-  // 以下の式とも同等
+  // 以下の式とも等価
   std::cout << std::ceil(std::log10(std::pow((float)FLT_RADIX, (float)(FLT_MIN_EXP - 1)))) << '\n';
 }
 ```

reference/cfloat/ldbl_dig.md

@@ -42,7 +42,7 @@ int main()
 {
   std::cout << LDBL_DIG << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   double log10b = std::log10(FLT_RADIX);
   double intpart;
   if (std::modf(log10b, &intpart) == 0.0) {

reference/cfloat/ldbl_epsilon.md

@@ -36,7 +36,7 @@ int main()
   std::cout << std::setprecision(LDBL_DIG);
   std::cout << LDBL_EPSILON << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   std::cout << std::pow(FLT_RADIX, 1 - LDBL_MANT_DIG) << '\n';
 }
 ```

reference/cfloat/ldbl_max.md

@@ -37,7 +37,7 @@ int main()
   std::cout << std::setprecision(LDBL_DIG);
   std::cout << LDBL_MAX << '\n';
 
-  // 以下の式と同等（std::pow((long double)FLT_RADIX, LDBL_MAX_EXP) は long double の最大値を超えてしまうため、式を調整してある）
+  // 以下の式と等価（std::pow((long double)FLT_RADIX, LDBL_MAX_EXP) は long double の最大値を超えてしまうため、式を調整してある）
   std::cout << (1 - std::pow((long double)FLT_RADIX, -LDBL_MANT_DIG)) * std::pow((long double)FLT_RADIX, LDBL_MAX_EXP - 1) * FLT_RADIX << '\n';
 }
 ```

reference/cfloat/ldbl_max_10_exp.md

@@ -37,10 +37,10 @@ int main()
 {
   std::cout << LDBL_MAX_10_EXP << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   std::cout << std::floor(std::log10(LDBL_MAX)) << '\n';
 
-  // 以下の式とも同等（std::pow((long double)FLT_RADIX, LDBL_MAX_EXP) は long double の最大値を超えてしまうため、式を調整してある）
+  // 以下の式とも等価（std::pow((long double)FLT_RADIX, LDBL_MAX_EXP) は long double の最大値を超えてしまうため、式を調整してある）
   std::cout << std::floor(std::log10((1 - std::pow((long double)FLT_RADIX, -LDBL_MANT_DIG)) * std::pow((long double)FLT_RADIX, LDBL_MAX_EXP - 1) * FLT_RADIX)) << '\n';
 
   std::cout << std::boolalpha;

reference/cfloat/ldbl_min.md

@@ -37,7 +37,7 @@ int main()
   std::cout << std::setprecision(LDBL_DIG);
   std::cout << LDBL_MIN << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   std::cout << std::pow((long double)FLT_RADIX, LDBL_MIN_EXP - 1) << '\n';
 }
 ```

reference/cfloat/ldbl_min_10_exp.md

@@ -37,10 +37,10 @@ int main()
 {
   std::cout << LDBL_MIN_10_EXP << '\n';
 
-  // 以下の式と同等
+  // 以下の式と等価
   std::cout << std::ceil(std::log10(LDBL_MIN)) << '\n';
 
-  // 以下の式とも同等
+  // 以下の式とも等価
   std::cout << std::ceil(std::log10(std::pow((long double)FLT_RADIX, LDBL_MIN_EXP - 1))) << '\n';
 }
 ```