Function grisu2

Source/Utils/json.hpp:15161–15212

            */
            JSON_HEDLEY_NON_NULL(1)
                inline void grisu2(char* buf, int& len, int& decimal_exponent,
                    diyfp m_minus, diyfp v, diyfp m_plus)
            {
                JSON_ASSERT(m_plus.e == m_minus.e);
                JSON_ASSERT(m_plus.e == v.e);

                //  --------(-----------------------+-----------------------)--------    (A)
                //          m-                      v                       m+
                //
                //  --------------------(-----------+-----------------------)--------    (B)
                //                      m-          v                       m+
                //
                // First scale v (and m- and m+) such that the exponent is in the range
                // [alpha, gamma].

                const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);

                const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k

                // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
                const diyfp w = diyfp::mul(v, c_minus_k);
                const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
                const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);

                //  ----(---+---)---------------(---+---)---------------(---+---)----
                //          w-                      w                       w+
                //          = c*m-                  = c*v                   = c*m+
                //
                // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
                // w+ are now off by a small amount.
                // In fact:
                //
                //      w - v * 10^k < 1 ulp
                //
                // To account for this inaccuracy, add resp. subtract 1 ulp.
                //
                //  --------+---[---------------(---+---)---------------]---+--------
                //          w-  M-                  w                   M+  w+
                //
                // Now any number in [M-, M+] (bounds included) will round to w when input,
                // regardless of how the input rounding algorithm breaks ties.
                //
                // And digit_gen generates the shortest possible such number in [M-, M+].
                // Note that this does not mean that Grisu2 always generates the shortest
                // possible number in the interval (m-, m+).
                const diyfp M_minus(w_minus.f + 1, w_minus.e);
                const diyfp M_plus(w_plus.f - 1, w_plus.e);

                decimal_exponent = -cached.k; // = -(-k) = k

                grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
            }

            /*!
            v = buf * 10^decimal_exponent