Repository: SethMMorton/fastnumbers (language: python)

Issue:
Big numbers handling: silencing arbitrary digits beyond least significant bit
**Describe the bug**

    fast_real(3.453e78)

returns

    3453000000000000090829207640410620202184021047720495530415184879687805108748288

instead of

    3453000000000000000000000000000000000000000000000000000000000000000000000000000

**Environment (please complete the following information):**
 - fastnumbers version: 5.0.1 (installed by pip on conda environment)
 - Python Version: 3.10.11
 - OS: Windows
 
## Observations

I know that the current behaviour is due to unavoidable numeric representation error, however the result is somewhat "disturbing". IMHO the ideal behaviour should be to round the result to the digit before the least significant bit. It's [not a surprise that](https://docs.python.org/3/library/math.html#math.ulp)

    math.ulp(3.453e78)

gives

    4.113761393303015e+62

which tells us that the last 62 digits of the integer output of `fast_real(3.453e78)` are, so to say, *arbitrary* and therefore misleading.


Discussion / hints:
`fastnumbers` aims to return the same results that python returns, and this is the same result as python:

```python
>>> int(3.453e78)
3453000000000000090829207640410620202184021047720495530415184879687805108748288
```
It would be nice adding an optional behaviour for `fastnumbers` to allow overcoming such Python limitations.

Otherwise, and in the meantime, I'll have to use a workaround like the following one, which I guess is not very *fast*:

```
>>> from decimal import Decimal
>>> int(Decimal(str(3.453e78)))
3453000000000000000000000000000000000000000000000000000000000000000000000000000
```
But consider this:

```python
>>> decimal.Decimal(3.453e78)
Decimal('3453000000000000090829207640410620202184021047720495530415184879687805108748288')
```

When you do e.g. `a = 3.453e78`, that number is already `3453000000000000090829207640410620202184021047720495530415184879687805108748288.0`. So, when you do `int(a)` , Python is accurately and correctly returning `3453000000000000090829207640410620202184021047720495530415184879687805108748288`.

The reason that `Decimal(str(3.453e78))` gives what you expect is that Python has a heuristic for writing out string representations of floats that only gives what it anticipates is the user's desired human-readable output, and so the `Decimal` class only sees the 3 digits you gave.

```python
>>> str(3.453e78)
'3.453e+78'
>>> format(3.453e78, ".0f")
'3453000000000000090829207640410620202184021047720495530415184879687805108748288'
```

So, when you do `fast_real(3.453e78)`, `fastnumbers` is *actually* seeing `3453000000000000090829207640410620202184021047720495530415184879687805108748288.0`. For it to return `3453000000000000000000000000000000000000000000000000000000000000000000000000000` instead would mean that it has to guess that you only want to keep the first 4 digits. But, from `fastnumbers`'s perspective, `fast_real(3.453e78)` is no different from `fast_real(3453000000000000090829207640410620202184021047720495530415184879687805108748288.0)`, and in the latter case it seems like all those digits are important.

I simply don't see how this request can be satisfied as given.

---

Now, if the request were to make it so that `fast_real("3.453e78")` returned `3453000000000000000000000000000000000000000000000000000000000000000000000000000`, that is possible and could be done.
Yes, making `fast_real("3.453e78")` return

`3453000000000000000000000000000000000000000000000000000000000000000000000000000`

it's the first request and I think would be a nice improvement.

About the rest, I understand your explanation and I'm aware that `fastnumbers` sees the numeric literal `3.453e78` as

`3453000000000000090829207640410620202184021047720495530415184879687805108748288`

but at the same time I guess (correct me if I'm wrong) that `fastnumbers` is aware that the least significant bit of the numeric literal `3.453e78` is `4.113761393303015e+62` (given by `math.ulp(3.453e78)`), so **it could be aware** that all the last 62 digits of 

`34530000000000000 90829207640410620202184021047720495530415184879687805108748288`

which are precisely those after the added space, are arbitrary and therefore could be set to zero.

If this is the case, I think that an option to let `fastnumbers` *silence* arbitrary digits (those beyond the least significant bit) would be a valuable feature.
I'll take a look, but I'm not really sure how one "silences" digits, especially in the python long type. I assume you have an idea?
After some tentatives I came up with the following pure numerical way (in Python), which handles rounding and negative numbers and delivers the same results as `decimal.Decimal(str(n))` for the tests I made on big floats:

```
import math
n=3.453e78
n_sign = (n>0)-(n<0)
digits = 1+int(math.log10(math.ulp(abs(n))))
int_n = int(abs(n))
roundup = 1 if int_n // 10**digits % 10 == 9 else 0 # 1 if least decimal significant digit is 9, else 0
fixed_n = (roundup + int_n // (10 ** digits)) * (10 ** digits) * n_sign
```
gives
```
>>> n = 3.453e78
>>> int(n)
3453000000000000090829207640410620202184021047720495530415184879687805108748288
>>> fixed_n
3453000000000000000000000000000000000000000000000000000000000000000000000000000
>>> n = -6.853808e38
>>> int(n)
-685380799999999969504234500079333933056
>>> fixed_n
-685380800000000000000000000000000000000
```


Fix patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b051f788..6041e0a4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,10 @@ Unreleased
 
 ### Added
 
+- Added the ``denoise`` option to convert floats to int without
+  numerical noise (issues
+  [#69](https://github.com/SethMMorton/fastnumbers/issues/69) and
+  [#77](https://github.com/SethMMorton/fastnumbers/pull/77))
 - Support for Python 3.12 (issues
   [#73](https://github.com/SethMMorton/fastnumbers/issues/73) and
   [#75](https://github.com/SethMMorton/fastnumbers/pull/75))
diff --git a/README.rst b/README.rst
index c91df8ac..c0561450 100644
--- a/README.rst
+++ b/README.rst
@@ -95,6 +95,7 @@ Error-Handling Functions
 - `Error-handling function API <https://fastnumbers.readthedocs.io/en/stable/api.html#the-error-handling-functions>`_
 - `Fast operations on lists and other iterables`_
 - `About the on_fail option`_
+- `About the denoise option`_
 
 ``try_float`` will be used to demonstrate the functionality of the
 ``try_*`` functions.
@@ -311,6 +312,57 @@ invalid type and b) the default value is ``fastnumbers.RAISE``, not
     The input 'invalid input' is not valid!
     nan
 
+About the ``denoise`` option
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The ``denoise`` option is available on the ``try_real`` and ``try_forceint`` options.
+To best understand its usage, consider the following native Python behavior:
+
+.. code-block:: python
+
+    >>> int(3.453e21)
+    3452999999999999737856
+    >>> int(float("3.453e21"))
+    3452999999999999737856
+    >>> # Most users would likely expect this result from decimal.Decimal
+    >>> import decimal
+    >>> int(decimal.Decimal("3.453e21"))
+    3453000000000000000000
+    >>> # But watch out, even decimal.Decimal doesn't help for float input
+    >>> import decimal
+    >>> int(decimal.Decimal(3.453e21))
+    3452999999999999737856
+
+Because the conversion of a float to an int goes through the C ``double`` data type which
+has inherent limitations on accuracy (See
+`this Stack Overflow question for examples <https://stackoverflow.com/questions/588004/is-floating-point-math-broken>`_)
+the resulting ``int`` result has "noise" digits that are not part of the original float
+representation.
+
+For functions where this makes sense, ``fastnumbers`` provides the ``denoise`` option to
+give you the results that ``decimal.Decimal`` would give for strings containing floats.
+
+.. code-block:: python
+
+    >>> from fastnumbers import try_real
+    >>> try_real(3.453e21)
+    3452999999999999737856
+    >>> try_real("3.453e21")
+    3452999999999999737856
+    >>> try_real(3.453e21, denoise=True)
+    3453000000000000000000
+    >>> try_real("3.453e21", denoise=True)
+    3453000000000000000000
+
+Two things to keep in mind:
+
+1. The ``denoise`` option adds additional overhead to the conversion calculation, so please consider
+   the trade-offs between speed and accuracy when determining whether or not to use it. It is
+   *significantly* faster than using ``decimal.Decimal``, but much slower than not using it at all.
+2. For string input, ``denoise`` will return results identical to ``decimal.Decimal``. For float
+   input, ``denoise`` will return results that are accurate to about 15 digits (C ``double`` can
+   only store 16 decimal digits, so this means that only the last possible digit may not be accurate).
+
 Checking Functions
 ++++++++++++++++++
 
diff --git a/include/fastnumbers/buffer.hpp b/include/fastnumbers/buffer.hpp
index d28e9e96..b111f9d6 100644
--- a/include/fastnumbers/buffer.hpp
+++ b/include/fastnumbers/buffer.hpp
@@ -112,6 +112,24 @@ class Buffer {
         }
     }
 
+    /// Mark the first '.', 'e', or 'E' as '\0'.
+    void mark_integer_end() noexcept
+    {
+        // Technically, we set the exponent character to '\0'
+        // and then adjust the length. We are not actually removing data.
+        // Look for '.' or 'e'/'E'. Instead of searching simulataneously
+        // use memchr because it is so darn fast.
+        char* exp_loc = nullptr;
+        for (const char c : { '.', 'e', 'E' }) {
+            exp_loc = static_cast<char*>(std::memchr(m_buffer, c, m_len));
+            if (exp_loc != nullptr) {
+                *exp_loc = '\0';
+                m_len = m_size = exp_loc - m_buffer;
+                return;
+            }
+        }
+    }
+
     /// The largest amount of data the buffer can contain
     std::size_t max_size() const noexcept
     {
diff --git a/include/fastnumbers/c_str_parsing.hpp b/include/fastnumbers/c_str_parsing.hpp
index cc565231..c524e925 100644
--- a/include/fastnumbers/c_str_parsing.hpp
+++ b/include/fastnumbers/c_str_parsing.hpp
@@ -55,21 +55,182 @@ constexpr int8_t DIGIT_TABLE_ARBITRARY_BASE[]
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
         -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
 
+/// Selector for the type of data a string can contain
+enum class StringType {
+    INVALID, ///< Contains an invalid number
+    INTEGER, ///< Contains an integer
+    FLOAT, ///< Contains a float
+    INTLIKE_FLOAT, ///< Contains an integer-like float
+};
+
 /**
- * \brief Check if a string could be converted to some numeric type
- *
- * Assumes no sign or whitespace.
- *
- * \param str The string to parse, assumed to be non-NULL
- * \param end The end of the string being checked
- * \param base The base to assume when checking an integer, set to 10
- *             unless you know it *must* be an integer.
- * \return 0 - invalid
- *         1 - integer
- *         2 - float
- *         3 - "intlike" float
+ * \class StringChecker
+ * \brief Assess the type of number that is contained in a string
  */
-int string_contains_what(const char* str, const char* end, int base) noexcept;
+class StringChecker {
+public:
+    /**
+     * \brief Check if a string could be converted to some numeric type
+     *
+     * Assumes no sign or whitespace.
+     *
+     * \param str The string to parse, assumed to be non-NULL
+     * \param end The end of the string being checked
+     * \param base The base to assume when checking an integer, set to 10
+     *             unless you know it *must* be an integer.
+     */
+    StringChecker(const char* str, const char* end, int base) noexcept;
+
+    // Default copy/move/assign/destruct
+    StringChecker(const StringChecker&) = default;
+    StringChecker(StringChecker&&) = default;
+    StringChecker& operator=(const StringChecker&) = default;
+    ~StringChecker() = default;
+
+    /// Return the contained type of the string
+    StringType get_type() const { return m_contained_type; }
+
+    /// Is the contained string an invalid number?
+    bool is_invalid() const { return get_type() == StringType::INVALID; }
+
+    /// Is the contained string an integer?
+    bool is_integer() const { return get_type() == StringType::INTEGER; }
+
+    /// Is the contained string a float?
+    bool is_float() const { return get_type() == StringType::FLOAT; }
+
+    /// Is the contained string an int-like float?
+    bool is_intlike_float() const { return get_type() == StringType::INTLIKE_FLOAT; }
+
+    /// The start of the integer component of the contained number.
+    const char* integer_start() const { return m_integer_start; }
+
+    /// The end of the integer component of the contained number.
+    const char* integer_end() const { return m_decimal_start; }
+
+    /// The length of the integer component of the contained number.
+    uint32_t integer_length() const
+    {
+        return std::max(static_cast<uint32_t>(integer_end() - integer_start()), 0U);
+    }
+
+    /// The number of zeros that trail the integer part of the contained number.
+    uint32_t integer_trailing_zeros() const { return m_int_trailing_zeros; }
+
+    /// The start of the decimal component of the contained number.
+    const char* decimal_start() const
+    {
+        return (m_decimal_start == m_decimal_end) ? m_decimal_start
+                                                  : (m_decimal_start + 1);
+    }
+
+    /// The end of the decimal component of the contained number.
+    const char* decimal_end() const { return m_decimal_end; }
+
+    /// The length of the decimal component of the contained number.
+    uint32_t decimal_length() const
+    {
+        return std::max(static_cast<uint32_t>(decimal_end() - decimal_start()), 0U);
+    }
+
+    /// The number of zeros that trail the decimal part of the contained number.
+    uint32_t decimal_trailing_zeros() const { return m_dec_trailing_zeros; }
+
+    /// Was any decimal data found in the string?
+    bool has_decimal_data() const { return m_decimal_start != m_decimal_end; }
+
+    /// The value of the exponent of the nubmer.
+    uint32_t exponent_value() const { return m_expon; }
+
+    /// Is the exponent negative?
+    bool is_exponent_negative() const { return m_exp_negative; }
+
+    /// The total length of the integer plus decimal components.
+    uint32_t digit_length() const { return integer_length() + decimal_length(); }
+
+    /// The decimal length after removing trailing zeros.
+    uint32_t truncated_decimal_length() const
+    {
+        return std::max(decimal_length() - decimal_trailing_zeros(), 0U);
+    }
+
+    /// The exponent after taking into account the decimal digits.
+    uint32_t adjusted_exponent_value() const
+    {
+        if (is_exponent_negative()) {
+            return exponent_value();
+        } else {
+            return std::max(exponent_value() - truncated_decimal_length(), 0U);
+        }
+    }
+
+    /// The total length of the entire number.
+    uint32_t total_length() const
+    {
+        return std::max(static_cast<uint32_t>(m_total_end - integer_start()), 0U);
+    }
+
+    /// The length of the start of the decimal component to the end of the number.
+    uint32_t decimal_and_exponent_length() const
+    {
+        return std::max(static_cast<uint32_t>(m_total_end - decimal_start()), 0U);
+    }
+
+private:
+    /// Set the contained type.
+    void set_type(StringType val) { m_contained_type = val; }
+
+    /// Set the integer start.
+    void set_integer_start(const char* val) { m_integer_start = val; }
+
+    /// Set the decimal start.
+    void set_decimal_start(const char* val) { m_decimal_start = val; }
+
+    /// Set the decimal end.
+    void set_decimal_end(const char* val) { m_decimal_end = val; }
+
+    /// Set the total end.
+    void set_total_end(const char* val) { m_total_end = val; }
+
+    /// Set the exponent value.
+    void set_exponent(const uint32_t val) { m_expon = val; }
+
+    /// Set whether or not the exponent is negative.
+    void set_exponent_negative(const bool val) { m_exp_negative = val; }
+
+    /// Set the number of trailing zeros on the integer part.
+    void set_int_trailing_zeros(const uint32_t val) { m_int_trailing_zeros = val; }
+
+    /// Set the number of trailing zeros on the decimal part.
+    void set_dec_trailing_zeros(const uint32_t val) { m_dec_trailing_zeros = val; }
+
+    /// The start of the integer component of the contained number.
+    const char* m_integer_start;
+
+    /// The start of the decimal component of the contained number.
+    const char* m_decimal_start;
+
+    /// The end of the decimal component of the contained number.
+    const char* m_decimal_end;
+
+    /// The end of the contained number.
+    const char* m_total_end;
+
+    /// The value of the exponent of the nubmer.
+    uint32_t m_expon;
+
+    /// Whether or not the exponent is negative.
+    bool m_exp_negative;
+
+    /// The number of zeros that trail the integer part of the contained number.
+    uint32_t m_int_trailing_zeros;
+
+    /// The number of zeros that trail the decimal part of the contained number.
+    uint32_t m_dec_trailing_zeros;
+
+    /// The contained type of the string.
+    StringType m_contained_type;
+};
 
 /**
  * \brief Remove underscores in a numeric-representing string
@@ -207,11 +368,6 @@ constexpr inline bool is_sign(const char c) noexcept
  */
 constexpr inline bool is_base_prefix(const char c) noexcept
 {
-    // The ASCII standard was quite clever... upper- and lower-case
-    // letters only differ from each other by the 32 bit, otherwise
-    // they are identical.
-    // So, we can OR the 32 bit to force the character to be
-    // lowercase and then just check against the lowercase characters.
     const char lowered = lowercase(c);
     return (lowered == 'x') || (lowered == 'o') || (lowered == 'b');
 }
@@ -370,7 +526,7 @@ constexpr inline int detect_base(const char* str, const char* end) noexcept
  * \brief Return the number of digits an integer type can safely parse without overflow
  */
 template <typename T, typename std::enable_if_t<std::is_integral_v<T>, bool> = true>
-constexpr inline int8_t overflow_cutoff() noexcept
+constexpr inline uint8_t overflow_cutoff() noexcept
 {
     // len('std::numeric_limits<T>::max()') - 1 == return value
     constexpr uint64_t limit = static_cast<uint64_t>(std::numeric_limits<T>::max());
@@ -408,7 +564,7 @@ constexpr inline int8_t overflow_cutoff() noexcept
  * \param always_convert
  */
 template <typename T, typename std::enable_if_t<std::is_integral_v<T>, bool> = true>
-T parse_int(
+inline T parse_int(
     const char* str,
     const char* end,
     int base,
@@ -528,7 +684,7 @@ T parse_int(
 template <
     typename T,
     typename std::enable_if_t<std::is_floating_point_v<T>, bool> = true>
-T parse_float(const char* str, const char* end, bool& error) noexcept
+inline T parse_float(const char* str, const char* end, bool& error) noexcept
 {
     // Use a very fast and accurate string-to-floating point parser
     T value;
diff --git a/include/fastnumbers/compatibility.hpp b/include/fastnumbers/compatibility.hpp
index ae296e44..4fe7ab25 100644
--- a/include/fastnumbers/compatibility.hpp
+++ b/include/fastnumbers/compatibility.hpp
@@ -9,7 +9,7 @@
 // in obtaining the name of a type.
 // The implementation was basically copied from the 3.11 source code,
 // but adjustments were made to make it C++.
-PyObject* PyType_GetName(PyTypeObject* type)
+inline PyObject* PyType_GetName(PyTypeObject* type)
 {
     auto _PyType_Name = [](PyTypeObject* type) -> const char* {
         assert(type->tp_name != nullptr);
diff --git a/include/fastnumbers/docstrings.hpp b/include/fastnumbers/docstrings.hpp
index 3dd90560..77d98746 100644
--- a/include/fastnumbers/docstrings.hpp
+++ b/include/fastnumbers/docstrings.hpp
@@ -49,6 +49,10 @@ PyDoc_STRVAR(
     "    If the input can be converted to an *int* without loss of precision\n"
     "    (even if the input was a *float* or float-containing *str*)\n"
     "    coerce to an *int* rather than returning a *float*.\n"
+    "denoise : bool, optional\n"
+    "    When coercing large floating point numbers to an integer, ensure that\n"
+    "    \"noise\" digits are not included. See README for more details.\n"
+    "    Ignored if *coerce* is *False*. The default is *False*.\n"
     "allow_underscores : bool, optional\n"
     "    Underscores are allowed in numeric literals and in strings passed to *int*\n"
     "    or *float* (see PEP 515 for details on what is and is not allowed). You can\n"
@@ -371,6 +375,10 @@ PyDoc_STRVAR(
     "    Control what happens when the input is neither numeric nor string. Behavior\n"
     "    matches that of `on_fail` except that the default value is *RAISE* and a\n"
     "    *TypeError* is raised instead of *ValueError*."
+    "denoise : bool, optional\n"
+    "    When converting large floating point numbers to an integer, ensure that\n"
+    "    \"noise\" digits are not included. See README for more details.\n"
+    "    The default is *False*.\n"
     "allow_underscores : bool, optional\n"
     "    Underscores are allowed in numeric literals and in strings passed to *int*\n"
     "    or *float* (see PEP 515 for details on what is and is not allowed). You can\n"
diff --git a/include/fastnumbers/helpers.hpp b/include/fastnumbers/helpers.hpp
index ee1ad97b..b6061fd3 100644
--- a/include/fastnumbers/helpers.hpp
+++ b/include/fastnumbers/helpers.hpp
@@ -12,3 +12,62 @@ struct overloaded : Ts... {
 };
 template <class... Ts>
 overloaded(Ts...) -> overloaded<Ts...>;
+
+/// In-place addition of a number, handling reference counting.
+inline void in_place_add(PyObject*& self, PyObject* x)
+{
+    // The in-place method *might* return a new object. As a result
+    // we should be good citizens and decref the after the operation.
+    PyObject* temp = self;
+    self = PyNumber_InPlaceAdd(temp, x);
+    Py_DECREF(temp);
+}
+
+/// In-place multiplication of a number, handling reference counting.
+inline void in_place_multiply(PyObject*& self, PyObject* x)
+{
+    // The in-place method *might* return a new object. As a result
+    // we should be good citizens and decref the after the operation.
+    PyObject* temp = self;
+    self = PyNumber_InPlaceMultiply(temp, x);
+    Py_DECREF(temp);
+}
+
+/// In-place division of a number, handling reference counting.
+inline void in_place_divide(PyObject*& self, PyObject* x)
+{
+    // The in-place method *might* return a new object. As a result
+    // we should be good citizens and decref the after the operation.
+    PyObject* temp = self;
+    self = PyNumber_InPlaceFloorDivide(temp, x);
+    Py_DECREF(temp);
+}
+
+/// In-place power of a number, handling reference counting.
+inline void in_place_pow(PyObject*& self, PyObject* x)
+{
+    // The in-place method *might* return a new object. As a result
+    // we should be good citizens and decref the after the operation.
+    PyObject* temp = self;
+    self = PyNumber_InPlacePower(temp, x, Py_None);
+    Py_DECREF(temp);
+}
+
+/// Convert an integer to a Python long
+template <typename T, typename std::enable_if_t<std::is_integral_v<T>, bool> = true>
+inline PyObject* pyobject_from_int(const T value) noexcept
+{
+    if constexpr (std::is_same_v<T, long>) {
+        return PyLong_FromLong(value);
+    } else if constexpr (std::is_same_v<T, unsigned long>) {
+        return PyLong_FromUnsignedLong(value);
+    } else if constexpr (std::is_same_v<T, long long>) {
+        return PyLong_FromLongLong(value);
+    } else if constexpr (std::is_same_v<T, unsigned long long>) {
+        return PyLong_FromUnsignedLongLong(value);
+    } else if constexpr (std::is_signed_v<T>) {
+        return PyLong_FromLong(static_cast<long>(value));
+    } else {
+        return PyLong_FromUnsignedLong(static_cast<unsigned long>(value));
+    };
+}
diff --git a/include/fastnumbers/implementation.hpp b/include/fastnumbers/implementation.hpp
index 3e4118e6..9ac36046 100644
--- a/include/fastnumbers/implementation.hpp
+++ b/include/fastnumbers/implementation.hpp
@@ -114,6 +114,9 @@ class Implementation {
     /// Set whether intlike floats should be returned as ints
     void set_coerce(const bool val) noexcept { m_options.set_coerce(val); }
 
+    /// Set whether float to int conversion should include denoising
+    void set_denoise(const bool val) noexcept { m_options.set_denoise(val); }
+
     /// Set whether we accept NaN
     void set_nan_allowed(const PyObject* val) noexcept(false)
     {
diff --git a/include/fastnumbers/introspection.hpp b/include/fastnumbers/introspection.hpp
index 566e3368..ffe14c33 100644
--- a/include/fastnumbers/introspection.hpp
+++ b/include/fastnumbers/introspection.hpp
@@ -2,76 +2,76 @@
 
 /// Return a string form of the given type
 template <typename T>
-constexpr const char* type_name() noexcept;
+constexpr inline const char* type_name() noexcept;
 
 template <>
-constexpr const char* type_name<double>() noexcept
+constexpr inline const char* type_name<double>() noexcept
 {
     return "double";
 }
 
 template <>
-constexpr const char* type_name<float>() noexcept
+constexpr inline const char* type_name<float>() noexcept
 {
     return "float";
 }
 
 template <>
-constexpr const char* type_name<signed long long>() noexcept
+constexpr inline const char* type_name<signed long long>() noexcept
 {
     return "signed long long";
 }
 
 template <>
-constexpr const char* type_name<signed long>() noexcept
+constexpr inline const char* type_name<signed long>() noexcept
 {
     return "signed long";
 }
 
 template <>
-constexpr const char* type_name<signed int>() noexcept
+constexpr inline const char* type_name<signed int>() noexcept
 {
     return "signed int";
 }
 
 template <>
-constexpr const char* type_name<signed short>() noexcept
+constexpr inline const char* type_name<signed short>() noexcept
 {
     return "signed short";
 }
 
 template <>
-constexpr const char* type_name<signed char>() noexcept
+constexpr inline const char* type_name<signed char>() noexcept
 {
     return "signed char";
 }
 
 template <>
-constexpr const char* type_name<unsigned long long>() noexcept
+constexpr inline const char* type_name<unsigned long long>() noexcept
 {
     return "unsigned long long";
 }
 
 template <>
-constexpr const char* type_name<unsigned long>() noexcept
+constexpr inline const char* type_name<unsigned long>() noexcept
 {
     return "unsigned long";
 }
 
 template <>
-constexpr const char* type_name<unsigned int>() noexcept
+constexpr inline const char* type_name<unsigned int>() noexcept
 {
     return "unsigned int";
 }
 
 template <>
-constexpr const char* type_name<unsigned short>() noexcept
+constexpr inline const char* type_name<unsigned short>() noexcept
 {
     return "unsigned short";
 }
 
 template <>
-constexpr const char* type_name<unsigned char>() noexcept
+constexpr inline const char* type_name<unsigned char>() noexcept
 {
     return "unsigned char";
 }
diff --git a/include/fastnumbers/iteration.hpp b/include/fastnumbers/iteration.hpp
index f48edbd3..6375e19d 100644
--- a/include/fastnumbers/iteration.hpp
+++ b/include/fastnumbers/iteration.hpp
@@ -9,7 +9,7 @@
 #include "fastnumbers/selectors.hpp"
 
 /// Obtain the length hint from a Python object
-Py_ssize_t get_length_hint(PyObject* length_hint_base) noexcept(false)
+inline Py_ssize_t get_length_hint(PyObject* length_hint_base) noexcept(false)
 {
     Py_ssize_t length_hint = PyObject_LengthHint(length_hint_base, 0);
     if (length_hint < 0) {
diff --git a/include/fastnumbers/parser/base.hpp b/include/fastnumbers/parser/base.hpp
index 35b52dfc..1b5b8e30 100644
--- a/include/fastnumbers/parser/base.hpp
+++ b/include/fastnumbers/parser/base.hpp
@@ -8,6 +8,7 @@
 
 #include <Python.h>
 
+#include "fastnumbers/c_str_parsing.hpp"
 #include "fastnumbers/helpers.hpp"
 #include "fastnumbers/payload.hpp"
 #include "fastnumbers/third_party/EnumClass.h"
@@ -115,6 +116,19 @@ class Parser {
         return std::isfinite(x) && std::floor(x) == x && errno == 0;
     }
 
+    /**
+     * \brief Convert a Python float to Python int without floating-point noise
+     *
+     * Set to zero digits that are likely non-zero due to mis-representations
+     * arising from how floating point numbers are stored in memory.
+     */
+    static PyObject* float_as_int_without_noise(PyObject* obj) noexcept;
+
+    /// Same as above, but with string input
+    static PyObject* float_as_int_without_noise(
+        const StringChecker& checker, const bool is_negative
+    ) noexcept;
+
 protected:
     /// Constructor for use only by base-classes to define the parser type
     /// and base requirements
diff --git a/include/fastnumbers/parser/numeric.hpp b/include/fastnumbers/parser/numeric.hpp
index 9423258e..7d0f3f1b 100644
--- a/include/fastnumbers/parser/numeric.hpp
+++ b/include/fastnumbers/parser/numeric.hpp
@@ -66,9 +66,15 @@ class NumericParser final : public Parser {
         if (get_number_type() == static_cast<NumberFlags>(NumberType::INVALID)) {
             return ErrorType::TYPE_ERROR;
         } else if (force_int) {
-            return PyNumber_Long(m_obj);
+            if (options().do_denoise() && (get_number_type() & NumberType::IntLike)) {
+                return Parser::float_as_int_without_noise(m_obj);
+            } else {
+                return PyNumber_Long(m_obj);
+            }
         } else if (coerce) {
-            if (get_number_type() & (NumberType::IntLike | NumberType::Integer)) {
+            if (options().do_denoise() && (get_number_type() & NumberType::IntLike)) {
+                return Parser::float_as_int_without_noise(m_obj);
+            } else if (get_number_type() & (NumberType::IntLike | NumberType::Integer)) {
                 return PyNumber_Long(m_obj);
             } else {
                 return PyNumber_Float(m_obj);
diff --git a/include/fastnumbers/third_party/ipow.hpp b/include/fastnumbers/third_party/ipow.hpp
new file mode 100644
index 00000000..3a057d45
--- /dev/null
+++ b/include/fastnumbers/third_party/ipow.hpp
@@ -0,0 +1,99 @@
+#pragma once
+
+// Adapted from https://gist.github.com/orlp/3551590
+
+#include <cstdint>
+#include <type_traits>
+
+namespace ipow {
+
+template<
+    typename T1,
+    typename T2,
+    typename std::enable_if_t<
+        std::is_integral_v<T1> && std::is_integral_v<T2>, bool
+    > = true
+>
+inline T1 ipow(T1 base, T2 exp) {
+    static const uint8_t highest_bit_set[] = {
+        0, 1, 2, 2, 3, 3, 3, 3,
+        4, 4, 4, 4, 4, 4, 4, 4,
+        5, 5, 5, 5, 5, 5, 5, 5,
+        5, 5, 5, 5, 5, 5, 5, 5,
+        6, 6, 6, 6, 6, 6, 6, 6,
+        6, 6, 6, 6, 6, 6, 6, 6,
+        6, 6, 6, 6, 6, 6, 6, 6,
+        6, 6, 6, 6, 6, 6, 6, 255, // anything past 63 is a guaranteed overflow with base > 1
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255,
+    };
+
+    T1 result = 1;
+
+    switch (highest_bit_set[exp]) {
+    case 255: // we use 255 as an overflow marker and return 0 on overflow/underflow
+        if (base == 1) {
+            return 1;
+        }
+        
+        if (base == -1) {
+            return 1 - 2 * (exp & 1);
+        }
+        
+        return 0;
+    case 6:
+        if (exp & 1) result *= base;
+        exp >>= 1;
+        base *= base;
+        [[fallthrough]];
+    case 5:
+        if (exp & 1) result *= base;
+        exp >>= 1;
+        base *= base;
+        [[fallthrough]];
+    case 4:
+        if (exp & 1) result *= base;
+        exp >>= 1;
+        base *= base;
+        [[fallthrough]];
+    case 3:
+        if (exp & 1) result *= base;
+        exp >>= 1;
+        base *= base;
+        [[fallthrough]];
+    case 2:
+        if (exp & 1) result *= base;
+        exp >>= 1;
+        base *= base;
+        [[fallthrough]];
+    case 1:
+        if (exp & 1) result *= base;
+        [[fallthrough]];
+    default:
+        return result;
+    }
+}
+
+};
\ No newline at end of file
diff --git a/include/fastnumbers/user_options.hpp b/include/fastnumbers/user_options.hpp
index 68bbd02f..32f8e320 100644
--- a/include/fastnumbers/user_options.hpp
+++ b/include/fastnumbers/user_options.hpp
@@ -26,6 +26,7 @@ class UserOptions final {
         , m_default_base(true)
         , m_underscore_allowed(false)
         , m_coerce(false)
+        , m_denoise(false)
         , m_nan_allowed_str(false)
         , m_nan_allowed_num(false)
         , m_inf_allowed_str(false)
@@ -62,6 +63,12 @@ class UserOptions final {
     /// Indicate if we are allowing coersion of floats to ints
     bool allow_coerce() const noexcept { return m_coerce; }
 
+    /// Tell the analyzer whether or not to denoise float to int
+    void set_denoise(const bool denoise) noexcept { m_denoise = denoise; }
+
+    /// Indicate if we are allowing denoise for float to int
+    bool do_denoise() const noexcept { return m_denoise; }
+
     /// Tell the analyzer if NaN is allowed when type checking
     void set_nan_allowed(const bool nan_allowed) noexcept
     {
@@ -154,6 +161,10 @@ class UserOptions final {
     /// Whether or not floats should be coerced to integers if user wants REAL
     bool m_coerce;
 
+    /// When converting float to integer, remove digits that could be incorrect
+    /// due to floating-point representations
+    bool m_denoise;
+
     /// Whether or not an NaN is allowed for strings
     bool m_nan_allowed_str;
 
diff --git a/profiling/profile.py b/profiling/profile.py
index 1bd012ec..0b23ab04 100644
--- a/profiling/profile.py
+++ b/profiling/profile.py
@@ -1,6 +1,7 @@
 #! /usr/bin/env python
 
 import copy
+import decimal
 import gc
 import math
 import re
@@ -274,6 +275,31 @@ def forceint_try(x):
             return x
 
 
+if sys.version_info >= (3, 9):
+
+    def forceint_denoise(
+        x, _decimal=decimal.Decimal, ceil=math.ceil, log10=math.log10, ulp=math.ulp
+    ):
+        """Function to noiselessly convert a float to an integer."""
+        try:
+            # Integer method
+            int_val = int(x)
+            if x == int_val:
+                return int_val
+            double_digits = ceil(log10(ulp(abs(x))))
+            return round(int_val, -int(double_digits))
+        except (TypeError, ValueError):
+            # String method
+            try:
+                return int(_decimal(x))
+            except decimal.InvalidOperation:
+                raise TypeError
+
+    def forceint_denoise_fn(x, try_forceint=fastnumbers.try_forceint):
+        """Function to noiselessly convert a float to an integer using fastnumbers."""
+        return try_forceint(x, denoise=True)
+
+
 def check_int_re(x, int_match=re.compile(r"[-+]?\d+$").match):
     """Function to simulate check_int but with regular expressions."""
     t = type(x)
@@ -424,6 +450,19 @@ def fn_into_array(iterable, func=fastnumbers.try_array, out=output):
 )
 timer.time_functions()
 
+if sys.version_info >= (3, 9):
+    timer = Timer(
+        "Timing comparison of forced `int` functions with error handling "
+        "and denoising"
+    )
+    timer.add_function(
+        "forceint_denoise", "Python", "from __main__ import forceint_denoise"
+    )
+    timer.add_function(
+        "forceint_denoise_fn", "fastnumbers", "from __main__ import forceint_denoise_fn"
+    )
+    timer.time_functions()
+
 timer = Timer("Timing comparison to check if value can be converted to `int`")
 timer.add_function("check_int_try", "try/except", "from __main__ import check_int_try")
 timer.add_function("check_int_re", "regex", "from __main__ import check_int_re")
diff --git a/profiling/results-3.10.md b/profiling/results-3.10.md
index 16821ec2..ee30df4b 100644
--- a/profiling/results-3.10.md
+++ b/profiling/results-3.10.md
@@ -1,176 +1,187 @@
-sys.version_info(major=3, minor=10, micro=6, releaselevel='final', serial=0)
+sys.version_info(major=3, minor=10, micro=12, releaselevel='final', serial=0)
 
 ### Timing comparison of `int` functions
 
 | Input type        | builtin (ms)       | fastnumbers (ms) |
 | ----------------: | -----------------: | ---------------: |
-|  Small Int String |  **9.548 ± 0.125** |   11.003 ± 0.178 |
-|        Int String | **10.105 ± 0.208** |   11.739 ± 0.350 |
-| Medium Int String | **11.495 ± 0.690** |   12.096 ± 0.087 |
-|  Large Int String | **16.456 ± 1.849** |   19.369 ± 0.446 |
-|               Int |  **5.771 ± 0.241** |    9.186 ± 0.121 |
-|             Float | **15.205 ± 0.176** |   19.751 ± 1.484 |
+|  Small Int String | **11.092 ± 0.432** |   12.237 ± 0.208 |
+|        Int String | **11.861 ± 0.396** |   13.258 ± 0.604 |
+| Medium Int String | **12.997 ± 0.203** |   13.446 ± 0.149 |
+|  Large Int String | **17.833 ± 0.165** |   21.808 ± 0.589 |
+|               Int |  **6.643 ± 0.078** |   10.165 ± 0.072 |
+|             Float | **15.842 ± 0.077** |   20.163 ± 0.222 |
 
 ### Timing comparison of `float` functions
 
 | Input type         | builtin (ms)       | fastnumbers (ms)   |
 | -----------------: | -----------------: | -----------------: |
-|   Small Int String |  **8.527 ± 0.207** |   11.439 ± 0.179   |
-|         Int String |  **9.308 ± 0.137** |   11.598 ± 0.130   |
-|  Medium Int String | **10.613 ± 0.626** |   11.896 ± 0.237   |
-|   Large Int String |   29.491 ± 0.267   | **16.386 ± 0.537** |
-| Small Float String |  **8.799 ± 0.165** |   11.690 ± 0.127   |
-|       Float String |   26.393 ± 0.793   | **13.220 ± 0.214** |
-| Large Float String |   50.519 ± 0.386   | **13.347 ± 0.207** |
-|                Int |  **4.763 ± 0.038** |    9.510 ± 0.177   |
-|              Float |  **3.964 ± 0.050** |    9.079 ± 0.123   |
+|   Small Int String |  **9.566 ± 0.183** |   13.027 ± 0.243   |
+|         Int String | **10.394 ± 0.506** |   13.096 ± 0.291   |
+|  Medium Int String | **11.413 ± 0.123** |   13.336 ± 0.032   |
+|   Large Int String |   31.631 ± 1.921   | **18.929 ± 0.653** |
+| Small Float String | **10.273 ± 0.231** |   14.179 ± 0.401   |
+|       Float String |   30.081 ± 0.475   | **16.037 ± 1.841** |
+| Large Float String |   54.017 ± 0.483   | **15.901 ± 0.240** |
+|                Int |  **6.100 ± 0.116** |   11.657 ± 0.110   |
+|              Float |  **5.161 ± 0.118** |   11.155 ± 0.830   |
 
 ### Timing comparison of `int` functions with error handling
 
 | Input type         | try/except (ms)    | regex (ms)     | fastnumbers (ms)   |
 | -----------------: | -----------------: | -------------: | -----------------: |
-|  Non-number String |   90.966 ± 1.293   | 21.928 ± 0.030 | **16.877 ± 0.055** |
-|   Small Int String | **12.827 ± 0.086** | 34.176 ± 0.072 |   16.034 ± 0.034   |
-|         Int String | **13.676 ± 0.095** | 36.215 ± 0.057 |   17.309 ± 0.691   |
-|  Medium Int String | **14.860 ± 0.052** | 40.369 ± 0.126 |   17.448 ± 0.036   |
-|   Large Int String | **19.775 ± 0.077** | 54.799 ± 0.046 |   25.012 ± 0.078   |
-| Small Float String |   85.947 ± 0.826   | 24.252 ± 0.035 | **16.923 ± 0.011** |
-|       Float String |   90.124 ± 0.645   | 28.578 ± 0.760 | **17.164 ± 0.036** |
-| Large Float String |   92.206 ± 0.468   | 28.238 ± 0.028 | **17.282 ± 0.045** |
-|                Int |  **9.187 ± 0.087** | 44.301 ± 0.739 |   14.891 ± 1.743   |
-|              Float | **18.628 ± 0.024** | 54.239 ± 0.032 |   24.525 ± 0.043   |
+|  Non-number String |  113.202 ± 0.579   | 25.564 ± 0.110 | **25.252 ± 0.269** |
+|   Small Int String | **16.965 ± 0.173** | 39.167 ± 0.142 |   24.718 ± 0.129   |
+|         Int String | **17.452 ± 0.100** | 41.228 ± 0.315 |   24.957 ± 0.245   |
+|  Medium Int String | **18.582 ± 0.040** | 45.616 ± 0.582 |   25.866 ± 0.241   |
+|   Large Int String | **24.156 ± 0.145** | 63.173 ± 0.971 |   36.465 ± 0.163   |
+| Small Float String |  110.149 ± 1.713   | 28.186 ± 0.097 | **24.986 ± 0.009** |
+|       Float String |  114.896 ± 2.194   | 31.928 ± 0.195 | **24.745 ± 0.012** |
+| Large Float String |  119.042 ± 2.276   | 31.819 ± 0.032 | **24.555 ± 0.003** |
+|                Int | **11.635 ± 0.126** | 53.456 ± 1.543 |   20.933 ± 0.008   |
+|              Float | **22.063 ± 0.034** | 63.347 ± 0.234 |   33.105 ± 0.009   |
 
 ### Timing comparison of `float` functions with error handling
 
-| Input type         | try/except (ms)    | regex (ms)     | fastnumbers (ms)   |
-| -----------------: | -----------------: | -------------: | -----------------: |
-|  Non-number String |   44.421 ± 0.338   | 25.325 ± 0.753 | **17.884 ± 0.048** |
-|   Small Int String | **11.822 ± 0.039** | 39.660 ± 0.070 |   16.704 ± 0.037   |
-|         Int String | **12.671 ± 0.060** | 41.830 ± 0.065 |   17.008 ± 0.044   |
-|  Medium Int String | **13.927 ± 0.047** | 46.387 ± 0.827 |   17.644 ± 0.026   |
-|   Large Int String |   33.121 ± 0.089   | 75.708 ± 0.233 | **22.150 ± 0.721** |
-| Small Float String | **12.165 ± 0.057** | 39.166 ± 0.773 |   17.111 ± 0.028   |
-|       Float String |   30.079 ± 0.038   | 66.766 ± 0.545 | **18.588 ± 0.010** |
-| Large Float String |   54.489 ± 0.764   | 94.288 ± 0.079 | **18.800 ± 0.029** |
-|                Int |  **8.057 ± 0.074** | 42.961 ± 0.132 |   15.064 ± 0.138   |
-|              Float |  **7.527 ± 0.756** | 42.180 ± 0.068 |   20.040 ± 7.655   |
+| Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | -----------------: | --------------: | -----------------: |
+|  Non-number String |   56.617 ± 1.375   |  32.739 ± 0.163 | **27.683 ± 0.303** |
+|   Small Int String | **15.291 ± 0.485** |  50.644 ± 0.255 |   28.029 ± 0.843   |
+|         Int String | **15.720 ± 0.121** |  51.995 ± 0.196 |   27.200 ± 0.282   |
+|  Medium Int String | **17.134 ± 0.069** |  55.756 ± 0.792 |   27.009 ± 0.735   |
+|   Large Int String |   40.095 ± 0.966   |  93.589 ± 0.880 | **34.135 ± 0.171** |
+| Small Float String | **15.468 ± 0.466** |  49.260 ± 0.964 |   27.918 ± 0.268   |
+|       Float String |   36.782 ± 1.775   |  81.130 ± 1.230 | **28.737 ± 0.708** |
+| Large Float String |   58.457 ± 0.102   | 108.927 ± 1.635 | **29.112 ± 0.794** |
+|                Int | **10.307 ± 0.058** |  52.180 ± 0.937 |   23.691 ± 0.041   |
+|              Float |  **9.346 ± 0.106** |  51.267 ± 0.351 |   22.532 ± 0.043   |
 
 ### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
-| -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  43.998 ± 0.222 |  42.957 ± 0.018 | **18.026 ± 0.027** |
-|   Small Int String |  20.408 ± 0.062 |  34.880 ± 0.504 | **17.308 ± 0.017** |
-|         Int String |  22.014 ± 0.056 |  36.306 ± 0.028 | **18.175 ± 0.056** |
-|  Medium Int String |  26.965 ± 0.049 |  40.398 ± 0.034 | **19.142 ± 0.782** |
-|   Large Int String |  53.258 ± 0.071 |  54.113 ± 0.036 | **26.414 ± 0.026** |
-| Small Float String |  20.824 ± 0.049 |  61.023 ± 0.770 | **18.290 ± 0.026** |
-|       Float String |  54.895 ± 0.048 |  94.244 ± 0.778 | **26.867 ± 1.101** |
-| Large Float String | 111.501 ± 0.048 | 120.295 ± 1.255 | **41.655 ± 2.879** |
-|                Int |  17.092 ± 0.053 |  47.681 ± 0.919 | **14.645 ± 0.030** |
-|              Float |  38.289 ± 0.773 |  46.299 ± 0.059 | **24.821 ± 0.030** |
+| Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | -----------------: | --------------: | -----------------: |
+|  Non-number String |   57.608 ± 1.651   |  54.978 ± 0.326 | **27.921 ± 0.177** |
+|   Small Int String | **26.613 ± 0.392** |  46.520 ± 1.416 |   29.897 ± 1.089   |
+|         Int String |   29.245 ± 0.405   |  45.891 ± 0.712 | **28.096 ± 0.224** |
+|  Medium Int String |   32.873 ± 0.565   |  49.332 ± 1.103 | **28.462 ± 0.428** |
+|   Large Int String |   66.924 ± 0.429   |  67.025 ± 0.641 | **38.593 ± 0.716** |
+| Small Float String | **25.545 ± 0.070** |  72.406 ± 0.396 |   27.890 ± 0.049   |
+|       Float String |   62.505 ± 0.280   | 109.089 ± 0.757 | **35.906 ± 0.062** |
+| Large Float String |  118.232 ± 1.297   | 136.863 ± 0.331 | **52.193 ± 1.313** |
+|                Int | **20.701 ± 0.301** |  56.421 ± 0.255 |   22.572 ± 0.032   |
+|              Float |   44.322 ± 0.212   |  55.771 ± 0.746 | **35.303 ± 0.059** |
 
 ### Timing comparison of forced `int` functions with error handling
 
 | Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | -----------------: | --------------: | -----------------: |
-|  Non-number String |  135.643 ± 1.892   |  43.506 ± 0.036 | **17.209 ± 0.027** |
-|   Small Int String | **12.774 ± 0.071** |  33.734 ± 0.063 |   16.206 ± 0.017   |
-|         Int String | **13.569 ± 0.085** |  35.801 ± 0.016 |   17.258 ± 0.027   |
-|  Medium Int String | **15.143 ± 0.797** |  70.075 ± 0.117 |   18.117 ± 0.027   |
-|   Large Int String | **19.506 ± 0.077** | 102.684 ± 0.756 |   25.504 ± 0.041   |
-| Small Float String |  104.653 ± 0.722   |  63.481 ± 0.759 | **16.762 ± 0.026** |
-|       Float String |  137.297 ± 3.513   | 103.498 ± 0.699 | **24.768 ± 0.029** |
-| Large Float String |  181.670 ± 0.542   | 146.281 ± 0.694 | **39.485 ± 0.036** |
-|                Int |  **9.145 ± 0.083** |  43.884 ± 0.046 |   13.515 ± 0.026   |
-|              Float | **18.699 ± 0.180** |  54.672 ± 0.771 |   23.970 ± 0.038   |
+|  Non-number String |  175.536 ± 2.587   |  58.207 ± 1.653 | **26.633 ± 0.464** |
+|   Small Int String | **16.959 ± 0.182** |  40.102 ± 0.287 |   24.765 ± 0.468   |
+|         Int String | **16.974 ± 0.073** |  42.753 ± 0.154 |   25.931 ± 0.341   |
+|  Medium Int String | **19.218 ± 0.021** |  86.577 ± 0.956 |   27.437 ± 0.051   |
+|   Large Int String | **24.800 ± 0.063** | 123.863 ± 1.388 |   36.065 ± 0.708   |
+| Small Float String |  120.859 ± 1.432   |  77.422 ± 1.719 | **25.935 ± 0.035** |
+|       Float String |  157.032 ± 2.880   | 123.336 ± 2.130 | **34.594 ± 0.549** |
+| Large Float String |  199.295 ± 1.216   | 165.259 ± 0.766 | **50.933 ± 0.184** |
+|                Int | **11.577 ± 0.136** |  52.683 ± 0.715 |   20.948 ± 0.170   |
+|              Float | **21.888 ± 0.056** |  63.656 ± 0.202 |   32.672 ± 0.499   |
+
+### Timing comparison of forced `int` functions with error handling and denoising
+
+| Input type        | Python (ms)        | fastnumbers (ms)   |
+| ----------------: | -----------------: | -----------------: |
+|  Small Int String |   93.493 ± 2.242   | **36.376 ± 0.558** |
+|        Int String |  100.662 ± 2.329   | **36.382 ± 0.060** |
+| Medium Int String |  102.393 ± 0.312   | **36.916 ± 0.585** |
+|  Large Int String |  130.328 ± 0.827   | **46.775 ± 0.196** |
+|               Int | **16.143 ± 0.139** |   31.414 ± 0.492   |
+|             Float | **44.120 ± 0.474** |  147.534 ± 2.202   |
 
 ### Timing comparison to check if value can be converted to `int`
 
 | Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
 | -----------------: | --------------: | -------------: | -----------------: |
-|  Non-number String |  90.483 ± 0.819 | 30.680 ± 0.058 |  **8.641 ± 0.090** |
-|   Small Int String |  16.892 ± 0.047 | 34.009 ± 0.751 |  **8.519 ± 0.041** |
-|         Int String |  17.473 ± 0.065 | 35.456 ± 0.057 |  **8.782 ± 0.055** |
-|  Medium Int String |  18.772 ± 0.032 | 38.207 ± 0.049 |  **8.861 ± 0.039** |
-|   Large Int String |  23.639 ± 0.060 | 47.390 ± 0.716 |  **8.882 ± 0.077** |
-| Small Float String |  85.183 ± 0.641 | 33.023 ± 0.030 |  **9.380 ± 0.025** |
-|       Float String |  89.017 ± 0.946 | 37.119 ± 0.030 | **10.159 ± 0.014** |
-| Large Float String |  93.409 ± 2.695 | 37.413 ± 0.770 | **10.213 ± 0.003** |
-|                Int |  13.115 ± 0.073 | 13.333 ± 0.110 |  **7.752 ± 0.033** |
-|              Float |  22.273 ± 0.044 | 12.913 ± 0.033 |  **8.013 ± 0.071** |
+|  Non-number String | 118.028 ± 1.823 | 41.887 ± 0.088 | **13.041 ± 0.050** |
+|   Small Int String |  19.945 ± 0.062 | 43.000 ± 0.837 | **12.992 ± 0.108** |
+|         Int String |  20.728 ± 0.061 | 44.557 ± 0.078 | **13.261 ± 0.049** |
+|  Medium Int String |  22.067 ± 0.383 | 49.914 ± 1.883 | **13.193 ± 0.720** |
+|   Large Int String |  28.054 ± 0.112 | 61.048 ± 0.344 | **13.330 ± 0.018** |
+| Small Float String | 112.634 ± 2.110 | 41.909 ± 0.103 | **13.664 ± 0.051** |
+|       Float String | 113.043 ± 1.858 | 46.018 ± 0.796 | **14.704 ± 0.023** |
+| Large Float String | 116.146 ± 0.974 | 45.656 ± 0.831 | **14.341 ± 0.026** |
+|                Int |  14.687 ± 0.100 | 15.973 ± 0.034 | **11.135 ± 0.055** |
+|              Float |  25.165 ± 0.061 | 14.810 ± 0.048 | **11.580 ± 0.032** |
 
 ### Timing comparison to check if value can be converted to `float`
 
-| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
-| -----------------: | --------------: | -------------: | -----------------: |
-|  Non-number String |  43.571 ± 0.167 | 31.189 ± 0.059 |  **9.309 ± 0.059** |
-|   Small Int String |  16.096 ± 0.754 | 38.146 ± 0.033 |  **9.319 ± 0.067** |
-|         Int String |  16.665 ± 0.092 | 39.828 ± 0.047 |  **9.542 ± 0.082** |
-|  Medium Int String |  17.983 ± 0.109 | 42.702 ± 0.036 |  **9.613 ± 0.039** |
-|   Large Int String |  37.669 ± 0.770 | 51.435 ± 0.082 |  **9.659 ± 0.041** |
-| Small Float String |  16.245 ± 0.015 | 37.187 ± 0.073 | **10.198 ± 0.105** |
-|       Float String |  34.223 ± 0.028 | 45.392 ± 0.771 | **10.718 ± 0.043** |
-| Large Float String |  58.432 ± 0.032 | 47.934 ± 0.076 | **10.790 ± 0.025** |
-|                Int |  11.511 ± 0.040 | 13.673 ± 0.038 |  **8.764 ± 0.052** |
-|              Float |  11.159 ± 0.021 | 12.898 ± 0.715 |  **8.926 ± 0.028** |
+| Input type         | try/except (ms)    | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | -----------------: | -------------: | -----------------: |
+|  Non-number String |   54.271 ± 0.501   | 39.412 ± 0.742 | **13.743 ± 0.046** |
+|   Small Int String |   18.396 ± 0.075   | 48.818 ± 0.773 | **13.977 ± 0.082** |
+|         Int String |   19.097 ± 0.081   | 49.772 ± 0.084 | **13.918 ± 0.165** |
+|  Medium Int String |   22.318 ± 2.071   | 53.233 ± 0.140 | **13.738 ± 0.058** |
+|   Large Int String |   43.237 ± 0.077   | 62.866 ± 0.820 | **13.883 ± 0.070** |
+| Small Float String |   19.097 ± 0.765   | 46.680 ± 0.233 | **14.549 ± 0.041** |
+|       Float String |   39.558 ± 0.065   | 58.776 ± 0.069 | **15.406 ± 0.039** |
+| Large Float String |   64.763 ± 0.753   | 60.598 ± 0.875 | **14.992 ± 0.043** |
+|                Int |   13.656 ± 0.097   | 15.824 ± 0.057 | **11.930 ± 0.044** |
+|              Float | **12.355 ± 0.051** | 14.945 ± 0.074 |   12.445 ± 0.354   |
 
 ### Timing comparison to check if value can be converted to `float` or `int`
 
-| Input type         | try/except (ms)   | regex (ms)     | fastnumbers (ms)   |
-| -----------------: | ----------------: | -------------: | -----------------: |
-|  Non-number String |  43.795 ± 0.166   | 30.572 ± 0.057 |  **9.232 ± 0.071** |
-|   Small Int String |  12.179 ± 0.058   | 37.845 ± 0.111 |  **9.231 ± 0.053** |
-|         Int String |  12.941 ± 0.082   | 39.766 ± 0.741 |  **9.633 ± 0.027** |
-|  Medium Int String |  14.249 ± 0.068   | 42.121 ± 0.020 |  **9.528 ± 0.131** |
-|   Large Int String |  33.478 ± 0.044   | 51.046 ± 0.048 |  **9.555 ± 0.056** |
-| Small Float String |  12.589 ± 0.049   | 37.027 ± 0.797 | **10.080 ± 0.068** |
-|       Float String |  30.388 ± 0.034   | 46.199 ± 1.010 | **10.647 ± 0.055** |
-| Large Float String |  54.452 ± 0.024   | 47.638 ± 0.759 | **10.791 ± 0.085** |
-|                Int | **8.322 ± 0.037** | 11.141 ± 0.089 |    8.467 ± 0.035   |
-|              Float | **7.643 ± 0.027** | 10.353 ± 0.067 |    8.597 ± 0.056   |
+| Input type         | try/except (ms)    | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | -----------------: | -------------: | -----------------: |
+|  Non-number String |   53.658 ± 0.350   | 39.587 ± 0.153 | **14.210 ± 0.044** |
+|   Small Int String |   15.975 ± 0.051   | 48.993 ± 0.085 | **13.812 ± 0.290** |
+|         Int String |   16.725 ± 0.616   | 50.617 ± 0.763 | **13.878 ± 0.152** |
+|  Medium Int String |   17.625 ± 0.123   | 52.930 ± 0.106 | **13.833 ± 0.066** |
+|   Large Int String |   40.287 ± 0.038   | 66.025 ± 2.936 | **14.981 ± 0.043** |
+| Small Float String |   17.528 ± 0.114   | 52.857 ± 1.250 | **16.117 ± 0.082** |
+|       Float String |   39.864 ± 0.734   | 61.293 ± 1.203 | **16.062 ± 0.112** |
+| Large Float String |   61.656 ± 0.910   | 62.064 ± 1.048 | **15.764 ± 0.083** |
+|                Int | **11.164 ± 0.112** | 14.399 ± 0.070 |   12.288 ± 0.112   |
+|              Float |  **9.936 ± 0.134** | 12.923 ± 0.092 |   12.258 ± 0.124   |
 
 ### Timing comparison to check if value can be coerced losslessly to `int`
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)  |
-| -----------------: | --------------: | --------------: | ----------------: |
-|  Non-number String | 136.979 ± 1.841 |  38.640 ± 0.043 | **8.379 ± 0.043** |
-|   Small Int String |  23.077 ± 0.068 |  23.398 ± 0.040 | **8.341 ± 0.057** |
-|         Int String |  24.294 ± 0.041 |  24.904 ± 0.021 | **8.547 ± 0.028** |
-|  Medium Int String |  30.695 ± 0.740 |  27.770 ± 0.029 | **8.667 ± 0.020** |
-|   Large Int String |  58.530 ± 0.226 |  36.458 ± 0.052 | **8.727 ± 0.030** |
-| Small Float String | 103.628 ± 1.751 |  59.019 ± 0.023 | **9.142 ± 0.064** |
-|       Float String | 130.847 ± 0.955 |  91.032 ± 0.202 | **9.954 ± 0.018** |
-| Large Float String | 159.193 ± 1.278 | 118.775 ± 0.563 | **9.857 ± 0.109** |
-|                Int |  15.055 ± 0.043 |  45.855 ± 0.075 | **7.558 ± 0.070** |
-|              Float |  37.268 ± 0.024 |  71.686 ± 1.860 | **7.862 ± 0.051** |
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String | 170.765 ± 1.858 |  50.004 ± 0.021 | **12.958 ± 0.096** |
+|   Small Int String |  29.082 ± 0.030 |  28.829 ± 0.096 | **12.845 ± 0.085** |
+|         Int String |  30.915 ± 0.752 |  30.586 ± 0.061 | **13.100 ± 0.060** |
+|  Medium Int String |  37.731 ± 0.176 |  34.163 ± 0.044 | **13.224 ± 0.031** |
+|   Large Int String |  72.769 ± 1.948 |  46.075 ± 0.071 | **13.854 ± 0.105** |
+| Small Float String | 127.177 ± 2.296 |  71.233 ± 0.069 | **13.773 ± 0.040** |
+|       Float String | 151.302 ± 2.129 | 107.778 ± 1.722 | **14.639 ± 0.052** |
+| Large Float String | 180.478 ± 2.451 | 136.962 ± 2.403 | **14.761 ± 0.050** |
+|                Int |  19.196 ± 0.090 |  55.841 ± 0.960 | **11.093 ± 0.024** |
+|              Float |  43.682 ± 0.958 |  87.132 ± 4.137 | **11.791 ± 0.029** |
 
 ### Timing comparison of `map` option vs. iterating over `try_float` for a 50 element list
 
 | Input type         | [try_float(x) for x in iterable] (ms) | list(map(try_float, iterable)) (ms) | list(try_float(iterable, map=True)) (ms) | try_float(iterable, map=list) (ms) |
 | -----------------: | ------------------------------------: | ----------------------------------: | ---------------------------------------: | ---------------------------------: |
-|  Non-number String |                      1001.854 ± 2.323 |                    902.895 ± 8.884  |                          577.611 ± 1.459 |                **531.019 ± 2.326** |
-|   Small Int String |                       945.279 ± 1.425 |                    840.040 ± 8.162  |                          530.106 ± 2.430 |                **482.270 ± 1.599** |
-|         Int String |                       964.077 ± 1.593 |                    857.475 ± 8.228  |                          545.166 ± 0.768 |                **498.248 ± 1.450** |
-|  Medium Int String |                       988.419 ± 1.652 |                    893.111 ± 21.672 |                          571.763 ± 4.063 |                **519.087 ± 1.961** |
-|   Large Int String |                      1287.110 ± 7.120 |                   1165.471 ± 7.895  |                          802.560 ± 4.907 |                **754.931 ± 8.629** |
-| Small Float String |                      1032.001 ± 7.630 |                    906.588 ± 20.243 |                          553.083 ± 1.872 |                **504.151 ± 2.354** |
-|       Float String |                      1065.359 ± 2.256 |                    937.700 ± 2.262  |                          627.927 ± 2.766 |                **579.561 ± 1.392** |
-| Large Float String |                      1072.621 ± 3.306 |                    945.579 ± 2.150  |                          636.708 ± 1.434 |                **585.016 ± 0.816** |
-|                Int |                       872.710 ± 3.427 |                    747.316 ± 1.262  |                          441.310 ± 0.928 |                **384.457 ± 1.440** |
-|              Float |                       801.634 ± 0.751 |                    700.659 ± 2.066  |                          411.928 ± 1.208 |                **362.799 ± 0.883** |
+|  Non-number String |                     1482.567 ± 20.256 |                   1236.148 ± 49.371 |                         565.553 ± 1.914  |                **518.170 ± 1.063** |
+|   Small Int String |                     1305.220 ± 3.554  |                   1206.032 ± 13.992 |                         512.903 ± 3.340  |                **465.668 ± 4.668** |
+|         Int String |                     1348.915 ± 6.915  |                   1242.778 ± 13.141 |                         545.363 ± 4.215  |                **503.872 ± 4.873** |
+|  Medium Int String |                     1453.734 ± 32.830 |                   1312.213 ± 6.849  |                         573.176 ± 3.782  |                **516.781 ± 5.425** |
+|   Large Int String |                     1712.902 ± 24.834 |                   1594.502 ± 23.588 |                         816.883 ± 1.048  |                **765.571 ± 0.891** |
+| Small Float String |                     1453.519 ± 6.409  |                   1323.319 ± 7.257  |                         577.669 ± 3.256  |                **521.870 ± 3.854** |
+|       Float String |                     1548.539 ± 26.220 |                   1290.591 ± 2.738  |                         609.395 ± 2.951  |                **559.704 ± 0.929** |
+| Large Float String |                     1427.750 ± 3.479  |                   1304.587 ± 2.346  |                         618.428 ± 4.291  |                **567.612 ± 0.963** |
+|                Int |                     1228.263 ± 32.644 |                   1118.997 ± 11.022 |                         434.530 ± 2.691  |                **389.568 ± 7.671** |
+|              Float |                     1261.292 ± 5.261  |                   1109.500 ± 3.782  |                         415.979 ± 10.739 |                **355.064 ± 3.159** |
 
 ### Timing comparison of `try_array` vs. `map` option for a 50 element list to a numpy array
 
 | Input type         | np.array(try_float(iterable, map=True)) (ms) | try_array(iterable) (ms) | try_array(iterable, output) (ms) |
 | -----------------: | -------------------------------------------: | -----------------------: | -------------------------------: |
-|   Small Int String |                              675.185 ± 1.198 |          313.506 ± 0.928 |              **293.928 ± 0.794** |
-|         Int String |                              692.571 ± 1.993 |          328.146 ± 1.956 |              **308.975 ± 0.651** |
-|  Medium Int String |                              707.320 ± 3.232 |          344.311 ± 0.809 |              **327.496 ± 4.060** |
-|   Large Int String |                              926.292 ± 1.845 |          567.859 ± 1.338 |              **547.848 ± 1.082** |
-| Small Float String |                              693.925 ± 1.557 |          332.155 ± 6.669 |              **308.060 ± 3.107** |
-|       Float String |                              776.162 ± 8.379 |          444.758 ± 1.795 |              **423.833 ± 1.745** |
-| Large Float String |                              803.179 ± 3.356 |          457.605 ± 2.886 |              **434.210 ± 3.770** |
-|                Int |                              611.013 ± 7.020 |          362.952 ± 1.892 |              **341.909 ± 3.633** |
-|              Float |                              578.320 ± 2.798 |          314.324 ± 4.240 |              **294.071 ± 5.073** |
+|   Small Int String |                             732.517 ± 15.921 |          348.400 ± 4.755 |              **318.083 ± 3.908** |
+|         Int String |                             737.113 ± 8.770  |          371.494 ± 5.423 |              **341.768 ± 1.819** |
+|  Medium Int String |                             758.224 ± 5.928  |          387.031 ± 1.666 |              **360.645 ± 4.783** |
+|   Large Int String |                             991.258 ± 3.948  |          622.803 ± 1.156 |              **599.306 ± 7.056** |
+| Small Float String |                             743.274 ± 4.975  |          367.816 ± 0.625 |              **342.918 ± 3.585** |
+|       Float String |                             833.836 ± 3.685  |          482.629 ± 5.504 |              **448.936 ± 3.358** |
+| Large Float String |                             833.565 ± 3.566  |          490.710 ± 1.109 |              **446.306 ± 9.360** |
+|                Int |                             564.029 ± 2.480  |          347.858 ± 1.909 |              **322.863 ± 0.912** |
+|              Float |                             527.257 ± 3.082  |          307.528 ± 1.075 |              **282.723 ± 1.460** |
 
diff --git a/profiling/results-3.11.md b/profiling/results-3.11.md
index cd717c33..3c5ed9e6 100644
--- a/profiling/results-3.11.md
+++ b/profiling/results-3.11.md
@@ -4,173 +4,184 @@ sys.version_info(major=3, minor=11, micro=1, releaselevel='final', serial=0)
 
 | Input type        | builtin (ms)       | fastnumbers (ms)   |
 | ----------------: | -----------------: | -----------------: |
-|  Small Int String |   12.462 ± 0.104   | **10.694 ± 0.020** |
-|        Int String |   13.289 ± 0.030   | **11.761 ± 0.016** |
-| Medium Int String |   15.611 ± 0.799   | **12.080 ± 0.020** |
-|  Large Int String | **21.261 ± 0.040** |   22.626 ± 1.346   |
-|               Int |  **6.893 ± 0.044** |    7.896 ± 0.030   |
-|             Float | **16.371 ± 0.051** |   19.276 ± 3.026   |
+|  Small Int String |   13.492 ± 0.373   | **11.004 ± 0.258** |
+|        Int String |   14.725 ± 0.386   | **13.151 ± 0.878** |
+| Medium Int String |   17.223 ± 0.514   | **13.367 ± 0.789** |
+|  Large Int String | **23.453 ± 0.366** |   24.611 ± 0.654   |
+|               Int |  **7.815 ± 0.774** |    9.287 ± 0.252   |
+|             Float | **18.610 ± 0.782** |   21.966 ± 0.445   |
 
 ### Timing comparison of `float` functions
 
-| Input type         | builtin (ms)      | fastnumbers (ms)   |
-| -----------------: | ----------------: | -----------------: |
-|   Small Int String | **6.977 ± 0.070** |   10.938 ± 0.024   |
-|         Int String | **7.566 ± 0.056** |   11.427 ± 1.801   |
-|  Medium Int String | **8.663 ± 0.149** |   11.438 ± 0.281   |
-|   Large Int String |  28.395 ± 1.922   | **15.817 ± 0.013** |
-| Small Float String | **7.289 ± 0.067** |   11.313 ± 0.011   |
-|       Float String |  25.421 ± 0.296   | **12.788 ± 0.014** |
-| Large Float String |  47.363 ± 0.361   | **13.004 ± 0.021** |
-|                Int | **3.460 ± 0.059** |    9.040 ± 0.014   |
-|              Float | **2.438 ± 0.050** |    8.137 ± 0.306   |
+| Input type         | builtin (ms)       | fastnumbers (ms)   |
+| -----------------: | -----------------: | -----------------: |
+|   Small Int String |  **8.422 ± 0.285** |   13.397 ± 0.791   |
+|         Int String |  **9.293 ± 0.262** |   13.264 ± 0.384   |
+|  Medium Int String | **10.383 ± 0.474** |   13.756 ± 0.411   |
+|   Large Int String |   32.028 ± 0.870   | **18.679 ± 0.575** |
+| Small Float String |  **8.601 ± 0.228** |   13.438 ± 0.299   |
+|       Float String |   29.338 ± 0.904   | **15.230 ± 0.283** |
+| Large Float String |   54.412 ± 1.534   | **15.528 ± 0.310** |
+|                Int |  **3.988 ± 0.145** |   11.259 ± 0.415   |
+|              Float |  **2.859 ± 0.071** |    9.968 ± 0.152   |
 
 ### Timing comparison of `int` functions with error handling
 
 | Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | -----------------: | --------------: | -----------------: |
-|  Non-number String |  129.891 ± 0.413   |  23.063 ± 0.008 | **16.338 ± 0.036** |
-|   Small Int String |   15.822 ± 0.003   |  42.137 ± 0.027 | **15.676 ± 0.040** |
-|         Int String | **16.798 ± 0.021** |  46.426 ± 0.054 |   16.974 ± 0.058   |
-|  Medium Int String |   18.939 ± 0.023   |  54.832 ± 0.024 | **17.307 ± 0.006** |
-|   Large Int String | **24.740 ± 0.016** |  75.430 ± 0.082 |   27.690 ± 0.016   |
-| Small Float String |  127.423 ± 2.486   |  26.737 ± 0.025 | **16.546 ± 0.022** |
-|       Float String |  131.447 ± 0.113   |  32.571 ± 0.015 | **16.869 ± 0.019** |
-| Large Float String |  135.510 ± 3.045   |  34.187 ± 2.201 | **16.990 ± 0.005** |
-|                Int | **10.132 ± 0.015** |  93.091 ± 1.639 |   12.324 ± 0.017   |
-|              Float | **19.512 ± 0.016** | 101.762 ± 0.916 |   24.245 ± 0.030   |
+|  Non-number String |  157.691 ± 3.084   |  28.967 ± 0.130 | **24.579 ± 0.427** |
+|   Small Int String | **19.136 ± 0.057** |  50.437 ± 0.767 |   23.320 ± 0.133   |
+|         Int String | **20.313 ± 0.080** |  55.102 ± 0.458 |   25.452 ± 0.183   |
+|  Medium Int String | **21.998 ± 0.087** |  66.150 ± 1.078 |   27.011 ± 0.158   |
+|   Large Int String | **29.871 ± 0.110** |  90.713 ± 1.015 |   38.452 ± 0.730   |
+| Small Float String |  149.079 ± 1.796   |  32.175 ± 1.127 | **24.148 ± 0.082** |
+|       Float String |  158.483 ± 2.146   |  39.361 ± 1.154 | **23.777 ± 0.055** |
+| Large Float String |  163.482 ± 1.390   |  39.387 ± 0.058 | **24.483 ± 0.198** |
+|                Int | **11.471 ± 0.036** | 103.820 ± 1.877 |   20.630 ± 0.674   |
+|              Float | **22.415 ± 0.033** | 117.185 ± 2.730 |   34.055 ± 0.577   |
 
 ### Timing comparison of `float` functions with error handling
 
 | Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | -----------------: | --------------: | -----------------: |
-|  Non-number String |   68.582 ± 0.267   |  27.162 ± 0.009 | **17.611 ± 0.071** |
-|   Small Int String | **10.246 ± 0.067** |  46.749 ± 0.076 |   16.486 ± 0.030   |
-|         Int String | **10.914 ± 0.040** |  50.349 ± 0.085 |   16.758 ± 0.006   |
-|  Medium Int String | **12.092 ± 0.032** |  57.916 ± 0.056 |   17.244 ± 0.018   |
-|   Large Int String |   32.122 ± 0.009   |  93.395 ± 0.125 | **21.739 ± 0.003** |
-| Small Float String | **10.567 ± 0.102** |  45.780 ± 0.014 |   17.105 ± 0.019   |
-|       Float String |   29.090 ± 0.057   |  80.801 ± 2.531 | **18.574 ± 0.019** |
-| Large Float String |   50.884 ± 0.025   | 108.996 ± 0.108 | **18.867 ± 0.031** |
-|                Int |  **6.240 ± 0.054** |  90.673 ± 1.547 |   15.039 ± 0.011   |
-|              Float |  **5.117 ± 0.043** |  91.220 ± 0.979 |   13.476 ± 0.005   |
+|  Non-number String |   85.899 ± 1.685   |  34.438 ± 0.029 | **27.620 ± 0.039** |
+|   Small Int String | **13.120 ± 0.063** |  60.600 ± 0.875 |   26.335 ± 0.056   |
+|         Int String | **13.260 ± 0.093** |  61.402 ± 1.131 |   26.676 ± 0.025   |
+|  Medium Int String | **14.652 ± 0.038** |  69.095 ± 1.247 |   27.654 ± 0.041   |
+|   Large Int String |   37.885 ± 0.059   | 114.112 ± 1.530 | **33.053 ± 0.115** |
+| Small Float String | **12.880 ± 0.079** |  54.909 ± 0.201 |   26.930 ± 0.340   |
+|       Float String |   33.225 ± 0.077   |  94.197 ± 1.488 | **28.975 ± 0.070** |
+| Large Float String |   57.571 ± 0.094   | 125.751 ± 2.583 | **28.249 ± 0.043** |
+|                Int |  **7.938 ± 1.187** | 102.491 ± 0.703 |   23.810 ± 0.084   |
+|              Float |  **6.043 ± 0.050** | 100.980 ± 2.115 |   21.932 ± 0.042   |
 
 ### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
-| -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  69.025 ± 0.183 |  50.793 ± 0.158 | **18.131 ± 0.023** |
-|   Small Int String |  24.727 ± 0.061 |  42.899 ± 0.084 | **16.805 ± 0.017** |
-|         Int String |  27.141 ± 1.073 |  47.119 ± 0.099 | **18.918 ± 0.008** |
-|  Medium Int String |  29.933 ± 0.050 |  55.486 ± 0.056 | **19.189 ± 0.006** |
-|   Large Int String |  59.433 ± 0.063 |  77.151 ± 2.549 | **29.707 ± 0.058** |
-| Small Float String |  24.974 ± 0.022 |  71.841 ± 0.083 | **18.833 ± 0.070** |
-|       Float String |  58.700 ± 0.049 | 111.038 ± 0.087 | **26.906 ± 0.364** |
-| Large Float String | 114.617 ± 0.203 | 140.597 ± 0.089 | **41.390 ± 0.027** |
-|                Int |  20.228 ± 0.125 |  94.594 ± 0.219 | **13.774 ± 0.006** |
-|              Float |  40.516 ± 0.022 |  94.066 ± 1.115 | **24.937 ± 0.024** |
+| Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | -----------------: | --------------: | -----------------: |
+|  Non-number String |   83.327 ± 1.149   |  63.467 ± 0.155 | **28.862 ± 0.455** |
+|   Small Int String |   29.489 ± 0.660   |  51.649 ± 0.812 | **26.198 ± 0.055** |
+|         Int String |   31.617 ± 0.445   |  56.614 ± 0.215 | **28.697 ± 0.326** |
+|  Medium Int String |   35.158 ± 0.498   |  67.712 ± 1.921 | **29.901 ± 0.538** |
+|   Large Int String |   70.937 ± 0.204   |  91.398 ± 1.357 | **41.242 ± 0.149** |
+| Small Float String |   30.544 ± 1.709   |  86.300 ± 0.604 | **28.901 ± 0.490** |
+|       Float String |   67.938 ± 0.177   | 130.818 ± 0.727 | **37.817 ± 0.663** |
+| Large Float String |  130.273 ± 2.353   | 159.576 ± 0.289 | **54.364 ± 1.010** |
+|                Int | **22.603 ± 0.042** | 103.948 ± 1.462 |   23.448 ± 0.250   |
+|              Float |   49.514 ± 0.890   | 104.917 ± 3.527 | **33.458 ± 0.429** |
 
 ### Timing comparison of forced `int` functions with error handling
 
 | Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | -----------------: | --------------: | -----------------: |
-|  Non-number String |  213.124 ± 12.551  |  47.109 ± 0.025 | **17.141 ± 0.069** |
-|   Small Int String |   15.829 ± 0.016   |  39.121 ± 0.054 | **15.711 ± 0.005** |
-|         Int String | **16.797 ± 0.031** |  44.304 ± 1.011 |   17.452 ± 0.008   |
-|  Medium Int String |   18.926 ± 0.005   |  86.352 ± 0.433 | **18.099 ± 0.015** |
-|   Large Int String | **24.735 ± 0.006** | 124.967 ± 0.721 |   28.577 ± 0.006   |
-| Small Float String |  148.734 ± 1.288   |  75.186 ± 0.104 | **17.033 ± 0.007** |
-|       Float String |  177.638 ± 2.363   | 119.011 ± 0.180 | **24.490 ± 0.008** |
-| Large Float String |  219.678 ± 1.023   | 163.725 ± 0.170 | **40.073 ± 0.007** |
-|                Int |  **9.984 ± 0.019** |  93.181 ± 1.161 |   11.836 ± 0.004   |
-|              Float | **19.554 ± 0.020** | 108.745 ± 0.354 |   23.934 ± 0.024   |
+|  Non-number String |  228.547 ± 3.790   |  53.770 ± 1.224 | **23.360 ± 0.405** |
+|   Small Int String | **16.869 ± 0.029** |  44.043 ± 0.141 |   21.237 ± 0.045   |
+|         Int String | **17.910 ± 0.042** |  49.156 ± 0.728 |   23.583 ± 0.124   |
+|  Medium Int String | **20.093 ± 0.089** |  93.487 ± 0.869 |   24.909 ± 0.079   |
+|   Large Int String | **26.315 ± 0.400** | 135.438 ± 1.671 |   34.653 ± 0.040   |
+| Small Float String |  150.824 ± 0.739   |  84.492 ± 0.824 | **23.743 ± 0.577** |
+|       Float String |  186.660 ± 1.306   | 131.185 ± 0.389 | **31.834 ± 0.034** |
+| Large Float String |  228.777 ± 1.286   | 176.667 ± 0.883 | **47.630 ± 0.656** |
+|                Int | **10.418 ± 0.012** |  94.272 ± 0.812 |   18.056 ± 0.035   |
+|              Float | **20.310 ± 0.030** | 108.679 ± 2.302 |   30.374 ± 0.185   |
+
+### Timing comparison of forced `int` functions with error handling and denoising
+
+| Input type        | Python (ms)        | fastnumbers (ms)   |
+| ----------------: | -----------------: | -----------------: |
+|  Small Int String |  139.105 ± 2.718   | **27.289 ± 0.059** |
+|        Int String |  142.486 ± 3.238   | **29.521 ± 0.106** |
+| Medium Int String |  151.376 ± 0.612   | **30.803 ± 0.725** |
+|  Large Int String |  176.196 ± 1.995   | **41.034 ± 0.729** |
+|               Int | **13.228 ± 0.022** |   23.824 ± 0.031   |
+|             Float | **40.349 ± 0.051** |  147.275 ± 1.867   |
 
 ### Timing comparison to check if value can be converted to `int`
 
-| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)  |
-| -----------------: | --------------: | -------------: | ----------------: |
-|  Non-number String | 129.501 ± 0.159 | 40.136 ± 7.315 | **8.215 ± 0.040** |
-|   Small Int String |  20.883 ± 0.518 | 40.650 ± 0.072 | **8.248 ± 0.043** |
-|         Int String |  20.030 ± 0.034 | 43.847 ± 0.039 | **8.456 ± 0.065** |
-|  Medium Int String |  22.179 ± 0.087 | 50.131 ± 0.031 | **8.474 ± 0.032** |
-|   Large Int String |  28.002 ± 0.009 | 64.560 ± 0.032 | **8.506 ± 0.042** |
-| Small Float String | 127.158 ± 0.409 | 38.500 ± 0.019 | **9.138 ± 0.065** |
-|       Float String | 130.870 ± 0.283 | 44.438 ± 0.036 | **9.635 ± 0.053** |
-| Large Float String | 133.237 ± 0.053 | 44.391 ± 0.020 | **9.821 ± 0.176** |
-|                Int |  15.408 ± 0.203 | 12.640 ± 0.007 | **7.281 ± 0.048** |
-|              Float |  22.461 ± 0.053 | 11.694 ± 0.006 | **7.443 ± 0.090** |
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | --------------: | -------------: | -----------------: |
+|  Non-number String | 140.090 ± 1.949 | 34.232 ± 0.834 | **11.001 ± 0.014** |
+|   Small Int String |  18.800 ± 0.090 | 40.024 ± 0.056 | **10.813 ± 0.024** |
+|         Int String |  19.621 ± 0.040 | 43.323 ± 0.099 | **11.117 ± 0.021** |
+|  Medium Int String |  22.261 ± 1.016 | 49.623 ± 0.056 | **11.314 ± 0.050** |
+|   Large Int String |  27.774 ± 0.231 | 64.847 ± 0.236 | **11.245 ± 0.024** |
+| Small Float String | 133.269 ± 0.912 | 37.699 ± 0.090 | **11.772 ± 0.066** |
+|       Float String | 143.097 ± 1.082 | 44.030 ± 0.051 | **12.864 ± 0.091** |
+| Large Float String | 145.790 ± 1.723 | 44.044 ± 0.084 | **12.968 ± 0.035** |
+|                Int |  12.097 ± 0.037 | 12.761 ± 0.057 |  **9.626 ± 0.037** |
+|              Float |  22.631 ± 0.749 | 11.333 ± 0.017 |  **9.631 ± 0.066** |
 
 ### Timing comparison to check if value can be converted to `float`
 
 | Input type         | try/except (ms)   | regex (ms)     | fastnumbers (ms)   |
 | -----------------: | ----------------: | -------------: | -----------------: |
-|  Non-number String |  73.642 ± 9.621   | 36.004 ± 0.026 |  **9.147 ± 0.062** |
-|   Small Int String |  13.528 ± 0.005   | 46.911 ± 0.062 |  **9.431 ± 0.059** |
-|         Int String |  14.175 ± 0.006   | 49.840 ± 0.020 |  **9.677 ± 0.027** |
-|  Medium Int String |  15.280 ± 0.021   | 56.306 ± 0.056 |  **9.712 ± 0.005** |
-|   Large Int String |  35.723 ± 0.020   | 70.878 ± 0.081 |  **9.712 ± 0.090** |
-| Small Float String |  13.998 ± 0.032   | 45.669 ± 0.018 | **10.221 ± 0.038** |
-|       Float String |  32.565 ± 0.047   | 60.336 ± 0.022 | **10.894 ± 0.033** |
-| Large Float String |  54.539 ± 0.039   | 66.600 ± 0.040 | **10.977 ± 0.109** |
-|                Int |   8.933 ± 0.231   | 13.048 ± 0.030 |  **8.151 ± 0.047** |
-|              Float | **7.951 ± 0.052** | 11.299 ± 0.007 |    8.381 ± 0.041   |
+|  Non-number String |  72.317 ± 1.182   | 37.780 ± 0.045 | **11.799 ± 0.078** |
+|   Small Int String |  12.818 ± 0.088   | 50.080 ± 0.714 | **11.701 ± 0.035** |
+|         Int String |  13.335 ± 0.027   | 53.343 ± 1.050 | **11.946 ± 0.027** |
+|  Medium Int String |  14.497 ± 0.009   | 59.209 ± 0.108 | **12.105 ± 0.064** |
+|   Large Int String |  35.766 ± 0.751   | 74.814 ± 0.921 | **12.123 ± 0.026** |
+| Small Float String |  13.294 ± 0.116   | 50.389 ± 4.640 | **12.713 ± 0.064** |
+|       Float String |  32.504 ± 0.808   | 63.549 ± 0.101 | **13.780 ± 0.043** |
+| Large Float String |  54.379 ± 0.046   | 71.365 ± 0.614 | **14.281 ± 1.074** |
+|                Int | **8.261 ± 0.042** | 12.730 ± 0.030 |   10.359 ± 0.039   |
+|              Float | **6.942 ± 0.043** | 11.528 ± 0.070 |   10.269 ± 0.044   |
 
 ### Timing comparison to check if value can be converted to `float` or `int`
 
-| Input type         | try/except (ms)   | regex (ms)     | fastnumbers (ms)   |
-| -----------------: | ----------------: | -------------: | -----------------: |
-|  Non-number String |  69.597 ± 0.459   | 38.477 ± 0.498 |  **9.240 ± 0.070** |
-|   Small Int String |  10.628 ± 0.046   | 49.035 ± 0.041 |  **9.360 ± 0.085** |
-|         Int String |  11.315 ± 0.014   | 54.267 ± 5.047 |  **9.496 ± 0.014** |
-|  Medium Int String |  12.433 ± 0.016   | 58.682 ± 0.398 |  **9.514 ± 0.032** |
-|   Large Int String |  32.452 ± 0.007   | 72.959 ± 0.102 |  **9.484 ± 0.010** |
-| Small Float String |  10.913 ± 0.057   | 47.603 ± 0.010 | **10.197 ± 0.005** |
-|       Float String |  29.428 ± 0.164   | 62.363 ± 0.012 | **10.808 ± 0.013** |
-| Large Float String |  51.204 ± 0.024   | 68.790 ± 0.025 | **10.864 ± 0.006** |
-|                Int | **6.531 ± 0.025** | 10.482 ± 0.035 |    8.104 ± 0.031   |
-|              Float | **5.345 ± 0.014** |  9.238 ± 0.057 |    8.260 ± 0.052   |
+| Input type         | try/except (ms)    | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | -----------------: | -------------: | -----------------: |
+|  Non-number String |   76.922 ± 2.015   | 37.577 ± 0.742 | **11.969 ± 0.074** |
+|   Small Int String | **11.434 ± 0.028** | 50.550 ± 0.297 |   11.830 ± 0.030   |
+|         Int String | **11.938 ± 0.040** | 53.539 ± 0.330 |   12.078 ± 0.021   |
+|  Medium Int String |   13.153 ± 0.026   | 60.581 ± 0.797 | **12.188 ± 0.027** |
+|   Large Int String |   33.873 ± 0.086   | 76.177 ± 2.773 | **12.235 ± 0.065** |
+| Small Float String | **11.782 ± 0.038** | 49.166 ± 0.931 |   12.728 ± 0.064   |
+|       Float String |   30.677 ± 0.107   | 62.722 ± 0.170 | **13.788 ± 0.026** |
+| Large Float String |   53.265 ± 0.783   | 70.607 ± 1.505 | **13.818 ± 0.052** |
+|                Int |  **6.830 ± 0.050** | 11.113 ± 0.032 |   10.123 ± 0.048   |
+|              Float |  **5.612 ± 0.048** |  9.511 ± 0.044 |   10.203 ± 0.033   |
 
 ### Timing comparison to check if value can be coerced losslessly to `int`
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String | 206.502 ± 0.646 |  50.757 ± 0.165 |  **7.897 ± 0.047** |
-|   Small Int String |  31.244 ± 0.116 |  29.937 ± 0.169 |  **7.902 ± 0.100** |
-|         Int String |  30.722 ± 0.052 |  32.866 ± 0.014 |  **8.083 ± 0.063** |
-|  Medium Int String |  35.906 ± 0.053 |  40.000 ± 2.468 |  **8.072 ± 0.032** |
-|   Large Int String |  69.342 ± 1.015 |  56.078 ± 0.972 |  **8.554 ± 0.026** |
-| Small Float String | 153.780 ± 1.623 |  80.417 ± 0.743 |  **9.405 ± 0.064** |
-|       Float String | 182.261 ± 2.431 | 121.158 ± 1.673 | **10.286 ± 0.083** |
-| Large Float String | 209.102 ± 2.088 | 154.173 ± 3.385 | **10.001 ± 0.060** |
-|                Int |  18.646 ± 0.002 | 102.406 ± 1.131 |  **7.504 ± 0.011** |
-|              Float |  42.653 ± 0.624 | 132.264 ± 0.322 |  **7.469 ± 0.026** |
+|  Non-number String | 221.356 ± 3.128 |  49.047 ± 0.861 | **10.732 ± 0.225** |
+|   Small Int String |  30.695 ± 0.475 |  29.109 ± 0.522 | **10.581 ± 0.015** |
+|         Int String |  32.416 ± 0.144 |  32.272 ± 0.177 | **10.844 ± 0.065** |
+|  Medium Int String |  38.298 ± 1.225 |  38.599 ± 0.158 | **10.938 ± 0.058** |
+|   Large Int String |  71.065 ± 0.084 |  53.337 ± 0.172 | **11.363 ± 1.014** |
+| Small Float String | 147.631 ± 0.605 |  72.999 ± 1.437 | **11.479 ± 0.070** |
+|       Float String | 175.277 ± 1.268 | 112.006 ± 0.128 | **12.399 ± 0.013** |
+| Large Float String | 201.598 ± 1.203 | 142.936 ± 1.686 | **12.458 ± 0.016** |
+|                Int |  18.633 ± 0.025 |  96.076 ± 1.847 |  **9.109 ± 0.064** |
+|              Float |  41.923 ± 0.442 | 130.741 ± 0.619 |  **9.079 ± 0.046** |
 
 ### Timing comparison of `map` option vs. iterating over `try_float` for a 50 element list
 
 | Input type         | [try_float(x) for x in iterable] (ms) | list(map(try_float, iterable)) (ms) | list(try_float(iterable, map=True)) (ms) | try_float(iterable, map=list) (ms) |
 | -----------------: | ------------------------------------: | ----------------------------------: | ---------------------------------------: | ---------------------------------: |
-|  Non-number String |                     1148.037 ± 25.880 |                   1013.306 ± 37.538 |                         590.851 ± 21.154 |                **515.890 ± 3.011** |
-|   Small Int String |                      987.896 ± 7.727  |                    960.128 ± 5.922  |                         542.909 ± 3.683  |                **481.335 ± 6.298** |
-|         Int String |                     1014.824 ± 17.555 |                    932.395 ± 11.245 |                         532.341 ± 0.683  |                **478.568 ± 3.526** |
-|  Medium Int String |                      969.427 ± 4.794  |                    938.731 ± 3.348  |                         546.109 ± 0.626  |                **491.242 ± 4.167** |
-|   Large Int String |                     1220.263 ± 2.868  |                   1187.911 ± 7.779  |                         765.318 ± 3.377  |                **703.281 ± 3.228** |
-| Small Float String |                      959.684 ± 0.879  |                    933.657 ± 16.780 |                         541.608 ± 4.661  |                **481.439 ± 0.833** |
-|       Float String |                     1087.549 ± 7.231  |                   1057.860 ± 12.759 |                         618.012 ± 8.823  |                **558.839 ± 4.767** |
-| Large Float String |                     1102.770 ± 8.275  |                   1096.567 ± 8.527  |                         641.963 ± 2.486  |                **575.283 ± 4.615** |
-|                Int |                      900.061 ± 11.115 |                    868.973 ± 13.691 |                         414.174 ± 0.836  |                **363.310 ± 0.917** |
-|              Float |                      757.135 ± 2.577  |                    728.186 ± 12.985 |                         368.202 ± 0.237  |                **314.194 ± 3.289** |
+|  Non-number String |                     1299.311 ± 5.254  |                   1247.241 ± 7.474  |                         560.809 ± 1.190  |               **494.486 ± 2.851**  |
+|   Small Int String |                     1273.276 ± 1.030  |                   1255.641 ± 6.403  |                         516.167 ± 4.905  |               **446.821 ± 1.338**  |
+|         Int String |                     1322.434 ± 6.277  |                   1272.047 ± 8.492  |                         534.366 ± 1.571  |               **477.241 ± 10.376** |
+|  Medium Int String |                     1416.366 ± 40.058 |                   1349.562 ± 9.407  |                         566.972 ± 3.462  |               **519.710 ± 29.221** |
+|   Large Int String |                     1696.123 ± 20.949 |                   1665.578 ± 7.963  |                         840.430 ± 27.274 |               **751.934 ± 2.454**  |
+| Small Float String |                     1433.688 ± 3.826  |                   1373.735 ± 5.937  |                         578.460 ± 1.822  |               **506.822 ± 1.503**  |
+|       Float String |                     1461.269 ± 64.907 |                   1353.288 ± 1.358  |                         607.726 ± 1.668  |               **544.253 ± 1.179**  |
+| Large Float String |                     1406.407 ± 2.045  |                   1362.415 ± 2.180  |                         617.822 ± 3.848  |               **559.996 ± 5.369**  |
+|                Int |                     1203.485 ± 27.449 |                   1201.125 ± 67.883 |                         462.555 ± 23.075 |               **361.679 ± 2.566**  |
+|              Float |                     1176.710 ± 11.387 |                   1116.375 ± 3.596  |                         390.160 ± 7.244  |               **327.914 ± 18.740** |
 
 ### Timing comparison of `try_array` vs. `map` option for a 50 element list to a numpy array
 
 | Input type         | np.array(try_float(iterable, map=True)) (ms) | try_array(iterable) (ms) | try_array(iterable, output) (ms) |
 | -----------------: | -------------------------------------------: | -----------------------: | -------------------------------: |
-|   Small Int String |                            664.025 ± 2.316   |       307.078 ± 5.697    |             **280.075 ± 0.160**  |
-|         Int String |                            675.276 ± 1.065   |       316.907 ± 0.485    |             **291.029 ± 0.266**  |
-|  Medium Int String |                            702.673 ± 20.459  |       433.230 ± 30.390   |             **354.109 ± 19.401** |
-|   Large Int String |                           1114.763 ± 235.736 |       565.220 ± 3.683    |             **560.142 ± 26.596** |
-| Small Float String |                            738.377 ± 21.590  |       374.815 ± 15.862   |             **351.147 ± 16.242** |
-|       Float String |                            880.960 ± 28.201  |       525.248 ± 61.307   |             **472.148 ± 29.114** |
-| Large Float String |                            889.239 ± 52.519  |       491.519 ± 54.666   |             **445.087 ± 23.327** |
-|                Int |                            681.099 ± 45.200  |     **380.157 ± 14.904** |               383.153 ± 13.074   |
-|              Float |                            584.873 ± 21.257  |       314.687 ± 20.742   |             **292.431 ± 7.202**  |
+|   Small Int String |                             743.050 ± 22.348 |         321.168 ± 2.414  |             **290.426 ± 1.651**  |
+|         Int String |                             738.374 ± 9.285  |         347.425 ± 1.084  |             **327.643 ± 10.743** |
+|  Medium Int String |                             758.418 ± 3.978  |         363.158 ± 7.683  |             **329.252 ± 2.910**  |
+|   Large Int String |                            1008.926 ± 15.124 |         588.733 ± 5.415  |             **562.032 ± 3.643**  |
+| Small Float String |                             750.907 ± 11.667 |         351.727 ± 6.960  |             **323.021 ± 5.012**  |
+|       Float String |                             839.672 ± 4.795  |         443.952 ± 8.718  |             **408.523 ± 3.236**  |
+| Large Float String |                             862.456 ± 20.592 |         452.004 ± 1.994  |             **444.893 ± 39.630** |
+|                Int |                             656.702 ± 42.060 |         388.861 ± 22.340 |             **339.328 ± 6.071**  |
+|              Float |                             527.822 ± 14.362 |         271.859 ± 2.069  |             **243.611 ± 0.738**  |
 
diff --git a/profiling/results-3.12.md b/profiling/results-3.12.md
new file mode 100644
index 00000000..4b9eeb78
--- /dev/null
+++ b/profiling/results-3.12.md
@@ -0,0 +1,190 @@
+sys.version_info(major=3, minor=12, micro=0, releaselevel='final', serial=0)
+
+### Timing comparison of `int` functions
+
+| Input type        | builtin (ms)   | fastnumbers (ms)   |
+| ----------------: | -------------: | -----------------: |
+|  Small Int String | 24.635 ± 1.615 | **13.154 ± 0.493** |
+|        Int String | 26.275 ± 2.502 | **15.228 ± 0.310** |
+| Medium Int String | 24.221 ± 3.531 | **15.873 ± 0.395** |
+|  Large Int String | 28.414 ± 0.798 | **24.264 ± 0.452** |
+|               Int | 11.924 ± 0.178 |  **9.711 ± 0.141** |
+|             Float | 24.943 ± 0.228 | **24.780 ± 1.587** |
+
+### Timing comparison of `float` functions
+
+| Input type         | builtin (ms)       | fastnumbers (ms)   |
+| -----------------: | -----------------: | -----------------: |
+|   Small Int String | **10.457 ± 0.628** |   16.129 ± 0.359   |
+|         Int String | **11.090 ± 0.226** |   16.848 ± 2.782   |
+|  Medium Int String | **12.364 ± 0.083** |   16.428 ± 0.790   |
+|   Large Int String |   43.676 ± 1.631   | **21.551 ± 0.425** |
+| Small Float String | **10.528 ± 0.201** |   16.285 ± 0.454   |
+|       Float String |   47.880 ± 1.731   | **18.320 ± 0.409** |
+| Large Float String |   76.427 ± 2.525   | **18.403 ± 0.273** |
+|                Int |  **5.369 ± 0.066** |   13.463 ± 0.144   |
+|              Float |  **2.827 ± 0.064** |   10.323 ± 0.140   |
+
+### Timing comparison of `int` functions with error handling
+
+| Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | -----------------: | --------------: | -----------------: |
+|  Non-number String |  234.845 ± 9.790   |  32.030 ± 0.556 | **26.128 ± 0.145** |
+|   Small Int String |   26.855 ± 0.536   |  65.617 ± 0.292 | **23.316 ± 0.019** |
+|         Int String | **28.137 ± 0.247** |  72.539 ± 1.459 |   30.087 ± 0.632   |
+|  Medium Int String |   30.332 ± 0.534   |  81.970 ± 0.891 | **29.387 ± 0.263** |
+|   Large Int String | **34.138 ± 0.019** | 103.190 ± 0.230 |   37.392 ± 0.547   |
+| Small Float String |  223.572 ± 9.379   |  35.173 ± 0.337 | **25.469 ± 0.345** |
+|       Float String |  224.133 ± 3.795   |  41.812 ± 0.018 | **25.797 ± 0.017** |
+| Large Float String |  230.232 ± 2.285   |  40.852 ± 0.439 | **25.921 ± 0.167** |
+|                Int | **15.191 ± 0.018** | 180.278 ± 1.367 |   20.281 ± 0.357   |
+|              Float | **28.719 ± 0.009** | 192.572 ± 2.780 |   36.727 ± 1.367   |
+
+### Timing comparison of `float` functions with error handling
+
+| Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | -----------------: | --------------: | -----------------: |
+|  Non-number String |  120.907 ± 2.340   |  39.785 ± 0.194 | **28.419 ± 0.371** |
+|   Small Int String | **14.034 ± 0.146** |  69.899 ± 0.962 |   29.339 ± 0.026   |
+|         Int String | **14.726 ± 0.009** |  73.257 ± 0.455 |   29.822 ± 0.397   |
+|  Medium Int String | **16.318 ± 0.201** |  85.362 ± 1.213 |   31.298 ± 0.602   |
+|   Large Int String |   49.533 ± 0.939   | 136.248 ± 2.510 | **36.404 ± 0.323** |
+| Small Float String | **14.519 ± 0.040** |  67.837 ± 0.175 |   29.951 ± 0.214   |
+|       Float String |   51.618 ± 0.241   | 123.078 ± 2.196 | **31.766 ± 0.017** |
+| Large Float String |   80.187 ± 1.307   | 161.382 ± 4.170 | **32.154 ± 0.490** |
+|                Int |  **8.298 ± 0.025** | 167.923 ± 3.304 |   26.998 ± 0.194   |
+|              Float |  **5.953 ± 0.082** | 165.653 ± 2.242 |   21.980 ± 0.332   |
+
+### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String | 120.177 ± 1.498 |  75.783 ± 2.725 | **29.731 ± 0.435** |
+|   Small Int String |  34.998 ± 0.214 |  69.292 ± 0.148 | **26.041 ± 0.020** |
+|         Int String |  39.130 ± 0.289 |  74.957 ± 0.634 | **33.089 ± 0.128** |
+|  Medium Int String |  45.075 ± 0.176 |  85.845 ± 1.256 | **32.209 ± 0.554** |
+|   Large Int String |  89.449 ± 0.394 | 106.398 ± 0.129 | **40.429 ± 0.734** |
+| Small Float String |  34.313 ± 0.007 | 103.443 ± 2.124 | **31.254 ± 0.557** |
+|       Float String | 100.799 ± 5.157 | 165.850 ± 1.554 | **40.645 ± 0.033** |
+| Large Float String | 162.963 ± 0.989 | 205.402 ± 3.933 | **56.570 ± 0.135** |
+|                Int |  30.773 ± 0.008 | 176.851 ± 2.585 | **22.354 ± 0.006** |
+|              Float |  57.993 ± 0.337 | 176.594 ± 1.236 | **38.204 ± 0.709** |
+
+### Timing comparison of forced `int` functions with error handling
+
+| Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | -----------------: | --------------: | -----------------: |
+|  Non-number String |  361.626 ± 10.118  |  64.333 ± 1.189 | **30.101 ± 0.529** |
+|   Small Int String |   29.752 ± 0.488   |  70.482 ± 2.336 | **26.093 ± 0.471** |
+|         Int String | **29.587 ± 0.468** |  70.930 ± 1.134 |   29.800 ± 0.504   |
+|  Medium Int String | **28.801 ± 0.012** | 129.203 ± 1.328 |   31.502 ± 3.941   |
+|   Large Int String | **34.385 ± 0.399** | 184.889 ± 2.642 |   39.276 ± 0.680   |
+| Small Float String |  259.010 ± 2.715   | 111.569 ± 0.560 | **26.114 ± 0.540** |
+|       Float String |  324.894 ± 5.008   | 187.371 ± 5.361 | **37.043 ± 0.023** |
+| Large Float String |  376.711 ± 4.473   | 237.102 ± 3.476 | **54.052 ± 0.117** |
+|                Int | **15.189 ± 0.019** | 179.399 ± 3.085 |   20.190 ± 0.397   |
+|              Float | **28.648 ± 0.009** | 197.071 ± 1.072 |   35.610 ± 0.092   |
+
+### Timing comparison of forced `int` functions with error handling and denoising
+
+| Input type         | Python (ms)        | fastnumbers (ms)    |
+| -----------------: | -----------------: | ------------------: |
+|   Small Int String |  238.793 ± 4.818   |  **30.758 ± 0.113** |
+|         Int String |  241.800 ± 6.548   |  **38.092 ± 0.217** |
+|  Medium Int String |  249.927 ± 7.704   |  **37.361 ± 0.013** |
+|   Large Int String |  273.811 ± 4.946   |  **44.461 ± 0.016** |
+| Small Float String |  327.947 ± 3.197   |  **35.026 ± 0.020** |
+|       Float String |  367.330 ± 3.054   |  **85.419 ± 1.314** |
+| Large Float String |  890.195 ± 12.167  | **175.610 ± 4.288** |
+|                Int | **18.923 ± 0.028** |    27.118 ± 0.060   |
+|              Float | **60.149 ± 3.197** |   230.257 ± 2.724   |
+
+### Timing comparison to check if value can be converted to `int`
+
+| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | --------------: | -------------: | -----------------: |
+|  Non-number String | 234.396 ± 1.807 | 47.227 ± 0.162 | **11.899 ± 0.057** |
+|   Small Int String |  28.570 ± 0.090 | 61.325 ± 3.091 | **13.612 ± 0.173** |
+|         Int String |  33.995 ± 2.765 | 69.057 ± 1.706 | **13.713 ± 0.206** |
+|  Medium Int String |  32.528 ± 0.051 | 73.625 ± 0.121 | **12.925 ± 0.015** |
+|   Large Int String |  37.657 ± 2.669 | 88.492 ± 0.315 | **12.567 ± 0.074** |
+| Small Float String | 220.666 ± 1.905 | 52.133 ± 0.021 | **13.335 ± 0.031** |
+|       Float String | 226.589 ± 2.125 | 59.331 ± 0.201 | **14.370 ± 0.013** |
+| Large Float String | 233.543 ± 4.500 | 60.131 ± 1.853 | **14.470 ± 0.007** |
+|                Int |  17.977 ± 0.110 | 17.860 ± 0.026 | **10.760 ± 0.016** |
+|              Float |  31.153 ± 0.452 | 14.536 ± 0.005 | **10.426 ± 0.052** |
+
+### Timing comparison to check if value can be converted to `float`
+
+| Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | -----------------: | --------------: | -----------------: |
+|  Non-number String |  118.843 ± 0.423   |  54.451 ± 0.186 | **13.937 ± 0.207** |
+|   Small Int String |   16.787 ± 0.102   |  72.212 ± 1.125 | **13.877 ± 0.181** |
+|         Int String |   17.200 ± 0.240   |  74.952 ± 0.182 | **13.685 ± 0.095** |
+|  Medium Int String |   18.269 ± 0.133   |  84.894 ± 2.083 | **15.619 ± 1.972** |
+|   Large Int String |   53.857 ± 1.116   | 102.449 ± 1.921 | **14.441 ± 1.028** |
+| Small Float String |   16.595 ± 0.006   |  70.805 ± 1.416 | **14.999 ± 0.262** |
+|       Float String |   53.554 ± 0.015   |  86.999 ± 0.282 | **15.746 ± 0.020** |
+| Large Float String |   83.538 ± 0.135   |  95.548 ± 1.228 | **15.819 ± 0.020** |
+|                Int | **10.576 ± 0.108** |  17.378 ± 0.013 |   11.717 ± 0.018   |
+|              Float |  **7.553 ± 0.041** |  14.692 ± 0.215 |   12.354 ± 0.008   |
+
+### Timing comparison to check if value can be converted to `float` or `int`
+
+| Input type         | try/except (ms)   | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | ----------------: | --------------: | -----------------: |
+|  Non-number String | 119.408 ± 3.520   |  56.814 ± 0.243 | **13.422 ± 0.191** |
+|   Small Int String |  14.879 ± 0.184   |  75.765 ± 1.496 | **12.884 ± 0.026** |
+|         Int String |  14.983 ± 0.020   |  77.963 ± 0.696 | **13.394 ± 0.062** |
+|  Medium Int String |  16.768 ± 0.514   |  88.410 ± 0.835 | **14.017 ± 0.194** |
+|   Large Int String |  51.142 ± 0.296   | 106.822 ± 0.585 | **13.516 ± 0.264** |
+| Small Float String |  14.823 ± 0.104   |  72.550 ± 0.437 | **14.253 ± 0.011** |
+|       Float String |  51.736 ± 0.012   |  89.724 ± 0.218 | **15.257 ± 0.018** |
+| Large Float String |  81.507 ± 0.122   |  97.461 ± 0.348 | **15.089 ± 0.277** |
+|                Int | **8.509 ± 0.070** |  15.920 ± 0.023 |   10.879 ± 0.093   |
+|              Float | **5.991 ± 0.141** |  13.468 ± 0.028 |   11.178 ± 0.026   |
+
+### Timing comparison to check if value can be coerced losslessly to `int`
+
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String | 362.617 ± 9.047 |  65.061 ± 0.714 | **12.042 ± 0.280** |
+|   Small Int String |  45.274 ± 0.868 |  45.014 ± 0.264 | **12.991 ± 0.264** |
+|         Int String |  47.882 ± 0.988 |  46.900 ± 0.663 | **12.527 ± 0.131** |
+|  Medium Int String |  53.543 ± 0.349 |  54.187 ± 0.459 | **12.340 ± 0.058** |
+|   Large Int String | 104.963 ± 2.130 |  71.394 ± 0.140 | **12.326 ± 0.045** |
+| Small Float String | 246.515 ± 2.137 |  99.012 ± 0.097 | **13.266 ± 0.173** |
+|       Float String | 301.467 ± 4.901 | 159.821 ± 2.570 | **14.376 ± 0.062** |
+| Large Float String | 341.923 ± 5.082 | 198.709 ± 2.730 | **16.297 ± 4.180** |
+|                Int |  26.847 ± 0.014 | 183.745 ± 0.186 | **10.428 ± 0.045** |
+|              Float |  59.639 ± 1.208 | 235.879 ± 6.727 | **10.537 ± 0.055** |
+
+### Timing comparison of `map` option vs. iterating over `try_float` for a 50 element list
+
+| Input type         | [try_float(x) for x in iterable] (ms) | list(map(try_float, iterable)) (ms) | list(try_float(iterable, map=True)) (ms) | try_float(iterable, map=list) (ms) |
+| -----------------: | ------------------------------------: | ----------------------------------: | ---------------------------------------: | ---------------------------------: |
+|  Non-number String |                     1524.104 ± 34.525 |                   1619.076 ± 11.811 |                         662.028 ± 5.512  |               **570.685 ± 7.025**  |
+|   Small Int String |                     1576.737 ± 4.754  |                   1683.317 ± 93.867 |                         680.886 ± 12.552 |               **572.546 ± 12.634** |
+|         Int String |                     1593.893 ± 18.140 |                   1573.295 ± 79.725 |                         627.236 ± 6.802  |               **547.711 ± 4.216**  |
+|  Medium Int String |                     1467.810 ± 24.621 |                   1539.761 ± 8.996  |                         651.809 ± 4.483  |               **562.207 ± 6.680**  |
+|   Large Int String |                     1789.221 ± 39.664 |                   1867.075 ± 13.840 |                         917.501 ± 4.393  |               **831.091 ± 5.779**  |
+| Small Float String |                     1523.855 ± 6.167  |                   1662.047 ± 17.450 |                         704.741 ± 13.204 |               **604.618 ± 7.060**  |
+|       Float String |                     1673.528 ± 28.246 |                   1745.992 ± 14.415 |                         790.421 ± 7.136  |               **690.652 ± 4.371**  |
+| Large Float String |                     1738.715 ± 63.422 |                   1764.399 ± 11.072 |                         799.188 ± 11.476 |               **644.781 ± 7.359**  |
+|                Int |                     1290.682 ± 5.042  |                   1345.851 ± 3.199  |                         513.471 ± 2.576  |               **420.010 ± 2.399**  |
+|              Float |                     1127.292 ± 16.645 |                   1226.058 ± 8.238  |                         378.733 ± 1.439  |               **304.793 ± 2.877**  |
+
+### Timing comparison of `try_array` vs. `map` option for a 50 element list to a numpy array
+
+| Input type         | np.array(try_float(iterable, map=True)) (ms) | try_array(iterable) (ms) | try_array(iterable, output) (ms) |
+| -----------------: | -------------------------------------------: | -----------------------: | -------------------------------: |
+|   Small Int String |                             855.609 ± 8.659  |          343.081 ± 6.371 |             **324.078 ± 2.348**  |
+|         Int String |                             950.831 ± 81.819 |          368.905 ± 6.318 |             **340.684 ± 3.316**  |
+|  Medium Int String |                             922.925 ± 4.761  |          382.501 ± 3.953 |             **365.910 ± 11.836** |
+|   Large Int String |                            1181.628 ± 6.922  |          596.607 ± 4.288 |             **572.411 ± 6.948**  |
+| Small Float String |                             932.115 ± 6.361  |          379.504 ± 3.303 |             **352.595 ± 1.679**  |
+|       Float String |                            1028.312 ± 8.358  |          456.616 ± 2.946 |             **432.736 ± 2.315**  |
+| Large Float String |                            1034.977 ± 6.418  |          470.888 ± 1.473 |             **446.550 ± 0.928**  |
+|                Int |                             811.945 ± 9.017  |          472.875 ± 2.620 |             **448.015 ± 6.498**  |
+|              Float |                             659.352 ± 9.414  |          299.986 ± 4.960 |             **273.487 ± 0.411**  |
+
diff --git a/profiling/results-3.7.md b/profiling/results-3.7.md
index 2d052875..16b92273 100644
--- a/profiling/results-3.7.md
+++ b/profiling/results-3.7.md
@@ -4,173 +4,173 @@ sys.version_info(major=3, minor=7, micro=16, releaselevel='final', serial=0)
 
 | Input type        | builtin (ms)       | fastnumbers (ms)   |
 | ----------------: | -----------------: | -----------------: |
-|  Small Int String |   16.263 ± 0.230   | **11.777 ± 0.035** |
-|        Int String |   17.326 ± 1.382   | **13.430 ± 0.566** |
-| Medium Int String |   18.591 ± 0.288   | **13.513 ± 0.070** |
-|  Large Int String |   23.693 ± 0.613   | **22.451 ± 0.044** |
-|               Int |   10.034 ± 0.076   |  **8.997 ± 0.589** |
-|             Float | **20.933 ± 0.072** |   21.393 ± 0.091   |
+|  Small Int String |   18.492 ± 1.558   | **13.443 ± 2.873** |
+|        Int String |   18.950 ± 1.178   | **14.832 ± 1.002** |
+| Medium Int String |   20.554 ± 0.431   | **15.571 ± 2.192** |
+|  Large Int String |   26.547 ± 0.755   | **26.061 ± 2.948** |
+|               Int |   10.772 ± 0.438   | **10.484 ± 0.548** |
+|             Float | **22.680 ± 0.944** |   24.013 ± 0.891   |
 
 ### Timing comparison of `float` functions
 
-| Input type         | builtin (ms)      | fastnumbers (ms)   |
-| -----------------: | ----------------: | -----------------: |
-|   Small Int String |  13.735 ± 0.522   | **12.136 ± 0.097** |
-|         Int String |  14.269 ± 0.067   | **12.249 ± 0.039** |
-|  Medium Int String |  15.419 ± 0.518   | **12.585 ± 0.082** |
-|   Large Int String |  36.241 ± 1.834   | **17.015 ± 0.015** |
-| Small Float String |  14.098 ± 0.066   | **12.538 ± 0.707** |
-|       Float String |  32.492 ± 0.051   | **13.738 ± 0.018** |
-| Large Float String |  54.873 ± 2.195   | **14.024 ± 0.377** |
-|                Int | **9.189 ± 0.082** |    9.848 ± 0.047   |
-|              Float | **8.480 ± 0.087** |    9.342 ± 0.078   |
+| Input type         | builtin (ms)       | fastnumbers (ms)   |
+| -----------------: | -----------------: | -----------------: |
+|   Small Int String |   15.585 ± 1.017   | **13.691 ± 0.410** |
+|         Int String |   16.137 ± 1.180   | **13.899 ± 0.280** |
+|  Medium Int String |   16.784 ± 0.512   | **14.746 ± 0.385** |
+|   Large Int String |   39.173 ± 1.027   | **19.613 ± 0.893** |
+| Small Float String | **16.671 ± 3.250** |   16.785 ± 2.395   |
+|       Float String |   44.336 ± 2.605   | **19.556 ± 0.994** |
+| Large Float String |   72.683 ± 5.371   | **20.614 ± 2.126** |
+|                Int | **12.105 ± 0.379** |   14.045 ± 0.374   |
+|              Float | **11.232 ± 0.462** |   12.465 ± 0.638   |
 
 ### Timing comparison of `int` functions with error handling
 
-| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
-| -----------------: | --------------: | -------------: | -----------------: |
-|  Non-number String | 126.409 ± 3.586 | 29.773 ± 0.022 | **17.785 ± 0.024** |
-|   Small Int String |  24.413 ± 0.007 | 50.872 ± 0.130 | **16.990 ± 0.025** |
-|         Int String |  25.150 ± 0.022 | 54.874 ± 0.042 | **18.674 ± 0.069** |
-|  Medium Int String |  26.671 ± 0.018 | 62.638 ± 0.119 | **18.801 ± 0.008** |
-|   Large Int String |  31.778 ± 0.072 | 82.017 ± 0.052 | **27.903 ± 0.051** |
-| Small Float String | 122.618 ± 0.188 | 33.775 ± 0.005 | **18.110 ± 0.052** |
-|       Float String | 129.271 ± 1.602 | 40.382 ± 0.014 | **18.414 ± 0.076** |
-| Large Float String | 134.041 ± 3.343 | 40.382 ± 0.033 | **18.554 ± 0.012** |
-|                Int |  18.088 ± 0.002 | 76.783 ± 0.334 | **14.367 ± 0.043** |
-|              Float |  29.020 ± 0.006 | 89.684 ± 0.212 | **26.908 ± 0.004** |
+| Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | -----------------: | --------------: | -----------------: |
+|  Non-number String |  181.248 ± 10.504  |  40.104 ± 0.699 | **29.361 ± 0.597** |
+|   Small Int String |   31.774 ± 0.496   |  65.478 ± 0.636 | **28.557 ± 0.920** |
+|         Int String |   32.852 ± 0.565   |  74.666 ± 2.992 | **32.476 ± 0.299** |
+|  Medium Int String |   36.822 ± 1.238   |  84.148 ± 0.957 | **31.932 ± 0.767** |
+|   Large Int String | **43.944 ± 2.517** | 112.196 ± 3.438 |   47.543 ± 1.731   |
+| Small Float String |  166.168 ± 4.919   |  51.944 ± 3.238 | **32.968 ± 1.646** |
+|       Float String |  175.452 ± 3.866   |  54.230 ± 0.733 | **30.191 ± 0.292** |
+| Large Float String |  176.572 ± 3.389   |  57.476 ± 1.427 | **32.707 ± 0.968** |
+|                Int | **24.987 ± 0.665** | 102.499 ± 1.835 |   26.025 ± 0.887   |
+|              Float | **37.035 ± 0.802** | 111.166 ± 1.799 |   41.496 ± 2.037   |
 
 ### Timing comparison of `float` functions with error handling
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
-| -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  69.455 ± 0.967 |  33.465 ± 0.010 | **18.853 ± 0.017** |
-|   Small Int String |  21.799 ± 0.121 |  58.119 ± 0.035 | **18.384 ± 0.396** |
-|         Int String |  22.616 ± 0.230 |  62.377 ± 0.989 | **18.112 ± 0.005** |
-|  Medium Int String |  23.516 ± 0.002 |  69.600 ± 0.725 | **18.756 ± 0.090** |
-|   Large Int String |  44.469 ± 0.012 | 105.333 ± 1.232 | **23.266 ± 0.031** |
-| Small Float String |  23.921 ± 3.446 |  57.166 ± 0.104 | **18.334 ± 0.007** |
-|       Float String |  40.994 ± 0.087 |  93.117 ± 0.062 | **20.009 ± 0.065** |
-| Large Float String |  63.374 ± 0.074 | 122.648 ± 0.203 | **20.125 ± 0.011** |
-|                Int |  17.149 ± 0.008 |  75.502 ± 0.139 | **15.581 ± 0.004** |
-|              Float |  16.123 ± 0.002 |  74.961 ± 1.108 | **14.691 ± 0.007** |
+| Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | -----------------: | --------------: | -----------------: |
+|  Non-number String |   95.111 ± 3.735   |  55.494 ± 2.576 | **35.130 ± 0.507** |
+|   Small Int String | **29.882 ± 0.323** |  82.469 ± 1.202 |   31.334 ± 0.450   |
+|         Int String | **30.897 ± 0.175** |  97.082 ± 2.160 |   35.200 ± 0.918   |
+|  Medium Int String |   34.836 ± 0.600   | 105.789 ± 2.380 | **33.603 ± 0.621** |
+|   Large Int String |   58.773 ± 0.161   | 144.883 ± 2.560 | **38.455 ± 1.023** |
+| Small Float String | **28.763 ± 0.434** |  79.134 ± 0.885 |   30.725 ± 0.253   |
+|       Float String |   51.571 ± 1.572   | 131.249 ± 4.888 | **34.240 ± 0.509** |
+| Large Float String |   83.568 ± 4.289   | 165.976 ± 5.053 | **35.263 ± 0.367** |
+|                Int | **23.409 ± 0.369** | 104.484 ± 2.531 |   29.419 ± 0.229   |
+|              Float | **21.641 ± 0.223** |  97.685 ± 0.570 |   26.933 ± 0.342   |
 
 ### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
-| -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  70.347 ± 0.540 |  56.349 ± 0.127 | **19.957 ± 0.897** |
-|   Small Int String |  42.966 ± 0.246 |  51.034 ± 0.091 | **18.054 ± 0.011** |
-|         Int String |  45.434 ± 0.348 |  55.079 ± 0.191 | **22.065 ± 2.722** |
-|  Medium Int String |  49.614 ± 1.971 |  62.620 ± 0.016 | **20.547 ± 0.003** |
-|   Large Int String |  79.348 ± 1.559 |  82.074 ± 0.097 | **29.449 ± 0.010** |
-| Small Float String |  44.136 ± 0.886 |  84.031 ± 0.096 | **20.082 ± 0.006** |
-|       Float String |  77.606 ± 0.180 | 126.025 ± 0.143 | **27.468 ± 0.016** |
-| Large Float String | 133.937 ± 0.148 | 156.727 ± 1.120 | **45.047 ± 4.298** |
-|                Int |  39.682 ± 0.017 |  85.638 ± 0.472 | **15.157 ± 0.006** |
-|              Float |  61.403 ± 0.532 |  83.610 ± 0.074 | **27.231 ± 0.005** |
+| Input type         | try/except (ms)  | regex (ms)       | fastnumbers (ms)   |
+| -----------------: | ---------------: | ---------------: | -----------------: |
+|  Non-number String |  97.024 ± 2.848  |  85.273 ± 1.053  | **34.931 ± 2.575** |
+|   Small Int String |  56.887 ± 0.598  |  73.155 ± 4.604  | **31.803 ± 0.453** |
+|         Int String |  60.894 ± 2.876  |  78.413 ± 2.697  | **37.186 ± 0.595** |
+|  Medium Int String |  70.703 ± 4.991  |  86.057 ± 1.662  | **33.614 ± 0.732** |
+|   Large Int String | 102.731 ± 5.338  | 112.028 ± 3.845  | **45.225 ± 0.789** |
+| Small Float String |  53.630 ± 1.232  | 119.587 ± 5.978  | **32.088 ± 0.530** |
+|       Float String | 108.208 ± 14.258 | 181.574 ± 14.667 | **43.376 ± 0.915** |
+| Large Float String | 163.967 ± 5.809  | 206.731 ± 7.002  | **58.475 ± 0.582** |
+|                Int |  47.026 ± 0.489  | 101.903 ± 1.523  | **25.980 ± 0.369** |
+|              Float |  74.574 ± 1.088  | 116.164 ± 6.403  | **44.735 ± 2.882** |
 
 ### Timing comparison of forced `int` functions with error handling
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
-| -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String | 197.645 ± 0.778 |  55.176 ± 0.331 | **18.723 ± 0.031** |
-|   Small Int String |  24.397 ± 0.006 |  50.214 ± 0.044 | **17.307 ± 0.013** |
-|         Int String |  25.199 ± 0.125 |  54.232 ± 0.160 | **19.405 ± 0.009** |
-|  Medium Int String |  26.716 ± 0.209 | 103.098 ± 0.361 | **19.788 ± 0.048** |
-|   Large Int String |  31.662 ± 0.007 | 144.452 ± 2.430 | **28.859 ± 0.179** |
-| Small Float String | 150.898 ± 0.935 |  95.443 ± 0.082 | **21.557 ± 0.018** |
-|       Float String | 187.646 ± 1.376 | 143.103 ± 0.255 | **26.283 ± 0.003** |
-| Large Float String | 230.618 ± 1.497 | 194.273 ± 8.587 | **41.914 ± 0.029** |
-|                Int |  18.093 ± 0.005 |  77.809 ± 0.722 | **13.652 ± 0.029** |
-|              Float |  29.168 ± 0.058 |  89.335 ± 1.074 | **26.577 ± 0.005** |
+| Input type         | try/except (ms)    | regex (ms)       | fastnumbers (ms)   |
+| -----------------: | -----------------: | ---------------: | -----------------: |
+|  Non-number String |  280.455 ± 15.342  |  73.340 ± 1.544  | **32.370 ± 0.729** |
+|   Small Int String |   31.666 ± 0.268   |  65.351 ± 2.319  | **31.459 ± 1.717** |
+|         Int String |   33.905 ± 0.255   |  74.778 ± 8.272  | **31.145 ± 0.912** |
+|  Medium Int String |   34.297 ± 0.800   | 145.180 ± 4.695  | **31.286 ± 0.403** |
+|   Large Int String | **40.254 ± 0.432** | 181.170 ± 6.953  |   42.179 ± 1.042   |
+| Small Float String |  189.084 ± 3.688   | 123.072 ± 4.071  | **34.565 ± 0.535** |
+|       Float String |  237.215 ± 3.797   | 178.502 ± 3.473  | **43.137 ± 0.322** |
+| Large Float String |  299.875 ± 3.639   | 249.003 ± 14.838 | **66.648 ± 2.127** |
+|                Int | **22.433 ± 0.367** |  96.230 ± 2.930  |   24.248 ± 0.194   |
+|              Float | **34.520 ± 0.475** | 107.538 ± 2.271  |   39.348 ± 0.690   |
 
 ### Timing comparison to check if value can be converted to `int`
 
-| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
-| -----------------: | --------------: | -------------: | -----------------: |
-|  Non-number String | 126.286 ± 1.873 | 55.273 ± 0.027 |  **9.957 ± 0.025** |
-|   Small Int String |  37.742 ± 0.014 | 60.228 ± 0.265 | **10.035 ± 0.014** |
-|         Int String |  38.600 ± 0.030 | 63.322 ± 0.142 | **10.269 ± 0.019** |
-|  Medium Int String |  40.145 ± 0.023 | 69.459 ± 0.244 | **10.269 ± 0.076** |
-|   Large Int String |  45.263 ± 0.026 | 83.824 ± 0.307 | **10.214 ± 0.034** |
-| Small Float String | 123.585 ± 1.229 | 59.600 ± 0.112 | **10.937 ± 0.024** |
-|       Float String | 128.205 ± 1.506 | 66.505 ± 0.146 | **11.486 ± 0.020** |
-| Large Float String | 133.075 ± 0.783 | 66.497 ± 0.126 | **11.559 ± 0.007** |
-|                Int |  31.301 ± 0.043 | 28.547 ± 0.197 |  **8.865 ± 0.112** |
-|              Float |  43.396 ± 0.686 | 28.947 ± 0.002 |  **9.639 ± 0.029** |
+| Input type         | try/except (ms)  | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | ---------------: | --------------: | -----------------: |
+|  Non-number String | 167.191 ± 3.509  |  80.446 ± 2.440 | **15.665 ± 0.518** |
+|   Small Int String |  44.787 ± 0.740  |  79.697 ± 1.120 | **17.040 ± 1.068** |
+|         Int String |  49.429 ± 0.928  |  91.809 ± 7.419 | **16.855 ± 0.418** |
+|  Medium Int String |  49.653 ± 0.694  |  96.347 ± 3.921 | **17.963 ± 0.979** |
+|   Large Int String |  59.494 ± 0.779  | 120.027 ± 3.064 | **17.975 ± 0.118** |
+| Small Float String | 181.434 ± 18.632 |  96.831 ± 7.084 | **19.762 ± 3.148** |
+|       Float String | 179.713 ± 7.931  | 100.555 ± 4.323 | **20.960 ± 3.773** |
+| Large Float String | 187.430 ± 3.820  | 104.069 ± 4.713 | **21.572 ± 3.280** |
+|                Int |  40.318 ± 2.594  |  40.800 ± 2.210 | **15.614 ± 1.768** |
+|              Float |  54.958 ± 0.960  |  37.148 ± 1.588 | **14.975 ± 0.062** |
 
 ### Timing comparison to check if value can be converted to `float`
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
-| -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String | 77.588 ± 1.278  |  65.104 ± 0.325 | **11.919 ± 0.035** |
-|   Small Int String | 44.903 ± 14.348 |  77.039 ± 0.781 | **11.950 ± 0.005** |
-|         Int String | 39.372 ± 0.050  |  79.519 ± 1.561 | **12.224 ± 0.020** |
-|  Medium Int String | 40.269 ± 0.643  |  86.018 ± 1.257 | **12.222 ± 0.012** |
-|   Large Int String | 62.876 ± 0.574  | 102.118 ± 0.498 | **11.989 ± 0.180** |
-| Small Float String | 38.828 ± 0.925  |  75.080 ± 0.110 | **13.062 ± 0.056** |
-|       Float String | 59.185 ± 0.860  |  92.201 ± 0.731 | **13.488 ± 0.002** |
-| Large Float String | 82.843 ± 0.191  |  99.077 ± 0.442 | **13.605 ± 0.033** |
-|                Int | 33.073 ± 0.049  |  31.761 ± 0.023 | **10.830 ± 0.036** |
-|              Float | 32.193 ± 0.021  |  29.339 ± 0.059 | **10.966 ± 0.158** |
+| Input type         | try/except (ms) | regex (ms)       | fastnumbers (ms)   |
+| -----------------: | --------------: | ---------------: | -----------------: |
+|  Non-number String | 100.437 ± 2.149 |  85.398 ± 10.305 | **17.936 ± 0.548** |
+|   Small Int String |  45.351 ± 0.772 |  94.174 ± 4.119  | **17.206 ± 0.071** |
+|         Int String |  43.862 ± 0.562 | 112.023 ± 22.924 | **20.747 ± 3.827** |
+|  Medium Int String |  49.095 ± 0.653 | 101.393 ± 1.863  | **16.791 ± 0.007** |
+|   Large Int String |  78.826 ± 3.151 | 123.459 ± 7.120  | **18.056 ± 1.290** |
+| Small Float String |  45.409 ± 1.793 |  85.398 ± 1.184  | **17.781 ± 0.031** |
+|       Float String |  65.984 ± 2.799 | 123.243 ± 11.227 | **19.456 ± 0.327** |
+| Large Float String |  94.924 ± 2.485 | 112.418 ± 2.626  | **20.462 ± 0.985** |
+|                Int |  37.291 ± 0.909 |  34.940 ± 0.586  | **14.436 ± 0.027** |
+|              Float |  34.362 ± 0.600 |  32.155 ± 0.677  | **14.308 ± 0.169** |
 
 ### Timing comparison to check if value can be converted to `float` or `int`
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  77.219 ± 0.846 |  64.552 ± 0.122 | **11.186 ± 0.027** |
-|   Small Int String |  24.127 ± 0.004 |  75.962 ± 1.258 | **11.448 ± 0.053** |
-|         Int String |  25.699 ± 0.057 |  80.755 ± 1.082 | **11.851 ± 0.073** |
-|  Medium Int String |  26.291 ± 0.372 |  87.248 ± 1.348 | **11.936 ± 0.043** |
-|   Large Int String |  48.533 ± 0.254 | 103.719 ± 0.287 | **11.539 ± 0.042** |
-| Small Float String |  25.190 ± 0.590 |  76.435 ± 0.547 | **12.567 ± 0.185** |
-|       Float String |  44.666 ± 0.020 |  93.919 ± 0.041 | **13.206 ± 0.008** |
-| Large Float String |  69.311 ± 1.169 |  99.432 ± 1.427 | **12.906 ± 0.066** |
-|                Int |  19.278 ± 0.004 |  26.655 ± 0.407 | **10.538 ± 0.059** |
-|              Float |  18.724 ± 0.002 |  25.152 ± 0.003 | **10.332 ± 0.049** |
+|  Non-number String |  99.365 ± 2.416 |  84.396 ± 2.536 | **19.400 ± 1.396** |
+|   Small Int String |  30.614 ± 0.531 |  90.333 ± 1.440 | **16.776 ± 0.305** |
+|         Int String |  29.965 ± 1.010 | 103.955 ± 3.801 | **18.529 ± 0.806** |
+|  Medium Int String |  33.165 ± 1.213 | 107.222 ± 7.073 | **17.756 ± 0.672** |
+|   Large Int String |  61.291 ± 2.660 | 117.750 ± 3.387 | **16.945 ± 0.221** |
+| Small Float String |  29.293 ± 0.476 |  89.788 ± 1.568 | **18.208 ± 0.233** |
+|       Float String |  51.701 ± 0.819 | 104.643 ± 1.845 | **17.642 ± 0.116** |
+| Large Float String |  76.931 ± 2.209 | 113.059 ± 1.234 | **17.745 ± 0.013** |
+|                Int |  21.649 ± 0.250 |  29.873 ± 0.160 | **14.299 ± 0.270** |
+|              Float |  20.913 ± 0.199 |  28.431 ± 0.294 | **14.102 ± 0.249** |
 
 ### Timing comparison to check if value can be coerced losslessly to `int`
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String | 217.528 ± 2.967 |  64.869 ± 0.643 | **10.746 ± 0.009** |
-|   Small Int String |  51.445 ± 0.597 |  39.435 ± 0.690 | **10.720 ± 0.037** |
-|         Int String |  53.206 ± 0.460 |  42.561 ± 0.826 | **11.028 ± 0.032** |
-|  Medium Int String |  58.794 ± 0.891 |  49.026 ± 0.994 | **10.986 ± 0.015** |
-|   Large Int String |  96.246 ± 3.206 |  63.981 ± 0.978 | **10.902 ± 0.117** |
-| Small Float String | 168.367 ± 2.139 | 102.441 ± 1.089 | **11.527 ± 0.165** |
-|       Float String | 199.440 ± 2.153 | 148.149 ± 2.376 | **11.846 ± 0.053** |
-| Large Float String | 230.747 ± 3.809 | 180.413 ± 3.087 | **12.098 ± 0.200** |
-|                Int |  38.794 ± 0.047 |  86.864 ± 1.708 |  **9.249 ± 0.039** |
-|              Float |  65.082 ± 0.895 | 116.289 ± 1.741 |  **9.256 ± 0.072** |
+|  Non-number String | 258.167 ± 8.754 |  70.654 ± 0.816 | **16.161 ± 0.325** |
+|   Small Int String |  62.746 ± 0.528 |  45.058 ± 1.185 | **16.485 ± 0.188** |
+|         Int String |  63.423 ± 0.855 |  49.169 ± 0.630 | **16.516 ± 0.034** |
+|  Medium Int String |  67.605 ± 0.881 |  54.139 ± 0.380 | **15.840 ± 0.233** |
+|   Large Int String | 104.735 ± 1.392 |  70.060 ± 0.756 | **16.039 ± 0.330** |
+| Small Float String | 192.902 ± 5.763 | 110.261 ± 2.496 | **16.244 ± 0.232** |
+|       Float String | 229.026 ± 4.354 | 161.774 ± 2.021 | **17.377 ± 0.253** |
+| Large Float String | 265.513 ± 3.916 | 197.812 ± 2.809 | **18.097 ± 1.274** |
+|                Int |  43.850 ± 1.171 |  98.423 ± 5.141 | **13.802 ± 0.897** |
+|              Float |  72.895 ± 0.955 | 132.667 ± 3.314 | **13.337 ± 0.152** |
 
 ### Timing comparison of `map` option vs. iterating over `try_float` for a 50 element list
 
 | Input type         | [try_float(x) for x in iterable] (ms) | list(map(try_float, iterable)) (ms) | list(try_float(iterable, map=True)) (ms) | try_float(iterable, map=list) (ms) |
 | -----------------: | ------------------------------------: | ----------------------------------: | ---------------------------------------: | ---------------------------------: |
-|  Non-number String |                     1233.129 ± 89.694 |                   1096.322 ± 15.854 |                          592.030 ± 3.566 |                **525.788 ± 2.145** |
-|   Small Int String |                     1010.786 ± 9.769  |                    951.523 ± 1.286  |                          521.243 ± 2.012 |                **460.269 ± 0.466** |
-|         Int String |                     1027.887 ± 2.902  |                    975.433 ± 2.168  |                          534.428 ± 6.017 |                **469.688 ± 1.515** |
-|  Medium Int String |                     1046.838 ± 2.056  |                    986.693 ± 5.289  |                          547.380 ± 8.323 |                **483.375 ± 0.832** |
-|   Large Int String |                     1279.247 ± 5.927  |                   1216.838 ± 3.788  |                          747.334 ± 2.052 |                **687.583 ± 2.669** |
-| Small Float String |                     1041.469 ± 7.480  |                    976.922 ± 3.301  |                          535.049 ± 0.994 |                **474.046 ± 0.740** |
-|       Float String |                     1118.595 ± 5.464  |                   1050.202 ± 2.283  |                          596.587 ± 2.947 |                **538.216 ± 0.782** |
-| Large Float String |                     1129.278 ± 2.159  |                   1065.641 ± 2.951  |                          605.202 ± 0.623 |                **546.162 ± 2.092** |
-|                Int |                      906.642 ± 1.203  |                    849.825 ± 2.963  |                          415.162 ± 2.611 |                **351.087 ± 0.098** |
-|              Float |                      860.826 ± 4.642  |                    815.129 ± 2.823  |                          384.984 ± 1.124 |                **326.830 ± 1.034** |
+|  Non-number String |                     1675.566 ± 26.121 |                   1595.255 ± 39.520 |                         631.079 ± 7.283  |               **563.415 ± 21.733** |
+|   Small Int String |                     1613.768 ± 18.402 |                   1501.392 ± 57.648 |                         504.206 ± 3.518  |               **442.391 ± 0.797**  |
+|         Int String |                     1442.778 ± 15.334 |                   1373.616 ± 16.840 |                         514.956 ± 7.282  |               **458.830 ± 4.594**  |
+|  Medium Int String |                     1462.945 ± 11.640 |                   1412.144 ± 18.371 |                         551.913 ± 6.763  |               **520.005 ± 16.900** |
+|   Large Int String |                     1980.722 ± 36.741 |                   1862.050 ± 29.796 |                         867.686 ± 24.647 |               **772.653 ± 5.732**  |
+| Small Float String |                     1648.982 ± 4.386  |                   1602.074 ± 43.868 |                         599.790 ± 7.464  |               **522.700 ± 4.994**  |
+|       Float String |                     1745.643 ± 3.224  |                   1683.681 ± 9.725  |                         659.025 ± 3.175  |               **602.141 ± 19.670** |
+| Large Float String |                     1766.833 ± 8.167  |                   1692.317 ± 4.062  |                         669.112 ± 2.019  |               **597.568 ± 8.448**  |
+|                Int |                     1466.055 ± 3.302  |                   1393.419 ± 24.103 |                         452.565 ± 4.473  |               **387.288 ± 1.464**  |
+|              Float |                     1416.448 ± 10.795 |                   1370.934 ± 67.480 |                         420.926 ± 2.786  |               **349.819 ± 2.130**  |
 
 ### Timing comparison of `try_array` vs. `map` option for a 50 element list to a numpy array
 
 | Input type         | np.array(try_float(iterable, map=True)) (ms) | try_array(iterable) (ms) | try_array(iterable, output) (ms) |
 | -----------------: | -------------------------------------------: | -----------------------: | -------------------------------: |
-|   Small Int String |                              707.658 ± 4.071 |          364.192 ± 0.468 |              **291.410 ± 6.516** |
-|         Int String |                              715.386 ± 2.653 |          385.715 ± 4.957 |              **304.591 ± 5.353** |
-|  Medium Int String |                              731.776 ± 1.081 |          392.611 ± 4.928 |              **323.325 ± 7.615** |
-|   Large Int String |                              940.714 ± 4.315 |          606.276 ± 2.181 |              **533.269 ± 1.641** |
-| Small Float String |                              724.538 ± 4.827 |          386.579 ± 2.874 |              **306.971 ± 4.104** |
-|       Float String |                              785.111 ± 1.900 |          467.706 ± 4.541 |              **389.865 ± 0.738** |
-| Large Float String |                              803.408 ± 3.070 |          474.546 ± 1.523 |              **393.767 ± 1.558** |
-|                Int |                              599.951 ± 3.730 |          380.704 ± 1.085 |              **304.972 ± 2.164** |
-|              Float |                              570.421 ± 2.668 |          334.218 ± 0.553 |              **258.831 ± 0.826** |
+|   Small Int String |                             816.455 ± 12.503 |         430.329 ± 9.079  |              **337.951 ± 1.485** |
+|         Int String |                             805.692 ± 6.858  |         436.277 ± 4.390  |              **354.996 ± 4.282** |
+|  Medium Int String |                             821.827 ± 6.694  |         451.937 ± 4.328  |              **367.192 ± 2.760** |
+|   Large Int String |                            1063.477 ± 4.983  |         697.205 ± 2.071  |              **621.098 ± 3.495** |
+| Small Float String |                             827.969 ± 10.856 |         455.198 ± 10.985 |              **360.429 ± 4.520** |
+|       Float String |                             901.801 ± 11.906 |         535.390 ± 7.637  |              **448.186 ± 5.311** |
+| Large Float String |                             876.733 ± 33.624 |         491.299 ± 6.308  |              **408.396 ± 4.583** |
+|                Int |                             603.832 ± 4.818  |         392.439 ± 18.852 |              **313.024 ± 2.858** |
+|              Float |                             569.313 ± 4.290  |         336.981 ± 1.757  |              **266.090 ± 1.708** |
 
diff --git a/profiling/results-3.8.md b/profiling/results-3.8.md
index 34027bcd..e88ac264 100644
--- a/profiling/results-3.8.md
+++ b/profiling/results-3.8.md
@@ -4,173 +4,173 @@ sys.version_info(major=3, minor=8, micro=16, releaselevel='final', serial=0)
 
 | Input type        | builtin (ms)       | fastnumbers (ms)   |
 | ----------------: | -----------------: | -----------------: |
-|  Small Int String |   14.459 ± 0.540   | **11.596 ± 0.476** |
-|        Int String |   15.526 ± 0.289   | **13.075 ± 0.835** |
-| Medium Int String |   17.363 ± 0.145   | **15.152 ± 0.098** |
-|  Large Int String | **23.496 ± 0.756** |   23.652 ± 0.029   |
-|               Int |  **8.191 ± 0.054** |    8.702 ± 0.386   |
-|             Float | **19.584 ± 2.690** |   21.234 ± 0.019   |
+|  Small Int String |   15.699 ± 0.372   | **12.087 ± 0.298** |
+|        Int String |   16.992 ± 1.436   | **13.965 ± 0.545** |
+| Medium Int String |   18.444 ± 0.238   | **14.619 ± 0.688** |
+|  Large Int String |   28.029 ± 1.302   | **26.856 ± 0.455** |
+|               Int | **10.091 ± 1.185** |   10.664 ± 0.181   |
+|             Float | **22.599 ± 0.418** |   25.529 ± 0.505   |
 
 ### Timing comparison of `float` functions
 
-| Input type         | builtin (ms)      | fastnumbers (ms)   |
-| -----------------: | ----------------: | -----------------: |
-|   Small Int String |  13.465 ± 0.682   | **11.887 ± 0.028** |
-|         Int String |  14.054 ± 0.063   | **12.057 ± 0.391** |
-|  Medium Int String |  15.369 ± 1.048   | **12.285 ± 0.034** |
-|   Large Int String |  34.520 ± 0.308   | **16.411 ± 0.024** |
-| Small Float String |  13.752 ± 0.264   | **12.525 ± 0.059** |
-|       Float String |  31.901 ± 0.508   | **13.420 ± 0.058** |
-| Large Float String |  54.460 ± 0.390   | **13.744 ± 0.467** |
-|                Int | **9.225 ± 0.050** |    9.721 ± 0.035   |
-|              Float | **8.044 ± 0.332** |    9.032 ± 0.039   |
+| Input type         | builtin (ms)       | fastnumbers (ms)   |
+| -----------------: | -----------------: | -----------------: |
+|   Small Int String |   16.993 ± 0.446   | **16.016 ± 1.509** |
+|         Int String |   18.518 ± 1.232   | **15.296 ± 0.504** |
+|  Medium Int String |   19.425 ± 1.324   | **15.711 ± 1.562** |
+|   Large Int String |   40.501 ± 1.102   | **21.050 ± 3.920** |
+| Small Float String |   16.780 ± 0.319   | **15.226 ± 0.966** |
+|       Float String |   37.526 ± 0.704   | **17.334 ± 1.002** |
+| Large Float String |   62.962 ± 1.156   | **17.301 ± 0.343** |
+|                Int | **11.047 ± 0.260** |   12.657 ± 0.210   |
+|              Float |  **9.704 ± 0.258** |   11.227 ± 0.179   |
 
 ### Timing comparison of `int` functions with error handling
 
-| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
-| -----------------: | --------------: | -------------: | -----------------: |
-|  Non-number String | 126.823 ± 0.554 | 26.968 ± 0.007 | **17.221 ± 0.027** |
-|   Small Int String |  20.951 ± 0.007 | 46.809 ± 2.460 | **16.310 ± 0.068** |
-|         Int String |  22.144 ± 0.020 | 49.714 ± 0.047 | **18.330 ± 0.004** |
-|  Medium Int String |  24.002 ± 0.017 | 58.045 ± 0.054 | **18.541 ± 0.009** |
-|   Large Int String |  30.082 ± 0.001 | 78.713 ± 0.065 | **29.096 ± 0.018** |
-| Small Float String | 123.690 ± 0.435 | 30.616 ± 0.177 | **17.482 ± 0.064** |
-|       Float String | 130.694 ± 0.056 | 36.779 ± 0.168 | **17.812 ± 0.100** |
-| Large Float String | 133.581 ± 0.295 | 37.856 ± 1.077 | **18.035 ± 0.103** |
-|                Int |  14.481 ± 0.003 | 71.489 ± 0.220 | **13.523 ± 0.155** |
-|              Float |  26.791 ± 2.440 | 82.951 ± 0.507 | **26.439 ± 0.009** |
+| Input type         | try/except (ms)    | regex (ms)     | fastnumbers (ms)   |
+| -----------------: | -----------------: | -------------: | -----------------: |
+|  Non-number String |  154.718 ± 3.795   | 33.646 ± 0.082 | **26.439 ± 0.056** |
+|   Small Int String |   25.688 ± 0.500   | 54.210 ± 0.078 | **25.010 ± 0.684** |
+|         Int String | **26.541 ± 0.090** | 59.609 ± 0.167 |   28.501 ± 2.297   |
+|  Medium Int String |   28.746 ± 0.090   | 71.828 ± 1.553 | **28.465 ± 0.063** |
+|   Large Int String | **36.052 ± 0.577** | 94.547 ± 0.176 |   40.398 ± 0.656   |
+| Small Float String |  146.968 ± 1.049   | 37.084 ± 0.684 | **25.669 ± 0.070** |
+|       Float String |  153.535 ± 2.963   | 44.585 ± 0.915 | **25.594 ± 0.444** |
+| Large Float String |  156.294 ± 1.972   | 44.134 ± 0.393 | **26.173 ± 0.033** |
+|                Int | **17.203 ± 0.223** | 83.751 ± 1.266 |   23.596 ± 3.102   |
+|              Float | **29.878 ± 0.484** | 96.626 ± 1.196 |   37.453 ± 1.410   |
 
 ### Timing comparison of `float` functions with error handling
 
 | Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | -----------------: | --------------: | -----------------: |
-|  Non-number String |   68.229 ± 0.379   |  30.508 ± 0.076 | **18.387 ± 0.032** |
-|   Small Int String |   20.140 ± 0.029   |  53.948 ± 0.011 | **17.321 ± 0.030** |
-|         Int String |   20.803 ± 0.017   |  57.764 ± 0.088 | **17.585 ± 0.008** |
-|  Medium Int String |   22.008 ± 0.020   |  65.180 ± 0.019 | **18.009 ± 0.024** |
-|   Large Int String |   42.160 ± 0.022   |  99.787 ± 0.047 | **22.545 ± 0.026** |
-| Small Float String |   20.484 ± 0.003   |  52.988 ± 0.018 | **17.946 ± 0.023** |
-|       Float String |   38.459 ± 0.037   |  86.655 ± 0.074 | **19.409 ± 0.018** |
-| Large Float String |   61.329 ± 0.140   | 121.508 ± 7.672 | **19.625 ± 0.004** |
-|                Int |   15.565 ± 0.007   |  73.159 ± 1.025 | **15.454 ± 0.006** |
-|              Float | **14.005 ± 0.003** |  71.922 ± 0.054 |   14.516 ± 0.025   |
+|  Non-number String |   86.598 ± 2.188   |  43.265 ± 0.441 | **30.301 ± 0.510** |
+|   Small Int String | **24.443 ± 0.129** |  68.611 ± 1.074 |   28.205 ± 0.410   |
+|         Int String | **25.091 ± 0.156** |  72.713 ± 1.277 |   28.181 ± 0.020   |
+|  Medium Int String | **26.476 ± 0.443** |  84.210 ± 1.338 |   30.385 ± 0.527   |
+|   Large Int String |   59.798 ± 0.776   | 129.196 ± 4.016 | **34.264 ± 0.042** |
+| Small Float String | **24.669 ± 0.037** |  66.836 ± 0.335 |   28.762 ± 0.140   |
+|       Float String |   44.446 ± 0.272   | 106.354 ± 0.922 | **29.988 ± 0.477** |
+| Large Float String |   70.419 ± 0.834   | 140.578 ± 2.404 | **29.939 ± 0.013** |
+|                Int | **18.365 ± 0.520** |  89.661 ± 0.248 |   25.445 ± 0.201   |
+|              Float | **16.224 ± 0.053** |  84.569 ± 0.986 |   24.075 ± 0.176   |
 
 ### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  68.719 ± 0.243 |  55.401 ± 0.393 | **18.782 ± 0.006** |
-|   Small Int String |  36.957 ± 0.129 |  48.023 ± 0.054 | **17.754 ± 0.037** |
-|         Int String |  40.035 ± 0.591 |  52.409 ± 0.050 | **20.060 ± 0.003** |
-|  Medium Int String |  42.908 ± 0.132 |  60.624 ± 0.053 | **20.269 ± 0.005** |
-|   Large Int String |  72.238 ± 0.139 |  81.613 ± 0.070 | **31.075 ± 0.036** |
-| Small Float String |  38.342 ± 1.415 |  81.530 ± 0.083 | **19.577 ± 0.006** |
-|       Float String |  71.830 ± 0.178 | 121.067 ± 0.057 | **27.074 ± 0.020** |
-| Large Float String | 128.415 ± 0.665 | 151.575 ± 0.325 | **42.617 ± 0.035** |
-|                Int |  34.241 ± 0.061 |  77.433 ± 0.346 | **14.564 ± 0.007** |
-|              Float |  55.258 ± 0.045 |  76.557 ± 0.014 | **27.071 ± 0.017** |
+|  Non-number String |  86.217 ± 1.811 |  70.659 ± 0.354 | **30.530 ± 0.538** |
+|   Small Int String |  46.760 ± 4.406 |  59.077 ± 0.471 | **26.990 ± 0.039** |
+|         Int String |  47.629 ± 0.241 |  62.973 ± 0.450 | **30.402 ± 0.019** |
+|  Medium Int String |  53.415 ± 1.036 |  76.074 ± 0.202 | **30.801 ± 0.401** |
+|   Large Int String |  88.056 ± 1.019 |  97.279 ± 0.166 | **42.355 ± 0.724** |
+| Small Float String |  43.477 ± 0.078 |  97.574 ± 0.320 | **30.048 ± 0.500** |
+|       Float String |  83.666 ± 1.579 | 144.446 ± 1.547 | **39.453 ± 0.069** |
+| Large Float String | 145.068 ± 1.037 | 179.341 ± 2.940 | **55.203 ± 0.013** |
+|                Int |  39.833 ± 0.133 |  91.357 ± 1.353 | **24.287 ± 0.013** |
+|              Float |  64.045 ± 0.957 |  89.551 ± 0.903 | **41.075 ± 0.589** |
 
 ### Timing comparison of forced `int` functions with error handling
 
 | Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | -----------------: | --------------: | -----------------: |
-|  Non-number String |  195.133 ± 2.454   |  48.912 ± 0.089 | **18.191 ± 0.010** |
-|   Small Int String |   20.962 ± 0.004   |  44.613 ± 0.019 | **16.862 ± 0.005** |
-|         Int String |   22.179 ± 0.027   |  48.783 ± 0.022 | **19.237 ± 0.008** |
-|  Medium Int String |   24.012 ± 0.004   |  92.834 ± 1.165 | **19.419 ± 0.004** |
-|   Large Int String | **30.140 ± 0.041** | 133.242 ± 1.175 |   30.153 ± 0.004   |
-| Small Float String |  151.625 ± 0.331   |  86.278 ± 0.107 | **21.286 ± 0.012** |
-|       Float String |  186.306 ± 6.400   | 131.265 ± 1.109 | **25.684 ± 0.020** |
-| Large Float String |  227.054 ± 0.876   | 178.061 ± 0.415 | **41.366 ± 0.031** |
-|                Int |   14.497 ± 0.010   |  71.896 ± 0.022 | **13.100 ± 0.010** |
-|              Float | **25.690 ± 0.015** |  82.895 ± 0.271 |   26.751 ± 0.024   |
+|  Non-number String |  241.228 ± 4.085   |  58.840 ± 0.878 | **27.949 ± 0.018** |
+|   Small Int String | **25.317 ± 0.071** |  53.246 ± 0.184 |   25.702 ± 0.132   |
+|         Int String | **26.905 ± 0.116** |  61.087 ± 1.090 |   29.805 ± 0.170   |
+|  Medium Int String |   29.459 ± 0.509   | 111.707 ± 1.462 | **28.635 ± 0.012** |
+|   Large Int String | **35.647 ± 0.124** | 158.334 ± 1.366 |   41.489 ± 0.705   |
+| Small Float String |  176.308 ± 2.195   |  99.908 ± 0.989 | **32.062 ± 0.445** |
+|       Float String |  215.008 ± 2.630   | 157.185 ± 1.461 | **36.764 ± 0.405** |
+| Large Float String |  263.093 ± 3.012   | 206.830 ± 2.568 | **53.842 ± 0.325** |
+|                Int | **16.723 ± 0.003** |  83.224 ± 1.513 |   21.989 ± 0.276   |
+|              Float | **30.218 ± 0.013** |  97.981 ± 0.229 |   37.607 ± 0.312   |
 
 ### Timing comparison to check if value can be converted to `int`
 
 | Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
 | -----------------: | --------------: | -------------: | -----------------: |
-|  Non-number String | 131.808 ± 7.581 | 51.922 ± 0.062 |  **9.296 ± 0.032** |
-|   Small Int String |  33.097 ± 0.065 | 54.644 ± 0.017 |  **9.372 ± 0.013** |
-|         Int String |  34.811 ± 0.126 | 57.934 ± 0.069 |  **9.594 ± 0.016** |
-|  Medium Int String |  36.359 ± 0.033 | 64.045 ± 0.044 |  **9.570 ± 0.042** |
-|   Large Int String |  42.702 ± 0.330 | 78.674 ± 0.211 |  **9.569 ± 0.033** |
-| Small Float String | 126.817 ± 0.342 | 55.851 ± 0.033 | **10.376 ± 0.014** |
-|       Float String | 129.871 ± 0.442 | 61.760 ± 0.021 | **10.782 ± 0.019** |
-| Large Float String | 138.514 ± 8.729 | 61.959 ± 0.053 | **10.845 ± 0.011** |
-|                Int |  26.367 ± 0.069 | 23.062 ± 0.005 |  **8.121 ± 0.050** |
-|              Float |  37.402 ± 0.019 | 21.811 ± 0.342 |  **8.299 ± 0.061** |
+|  Non-number String | 164.645 ± 1.707 | 64.340 ± 0.903 | **14.118 ± 0.384** |
+|   Small Int String |  37.913 ± 0.113 | 66.241 ± 1.006 | **13.837 ± 0.037** |
+|         Int String |  40.621 ± 3.173 | 72.188 ± 0.797 | **14.947 ± 0.181** |
+|  Medium Int String |  42.431 ± 0.528 | 81.629 ± 0.474 | **14.319 ± 0.041** |
+|   Large Int String |  48.527 ± 0.365 | 94.601 ± 0.260 | **14.354 ± 0.053** |
+| Small Float String | 148.304 ± 1.714 | 65.467 ± 1.071 | **15.505 ± 0.582** |
+|       Float String | 164.616 ± 5.853 | 74.629 ± 0.317 | **16.089 ± 0.054** |
+| Large Float String | 159.169 ± 1.457 | 73.413 ± 1.076 | **16.226 ± 0.033** |
+|                Int |  29.581 ± 0.058 | 26.854 ± 0.013 | **11.504 ± 0.160** |
+|              Float |  40.705 ± 0.248 | 24.453 ± 0.009 | **12.093 ± 0.025** |
 
 ### Timing comparison to check if value can be converted to `float`
 
-| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
-| -----------------: | --------------: | -------------: | -----------------: |
-|  Non-number String |  67.674 ± 0.206 | 52.672 ± 0.040 | **10.220 ± 0.024** |
-|   Small Int String |  32.701 ± 0.040 | 61.751 ± 0.740 | **10.333 ± 0.027** |
-|         Int String |  33.418 ± 0.052 | 64.819 ± 0.640 | **10.449 ± 0.007** |
-|  Medium Int String |  34.353 ± 0.099 | 72.758 ± 0.718 | **10.485 ± 0.016** |
-|   Large Int String |  54.824 ± 0.040 | 85.796 ± 0.786 | **10.509 ± 0.037** |
-| Small Float String |  32.873 ± 0.048 | 60.077 ± 0.072 | **11.158 ± 0.004** |
-|       Float String |  53.899 ± 4.194 | 75.834 ± 0.087 | **11.679 ± 0.004** |
-| Large Float String |  74.070 ± 0.093 | 82.292 ± 0.155 | **11.692 ± 0.042** |
-|                Int |  27.359 ± 0.016 | 23.535 ± 0.038 |  **9.204 ± 0.015** |
-|              Float |  26.269 ± 0.190 | 28.516 ± 8.667 | **11.593 ± 5.011** |
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String |  87.710 ± 1.956 |  66.969 ± 0.854 | **15.223 ± 0.168** |
+|   Small Int String |  39.015 ± 2.992 |  76.541 ± 1.941 | **15.327 ± 0.005** |
+|         Int String |  38.059 ± 0.257 |  79.302 ± 0.555 | **15.884 ± 0.269** |
+|  Medium Int String |  40.134 ± 0.556 |  88.587 ± 0.732 | **16.505 ± 0.174** |
+|   Large Int String |  66.063 ± 0.600 | 104.385 ± 0.943 | **15.703 ± 0.005** |
+| Small Float String |  37.502 ± 0.037 |  71.543 ± 0.026 | **16.306 ± 0.231** |
+|       Float String |  57.383 ± 0.776 |  90.858 ± 0.776 | **16.919 ± 0.004** |
+| Large Float String |  82.948 ± 0.342 |  98.796 ± 0.982 | **17.069 ± 0.010** |
+|                Int |  30.717 ± 1.323 |  27.535 ± 0.263 | **13.278 ± 0.230** |
+|              Float |  29.024 ± 0.026 |  24.608 ± 0.003 | **13.467 ± 0.008** |
 
 ### Timing comparison to check if value can be converted to `float` or `int`
 
-| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
-| -----------------: | --------------: | -------------: | -----------------: |
-|  Non-number String |  67.592 ± 0.169 | 52.654 ± 0.885 | **10.039 ± 0.100** |
-|   Small Int String |  20.560 ± 0.003 | 60.469 ± 0.054 | **10.111 ± 0.004** |
-|         Int String |  21.266 ± 0.069 | 63.658 ± 0.030 | **10.341 ± 0.004** |
-|  Medium Int String |  22.484 ± 0.132 | 69.842 ± 0.189 | **10.371 ± 0.008** |
-|   Large Int String |  42.634 ± 0.053 | 84.695 ± 0.752 | **10.332 ± 0.008** |
-| Small Float String |  20.923 ± 0.004 | 60.980 ± 3.967 | **11.119 ± 0.040** |
-|       Float String |  40.436 ± 1.383 | 78.966 ± 1.634 | **11.471 ± 0.069** |
-| Large Float String |  61.806 ± 0.042 | 80.923 ± 0.065 | **11.531 ± 0.022** |
-|                Int |  16.036 ± 0.022 | 20.523 ± 0.020 |  **8.891 ± 0.020** |
-|              Float |  14.483 ± 0.001 | 18.517 ± 0.008 |  **9.129 ± 0.005** |
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String |  87.172 ± 0.288 |  65.933 ± 1.711 | **15.998 ± 0.549** |
+|   Small Int String |  26.965 ± 0.410 |  75.435 ± 0.989 | **14.834 ± 0.039** |
+|         Int String |  25.788 ± 0.182 |  78.696 ± 0.833 | **15.114 ± 0.006** |
+|  Medium Int String |  28.390 ± 0.627 |  91.569 ± 2.343 | **16.813 ± 0.623** |
+|   Large Int String |  56.259 ± 0.737 | 106.234 ± 3.437 | **15.900 ± 0.194** |
+| Small Float String |  26.501 ± 0.597 |  72.269 ± 1.234 | **15.918 ± 0.005** |
+|       Float String |  50.542 ± 4.783 |  92.018 ± 1.521 | **16.862 ± 0.011** |
+| Large Float String |  72.821 ± 0.048 |  96.372 ± 1.293 | **16.956 ± 0.083** |
+|                Int |  18.639 ± 0.004 |  24.510 ± 0.346 | **12.780 ± 0.038** |
+|              Float |  17.284 ± 0.003 |  22.192 ± 0.001 | **13.135 ± 0.011** |
 
 ### Timing comparison to check if value can be coerced losslessly to `int`
 
 | Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String | 194.799 ± 0.727 |  48.919 ± 0.057 |  **9.118 ± 0.050** |
-|   Small Int String |  40.780 ± 0.701 |  32.338 ± 0.101 |  **8.945 ± 0.043** |
-|         Int String |  42.099 ± 0.042 |  35.409 ± 0.011 |  **9.109 ± 0.041** |
-|  Medium Int String |  46.993 ± 0.064 |  41.571 ± 0.082 |  **9.112 ± 0.059** |
-|   Large Int String |  79.255 ± 0.077 |  56.696 ± 1.811 |  **9.108 ± 0.024** |
-| Small Float String | 151.490 ± 2.006 |  81.929 ± 1.013 | **10.089 ± 0.090** |
-|       Float String | 179.496 ± 1.727 | 121.707 ± 1.016 | **10.416 ± 0.064** |
-| Large Float String | 208.664 ± 2.353 | 151.788 ± 0.210 | **10.568 ± 0.032** |
-|                Int |  28.804 ± 0.025 |  75.294 ± 4.210 |  **7.889 ± 0.066** |
-|              Float |  52.611 ± 0.044 | 103.256 ± 1.047 |  **8.086 ± 0.028** |
+|  Non-number String | 249.393 ± 6.900 |  59.222 ± 0.532 | **13.682 ± 0.008** |
+|   Small Int String |  49.834 ± 0.057 |  39.322 ± 0.723 | **14.296 ± 0.548** |
+|         Int String |  52.818 ± 0.769 |  45.349 ± 2.574 | **14.701 ± 0.516** |
+|  Medium Int String |  61.189 ± 3.687 |  52.700 ± 0.832 | **14.423 ± 0.226** |
+|   Large Int String |  96.325 ± 1.027 |  67.781 ± 0.023 | **14.429 ± 0.498** |
+| Small Float String | 178.351 ± 5.251 |  95.877 ± 1.635 | **14.881 ± 0.010** |
+|       Float String | 207.616 ± 3.939 | 144.261 ± 2.057 | **15.826 ± 0.018** |
+| Large Float String | 241.559 ± 3.013 | 180.959 ± 1.631 | **15.916 ± 0.125** |
+|                Int |  33.442 ± 0.147 |  86.692 ± 0.302 | **11.631 ± 0.024** |
+|              Float |  61.315 ± 0.411 | 119.964 ± 2.047 | **11.790 ± 0.014** |
 
 ### Timing comparison of `map` option vs. iterating over `try_float` for a 50 element list
 
 | Input type         | [try_float(x) for x in iterable] (ms) | list(map(try_float, iterable)) (ms) | list(try_float(iterable, map=True)) (ms) | try_float(iterable, map=list) (ms) |
 | -----------------: | ------------------------------------: | ----------------------------------: | ---------------------------------------: | ---------------------------------: |
-|  Non-number String |                      1037.707 ± 2.570 |                    960.152 ± 4.886  |                          579.796 ± 0.594 |                **519.344 ± 1.347** |
-|   Small Int String |                       983.185 ± 0.878 |                    911.148 ± 3.550  |                          528.966 ± 1.418 |                **469.440 ± 0.899** |
-|         Int String |                      1005.440 ± 2.221 |                    917.823 ± 0.727  |                          539.691 ± 4.334 |                **477.990 ± 1.464** |
-|  Medium Int String |                      1039.882 ± 0.928 |                    940.476 ± 0.692  |                          553.740 ± 3.451 |                **490.650 ± 0.336** |
-|   Large Int String |                      1260.645 ± 5.781 |                   1165.841 ± 0.434  |                          763.209 ± 1.774 |                **700.401 ± 2.590** |
-| Small Float String |                      1030.957 ± 3.514 |                    933.365 ± 4.517  |                          545.945 ± 3.495 |                **480.909 ± 0.932** |
-|       Float String |                      1096.457 ± 3.821 |                   1017.227 ± 2.579  |                          605.807 ± 0.314 |                **545.345 ± 0.578** |
-| Large Float String |                      1106.959 ± 0.516 |                   1041.786 ± 4.965  |                          614.232 ± 3.658 |                **553.534 ± 3.317** |
-|                Int |                       892.912 ± 3.706 |                    825.177 ± 10.391 |                          420.672 ± 0.776 |                **363.225 ± 3.502** |
-|              Float |                       848.361 ± 3.931 |                    757.406 ± 4.858  |                          380.570 ± 0.446 |                **320.717 ± 0.066** |
+|  Non-number String |                    1580.005 ± 23.429  |                   1427.914 ± 9.359  |                         615.306 ± 8.174  |               **540.761 ± 3.381**  |
+|   Small Int String |                    1515.484 ± 10.359  |                   1383.118 ± 4.676  |                         569.520 ± 26.396 |               **485.451 ± 5.911**  |
+|         Int String |                    1537.196 ± 9.088   |                   1393.319 ± 2.614  |                         568.305 ± 1.022  |               **498.157 ± 4.374**  |
+|  Medium Int String |                    1564.477 ± 23.196  |                   1326.677 ± 43.593 |                         530.775 ± 1.146  |               **472.142 ± 5.132**  |
+|   Large Int String |                    1642.801 ± 6.905   |                   1521.271 ± 4.209  |                         759.358 ± 2.331  |               **687.438 ± 7.948**  |
+| Small Float String |                    1404.051 ± 5.686   |                   1277.956 ± 2.678  |                         528.224 ± 1.799  |               **479.139 ± 14.680** |
+|       Float String |                    1830.355 ± 241.915 |                   1529.138 ± 26.605 |                         659.732 ± 6.407  |               **584.900 ± 3.662**  |
+| Large Float String |                    1690.406 ± 31.057  |                   1555.036 ± 11.756 |                         675.239 ± 12.731 |               **598.319 ± 12.562** |
+|                Int |                    1435.160 ± 32.353  |                   1280.176 ± 13.279 |                         466.837 ± 15.609 |               **382.573 ± 1.323**  |
+|              Float |                    1327.409 ± 20.466  |                   1182.671 ± 35.221 |                         366.099 ± 2.272  |               **302.390 ± 0.241**  |
 
 ### Timing comparison of `try_array` vs. `map` option for a 50 element list to a numpy array
 
 | Input type         | np.array(try_float(iterable, map=True)) (ms) | try_array(iterable) (ms) | try_array(iterable, output) (ms) |
 | -----------------: | -------------------------------------------: | -----------------------: | -------------------------------: |
-|   Small Int String |                              669.868 ± 9.593 |          304.980 ± 0.741 |              **285.220 ± 0.557** |
-|         Int String |                              674.323 ± 4.091 |          330.338 ± 0.358 |              **298.028 ± 0.798** |
-|  Medium Int String |                              685.949 ± 0.935 |          333.569 ± 4.652 |              **310.673 ± 0.892** |
-|   Large Int String |                              904.234 ± 3.792 |          547.190 ± 1.287 |              **524.761 ± 2.040** |
-| Small Float String |                              680.257 ± 1.703 |          323.580 ± 0.320 |              **300.972 ± 0.751** |
-|       Float String |                              741.684 ± 1.625 |          389.589 ± 0.779 |              **372.897 ± 2.749** |
-| Large Float String |                              757.028 ± 1.343 |          419.839 ± 1.975 |              **399.813 ± 1.221** |
-|                Int |                              580.083 ± 9.274 |          343.343 ± 2.708 |              **321.165 ± 0.715** |
-|              Float |                              531.391 ± 3.817 |          285.648 ± 0.420 |              **266.901 ± 2.505** |
+|   Small Int String |                             662.536 ± 10.492 |          304.161 ± 3.486 |              **285.220 ± 8.227** |
+|         Int String |                             671.805 ± 3.570  |          320.196 ± 5.383 |              **297.441 ± 0.427** |
+|  Medium Int String |                             686.088 ± 7.358  |          326.836 ± 0.707 |              **306.003 ± 1.717** |
+|   Large Int String |                             901.139 ± 3.296  |          549.774 ± 1.708 |              **524.948 ± 0.696** |
+| Small Float String |                             676.264 ± 0.818  |          337.833 ± 9.456 |              **316.153 ± 7.326** |
+|       Float String |                             781.376 ± 8.174  |          432.953 ± 5.851 |              **421.327 ± 5.367** |
+| Large Float String |                             828.351 ± 6.087  |          457.716 ± 1.902 |              **434.577 ± 4.817** |
+|                Int |                             615.707 ± 0.547  |          367.986 ± 2.431 |              **341.711 ± 5.491** |
+|              Float |                             567.293 ± 2.903  |          305.593 ± 4.210 |              **281.619 ± 2.427** |
 
diff --git a/profiling/results-3.9.md b/profiling/results-3.9.md
index 8ac49f17..fbfad5cd 100644
--- a/profiling/results-3.9.md
+++ b/profiling/results-3.9.md
@@ -4,173 +4,187 @@ sys.version_info(major=3, minor=9, micro=16, releaselevel='final', serial=0)
 
 | Input type        | builtin (ms)       | fastnumbers (ms)   |
 | ----------------: | -----------------: | -----------------: |
-|  Small Int String |   13.651 ± 0.085   | **12.096 ± 0.071** |
-|        Int String |   14.843 ± 0.026   | **14.204 ± 1.386** |
-| Medium Int String |   16.822 ± 0.016   | **14.124 ± 0.142** |
-|  Large Int String | **22.708 ± 0.029** |   25.055 ± 0.085   |
-|               Int |  **7.133 ± 0.074** |    8.429 ± 0.007   |
-|             Float | **17.902 ± 2.227** |   20.670 ± 0.012   |
+|  Small Int String |   14.997 ± 0.434   | **14.018 ± 2.790** |
+|        Int String |   23.327 ± 7.867   | **13.616 ± 0.262** |
+| Medium Int String |   17.902 ± 0.398   | **14.068 ± 0.825** |
+|  Large Int String | **24.640 ± 2.254** |   25.575 ± 1.652   |
+|               Int |  **8.333 ± 1.625** |    9.363 ± 0.175   |
+|             Float | **19.303 ± 2.990** |   22.910 ± 1.930   |
 
 ### Timing comparison of `float` functions
 
-| Input type         | builtin (ms)      | fastnumbers (ms)   |
-| -----------------: | ----------------: | -----------------: |
-|   Small Int String |  12.815 ± 0.076   | **11.903 ± 1.975** |
-|         Int String |  13.385 ± 0.053   | **11.899 ± 0.011** |
-|  Medium Int String |  14.480 ± 0.026   | **12.181 ± 0.051** |
-|   Large Int String |  35.599 ± 0.023   | **16.551 ± 0.743** |
-| Small Float String |  13.284 ± 0.013   | **12.023 ± 0.007** |
-|       Float String |  31.907 ± 0.016   | **13.451 ± 0.008** |
-| Large Float String |  54.142 ± 0.018   | **13.630 ± 0.015** |
-|                Int | **8.531 ± 1.207** |    9.675 ± 0.027   |
-|              Float | **6.907 ± 0.078** |    8.644 ± 0.005   |
+| Input type         | builtin (ms)       | fastnumbers (ms)   |
+| -----------------: | -----------------: | -----------------: |
+|   Small Int String |   14.326 ± 2.367   | **13.208 ± 0.423** |
+|         Int String |   14.852 ± 1.044   | **14.455 ± 2.289** |
+|  Medium Int String |   16.340 ± 1.965   | **14.287 ± 1.063** |
+|   Large Int String |   38.373 ± 2.658   | **19.939 ± 0.690** |
+| Small Float String | **14.539 ± 1.334** |   15.580 ± 3.611   |
+|       Float String |   35.869 ± 4.851   | **15.618 ± 0.280** |
+| Large Float String |   56.531 ± 3.044   | **15.768 ± 0.032** |
+|                Int |  **8.973 ± 0.583** |   11.129 ± 0.696   |
+|              Float |  **8.123 ± 4.439** |    9.971 ± 0.492   |
 
 ### Timing comparison of `int` functions with error handling
 
 | Input type         | try/except (ms)    | regex (ms)     | fastnumbers (ms)   |
 | -----------------: | -----------------: | -------------: | -----------------: |
-|  Non-number String |  126.009 ± 0.431   | 25.614 ± 0.056 | **17.543 ± 0.043** |
-|   Small Int String |   19.780 ± 0.004   | 42.922 ± 0.022 | **17.076 ± 0.016** |
-|         Int String |   21.049 ± 0.004   | 47.311 ± 0.030 | **18.761 ± 0.024** |
-|  Medium Int String |   23.021 ± 0.011   | 55.490 ± 0.135 | **19.510 ± 1.162** |
-|   Large Int String | **29.094 ± 0.014** | 80.353 ± 5.790 |   29.707 ± 0.014   |
-| Small Float String |  123.322 ± 0.391   | 29.286 ± 0.054 | **17.542 ± 0.008** |
-|       Float String |  127.646 ± 0.299   | 35.279 ± 0.015 | **17.891 ± 0.005** |
-| Large Float String |  132.059 ± 0.799   | 35.299 ± 0.040 | **18.067 ± 0.020** |
-|                Int |   14.786 ± 0.413   | 67.254 ± 1.170 | **12.920 ± 0.005** |
-|              Float | **23.849 ± 0.038** | 77.373 ± 0.049 |   25.635 ± 0.044   |
+|  Non-number String |  135.188 ± 1.080   | 27.664 ± 0.038 | **22.554 ± 0.061** |
+|   Small Int String | **22.869 ± 0.386** | 45.568 ± 0.043 |   23.109 ± 1.645   |
+|         Int String |   25.552 ± 2.800   | 50.471 ± 0.322 | **24.084 ± 0.014** |
+|  Medium Int String | **25.681 ± 0.290** | 58.940 ± 0.387 |   26.209 ± 0.081   |
+|   Large Int String | **31.870 ± 0.385** | 79.735 ± 0.296 |   35.253 ± 0.028   |
+| Small Float String |  129.276 ± 1.550   | 31.566 ± 0.204 | **22.605 ± 0.036** |
+|       Float String |  134.571 ± 0.506   | 37.984 ± 0.021 | **22.955 ± 0.024** |
+| Large Float String |  142.807 ± 1.673   | 38.035 ± 0.134 | **23.006 ± 0.021** |
+|                Int | **14.107 ± 0.130** | 71.135 ± 1.558 |   19.149 ± 0.004   |
+|              Float | **26.562 ± 0.228** | 83.172 ± 3.429 |   32.680 ± 0.020   |
 
 ### Timing comparison of `float` functions with error handling
 
 | Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | -----------------: | --------------: | -----------------: |
-|  Non-number String |   68.998 ± 0.253   |  32.235 ± 0.011 | **19.949 ± 1.620** |
-|   Small Int String |   18.986 ± 0.013   |  54.193 ± 0.030 | **18.211 ± 0.022** |
-|         Int String |   19.629 ± 0.019   |  59.861 ± 0.977 | **18.367 ± 0.027** |
-|  Medium Int String |   20.711 ± 0.011   |  66.439 ± 1.065 | **18.907 ± 0.054** |
-|   Large Int String |   42.045 ± 0.001   | 101.767 ± 0.436 | **23.659 ± 0.010** |
-| Small Float String |   19.470 ± 0.019   |  53.765 ± 0.924 | **18.555 ± 0.019** |
-|       Float String |   38.186 ± 0.045   |  87.653 ± 0.185 | **20.180 ± 0.005** |
-| Large Float String |   60.694 ± 0.035   | 118.437 ± 2.072 | **20.507 ± 0.004** |
-|                Int | **14.184 ± 0.004** |  73.745 ± 0.291 |   15.477 ± 0.047   |
-|              Float | **12.524 ± 0.022** |  71.241 ± 0.406 |   14.158 ± 0.009   |
+|  Non-number String |   74.710 ± 1.160   |  34.759 ± 0.076 | **24.943 ± 0.132** |
+|   Small Int String | **22.437 ± 1.125** |  61.343 ± 0.345 |   24.479 ± 0.057   |
+|         Int String | **23.412 ± 0.878** |  64.373 ± 0.912 |   24.805 ± 0.043   |
+|  Medium Int String | **22.294 ± 0.788** |  73.289 ± 1.202 |   25.609 ± 0.178   |
+|   Large Int String |   44.904 ± 1.067   | 109.586 ± 0.671 | **29.928 ± 0.034** |
+| Small Float String | **21.213 ± 0.819** |  59.789 ± 0.232 |   25.000 ± 0.136   |
+|       Float String |   40.613 ± 0.968   |  94.837 ± 0.219 | **27.487 ± 1.760** |
+| Large Float String |   62.987 ± 0.666   | 124.797 ± 0.285 | **26.953 ± 0.025** |
+|                Int | **15.153 ± 0.003** |  78.140 ± 0.627 |   22.203 ± 0.059   |
+|              Float | **14.918 ± 0.460** |  74.202 ± 0.294 |   20.739 ± 0.043   |
 
 ### Timing comparison of `float` (but coerce to `int` if possible) functions with error handling
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
-| -----------------: | --------------: | --------------: | -----------------: |
-|  Non-number String |  69.734 ± 0.273 |  53.491 ± 0.095 | **19.540 ± 0.008** |
-|   Small Int String |  32.844 ± 0.018 |  45.488 ± 0.077 | **18.498 ± 0.012** |
-|         Int String |  36.396 ± 0.836 |  49.872 ± 0.104 | **20.663 ± 0.037** |
-|  Medium Int String |  39.235 ± 0.036 |  57.836 ± 0.010 | **20.914 ± 0.022** |
-|   Large Int String |  68.931 ± 0.051 |  78.406 ± 0.050 | **31.609 ± 0.011** |
-| Small Float String |  33.298 ± 0.024 |  80.968 ± 2.416 | **20.385 ± 0.036** |
-|       Float String |  67.372 ± 0.029 | 120.978 ± 1.209 | **28.178 ± 0.001** |
-| Large Float String | 123.328 ± 0.215 | 149.853 ± 0.113 | **43.697 ± 0.029** |
-|                Int |  31.375 ± 0.112 |  72.405 ± 0.095 | **14.414 ± 0.005** |
-|              Float |  50.145 ± 0.014 |  71.895 ± 1.946 | **26.130 ± 0.021** |
+| Input type         | try/except (ms) | regex (ms)       | fastnumbers (ms)   |
+| -----------------: | --------------: | ---------------: | -----------------: |
+|  Non-number String |  74.253 ± 1.112 |  59.159 ± 0.388  | **25.424 ± 0.024** |
+|   Small Int String |  35.815 ± 0.341 |  53.409 ± 10.710 | **24.777 ± 1.247** |
+|         Int String |  40.447 ± 0.064 |  53.884 ± 0.707  | **26.213 ± 0.198** |
+|  Medium Int String |  43.105 ± 0.299 |  61.849 ± 0.265  | **26.523 ± 0.070** |
+|   Large Int String |  80.090 ± 3.192 |  82.827 ± 0.204  | **37.790 ± 0.253** |
+| Small Float String |  36.760 ± 0.894 |  85.120 ± 0.619  | **26.820 ± 0.131** |
+|       Float String |  75.596 ± 0.701 | 124.704 ± 0.259  | **34.749 ± 0.084** |
+| Large Float String | 130.958 ± 0.822 | 154.539 ± 0.588  | **50.478 ± 0.205** |
+|                Int |  32.430 ± 0.086 |  76.971 ± 1.314  | **21.101 ± 0.095** |
+|              Float |  54.644 ± 3.767 |  75.466 ± 0.682  | **33.594 ± 0.060** |
 
 ### Timing comparison of forced `int` functions with error handling
 
 | Input type         | try/except (ms)    | regex (ms)      | fastnumbers (ms)   |
 | -----------------: | -----------------: | --------------: | -----------------: |
-|  Non-number String |  196.987 ± 0.806   |  46.711 ± 0.031 | **19.555 ± 0.241** |
-|   Small Int String |   19.820 ± 0.024   |  42.300 ± 0.080 | **18.143 ± 0.008** |
-|         Int String |   21.077 ± 0.021   |  47.798 ± 2.666 | **20.442 ± 0.027** |
-|  Medium Int String |   23.027 ± 0.008   |  87.631 ± 0.135 | **20.675 ± 0.023** |
-|   Large Int String | **29.314 ± 0.318** | 127.952 ± 0.569 |   31.516 ± 0.026   |
-| Small Float String |  149.795 ± 1.782   |  79.391 ± 0.055 | **19.103 ± 0.005** |
-|       Float String |  177.062 ± 1.835   | 127.381 ± 0.201 | **27.542 ± 0.009** |
-| Large Float String |  224.054 ± 5.254   | 172.661 ± 0.400 | **43.286 ± 0.031** |
-|                Int |   13.528 ± 0.665   |  67.966 ± 1.967 | **13.210 ± 0.005** |
-|              Float | **23.908 ± 0.035** |  77.514 ± 0.316 |   26.393 ± 0.361   |
+|  Non-number String |  205.174 ± 2.702   |  59.974 ± 0.942 | **26.201 ± 0.430** |
+|   Small Int String | **25.146 ± 0.048** |  52.203 ± 0.079 |   25.731 ± 0.064   |
+|         Int String | **27.995 ± 3.330** |  59.969 ± 0.830 |   29.174 ± 0.092   |
+|  Medium Int String |   29.871 ± 0.559   | 116.564 ± 1.557 | **28.495 ± 0.059** |
+|   Large Int String | **34.623 ± 0.605** | 164.539 ± 0.814 |   44.977 ± 5.870   |
+| Small Float String |  174.006 ± 0.952   | 104.031 ± 0.909 | **28.136 ± 0.018** |
+|       Float String |  214.486 ± 1.186   | 159.277 ± 2.497 | **36.639 ± 0.659** |
+| Large Float String |  274.092 ± 15.225  | 214.138 ± 3.989 | **55.283 ± 1.041** |
+|                Int | **17.252 ± 1.366** |  79.299 ± 1.623 |   21.354 ± 0.122   |
+|              Float | **28.138 ± 0.778** |  91.926 ± 1.646 |   35.835 ± 0.555   |
+
+### Timing comparison of forced `int` functions with error handling and denoising
+
+| Input type         | Python (ms)        | fastnumbers (ms)    |
+| -----------------: | -----------------: | ------------------: |
+|   Small Int String |  139.155 ± 2.891   |  **42.096 ± 0.895** |
+|         Int String |  141.688 ± 3.845   |  **43.934 ± 0.110** |
+|  Medium Int String |  151.455 ± 7.514   |  **47.526 ± 0.937** |
+|   Large Int String |  175.798 ± 4.186   |  **55.993 ± 0.167** |
+| Small Float String |  218.123 ± 4.170   |  **43.292 ± 0.012** |
+|       Float String |  243.042 ± 1.174   | **105.386 ± 2.502** |
+| Large Float String |  708.739 ± 15.768  | **167.589 ± 1.997** |
+|                Int | **20.989 ± 0.017** |    34.775 ± 0.017   |
+|              Float | **51.168 ± 0.327** |   211.781 ± 10.027  |
 
 ### Timing comparison to check if value can be converted to `int`
 
-| Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
-| -----------------: | --------------: | -------------: | -----------------: |
-|  Non-number String | 128.908 ± 0.552 | 48.048 ± 0.030 |  **8.631 ± 0.030** |
-|   Small Int String |  28.196 ± 0.022 | 51.870 ± 1.496 |  **8.626 ± 0.054** |
-|         Int String |  29.615 ± 0.036 | 54.196 ± 0.124 |  **9.114 ± 0.038** |
-|  Medium Int String |  31.683 ± 0.065 | 63.347 ± 6.558 |  **8.881 ± 0.061** |
-|   Large Int String |  37.662 ± 0.038 | 75.245 ± 0.387 |  **8.867 ± 0.039** |
-| Small Float String | 123.335 ± 0.168 | 52.297 ± 0.057 |  **9.627 ± 0.027** |
-|       Float String | 126.901 ± 1.670 | 59.041 ± 0.051 | **10.090 ± 0.062** |
-| Large Float String | 132.962 ± 0.483 | 59.004 ± 0.057 | **10.122 ± 0.061** |
-|                Int |  23.189 ± 0.538 | 21.078 ± 0.013 |  **7.802 ± 0.073** |
-|              Float |  32.174 ± 0.043 | 19.883 ± 0.010 |  **7.838 ± 0.021** |
+| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)   |
+| -----------------: | --------------: | --------------: | -----------------: |
+|  Non-number String | 162.500 ± 0.821 | 57.524 ± 0.579  | **13.200 ± 0.072** |
+|   Small Int String |  33.044 ± 0.659 | 58.430 ± 0.208  | **13.127 ± 0.010** |
+|         Int String |  34.497 ± 0.446 | 62.851 ± 0.536  | **13.696 ± 0.218** |
+|  Medium Int String |  36.946 ± 0.507 | 71.509 ± 0.918  | **13.851 ± 0.303** |
+|   Large Int String |  44.025 ± 0.839 | 91.023 ± 1.234  | **14.071 ± 0.012** |
+| Small Float String | 149.048 ± 2.551 | 67.669 ± 17.644 | **14.341 ± 0.006** |
+|       Float String | 152.656 ± 0.528 | 67.468 ± 0.081  | **15.579 ± 0.007** |
+| Large Float String | 159.648 ± 2.064 | 67.402 ± 0.060  | **15.758 ± 0.313** |
+|                Int |  25.753 ± 0.673 | 23.614 ± 0.004  | **10.742 ± 0.079** |
+|              Float |  35.217 ± 0.038 | 21.387 ± 0.306  | **11.540 ± 0.009** |
 
 ### Timing comparison to check if value can be converted to `float`
 
 | Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
 | -----------------: | --------------: | -------------: | -----------------: |
-|  Non-number String |  69.403 ± 0.134 | 49.434 ± 0.032 |  **9.530 ± 0.051** |
-|   Small Int String |  27.630 ± 0.093 | 59.614 ± 4.516 |  **9.774 ± 0.008** |
-|         Int String |  28.230 ± 0.010 | 60.785 ± 0.192 | **10.077 ± 0.046** |
-|  Medium Int String |  29.301 ± 0.012 | 67.274 ± 1.192 |  **9.946 ± 0.060** |
-|   Large Int String |  51.439 ± 0.024 | 81.431 ± 0.546 |  **9.815 ± 0.037** |
-| Small Float String |  28.064 ± 0.036 | 56.580 ± 0.800 | **10.745 ± 0.006** |
-|       Float String |  47.782 ± 0.059 | 71.743 ± 0.235 | **11.216 ± 0.009** |
-| Large Float String |  70.765 ± 0.046 | 78.677 ± 0.679 | **11.271 ± 0.040** |
-|                Int |  22.693 ± 0.040 | 21.452 ± 0.034 |  **8.601 ± 0.056** |
-|              Float |  21.013 ± 0.004 | 19.464 ± 0.011 |  **8.598 ± 0.054** |
+|  Non-number String | 87.321 ± 2.868  | 62.996 ± 0.336 | **14.846 ± 0.210** |
+|   Small Int String | 32.417 ± 0.414  | 70.644 ± 1.597 | **14.537 ± 0.017** |
+|         Int String | 40.054 ± 10.624 | 76.115 ± 4.201 | **14.928 ± 0.136** |
+|  Medium Int String | 36.179 ± 0.918  | 84.745 ± 0.449 | **15.198 ± 0.137** |
+|   Large Int String | 60.911 ± 1.412  | 99.820 ± 1.930 | **15.142 ± 0.143** |
+| Small Float String | 32.841 ± 0.914  | 67.629 ± 0.009 | **15.445 ± 0.007** |
+|       Float String | 55.696 ± 0.476  | 85.962 ± 0.192 | **16.495 ± 0.248** |
+| Large Float String | 79.934 ± 0.996  | 93.587 ± 0.189 | **16.298 ± 0.132** |
+|                Int | 24.863 ± 0.576  | 23.510 ± 0.004 | **12.225 ± 0.211** |
+|              Float | 23.384 ± 0.034  | 22.305 ± 0.012 | **12.422 ± 0.220** |
 
 ### Timing comparison to check if value can be converted to `float` or `int`
 
 | Input type         | try/except (ms) | regex (ms)     | fastnumbers (ms)   |
 | -----------------: | --------------: | -------------: | -----------------: |
-|  Non-number String |  68.918 ± 0.247 | 48.873 ± 0.043 | **10.648 ± 1.483** |
-|   Small Int String |  19.561 ± 0.007 | 57.183 ± 0.575 |  **9.628 ± 0.017** |
-|         Int String |  20.226 ± 0.006 | 60.038 ± 0.081 |  **9.945 ± 0.022** |
-|  Medium Int String |  21.385 ± 0.301 | 66.465 ± 0.304 |  **9.951 ± 0.009** |
-|   Large Int String |  42.546 ± 0.032 | 80.959 ± 0.218 |  **9.905 ± 0.010** |
-| Small Float String |  20.028 ± 0.006 | 56.251 ± 0.398 | **10.544 ± 0.017** |
-|       Float String |  38.777 ± 0.026 | 71.665 ± 0.346 | **11.023 ± 0.015** |
-| Large Float String |  61.381 ± 0.030 | 78.195 ± 0.293 | **11.113 ± 0.019** |
-|                Int |  14.782 ± 0.040 | 19.006 ± 0.003 |  **8.421 ± 0.059** |
-|              Float |  13.138 ± 0.008 | 17.258 ± 0.003 |  **8.607 ± 0.020** |
+|  Non-number String |  85.659 ± 1.103 | 63.752 ± 2.247 | **15.080 ± 0.394** |
+|   Small Int String |  29.747 ± 3.240 | 74.806 ± 2.443 | **14.324 ± 0.208** |
+|         Int String |  28.252 ± 0.750 | 75.374 ± 3.088 | **15.513 ± 0.270** |
+|  Medium Int String |  32.280 ± 1.265 | 89.925 ± 1.655 | **15.933 ± 0.595** |
+|   Large Int String |  56.354 ± 1.231 | 97.999 ± 2.261 | **14.459 ± 0.010** |
+| Small Float String |  25.361 ± 1.221 | 69.460 ± 0.793 | **15.189 ± 0.007** |
+|       Float String |  47.095 ± 1.031 | 85.079 ± 0.238 | **16.165 ± 0.275** |
+| Large Float String |  69.972 ± 0.692 | 96.825 ± 7.692 | **16.563 ± 0.009** |
+|                Int |  19.474 ± 1.661 | 22.666 ± 0.006 | **12.168 ± 0.015** |
+|              Float |  16.010 ± 0.036 | 20.284 ± 0.349 | **11.919 ± 0.006** |
 
 ### Timing comparison to check if value can be coerced losslessly to `int`
 
-| Input type         | try/except (ms) | regex (ms)      | fastnumbers (ms)  |
-| -----------------: | --------------: | --------------: | ----------------: |
-|  Non-number String | 198.279 ± 6.454 |  48.916 ± 0.901 | **8.388 ± 0.033** |
-|   Small Int String |  38.142 ± 0.253 |  30.698 ± 0.006 | **8.379 ± 0.036** |
-|         Int String |  39.885 ± 0.046 |  33.671 ± 0.188 | **8.716 ± 0.010** |
-|  Medium Int String |  45.130 ± 0.059 |  39.734 ± 0.010 | **8.741 ± 0.175** |
-|   Large Int String |  78.477 ± 0.066 |  54.226 ± 0.161 | **8.587 ± 0.049** |
-| Small Float String | 148.144 ± 0.570 |  79.382 ± 0.873 | **9.452 ± 0.030** |
-|       Float String | 169.624 ± 1.015 | 124.210 ± 0.528 | **9.931 ± 0.003** |
-| Large Float String | 199.449 ± 0.721 | 151.911 ± 0.528 | **9.851 ± 0.029** |
-|                Int |  26.589 ± 0.031 |  68.913 ± 0.250 | **7.507 ± 0.065** |
-|              Float |  50.307 ± 2.006 | 100.357 ± 0.183 | **7.571 ± 0.021** |
+| Input type         | try/except (ms) | regex (ms)       | fastnumbers (ms)   |
+| -----------------: | --------------: | ---------------: | -----------------: |
+|  Non-number String | 239.708 ± 4.075 |  57.467 ± 0.773  | **13.042 ± 0.118** |
+|   Small Int String |  47.358 ± 0.232 |  37.252 ± 0.034  | **12.965 ± 0.008** |
+|         Int String |  55.595 ± 0.899 |  44.371 ± 0.778  | **14.021 ± 0.532** |
+|  Medium Int String |  59.703 ± 0.556 |  50.370 ± 1.636  | **13.294 ± 0.024** |
+|   Large Int String |  98.855 ± 1.340 |  63.297 ± 0.862  | **12.973 ± 0.024** |
+| Small Float String | 174.138 ± 2.861 |  95.834 ± 1.925  | **13.682 ± 0.014** |
+|       Float String | 202.825 ± 8.634 | 146.522 ± 2.990  | **15.325 ± 0.058** |
+| Large Float String | 234.110 ± 3.789 | 174.578 ± 3.566  | **15.499 ± 0.129** |
+|                Int |  37.158 ± 4.050 |  96.383 ± 18.034 | **13.116 ± 0.276** |
+|              Float |  65.431 ± 1.585 | 120.151 ± 2.707  | **11.280 ± 0.003** |
 
 ### Timing comparison of `map` option vs. iterating over `try_float` for a 50 element list
 
 | Input type         | [try_float(x) for x in iterable] (ms) | list(map(try_float, iterable)) (ms) | list(try_float(iterable, map=True)) (ms) | try_float(iterable, map=list) (ms) |
 | -----------------: | ------------------------------------: | ----------------------------------: | ---------------------------------------: | ---------------------------------: |
-|  Non-number String |                     1104.571 ± 16.457 |                   1002.597 ± 5.727  |                         585.278 ± 4.643  |                **520.386 ± 0.160** |
-|   Small Int String |                     1086.198 ± 26.903 |                    995.410 ± 9.925  |                         561.398 ± 10.919 |                **487.255 ± 2.562** |
-|         Int String |                     1135.490 ± 3.069  |                    986.150 ± 32.913 |                         547.204 ± 1.484  |                **481.627 ± 0.883** |
-|  Medium Int String |                     1097.460 ± 1.757  |                    963.461 ± 3.886  |                         563.170 ± 2.397  |                **496.681 ± 0.218** |
-|   Large Int String |                     1316.222 ± 2.073  |                   1210.110 ± 3.853  |                         770.220 ± 0.408  |                **704.117 ± 0.188** |
-| Small Float String |                     1074.648 ± 2.644  |                    948.521 ± 1.234  |                         571.533 ± 19.551 |                **502.232 ± 8.625** |
-|       Float String |                     1178.499 ± 14.269 |                   1075.171 ± 16.929 |                         620.742 ± 0.913  |                **554.279 ± 3.023** |
-| Large Float String |                     1164.468 ± 7.034  |                   1060.608 ± 3.636  |                         634.728 ± 2.736  |                **561.333 ± 0.805** |
-|                Int |                      888.412 ± 3.736  |                    788.176 ± 4.545  |                         427.349 ± 0.934  |                **364.555 ± 0.424** |
-|              Float |                      808.959 ± 7.812  |                    727.894 ± 8.191  |                         380.114 ± 1.456  |                **320.260 ± 2.669** |
+|  Non-number String |                   1544.535 ± 33.270   |                  1718.628 ± 336.746 |                        709.207 ± 74.856  |              **588.775 ± 74.396**  |
+|   Small Int String |                   1864.281 ± 260.557  |                  1391.718 ± 22.098  |                        569.029 ± 12.391  |              **551.698 ± 20.607**  |
+|         Int String |                   2006.434 ± 628.710  |                  1429.793 ± 72.702  |                        858.732 ± 199.618 |              **750.096 ± 130.048** |
+|  Medium Int String |                   1604.968 ± 14.954   |                  1741.884 ± 408.565 |                        952.376 ± 312.120 |              **660.700 ± 133.739** |
+|   Large Int String |                   2634.942 ± 1011.794 |                  2769.373 ± 610.573 |                       1496.633 ± 337.482 |             **1185.537 ± 157.885** |
+| Small Float String |                   2075.113 ± 161.513  |                  1800.332 ± 251.616 |                        692.011 ± 78.144  |              **538.998 ± 31.837**  |
+|       Float String |                   2065.716 ± 367.832  |                  1735.385 ± 113.789 |                        731.085 ± 78.617  |              **702.787 ± 149.784** |
+| Large Float String |                   1943.154 ± 105.208  |                  1725.349 ± 277.956 |                        686.610 ± 22.227  |              **598.690 ± 17.655**  |
+|                Int |                   1262.734 ± 43.827   |                  1144.253 ± 9.204   |                        409.536 ± 0.862   |              **351.136 ± 2.926**   |
+|              Float |                   1200.244 ± 57.008   |                  1080.316 ± 8.646   |                        356.837 ± 1.087   |              **311.554 ± 11.670**  |
 
 ### Timing comparison of `try_array` vs. `map` option for a 50 element list to a numpy array
 
 | Input type         | np.array(try_float(iterable, map=True)) (ms) | try_array(iterable) (ms) | try_array(iterable, output) (ms) |
 | -----------------: | -------------------------------------------: | -----------------------: | -------------------------------: |
-|   Small Int String |                             668.469 ± 0.452  |          307.021 ± 0.185 |              **288.770 ± 1.198** |
-|         Int String |                             686.129 ± 1.987  |          319.070 ± 1.445 |              **300.221 ± 0.173** |
-|  Medium Int String |                             700.306 ± 2.198  |          336.307 ± 4.616 |              **334.856 ± 3.052** |
-|   Large Int String |                             942.309 ± 11.606 |          562.068 ± 3.776 |              **536.699 ± 3.825** |
-| Small Float String |                             717.590 ± 5.627  |          342.301 ± 8.862 |              **327.554 ± 2.291** |
-|       Float String |                             784.617 ± 3.725  |          423.661 ± 2.002 |              **396.020 ± 1.143** |
-| Large Float String |                             806.635 ± 8.079  |          432.954 ± 3.492 |              **414.813 ± 1.535** |
-|                Int |                             596.151 ± 7.083  |          355.799 ± 0.973 |              **340.084 ± 4.310** |
-|              Float |                             545.639 ± 4.140  |          286.138 ± 5.404 |              **264.487 ± 2.991** |
+|   Small Int String |                            739.682 ± 137.044 |       390.639 ± 43.090   |            **358.663 ± 24.093**  |
+|         Int String |                            743.279 ± 10.494  |       370.635 ± 10.382   |            **350.745 ± 3.081**   |
+|  Medium Int String |                            772.731 ± 22.109  |       382.183 ± 5.391    |            **362.129 ± 4.341**   |
+|   Large Int String |                           1008.874 ± 15.525  |       632.274 ± 18.978   |            **605.948 ± 3.563**   |
+| Small Float String |                            770.579 ± 28.231  |       368.148 ± 1.745    |            **350.156 ± 7.886**   |
+|       Float String |                            833.215 ± 23.822  |       628.725 ± 140.157  |            **586.456 ± 115.026** |
+| Large Float String |                            860.126 ± 22.166  |       684.593 ± 80.410   |            **511.977 ± 94.349**  |
+|                Int |                            633.647 ± 2.328   |     **443.879 ± 24.318** |              651.288 ± 124.036   |
+|              Float |                            841.120 ± 273.540 |     **331.534 ± 6.559**  |              515.037 ± 62.076    |
 
diff --git a/src/cpp/c_str_parsing.cpp b/src/cpp/c_str_parsing.cpp
index 726f02b0..72b1a235 100644
--- a/src/cpp/c_str_parsing.cpp
+++ b/src/cpp/c_str_parsing.cpp
@@ -16,16 +16,19 @@
 /* EXPOSED FUNCTIONS */
 /*********************/
 
-int string_contains_what(const char* str, const char* end, int base) noexcept
+StringChecker::StringChecker(const char* str, const char* end, int base) noexcept
+    : m_integer_start(nullptr)
+    , m_decimal_start(nullptr)
+    , m_decimal_end(nullptr)
+    , m_total_end(nullptr)
+    , m_expon(0U)
+    , m_exp_negative(false)
+    , m_int_trailing_zeros(0U)
+    , m_dec_trailing_zeros(0U)
+    , m_contained_type(StringType::INVALID)
 {
     const std::size_t len = static_cast<std::size_t>(end - str);
 
-    // Define possible return values
-    static constexpr int INVALID = 0;
-    static constexpr int INTEGER = 1;
-    static constexpr int FLOAT = 2;
-    static constexpr int INTLIKE_FLOAT = 3;
-
     // If the base needs to be guessed, do so now and get it over with.
     if (base == 0) {
         base = detect_base(str, end);
@@ -33,7 +36,11 @@ int string_contains_what(const char* str, const char* end, int base) noexcept
 
     // Negative bases are illegal. So is zero length.
     if (base < 0 || len == 0) {
-        return INVALID;
+        set_integer_start(str);
+        set_decimal_start(str);
+        set_decimal_end(str);
+        set_total_end(str);
+        return;
     }
 
     // Special-case non-base 10.
@@ -44,26 +51,32 @@ int string_contains_what(const char* str, const char* end, int base) noexcept
         }
 
         // The rest behaves as normal.
-        const char* digit_start = str;
+        set_integer_start(str);
         while (str != end && is_valid_digit(*str, base)) {
             str += 1;
         }
-        return (str == end && str != digit_start) ? INTEGER : INVALID;
+        set_decimal_start(str);
+        set_decimal_end(str);
+        set_total_end(str);
+        set_type(
+            (str == end && str != integer_start()) ? StringType::INTEGER
+                                                   : StringType::INVALID
+        );
+        return;
     }
 
     // Before decimal. Keep track of the start location.
     bool valid = false;
-    int value = INVALID;
-    const char* int_start = str;
+    set_integer_start(str);
     consume_digits(str, len);
-    if (str != int_start) {
+    if (str != integer_start()) {
         valid = true;
-        value = INTEGER;
+        set_type(StringType::INTEGER);
     }
 
     // Decimal part of float. Keep track of number of digits read
     // as well as beginning and end locations.
-    const char* decimal_start = str;
+    set_decimal_start(str);
     uint32_t dec_length = 0;
     if (str != end && *str == '.') {
         str += 1;
@@ -72,16 +85,14 @@ int string_contains_what(const char* str, const char* end, int base) noexcept
         dec_length = static_cast<uint32_t>(str - dec_digits_start);
         valid = valid || dec_length > 0;
     }
-    const char* decimal_end = str;
+    set_decimal_end(str);
 
     // If there are any decimal components then we are looking at a float.
-    if (valid && decimal_end != decimal_start) {
-        value = FLOAT;
+    if (valid && has_decimal_data()) {
+        set_type(StringType::FLOAT);
     }
 
     // Exponential part of float. Parse the magnitude.
-    uint32_t expon = 0;
-    bool exp_negative = false;
     if (valid) {
         const char* exp_start = str;
         if (str != end && (*str == 'e' || *str == 'E')) {
@@ -89,7 +100,7 @@ int string_contains_what(const char* str, const char* end, int base) noexcept
             // Skip the 'e' and any sign that might be present.
             str += 1;
             if (str != end && is_sign(*str)) {
-                exp_negative = *str == '-';
+                set_exponent_negative(*str == '-');
                 str += 1;
             }
 
@@ -97,7 +108,7 @@ int string_contains_what(const char* str, const char* end, int base) noexcept
             const char* exp_digit_start = str;
             int32_t this_char_as_digit = 0L;
             while (str != end && (this_char_as_digit = to_digit<int32_t>(*str)) >= 0) {
-                expon = expon * 10L + this_char_as_digit;
+                set_exponent(exponent_value() * 10UL + this_char_as_digit);
                 str += 1;
             }
 
@@ -108,36 +119,33 @@ int string_contains_what(const char* str, const char* end, int base) noexcept
 
         // If we found an exponent AND it was parsed validly then this is a float.
         if (exp_end != exp_start && valid) {
-            value = FLOAT;
+            set_type(StringType::FLOAT);
         }
     }
+    set_total_end(str);
 
     // If the parsing was not valid or we are not at the end of the string
     // then the string is invalid.
     // Othewise, do a check to see if it is an *intlike* float.
     if (!valid || str != end) {
-        return INVALID;
-    } else if (value == FLOAT) {
+        set_type(StringType::INVALID);
+    } else if (is_float()) {
         // If we "move the decimal place" left or right depending on
         // exponent sign and magnitude, all digits after the decimal
         // must be zero.
-        const unsigned int_trailing_zeros
-            = number_trailing_zeros(int_start, decimal_start);
-        const unsigned dec_trailing_zeros = decimal_start == decimal_end
-            ? 0U
-            : number_trailing_zeros(decimal_start + 1, decimal_end);
-
-        if (exp_negative) {
-            if (expon <= int_trailing_zeros && dec_length == dec_trailing_zeros) {
-                value = INTLIKE_FLOAT;
+        set_int_trailing_zeros(number_trailing_zeros(integer_start(), integer_end()));
+        set_dec_trailing_zeros(number_trailing_zeros(decimal_start(), decimal_end()));
+        const uint32_t expval = exponent_value();
+        if (is_exponent_negative()) {
+            if (expval <= integer_trailing_zeros() && truncated_decimal_length() == 0) {
+                set_type(StringType::INTLIKE_FLOAT);
             }
         } else {
-            if (expon >= (dec_length - dec_trailing_zeros)) {
-                value = INTLIKE_FLOAT;
+            if (expval >= truncated_decimal_length()) {
+                set_type(StringType::INTLIKE_FLOAT);
             }
         }
     }
-    return value;
 }
 
 void remove_valid_underscores(char* str, const char*& end, const bool based) noexcept
diff --git a/src/cpp/fastnumbers.cpp b/src/cpp/fastnumbers.cpp
index 7696848a..eb960cbf 100644
--- a/src/cpp/fastnumbers.cpp
+++ b/src/cpp/fastnumbers.cpp
@@ -157,6 +157,7 @@ static PyObject* fastnumbers_try_real(
     PyObject* on_fail = Selectors::INPUT;
     PyObject* on_type_error = Selectors::RAISE;
     bool coerce = true;
+    bool denoise = false;
     bool allow_underscores = false;
     PyObject* map = Py_False;
 
@@ -172,6 +173,7 @@ static PyObject* fastnumbers_try_real(
                            "$coerce", true, &coerce,
                            "$allow_underscores", true, &allow_underscores,
                            "$map", false, &map,
+                           "$denoise", true, &denoise,
                            nullptr, false, nullptr
         )) return nullptr;
     // clang-format on
@@ -186,6 +188,7 @@ static PyObject* fastnumbers_try_real(
         impl.set_inf_action(inf);
         impl.set_nan_action(nan);
         impl.set_coerce(coerce);
+        impl.set_denoise(denoise);
         impl.set_underscores_allowed(allow_underscores);
         auto convert = [impl = std::move(impl)](PyObject* x) -> PyObject* {
             return impl.convert(x);
@@ -296,6 +299,7 @@ static PyObject* fastnumbers_try_forceint(
     PyObject* on_fail = Selectors::INPUT;
     PyObject* on_type_error = Selectors::RAISE;
     bool allow_underscores = false;
+    bool denoise = false;
     PyObject* map = Py_False;
 
     // Read the function arguments
@@ -307,6 +311,7 @@ static PyObject* fastnumbers_try_forceint(
                            "$on_type_error", false, &on_type_error,
                            "$allow_underscores", true, &allow_underscores,
                            "$map", false, &map,
+                           "$denoise", true, &denoise,
                            nullptr, false, nullptr
         )) return nullptr;
     // clang-format on
@@ -318,6 +323,7 @@ static PyObject* fastnumbers_try_forceint(
         Implementation impl(UserType::FORCEINT);
         impl.set_fail_action(on_fail);
         impl.set_type_error_action(on_type_error);
+        impl.set_denoise(denoise);
         impl.set_underscores_allowed(allow_underscores);
         auto convert = [impl = std::move(impl)](PyObject* x) -> PyObject* {
             return impl.convert(x);
@@ -643,6 +649,7 @@ static PyObject* fastnumbers_real(
 {
     PyObject* input = nullptr;
     bool coerce = true;
+    bool denoise = false;
 
     // Read the function arguments
     FN_PREPARE_ARGPARSER;
@@ -650,6 +657,7 @@ static PyObject* fastnumbers_real(
     if (fn_parse_arguments("real", args, len_args, kwnames,
                            "|", false,  &input,
                            "$coerce", true, &coerce,
+                           "$denoise", true, &denoise,
                            nullptr, false, nullptr
         )) return nullptr;
     // clang-format on
@@ -663,6 +671,7 @@ static PyObject* fastnumbers_real(
     return ExceptionHandler(input).run([&]() -> PyObject* {
         Implementation impl(UserType::REAL);
         impl.set_coerce(coerce);
+        impl.set_denoise(denoise);
         impl.set_unicode_allowed(false);
         impl.set_underscores_allowed(true);
         return impl.convert(input);
diff --git a/src/cpp/parser.cpp b/src/cpp/parser.cpp
index e76fdce3..5c703764 100644
--- a/src/cpp/parser.cpp
+++ b/src/cpp/parser.cpp
@@ -1,3 +1,4 @@
+#include <cmath>
 #include <cstdint>
 #include <limits>
 #include <type_traits>
@@ -12,8 +13,263 @@
 #include "fastnumbers/parser/numeric.hpp"
 #include "fastnumbers/parser/unicode.hpp"
 #include "fastnumbers/payload.hpp"
+#include "fastnumbers/third_party/ipow.hpp"
 #include "fastnumbers/user_options.hpp"
 
+// C++ version of https://docs.python.org/3/library/math.html#math.ulp
+static double ulp(const double x)
+{
+    // Assumes positive input
+    return std::nexttoward(x, std::numeric_limits<double>::infinity()) - x;
+}
+
+// Parse a sequence of characters as a Python long
+static PyObject* parse_long_helper(
+    const char* start,
+    const char* end,
+    const std::size_t length,
+    const std::size_t length_to_end
+)
+{
+    // We know by construction that this correctly stores a number, so we skip
+    // the error checking.
+    if (length < overflow_cutoff<uint64_t>()) {
+        bool error = false;
+        bool overflow = false;
+        return pyobject_from_int(
+            length ? parse_int<uint64_t>(start, end, 10, error, overflow) : 0ULL
+        );
+    } else {
+        // This Python parse won't let us specify the end of the string, and it errors
+        // out on non-numeric characters, so we have to copy our data to a buffer
+        // and set the exponent character to '\0' so that Python can parse it.
+        Buffer buffer(start, length_to_end);
+        buffer.mark_integer_end();
+        return PyLong_FromString(buffer.start(), nullptr, 10);
+    }
+}
+
+// Convert a value into a power of ten Python long in the most efficient method
+// depending on the value of the exponent.
+static PyObject* exponent_creation_helper(const uint32_t exp_val)
+{
+    if (exp_val < overflow_cutoff<uint64_t>()) {
+        return pyobject_from_int(ipow::ipow(10ULL, exp_val));
+    } else {
+        PyObject* py_expon = pyobject_from_int(10);
+        PyObject* py_exp_component = pyobject_from_int(exp_val);
+        in_place_pow(py_expon, py_exp_component);
+        Py_DECREF(py_exp_component);
+        return py_expon;
+    }
+}
+
+// Convert a PyObject to a negative number if needed.
+static PyObject* do_negative(PyObject* obj, const bool negative)
+{
+    if (negative) {
+        PyObject* temp = obj;
+        obj = PyNumber_Negative(temp);
+        Py_DECREF(temp);
+    }
+    return obj;
+}
+
+PyObject* Parser::float_as_int_without_noise(PyObject* obj) noexcept
+{
+    const double val = PyFloat_AsDouble(obj);
+    if (val == -1.0 && PyErr_Occurred()) {
+        return nullptr;
+    }
+
+    // To begin, get the absolute value of the input as a C++ double.
+    // Also store the input as a Python int to use as the basis for calculation.
+    const double abs_val = std::abs(val);
+    PyObject* val_int = PyLong_FromDouble(val);
+    if (val_int == nullptr) {
+        return nullptr;
+    }
+
+    // If the given float can fit a C long without loss then no need
+    // to go through the below rounding steps.
+    const double floor_val = std::floor(val);
+    if (floor_val == static_cast<long>(floor_val)) {
+        return val_int;
+    }
+
+    // Determine the number of digits that are "noise". Do this by using ULP to
+    // get the number that closest represents the noise inherint from the
+    // floating point representation, then using log10 to find the number of
+    // digits this represents.
+    // Note that the largest exponent component of a double is around 308, so
+    // we can be confident that this value will fit in an int.
+    // There is special case hanlding for if the abs_val is the next lowest value
+    // from infinity, in which case double_digits would be returned as infinity...
+    // in that case, we return 293, which is known to be the correct result for
+    // that number.
+    const double double_digits = std::ceil(std::log10(ulp(abs_val)));
+    constexpr int MAX_DIGITS = 293;
+    const int digits
+        = std::isfinite(double_digits) ? static_cast<int>(double_digits) : MAX_DIGITS;
+
+    // If the number of digits is less than 1 (e.g. the float is already noiselessly
+    // converted to an integer) just return the integer directly.
+    // Because of the floor check above, it is unlikely this will ever be true, but
+    // include it for completeness' sake.
+    if (digits < 1) {
+        return val_int;
+    }
+
+    // Use Python's built-in round to round the number to the desired number of
+    // digits. A negative input rounds to the left of the decimal place.
+    PyObject* retval = PyObject_CallMethod(val_int, "__round__", "i", -digits);
+
+    // Free the int value, and then return the rounded number.
+    Py_DecRef(val_int);
+    return retval;
+}
+
+PyObject* Parser::float_as_int_without_noise(
+    const StringChecker& checker, const bool is_negative
+) noexcept
+{
+    PyObject* py_integer = nullptr;
+
+    // As a special case, if the number of digits in the integer and decimal
+    // parts of the float are small enough that we know it could fit into a unsigned
+    // 64-bit integer, parse using C++ methods in the name of efficiency.
+    if (checker.digit_length() < overflow_cutoff<uint64_t>()) {
+        bool error = false;
+        bool overflow = false;
+        uint64_t integer = 0;
+
+        // First parse the integer component (if there is anything to parse).
+        if (checker.integer_length()) {
+            integer = parse_int<uint64_t>(
+                checker.integer_start(), checker.integer_end(), 10, error, overflow
+            );
+        }
+
+        // Next, parse the decimal component (if there is anything to parse) and
+        // then combine with the existing integer component to get a single integer.
+        if (checker.truncated_decimal_length()) {
+            uint64_t decimal = parse_int<uint64_t>(
+                checker.decimal_start(), checker.decimal_end(), 10, error, overflow
+            );
+            // We "remove" trailing zeros from the decimal component by dividing by
+            // the power of ten that corresponds to the number of trailing zeros.
+            if (checker.decimal_trailing_zeros()) {
+                decimal /= ipow::ipow(10ULL, checker.decimal_trailing_zeros());
+            }
+            // Add powers of 10 to the integer that correspond to the number of
+            // decimal digits parser (minus trailing zeros) so that when the decimal
+            // comppnent is added it results in a integer with all digits represented.
+            integer *= ipow::ipow(10ULL, checker.truncated_decimal_length());
+            integer += decimal;
+        }
+
+        // Convert this integer into a Python long object.
+        py_integer = pyobject_from_int(integer);
+    }
+
+    // Otherwise, if there are too manu digits to store in a C++ integer type, we
+    // need to use Python's arithmatic so we can take advantage of the arbitrarily
+    // long integer type.
+    else {
+        // First parse the integer components of the floating point number.
+        py_integer = parse_long_helper(
+            checker.integer_start(),
+            checker.integer_end(),
+            checker.integer_length(),
+            checker.total_length()
+        );
+        if (py_integer == nullptr) {
+            return py_integer;
+        }
+
+        // We then parse the decimal components if they exist, adding the values to
+        // the integer using the exact same algorithm as the C++ method above... it's
+        // just that this has to use a bunch more error checking and reference counting.
+        if (checker.truncated_decimal_length()) {
+            // Parse the decimal component...
+            PyObject* py_decimal = parse_long_helper(
+                checker.decimal_start(),
+                checker.decimal_end(),
+                checker.decimal_length(),
+                checker.decimal_and_exponent_length()
+            );
+            if (py_decimal == nullptr) {
+                return py_decimal;
+            }
+
+            // ... and then "remove" trailing zeros if they exist...
+            if (checker.decimal_trailing_zeros()) {
+                PyObject* divisor
+                    = exponent_creation_helper(checker.decimal_trailing_zeros());
+                if (divisor == nullptr) {
+                    return divisor;
+                }
+
+                in_place_divide(py_decimal, divisor);
+                Py_DECREF(divisor);
+                if (py_decimal == nullptr) {
+                    return py_decimal;
+                }
+            }
+
+            // ... and then "shift" the integer py powers of ten so we can
+            //     add in the decimal component...
+            {
+                PyObject* offset
+                    = exponent_creation_helper(checker.truncated_decimal_length());
+                if (offset == nullptr) {
+                    Py_DECREF(py_integer);
+                    return offset;
+                }
+
+                in_place_multiply(py_integer, offset);
+                Py_DECREF(offset);
+                if (py_integer == nullptr) {
+                    return py_integer;
+                }
+            }
+
+            // ... and finally add in the decimal component.
+            in_place_add(py_integer, py_decimal);
+            Py_DECREF(py_decimal);
+        }
+    }
+
+    // Error check this integer result.
+    if (py_integer == nullptr) {
+        return py_integer;
+    }
+
+    // If there is an exponent value (ajusted by the number of decimal digits that were
+    // present) then we have to multiply our integer by this value raised to the power
+    // of ten. Because this value could be *huge*, we cannot do power nor the
+    // mutliplication in the C++ space - it must be all done with Python's types.
+    if (checker.adjusted_exponent_value() > 0) {
+        PyObject* py_expon = exponent_creation_helper(checker.adjusted_exponent_value());
+        if (py_expon == nullptr) {
+            Py_DECREF(py_integer);
+            return py_expon;
+        }
+
+        // We are carrying around the exponent as an unsigned integer,
+        // so we handle negatives by dividing, and positives by multiplying.
+        if (checker.is_exponent_negative()) {
+            in_place_divide(py_integer, py_expon);
+        } else {
+            in_place_multiply(py_integer, py_expon);
+        }
+        Py_DECREF(py_expon);
+    }
+
+    // Finally, we negate the result if it is supposed to be negative.
+    return do_negative(py_integer, is_negative);
+}
+
 /**
  * \brief Remove whitespace at the end of a string
  *
@@ -32,16 +288,6 @@ inline void strip_trailing_whitespace(const char* start, const char*& end) noexc
     }
 }
 
-/// Convert a 64-int with the appropriate function depending on the compiler's long size
-inline PyObject* pyobject_from_int64(const int64_t value) noexcept
-{
-    if constexpr (std::numeric_limits<long>::max() == std::numeric_limits<int64_t>::max()) {
-        return PyLong_FromLong(static_cast<long>(value));
-    } else {
-        return PyLong_FromLongLong(static_cast<long long>(value));
-    };
-}
-
 CharacterParser::CharacterParser(
     const char* str,
     const std::size_t len,
@@ -116,22 +362,35 @@ RawPayload<PyObject*> CharacterParser::as_pyint() const noexcept(false)
         return ErrorType::BAD_VALUE;
     }
     if (!overflow) {
-        return pyobject_from_int64(result);
+        return pyobject_from_int(result);
     }
 
-    // Parse and record the location where parsing ended (including trailing whitespace)
-    // No need to do input validation with the second argument because we already know
-    // the input is valid from above.
-    PyObject* retval = PyLong_FromString(m_start_orig, nullptr, options().get_base());
-
-    // Return the value without checking python's error state
-    return retval;
+    // Parse and record the location where parsing ended (including trailing
+    // whitespace) No need to do input validation with the second argument because we
+    // already know the input is valid from above. Return the value without checking
+    // python's error state.
+    return PyLong_FromString(m_start_orig, nullptr, options().get_base());
 }
 
 RawPayload<PyObject*>
 CharacterParser::as_pyfloat(const bool force_int, const bool coerce) const
     noexcept(false)
 {
+    // If denoise is requested, use this algorithm *instead* of converting to a double
+    if (options().do_denoise() && (force_int || coerce)) {
+        StringChecker checker(m_start, end(), options().get_base());
+        if (checker.is_intlike_float()) {
+            return Parser::float_as_int_without_noise(checker, is_negative());
+        } else if (checker.is_invalid() && has_valid_underscores()) {
+            Buffer buffer(m_start, m_str_len);
+            buffer.remove_valid_underscores(options().get_base() != 10);
+            StringChecker checker(buffer.start(), buffer.end(), options().get_base());
+            if (checker.is_intlike_float()) {
+                return Parser::float_as_int_without_noise(checker, is_negative());
+            }
+        }
+    }
+
     // Perform the correct action depending on the payload's contents
     return std::visit(
         overloaded {
@@ -177,26 +436,28 @@ NumberFlags CharacterParser::get_number_type() const noexcept
 
     // If the string contains a numeric representation,
     // report which representation type is contained.
-    int value = string_contains_what(m_start, end(), options().get_base());
+    StringType value = StringChecker(m_start, end(), options().get_base()).get_type();
 
     // If it still looks like there is no numeric representation in the string,
     // check to see if it it contains underscores, and if so remove them and
     // try a numeric representation again. No need to check for infinity and
     // NaN here because those are not allowed to contain underscores.
-    if (value == 0 && has_valid_underscores()) {
+    if (value == StringType::INVALID && has_valid_underscores()) {
         Buffer buffer(m_start, m_str_len);
         buffer.remove_valid_underscores(!options().is_default_base());
-        value = string_contains_what(buffer.start(), buffer.end(), options().get_base());
+        value = StringChecker(buffer.start(), buffer.end(), options().get_base())
+                    .get_type();
     }
 
-    // Map integer values to numeric flag values
-    static constexpr NumberFlags type_mapping[] = {
-        /* 0 */ NumberType::INVALID,
-        /* 1 */ flag_wrap(NumberType::Integer),
-        /* 2 */ flag_wrap(NumberType::Float),
-        /* 3 */ flag_wrap(NumberType::Float | NumberType::IntLike),
-    };
-
     // Return the found type
-    return type_mapping[value];
+    switch (value) {
+    case StringType::INVALID:
+        return NumberType::INVALID;
+    case StringType::INTEGER:
+        return flag_wrap(NumberType::Integer);
+    case StringType::FLOAT:
+        return flag_wrap(NumberType::Float);
+    case StringType::INTLIKE_FLOAT:
+        return flag_wrap(NumberType::Float | NumberType::IntLike);
+    }
 }
diff --git a/src/fastnumbers/fastnumbers.pyi b/src/fastnumbers/fastnumbers.pyi
index add8d360..5803d03a 100644
--- a/src/fastnumbers/fastnumbers.pyi
+++ b/src/fastnumbers/fastnumbers.pyi
@@ -49,6 +49,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> pyint: ...
@@ -61,6 +62,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any = ...,
     coerce: Literal[False],
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> pyfloat: ...
@@ -73,6 +75,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> FloatInt: ...
@@ -91,6 +94,7 @@ def try_real(
     on_fail: INPUT_T = ...,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> FloatInt | StrInputType: ...
@@ -103,6 +107,7 @@ def try_real(
     on_fail: RAISE_T | FloatInt | Callable[[StrInputType], FloatInt],
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> FloatInt: ...
@@ -115,6 +120,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> Any: ...
@@ -127,6 +133,7 @@ def try_real(
     on_fail: Any,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> Any: ...
@@ -139,6 +146,7 @@ def try_real(
     on_fail: RAISE_T | FloatInt | Callable[[AnyInputType], FloatInt],
     on_type_error: FloatInt | Callable[[AnyInputType], FloatInt],
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> FloatInt: ...
@@ -151,6 +159,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> Any: ...
@@ -163,6 +172,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[pyint]: ...
@@ -175,6 +185,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any = ...,
     coerce: Literal[False],
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[pyfloat]: ...
@@ -187,6 +198,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[FloatInt]: ...
@@ -205,6 +217,7 @@ def try_real(
     on_fail: INPUT_T = ...,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[FloatInt | StrInputType]: ...
@@ -217,6 +230,7 @@ def try_real(
     on_fail: RAISE_T | FloatInt | Callable[[StrInputType], FloatInt],
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[FloatInt]: ...
@@ -229,6 +243,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[Any]: ...
@@ -241,6 +256,7 @@ def try_real(
     on_fail: Any,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[Any]: ...
@@ -253,6 +269,7 @@ def try_real(
     on_fail: RAISE_T | FloatInt | Callable[[AnyInputType], FloatInt],
     on_type_error: FloatInt | Callable[[AnyInputType], FloatInt],
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[FloatInt]: ...
@@ -265,6 +282,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[Any]: ...
@@ -277,6 +295,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[pyint]: ...
@@ -289,6 +308,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any = ...,
     coerce: Literal[False],
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[pyfloat]: ...
@@ -301,6 +321,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[FloatInt]: ...
@@ -319,6 +340,7 @@ def try_real(
     on_fail: INPUT_T = ...,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[FloatInt | StrInputType]: ...
@@ -331,6 +353,7 @@ def try_real(
     on_fail: RAISE_T | FloatInt | Callable[[StrInputType], FloatInt],
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[FloatInt]: ...
@@ -343,6 +366,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[Any]: ...
@@ -355,6 +379,7 @@ def try_real(
     on_fail: Any,
     on_type_error: Any = ...,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[Any]: ...
@@ -367,6 +392,7 @@ def try_real(
     on_fail: RAISE_T | FloatInt | Callable[[AnyInputType], FloatInt],
     on_type_error: FloatInt | Callable[[AnyInputType], FloatInt],
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[FloatInt]: ...
@@ -379,6 +405,7 @@ def try_real(
     on_fail: Any = ...,
     on_type_error: Any,
     coerce: bool = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[Any]: ...
@@ -820,6 +847,7 @@ def try_forceint(
     *,
     on_fail: Any = ...,
     on_type_error: Any = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> pyint: ...
@@ -829,6 +857,7 @@ def try_forceint(
     *,
     on_fail: INPUT_T = ...,
     on_type_error: Any = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> pyint | StrInputType: ...
@@ -838,6 +867,7 @@ def try_forceint(
     *,
     on_fail: RAISE_T | pyint | Callable[[StrInputType], pyint],
     on_type_error: Any = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> pyint: ...
@@ -847,6 +877,7 @@ def try_forceint(
     *,
     on_fail: Any,
     on_type_error: Any = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> Any: ...
@@ -856,6 +887,7 @@ def try_forceint(
     *,
     on_fail: RAISE_T | pyint | Callable[[AnyInputType], pyint],
     on_type_error: pyint | Callable[[AnyInputType], pyint],
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> pyint: ...
@@ -865,6 +897,7 @@ def try_forceint(
     *,
     on_fail: Any = ...,
     on_type_error: Any,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[False] = ...,
 ) -> Any: ...
@@ -874,6 +907,7 @@ def try_forceint(
     *,
     on_fail: Any = ...,
     on_type_error: Any = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[pyint]: ...
@@ -883,6 +917,7 @@ def try_forceint(
     *,
     on_fail: INPUT_T = ...,
     on_type_error: Any = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[pyint | StrInputType]: ...
@@ -892,6 +927,7 @@ def try_forceint(
     *,
     on_fail: RAISE_T | pyint | Callable[[StrInputType], pyint],
     on_type_error: Any = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[pyint]: ...
@@ -901,6 +937,7 @@ def try_forceint(
     *,
     on_fail: Any,
     on_type_error: Any = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[Any]: ...
@@ -910,6 +947,7 @@ def try_forceint(
     *,
     on_fail: RAISE_T | pyint | Callable[[AnyInputType], pyint],
     on_type_error: pyint | Callable[[AnyInputType], pyint],
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[pyint]: ...
@@ -919,6 +957,7 @@ def try_forceint(
     *,
     on_fail: Any = ...,
     on_type_error: Any,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Type[list],
 ) -> list[Any]: ...
@@ -928,6 +967,7 @@ def try_forceint(
     *,
     on_fail: Any = ...,
     on_type_error: Any = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[pyint]: ...
@@ -937,6 +977,7 @@ def try_forceint(
     *,
     on_fail: INPUT_T = ...,
     on_type_error: Any = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[pyint | StrInputType]: ...
@@ -946,6 +987,7 @@ def try_forceint(
     *,
     on_fail: RAISE_T | pyint | Callable[[StrInputType], pyint],
     on_type_error: Any = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[pyint]: ...
@@ -955,6 +997,7 @@ def try_forceint(
     *,
     on_fail: Any,
     on_type_error: Any = ...,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[Any]: ...
@@ -964,6 +1007,7 @@ def try_forceint(
     *,
     on_fail: RAISE_T | pyint | Callable[[AnyInputType], pyint],
     on_type_error: pyint | Callable[[AnyInputType], pyint],
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[pyint]: ...
@@ -973,6 +1017,7 @@ def try_forceint(
     *,
     on_fail: Any = ...,
     on_type_error: Any,
+    denoise: bool = ...,
     allow_underscores: bool = ...,
     map: Literal[True],
 ) -> Iterator[Any]: ...
diff --git a/tox.ini b/tox.ini
index 863450f3..c5c67e87 100644
--- a/tox.ini
+++ b/tox.ini
@@ -11,7 +11,7 @@ envlist = py37, py38, py39, py310, py311, py12
 #   docs
 #   bump
 #   clean
-#   py{37,38,39,310,311}-prof  (to update the profiling data}
+#   py{37,38,39,310,311,312}-prof  (to update the profiling data}
 
 # Don't error out if a user hasn't installed all python versions.
 skip_missing_interpreters =
@@ -85,25 +85,19 @@ commands = {envpython} dev/clean.py
 
 # For running profiling.
 [testenv:py37-prof]
-skip_install = false
 commands = {envpython} profiling/profile.py profiling/results-3.7.md
 
 [testenv:py38-prof]
-skip_install = false
 commands = {envpython} profiling/profile.py profiling/results-3.8.md
 
 [testenv:py39-prof]
-skip_install = false
 commands = {envpython} profiling/profile.py profiling/results-3.9.md
 
 [testenv:py310-prof]
-skip_install = false
 commands = {envpython} profiling/profile.py profiling/results-3.10.md
 
 [testenv:py311-prof]
-skip_install = false
 commands = {envpython} profiling/profile.py profiling/results-3.11.md
 
 [testenv:py312-prof]
-skip_install = false
 commands = {envpython} profiling/profile.py profiling/results-3.12.md


Test patch:
diff --git a/tests/test_fastnumbers.py b/tests/test_fastnumbers.py
index f76ba477..1de9e64d 100644
--- a/tests/test_fastnumbers.py
+++ b/tests/test_fastnumbers.py
@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
-# Find the build location and add that to the path
+import decimal
 import math
 import random
 import re
@@ -18,7 +18,7 @@
     Union,
 )
 
-from hypothesis import example, given
+from hypothesis import example, given, settings
 from hypothesis.strategies import (
     binary,
     dictionaries,
@@ -53,6 +53,7 @@ def __call__(
         on_fail: Any = ...,
         on_type_error: Any = ...,
         coerce: bool = ...,
+        denoise: bool = ...,
         allow_underscores: bool = ...,
     ) -> Any:
         ...
@@ -92,6 +93,7 @@ def __call__(
         *,
         on_fail: Any = ...,
         on_type_error: Any = ...,
+        denoise: bool = ...,
         allow_underscores: bool = ...,
     ) -> Any:
         ...
@@ -235,6 +237,32 @@ def capture_result(  # type: ignore [no-untyped-def]
         return str(e)
 
 
+def assert_integers_close(x: int, y: int) -> None:
+    """Integers are the same except for the last non-zero digit"""
+    x_str = str(x)
+    y_str = str(y)
+
+    # Get length with non-trailing zeros removed
+    x_len = len(re.sub(r"0+$", "", x_str))
+    y_len = len(re.sub(r"0+$", "", y_str))
+
+    # Remove the non-trailing zeros, only keep 16 digits, then round the last digit.
+    # Python's integer rounding seems to sometimes five up or down with no pattern
+    # that I can detect - so if an integer ends in "5", it is forced to be both ending
+    # in "4" and "6" to explore both rounding spaces.
+    comp_len = min(max(x_len, y_len), 16)
+    x_trimmed_1 = round(int(re.sub(r"5$", "4", x_str[:comp_len]) or 0), -1)
+    y_trimmed_1 = round(int(re.sub(r"5$", "4", y_str[:comp_len]) or 0), -1)
+    x_trimmed_2 = round(int(re.sub(r"5$", "6", x_str[:comp_len]) or 0), -1)
+    y_trimmed_2 = round(int(re.sub(r"5$", "6", y_str[:comp_len]) or 0), -1)
+    assert (
+        x_trimmed_1 == y_trimmed_1
+        or x_trimmed_1 == y_trimmed_2
+        or x_trimmed_2 == y_trimmed_1
+        or x_trimmed_2 == y_trimmed_2
+    )
+
+
 class DumbFloatClass(object):
     def __float__(self) -> NoReturn:
         raise ValueError("something here might go wrong")
@@ -1064,6 +1092,34 @@ def test_given_float_returns_int_if_intlike_with_coerce(self, x: float) -> None:
         assert result == expected
         assert isinstance(result, int)
 
+    @given(floats(allow_nan=False).filter(an_integer))
+    @settings(max_examples=500)
+    def test_given_float_returns_int_matching_decimal_object_with_denoise(
+        self, x: float
+    ) -> None:
+        expected = int(decimal.Decimal(str(x)))
+        result = fastnumbers.try_real(x, coerce=True, denoise=True)
+        # This is "best effort", and should be accurate to the final non-zero digit
+        assert isinstance(result, int)
+        assert_integers_close(result, expected)
+
+    @given(floats(allow_nan=False).filter(an_integer).map(repr))
+    @example("1234.56E56")
+    @example("12345.60000E56")
+    @example("1234560000E-3")
+    @example("1234.56789012345678901234567890123456789e56")
+    @example("1234.5678901234567890123456789012345678900000e56")
+    @example("1234567890123456789012345678901234567890000000000000.")
+    @example("123456789012345678901234567890123456789.0000000000000000000000000000")
+    @example("1234567890123456789012345678901234567890000000000000e-5")
+    def test_given_float_str_returns_int_matching_decimal_object_with_denoise(
+        self, x: str
+    ) -> None:
+        expected = int(decimal.Decimal(x))
+        result = fastnumbers.try_real(x, coerce=True, denoise=True)
+        assert isinstance(result, int)
+        assert result == expected
+
     @given(floats(allow_nan=False))
     def test_given_float_returns_float_or_int_with_coerce(self, x: float) -> None:
         expected = int(x) if x.is_integer() else x
@@ -1081,6 +1137,12 @@ def test_given_float_string_returns_int_with_coerce_with_intlike(
         assert result == expected
         assert isinstance(result, int)
 
+    def test_underscores_with_denoise(self) -> None:
+        given = "3.4_5_3e2_1"
+        expected = 3453000000000000000000
+        result = fastnumbers.try_real(given, denoise=True, allow_underscores=True)
+        assert result == expected
+
 
 class TestTryFloat:
     """
@@ -1202,6 +1264,40 @@ def test_given_unicode_numeral_returns_int(self, x: str) -> None:
         assert isinstance(result, int)
         assert fastnumbers.try_forceint(pad(x)) == expected  # Accepts padding
 
+    @given(floats(allow_nan=False, allow_infinity=False))
+    @settings(max_examples=500)
+    def test_given_float_returns_int_matching_decimal_object_with_denoise(
+        self, x: float
+    ) -> None:
+        expected = int(decimal.Decimal(str(x)))
+        result = fastnumbers.try_forceint(x, denoise=True)
+        # This is "best effort", and should be accurate to the final non-zero digit
+        assert isinstance(result, int)
+        assert_integers_close(result, expected)
+
+    @given(floats(allow_nan=False, allow_infinity=False).map(repr))
+    @example("1234.56E56")
+    @example("12345.60000E56")
+    @example("1234560000E-3")
+    @example("1234.56789012345678901234567890123456789e56")
+    @example("1234.5678901234567890123456789012345678900000e56")
+    @example("1234567890123456789012345678901234567890000000000000.")
+    @example("123456789012345678901234567890123456789.0000000000000000000000000000")
+    @example("1234567890123456789012345678901234567890000000000000e-5")
+    def test_given_float_str_returns_int_matching_decimal_object_with_denoise(
+        self, x: str
+    ) -> None:
+        expected = int(decimal.Decimal(x))
+        result = fastnumbers.try_forceint(x, denoise=True)
+        assert isinstance(result, int)
+        assert result == expected
+
+    def test_underscores_with_denoise(self) -> None:
+        given = "3.4_5_3e2_1"
+        expected = 3453000000000000000000
+        result = fastnumbers.try_forceint(given, denoise=True, allow_underscores=True)
+        assert result == expected
+
 
 class TestCheckingFunctions:
     """
diff --git a/tests/test_fastnumbers_examples.py b/tests/test_fastnumbers_examples.py
index e0cbc3e6..05226b19 100644
--- a/tests/test_fastnumbers_examples.py
+++ b/tests/test_fastnumbers_examples.py
@@ -1,5 +1,4 @@
 # -*- coding: utf-8 -*-
-# Find the build location and add that to the path
 import math
 from typing import cast
 
@@ -98,6 +97,11 @@ def test_try_real() -> None:
     # 20. Handling of type errors
     assert fastnumbers.try_real(["invalid"], on_fail=6, on_type_error=7.0) == 7.0
     assert fastnumbers.try_real(["invalid"], on_type_error=None) is None
+    # 21. Denoising large float to integer conversions
+    assert fastnumbers.try_real(3.453e21) == 3452999999999999737856
+    assert fastnumbers.try_real(3.453e21, denoise=True) == 3453000000000000000000
+    assert fastnumbers.try_real("3.453e21") == 3452999999999999737856
+    assert fastnumbers.try_real("3.453e21", denoise=True) == 3453000000000000000000
 
 
 def test_try_float() -> None:
@@ -290,6 +294,11 @@ def test_try_forceint() -> None:
     # 20. Handling of type errors
     assert fastnumbers.try_forceint(["invalid"], on_fail=6, on_type_error=7) == 7
     assert fastnumbers.try_forceint(["invalid"], on_type_error=None) is None
+    # 21. Denoising large float to integer conversions
+    assert fastnumbers.try_forceint(3.453e21) == 3452999999999999737856
+    assert fastnumbers.try_forceint(3.453e21, denoise=True) == 3453000000000000000000
+    assert fastnumbers.try_forceint("3.453e21") == 3452999999999999737856
+    assert fastnumbers.try_forceint("3.453e21", denoise=True) == 3453000000000000000000
 
 
 def test_check_real() -> None: