s/constructable/constructible/

[CI SKIP]

Author: jzmaddock

doc/concepts/concepts.qbk

@@ -285,9 +285,9 @@ of type `const RealType`, and /ca/ is an object of type `const arithmetic-type`
 [table
 [[Expression][Result Type][Notes]]
 [[`RealType(cr)`][RealType]
-      [RealType is copy constructable.]]
+      [RealType is copy constructible.]]
 [[`RealType(ca)`][RealType]
-      [RealType is copy constructable from the arithmetic types.]]
+      [RealType is copy constructible from the arithmetic types.]]
 [[`r = cr`][RealType&][Assignment operator.]]
 [[`r = ca`][RealType&][Assignment operator from the arithmetic types.]]
 [[`r += cr`][RealType&][Adds cr to r.]]
@@ -468,7 +468,7 @@ object of a type convertible to `RealType`.
 [[DistributionType::policy_type][RealType]
       [The __Policy to use when evaluating functions that depend on this distribution.]]
 [[d = cd][Distribution&][Distribution types are assignable.]]
-[[Distribution(cd)][Distribution][Distribution types are copy constructable.]]
+[[Distribution(cd)][Distribution][Distribution types are copy constructible.]]
 [[pdf(cd, cr)][RealType][Returns the PDF of the distribution.]]
 [[cdf(cd, cr)][RealType][Returns the CDF of the distribution.]]
 [[cdf(complement(cd, cr))][RealType]

doc/constants/constants.qbk

@@ -163,17 +163,17 @@ However, since the precision of the user-defined type may be much greater than t
 of the built-in floating point types, how the value returned is created is as follows:
 
 * If the precision of the type is known at compile time:
-   * If the precision is less than or equal to that of a `float` and the type is constructable from a `float`
+   * If the precision is less than or equal to that of a `float` and the type is constructible from a `float`
      then our code returns a `float` literal.  If the user-defined type is a literal type
      then the function call that returns the constant will be a `constexp`.
-   * If the precision is less than or equal to that of a `double` and the type is constructable from a `double`
+   * If the precision is less than or equal to that of a `double` and the type is constructible from a `double`
      then our code returns a `double` literal.  If the user-defined type is a literal type
      then the function call that returns the constant will be a `constexp`.
-   * If the precision is less than or equal to that of a `long double` and the type is constructable from a `long double`
+   * If the precision is less than or equal to that of a `long double` and the type is constructible from a `long double`
      then our code returns a `long double` literal.  If the user-defined type is a literal type
      then the function call that returns the constant will be a `constexp`.
    * If the precision is less than or equal to that of a `__float128` (and the compiler supports such a type)
-     and the type is constructable from a `__float128`
+     and the type is constructible from a `__float128`
      then our code returns a `__float128` literal.  If the user-defined type is a literal type
      then the function call that returns the constant will be a `constexp`.
    * If the precision is less than 100 decimal digits, then the constant will be constructed
@@ -610,7 +610,7 @@ accurate to at least 100 decimal digits (in practice that means at least 102 dig
 Again for consistency use scientific format with a signed exponent.
 
 For types with precision greater than a long double,
-then if T is constructable `T `is constructable from a `const char*`
+then if T is constructible `T `is constructible from a `const char*`
 then it's directly constructed from the string,
 otherwise we fall back on lexical_cast to convert to type `T`.
 (Using a string is necessary because you can't use a numeric constant

doc/html/math_toolkit/constants_faq.html

@@ -226,8 +226,8 @@ <h5>
       digits). Again for consistency use scientific format with a signed exponent.
     </p>
 <p>
-      For types with precision greater than a long double, then if T is constructable
-      <code class="computeroutput"><span class="identifier">T</span> </code>is constructable from a
+      For types with precision greater than a long double, then if T is constructible
+      <code class="computeroutput"><span class="identifier">T</span> </code>is constructible from a
       <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span></code> then it's directly constructed from the string,
       otherwise we fall back on lexical_cast to convert to type <code class="computeroutput"><span class="identifier">T</span></code>.
       (Using a string is necessary because you can't use a numeric constant since

doc/html/math_toolkit/dist_concept.html

@@ -131,7 +131,7 @@
             </td>
 <td>
               <p>
-                Distribution types are copy constructable.
+                Distribution types are copy constructible.
               </p>
             </td>
 </tr>

doc/html/math_toolkit/real_concepts.html

@@ -103,7 +103,7 @@ <h5>
             </td>
 <td>
               <p>
-                RealType is copy constructable.
+                RealType is copy constructible.
               </p>
             </td>
 </tr>
@@ -120,7 +120,7 @@ <h5>
             </td>
 <td>
               <p>
-                RealType is copy constructable from the arithmetic types.
+                RealType is copy constructible from the arithmetic types.
               </p>
             </td>
 </tr>

doc/html/math_toolkit/result_type.html

@@ -65,7 +65,7 @@
         </li>
 <li class="listitem">
           If any of the arguments is a user-defined class type, then the result type
-          is the first such class type that is constructable from all of the other
+          is the first such class type that is constructible from all of the other
           argument types.
         </li>
 <li class="listitem">

doc/html/math_toolkit/tutorial/user_def.html

@@ -57,30 +57,30 @@
             If the precision of the type is known at compile time:
             <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
 <li class="listitem">
-                  If the precision is less than or equal to that of a <code class="computeroutput"><span class="keyword">float</span></code> and the type is constructable
+                  If the precision is less than or equal to that of a <code class="computeroutput"><span class="keyword">float</span></code> and the type is constructible
                   from a <code class="computeroutput"><span class="keyword">float</span></code> then
                   our code returns a <code class="computeroutput"><span class="keyword">float</span></code>
                   literal. If the user-defined type is a literal type then the function
                   call that returns the constant will be a <code class="computeroutput"><span class="identifier">constexp</span></code>.
                 </li>
 <li class="listitem">
-                  If the precision is less than or equal to that of a <code class="computeroutput"><span class="keyword">double</span></code> and the type is constructable
+                  If the precision is less than or equal to that of a <code class="computeroutput"><span class="keyword">double</span></code> and the type is constructible
                   from a <code class="computeroutput"><span class="keyword">double</span></code> then
                   our code returns a <code class="computeroutput"><span class="keyword">double</span></code>
                   literal. If the user-defined type is a literal type then the function
                   call that returns the constant will be a <code class="computeroutput"><span class="identifier">constexp</span></code>.
                 </li>
 <li class="listitem">
                   If the precision is less than or equal to that of a <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>
-                  and the type is constructable from a <code class="computeroutput"><span class="keyword">long</span>
+                  and the type is constructible from a <code class="computeroutput"><span class="keyword">long</span>
                   <span class="keyword">double</span></code> then our code returns
                   a <code class="computeroutput"><span class="keyword">long</span> <span class="keyword">double</span></code>
                   literal. If the user-defined type is a literal type then the function
                   call that returns the constant will be a <code class="computeroutput"><span class="identifier">constexp</span></code>.
                 </li>
 <li class="listitem">
                   If the precision is less than or equal to that of a <code class="computeroutput"><span class="identifier">__float128</span></code> (and the compiler
-                  supports such a type) and the type is constructable from a <code class="computeroutput"><span class="identifier">__float128</span></code> then our code returns
+                  supports such a type) and the type is constructible from a <code class="computeroutput"><span class="identifier">__float128</span></code> then our code returns
                   a <code class="computeroutput"><span class="identifier">__float128</span></code> literal.
                   If the user-defined type is a literal type then the function call
                   that returns the constant will be a <code class="computeroutput"><span class="identifier">constexp</span></code>.

doc/overview/result_type_calc.qbk

@@ -26,7 +26,7 @@ further analysis.
 then it is treated as if it were of type `double` for the purposes of
 further analysis.
 # If any of the arguments is a user-defined class type, then the result type
-is the first such class type that is constructable from all of the other
+is the first such class type that is constructible from all of the other
 argument types.
 # If any of the arguments is of type `long double`, then the result is of type
 `long double`.

include/boost/math/concepts/distributions.hpp

@@ -42,7 +42,7 @@ class distribution_archetype
 public:
    typedef RealType value_type;
 
-   distribution_archetype(const distribution_archetype&); // Copy constructable.
+   distribution_archetype(const distribution_archetype&); // Copy constructible.
    distribution_archetype& operator=(const distribution_archetype&); // Assignable.
 
    // There is no default constructor,

include/boost/math/differentiation/autodiff.hpp

@@ -136,14 +136,14 @@ class fvar {
   // Initialize a variable or constant.
   fvar(root_type const&, bool const is_variable);
 
-  // RealType(cr) | RealType | RealType is copy constructable.
+  // RealType(cr) | RealType | RealType is copy constructible.
   fvar(fvar const&) = default;
 
   // Be aware of implicit casting from one fvar<> type to another by this copy constructor.
   template <typename RealType2, size_t Order2>
   fvar(fvar<RealType2, Order2> const&);
 
-  // RealType(ca) | RealType | RealType is copy constructable from the arithmetic types.
+  // RealType(ca) | RealType | RealType is copy constructible from the arithmetic types.
   explicit fvar(root_type const&);  // Initialize a constant. (No epsilon terms.)
 
   template <typename RealType2>