Efficient n-th Root Computation on Microcontrollers Employing Magic Constants and Modified Newton and Householder Methods

Abstract

With the growing number of applications in embedded systems—such as IoT modules, smart sensors, and wearable devices—there is an increasing demand for fast and accurate computations on resource-constrained platforms. In this paper, we present a new method for computing n-th roots in floating-point arithmetic based on an initial estimate generated by a “magic constant,” followed by one or two iterations of a modified Newton–Raphson or Householder algorithm. For cubic and quartic roots, we provide C implementations operating in single-precision floating-point format. The proposed algorithms are evaluated in terms of maximum relative error and execution time on selected microcontrollers. They exhibit high accuracy and noticeably reduced computation time. For example, our methods for computing cubic roots outperform the standard library function cbrtf() in both speed and precision. The results may be useful in a variety of fields, including biomedical and biophysical applications, statistical analysis, and real-time image and signal processing.

1. Introduction

Efficient evaluation of real-valued n-th roots is a fundamental building block in a wide range of numerical procedures, particularly in systems that must operate under strict constraints on computation time, memory footprint, and power consumption. Such constraints are especially pronounced in embedded systems, wearable devices, microcontroller-based biomedical instrumentation, and real-time signal-processing pipelines. Applications include dynamic-range and gamma-correction pipelines in modern imaging devices [1,2,3,4,5], fractional-order control algorithms implemented on microcontrollers [6], biomedical applications [7,8,9], and preprocessing stages in AI-driven statistical systems [10,11]. In all these contexts, root operations—square, cube, quartic, and inverse—can serve as essential primitives in normalization, error-transformation, spectral shaping, and nonlinear model components [12,13,14,15].

Power functions with sub-unit exponents can also appear in many of the same embedded perception and control pipelines. Gamma correction is a classical example: applying $Y_{\mathrm{out}}=Y_{\mathrm{in}}^{\gamma }$ with $0<\gamma <1$ lifts dark regions and protects highlights. Recent low-light methods make this operation spatially adaptive; adaptive chrominance gamma correction (ACGC) avoids hue shifts while enhancing detail [3]. A similar idea appears in rotation-aware object detection, where applying a small gamma on the Value channel of HSV improves robustness on aerial imagery [4]. Gradient-domain HDR compression is not pointwise $x^p$, but relies on the same principle of compressing large variations while preserving fine structure [2]. These transformations are evaluated at every pixel, often per frame. On microcontrollers, large lookup tables are expensive and generic pow calls are slow; compact and adjustable power-law or root-like operations are therefore crucial.

Power transformations have long been a fundamental tool in data analysis, both in classical exploratory approaches and in statistical modeling. Tukey emphasized their practical value in exploratory data analysis through the ladder of powers [16], while Box and Cox formalized them in a parametric framework that enables continuous optimization of the transformation exponent [17]. In modern applications, including advanced biochemical and metabolomic analyses [18], suitable power transformations remain an essential component of preprocessing pipelines for signal normalization and variance stabilization.

Audio pipelines create similar demands. Dynamic-range compression uses concave envelope curves behaving like $x^p$; theoretical analyses link such mappings to envelope correlations, effective gain, and SNR, motivating signal-dependent compression strength and frequent evaluation of sub-unit power laws [1]. Speech dereverberation with learning-based models uses magnitude compression ${\left|X\right|}^b$ with $b\in (0,1)$, increasing the number of power evaluations per time–frequency bin [19]. For on-device processing, these costs accumulate; microcontroller-friendly kernels for $x^p$ or $x^{1/n}$ can reduce latency and energy.

Control systems add further motivation. Fractional-order PID controllers have frequency responses scaling as ${\omega }^{\alpha }$ with $\alpha \in (0,1)$; microcontroller studies [6] demonstrate that approximations of these behaviors require frequent evaluation of power-law components, demanding predictable and efficient numerical routines.

Commonly used methods for general n-th root evaluation often rely on unoptimized Newton iterations or achieve accuracy at the cost of computational expense or divergence on devices without hardware floating-point units (FPUs). Even where FPUs exist, unoptimized approaches may suffice, but often, e.g., on ESP-32-class devices [20], the overhead becomes substantial, limiting real-time performance.

This limitation is significant because embedded and wearable systems increasingly require on-device computation. EMG, EEG, and BCI systems need low-latency in-place processing [21,22]. Remote-sensing systems using hyperspectral data [23] rely on efficient local preprocessing. In many such pipelines, power laws and n-th roots appear repeatedly, for instance, in dynamic-range compression [1], HDR/gamma correction [2,3,4,5], geometric normalization [24], real-time RMS voltage estimation [25], and nonlinear state-estimation routines [26]. These operations must be both fast and accurate.

The present paper is motivated by simple, fast, and accurate algorithms for the inverse square root [27,28,29] historically rooted in early floating-point tricks [30] and followed by works on some other power functions, including square roots [31], reciprocal functions [32,33], inverse cube roots [34,35,36], and other negative exponents [37].

In this work, we present a new, very fast, and practically machine-accurate algorithm for computing $x^{1/n}$ for arbitrary integers $n\ge 2$, with emphasis on cube and quartic roots. Our approach combines a bit-level initial multi-interval approximation (a generalized integer-arithmetic magic-seed construction), and one or two modified Newton–Raphson or Householder iterations.

To validate performance of cube and quartic root computation across hardware architectures, we benchmark it on five microcontroller platforms: two with hardware FPUs and three without, including representative STM-32 and ESP-32 devices. Results show that the proposed approach yields a high-performance, low-power, and highly accurate solution suitable for a broad spectrum of embedded and wearable signal-processing applications.

2. A Floating-Point Approximation of the n-th Root Functions with Magic Numbers

In this article, we deal with FP numbers in the following form:

$$x={(-1)}^{s_x}{2}^{e_x}·(1+m_x),$$

(1)

where $s_x\in \{0,1\}$ denotes the sign of the number, $e_x$ is the number’s exponent, and $m_x$ is its mantissa. The IEEE-754 standard [38] defines two kinds of FP number representations—32-bit and 64-bit. Despite the fact that the theory in the present article refers to both representations, the practical testing of the accuracy and performance achieved by the implemented algorithms was conducted only for 32-bit precision. In the case of the standard IEEE-754, a floating-point number, the first bit corresponds to an $s_x$, the next 8 bits correspond to the biased exponent $E_x=e_x+\mathrm{bias}$ ($\mathrm{bias}=127$), and the last 23 bits encode a mantissa. The range of available numbers for which we can determine n-th roots can be divided into disjoint intervals:

$$x\in \bigcup _j{A}_j\mathrm{where}{A}_j=\left[2^{n·j},2^{n·(j+1)}\right)\mathrm{for}j\in \{0,\pm 1,\pm 2,\dots \}.$$

(2)

If $x\in A_j$, then $y=\sqrt[n]{x}$ takes values within the interval $(2^j,2^{j+1}]$. By introducing the new variables

$$\tilde{x}=2^{-n·j}x=2^{e_{\tilde{x}}}·(1+m_{\tilde{x}}),\tilde{y}=2^{-n}y=2^{e_{\tilde{y}}}·(1+m_{\tilde{y}})$$

(3)

the whole problem may be restricted to computing the $\tilde{y}=\sqrt[n]{\tilde{x}}$ for the $\tilde{x}\in [1,2^n)$ and $e_{\tilde{x}}\in \{0,1,\dots n-1\}$; it follows from (3) that $e_{\tilde{y}}=0$.

If we calculate the logarithm base 2 of $\tilde{y}=\sqrt[n]{\tilde{x}}$, taking into account (3), we obtain the formula

$$e_{\tilde{y}}+{log}_2(1+m_{\tilde{y}})={\displaystyle \frac{1}{n}}{e}_{\tilde{x}}+{\displaystyle \frac{1}{n}}{log}_2(1+m_{\tilde{x}}).$$

(4)

By applying a linear approximation of the logarithmic function

$${log}_{2}a\simeq a+c_a,$$

where $c_a$ is a certain undetermined constant, we obtain

$$1+m_{\tilde{y}}+e_{\tilde{y}}\simeq {\displaystyle \frac{1}{n}}{e}_{\tilde{x}}+{\displaystyle \frac{1}{n}}(1+m_{\tilde{x}})+\underset{c}{\underbrace{\left({\displaystyle \frac{c_{1+m_{\tilde{x}}}}{n}}-c_{1+m_{\tilde{y}}}\right)}},$$

(5)

which, in equivalent form, is

$$\underset{I_y}{\underbrace{2^p\left(E_{\tilde{y}}+m_{\tilde{y}}\right)}}\simeq \underset{R\leftarrow \mathrm{magic}\mathrm{constant}}{\underbrace{⌊2^p\left(1-{\displaystyle \frac{1}{n}}\right)(bias-1)+2^{p}c⌉}}+\underset{I_x/n}{\underbrace{{\displaystyle \frac{2^p(E_{\tilde{x}}+m_{\tilde{x}})}{n}}}},I_y,I_x,R\in {\mathbb{N}}^{+},$$

(6)

where p is the number of mantissa bits. For 32-bit numbers, $p=23$, and for 64-bit numbers, $p=52$. Formula (6) is analogous to the equation $I_y\simeq R-I_x$ for reciprocal functions  [32,33], and $I_y\simeq R-I_x/2$ and $I_y\simeq R-I_x/3$ for computing the reciprocal square and cube roots [27,28,29,30,31,34,35].

Assuming from relation (5) that $e_{\tilde{x}}$ and $e_{\tilde{y}}$ are constant integer parameters, we may derive an approximate solution ${\tilde{y}}_{00}\simeq \tilde{y}$ that is linearly dependent on $\tilde{x}$:

$${\tilde{y}}_{00}\left(\tilde{x}\right)=2^{e_{\tilde{y}}}\left(-e_{\tilde{y}}+{\displaystyle \frac{e_{\tilde{x}}}{n}}+{\displaystyle \frac{2^{-e_{\tilde{x}}}}{n}}\tilde{x}+c\right).$$

(7)

Such an approximation is not optimal from the perspective of minimizing the relative error of n-th roots. To address this, it is sufficient to introduce an additional scaling parameter $\beta$:

$${\tilde{y}}_0\left(\tilde{x}\right)=\beta ·{\tilde{y}}_{00}\left(\tilde{x}\right),{\delta }_0\left(\tilde{x}\right)=\left({\tilde{y}}_0\left(\tilde{x}\right)/\sqrt[n]{\tilde{x}}\right)-1.$$

(8)

3. Multi-Interval Approximation

In order to obtain sufficiently accurate approximations, we divide the intervals $[2^{e_{\tilde{x}}},2^{e_{\tilde{x}}+1})$, where $e_{\tilde{x}}\in \{0,1,\dots ,n-1\}$, into M equal parts:

$$\tilde{x}\in [2^{e_{\tilde{x}}},2^{e_{\tilde{x}}+1})=\bigcup _{m=1}^M[x_{\mathbf{b},e_{\tilde{x}},m},x_{\mathbf{e},e_{\tilde{x}},m}),\mathrm{where}{\displaystyle \frac{x_{\mathbf{b},e_{\tilde{x}},m}}{2^{e_{\tilde{x}}}}}=1+{\displaystyle \frac{m-1}{M}},{\displaystyle \frac{x_{\mathbf{e},e_{\tilde{x}},m}}{2^{e_{\tilde{x}}}}}=1+{\displaystyle \frac{m}{M}}.$$

In every sub-interval $[x_{\mathbf{b},e_{\tilde{x}},m},x_{\mathbf{e},e_{\tilde{x}},m})$, we take a different piece-wise linear function of the form (8) as an initial approximation of the function $\sqrt[n]{\tilde{x}}$:

$${\tilde{y}}_{0,e_x,m}^{[n·M]}\left(\tilde{x}\right)={\beta }_{e_x,m}^{[n·M]}·2^{e_{\tilde{y}}}\left(-e_{\tilde{y}}+{\displaystyle \frac{e_{\tilde{x}}}{n}}+{\displaystyle \frac{2^{-e_{\tilde{x}}}}{n}}\tilde{x}+c_{e_x,m}^{[n·M]}\right),{\delta }_{0,e_x,m}^{[n·M]}\left(\tilde{x}\right)={\displaystyle \frac{{\tilde{y}}_{0,e_x,m}^{[n·M]}\left(\tilde{x}\right)}{\sqrt[n]{\tilde{x}}}}-1.$$

(9)

Optimal solutions minimizing the relative error ${{\delta }_{0,e_x,m}}^{[n·M]}\left(\tilde{x}\right)$ are obtained for

$$\begin{array}{cc}\hfill c_{e_x,m}^{[n·M]}& =e_{\tilde{y}}-{\displaystyle \frac{1}{n}}{e}_{\tilde{x}}+{\displaystyle \frac{1}{n}}{w}_{n,m,M},\hfill \end{array}$$

(10)

$$\begin{array}{cc}\hfill {\beta }_{e_x,m}^{[n·M]}& ={\displaystyle \frac{2^{1-e_{\tilde{y}}+e_{\tilde{x}}/n}n{(n-1)}^{1-1/n}{\left(1+\frac{m-1}{M}\right)}^{1/n}}{{(n-1)}^{1-1/n}\left(1+\frac{m-1}{M}+w_{n,m,M}\right)+n{\left(1+\frac{m-1}{M}\right)}^{1/n}{w}_{n,m,M}^{1-1/n}}},\hfill \end{array}$$

(11)

where

$$w_{n,m,M}=-1-{\displaystyle \frac{m}{M}}+{\displaystyle \frac{1}{M}}{\displaystyle \frac{\sqrt[n]{1+\frac{m}{M}}}{\sqrt[n]{1+\frac{m}{M}}-\sqrt[n]{1+\frac{m-1}{M}}}}.$$

(12)

The maximum error for a given sub-interval m does not depend on $e_{\tilde{y}}$ and equals

$${\delta }_{0,e_x,m,max}^{[n·M]}=1-{\displaystyle \frac{2n{\left(1+\frac{m-1}{M}\right)}^{1/n}{w}_{n,m,M}^{1-1/n}}{{(n-1)}^{1-1/n}\left(1+\frac{m-1}{M}+w_{n,m,M}\right)+n{\left(1+\frac{m-1}{M}\right)}^{1/n}{w}_{n,m,M}^{1-1/n}}}.$$

(13)

In this case, the equations that symmetrize the extreme values of the errors are satisfied:

$${\delta }_{0,e_x,m,max}^{[n·M]}={\tilde{y}}_{0,e_x,m}^{[n·M]}\left(x_{\mathbf{b},e_{\tilde{x}},m}\right)={\tilde{y}}_{0,e_x,m}^{[n·M]}\left(x_{\mathbf{e},e_{\tilde{x}},m}\right),{\delta }_{0,e_x,m,max}^{[n·M]}=-{\delta }_{0,e_x,m,min}^{[n·M]},$$

where ${\delta }_{0,e_x,m,min}^{[n·M]}$ is the minimum of the error function:

$${\delta }_{0,e_x,m,min}^{[n·M]}={\tilde{y}}_{0,e_x,m}^{[n·M]}\left(x_{min}\right),x_{min}={\displaystyle \frac{2^{e_x}\left(e_x+n{c}_{e_x,m}^{[n·M]}-n{e}_y\right)}{n-1}}.$$

The plots of relative error functions ${\delta }_{0,e_x,m}^{[n·M]}\left(\tilde{x}\right)$ (8) for $n=3$ and $n=4$ are shown in Figure 1 and Figure 2. The maximum error for all $e_{\tilde{x}}\in \{0,1,\dots ,n-1\}$ corresponds to $m=1$:

$${\delta }_{0,max}^{[n·M]}={\delta }_{0,e_x,1,max}^{[n·M]}.$$

(14)

The values of the maximal relative errors ${\delta }_{0,max}^{[n·M]}$ and their corresponding numbers of correct bits $a{c}_{\mathrm{bits}}^{[n·M]}=\lfloor -{log}_2{\delta }_{0,max}^{[n·M]}\rfloor$ for the approximation ${{\tilde{y}}_{0,e_x,m}}^{[n·M]}\left(\tilde{x}\right)$ with $n\in \{2,3,4\}$ and $M\in \{1,2,4,8,16\}$ are given in

Table 1. Maximal relative errors ${\delta }_{0,max}^{[n·M]}$ and their corresponding numbers of correct bits $a{c}_{\mathrm{bits}}^{[n·M]}=\lfloor -{log}_2{\delta }_{0,max}^{[n·M]}\rfloor$ for the approximation ${\tilde{y}}_{0,e_x,m}^{[n·M]}\left(\tilde{x}\right)$.

	$\mathit{M}=1$	$\mathit{M}=2$	$\mathit{M}=4$	$\mathit{M}=8$	$\mathit{M}=16$
${\delta }_{0,max}^{[2·M]}$	$7.47·{10}^{-3}$	$2.56·{10}^{-3}$	$7.78·{10}^{-4}$	$2.17·{10}^{-4}$	$5.74·{10}^{-5}$
$a{c}_{\mathrm{bits}}^{[2·M]}$	7	8	10	12	14
${\delta }_{0,max}^{[3·M]}$	$6.64·{10}^{-3}$	$2.28·{10}^{-3}$	$6.91·{10}^{-4}$	$1.93·{10}^{-4}$	$5.10·{10}^{-5}$
$a{c}_{\mathrm{bits}}^{[3·M]}$	7	8	10	12	14
${\delta }_{0,max}^{[4·M]}$	$5.60·{10}^{-3}$	$1.92·{10}^{-3}$	$5.83·{10}^{-4}$	$1.63·{10}^{-4}$	$4.31·{10}^{-5}$
$a{c}_{\mathrm{bits}}^{[4·M]}$	7	8	10	12	14

.

4. Modifications of the Newton–Raphson Method

In order to improve the accuracy, the zeroth approximation (${\tilde{y}}_{0,e_x,m}^{[n·M]}\left(\tilde{x}\right)$) can be corrected using the Newton–Raphson method:

$${\tilde{y}}_k^{\left(NR\right)}={\tilde{y}}_{k-1}^{\left(NR\right)}-f\left({\tilde{y}}_{k-1}^{\left(NR\right)}\right)/f^{\prime }\left({\tilde{y}}_{k-1}^{\left(NR\right)}\right),k\in \{1,2,\dots \},$$

(15)

where $f\left(y\right)=y^n-x$ and ${\tilde{y}}_k^{\left(NR\right)}={\tilde{y}}_{k,e_x,m}^{[n·M]}\left(\tilde{x}\right)$. Therefore,

$${\tilde{y}}_k^{\left(NR\right)}={\displaystyle \frac{1}{n}}{\tilde{y}}_{k-1}^{\left(NR\right)}\left(n-1+\tilde{x}{\tilde{y}}_{k-1}^{{\left(NR\right)}^{-n}}\right).$$

(16)

After the symmetrization of the relative error, the method takes the following form:

$${\tilde{y}}_k^{\left(M1\right)}={\displaystyle \frac{{\kappa }_{1,k}}{n}}{\tilde{y}}_{k-1}^{\left(M1\right)}\left((n-1){\kappa }_{0,k}+\tilde{x}{\tilde{y}}_{k-1}^{{\left(M1\right)}^{-n}}\right),$$

(17)

where

$$\begin{array}{cc}\hfill {\kappa }_{0,k}& ={\displaystyle \frac{{\left(1+{\delta }_{k-1,max}^{\left(M1\right)}\right)}^{n-1}-{\left(1-{\delta }_{k-1,max}^{\left(M1\right)}\right)}^{n-1}}{2(n-1){\delta }_{k-1,max}^{\left(M1\right)}{\left(1-{\delta }_{k-1,max}^{{\left(M1\right)}^2}\right)}^{n-1}}},\hfill \end{array}$$

(18)

$$\begin{array}{cc}\hfill {\kappa }_{1,k}& ={\displaystyle \frac{4n{\delta }_{k-1,max}^{\left(M1\right)}{\left(1-{\delta }_{k-1,max}^{{\left(M1\right)}^2}\right)}^{n-1}}{2n{\kappa }_{0,k}^{1-1/n}{\delta }_{k-1,max}^{\left(M1\right)}{\left(1-{\delta }_{k-1,max}^{{\left(M1\right)}^2}\right)}^{n-1}+{\left(1+{\delta }_{k-1,max}^{\left(M1\right)}\right)}^n-{\left(1-{\delta }_{k-1,max}^{\left(M1\right)}\right)}^n}},\hfill \end{array}$$

(19)

and ${\delta }_{k-1,max}^{\left(M1\right)}$ is the maximum relative error of the $(k - 1)$th iteration. Since the relationship between the relative errors of each iteration, according to Equation (17), is described by the equation

$${\delta }_k^{\left(M1\right)}={\displaystyle \frac{{\kappa }_{1,k}}{n}}\left(1+{\delta }_{k-1}^{\left(M1\right)}\right)\left((n-1){\kappa }_{0,k}+{\left(1+{\delta }_{k-1}^{\left(M1\right)}\right)}^{-n}\right)-1.$$

(20)

The maximum error of higher iterations can be expressed using the errors of earlier iterations:

$${\delta }_{k,max}^{\left(M1\right)}={\displaystyle \frac{{\kappa }_{1,k}}{2n}}{\displaystyle \frac{{\left(1+{\delta }_{k-1,max}^{\left(M1\right)}\right)}^n-{\left(1-{\delta }_{k-1,max}^{\left(M1\right)}\right)}^n}{{\delta }_{k-1,max}^{\left(M1\right)}{\left(1-{\delta }_{k-1,max}^{{\left(M1\right)}^2}\right)}^{n-1}}}-1.$$

(21)

The values of the maximal relative errors ${\delta }_{k,max}^{\left(M1\right)}$ for initial approximation ${\tilde{y}}_{0,e_x,m}^{[n·M]}\left(\tilde{x}\right)$ with $n\in \{3,4\}$ and $M\in \{1,2,4,8,16\}$ are given in

Table 2. Maximal relative errors ${\delta }_{k,max}^{\left(M1\right)}$ and their corresponding numbers of correct bits $a{c}_{\mathrm{bits},k}=\lfloor -{log}_2{\delta }_{k,max}^{\left(M1\right)}\rfloor$ for initial approximation $\sqrt[3]{\tilde{x}}\simeq {\tilde{y}}_{0,e_x,m}^{[3·M]}\left(\tilde{x}\right)$ and $k\in \{1,2\}$.

	$\mathit{M}=1$	$\mathit{M}=2$	$\mathit{M}=4$	$\mathit{M}=8$	$\mathit{M}=16$
${\delta }_{1,max}$	$2.20·{10}^{-5}$	$2.60·{10}^{-6}$	$2.39·{10}^{-7}$	$1.86·{10}^{-8}$	$1.30·{10}^{-9}$
$a{c}_{\mathrm{bits},1}$	15	18	21	25	29
${\delta }_{2,max}$	$2.43·{10}^{-10}$	$3.37·{10}^{-12}$	$2.85·{10}^{-14}$	$1.72·{10}^{-16}$	$8.49·{10}^{-19}$
$a{c}_{\mathrm{bits},2}$	31	38	44	52	60

and

Table 3. Maximal relative errors ${\delta }_{k,max}^{\left(M1\right)}$ and their corresponding numbers of correct bits $a{c}_{\mathrm{bits},k}=\lfloor -{log}_2{\delta }_{k,max}^{\left(M1\right)}\rfloor$ for initial approximation $\sqrt[4]{\tilde{x}}\simeq {\tilde{y}}_{0,e_x,m}^{[4·M]}\left(\tilde{x}\right)$ and $k\in \{1,2\}$.

	$\mathit{M}=1$	$\mathit{M}=2$	$\mathit{M}=4$	$\mathit{M}=8$	$\mathit{M}=16$
${\delta }_{1,max}$	$2.35·{10}^{-5}$	$2.77·{10}^{-6}$	$2.55·{10}^{-7}$	$1.98·{10}^{-8}$	$1.39·{10}^{-9}$
$a{c}_{\mathrm{bits},1}$	15	18	21	25	29
${\delta }_{2,max}$	$4.15·{10}^{-10}$	$5.77·{10}^{-12}$	$4.84·{10}^{-14}$	$2.95·{10}^{-16}$	$1.45·{10}^{-18}$
$a{c}_{\mathrm{bits},2}$	31	37	44	51	59

. Analyzing the data presented in the tables, it can be concluded that for floating-point calculations with a 23-bit mantissa, two iterations of type $M1$ are sufficient when $M=1$, while for $M=16$, only one iteration is needed. In the case of $M=8$, using only one iteration, due to rounding errors, results in maximum relative errors greater than ${10}^{-7}$.

4.1. Algorithms Based on Two Iterations

In this subsection, we present algorithms to compute $\sqrt[3]{x}$ and $\sqrt[4]{x}$, derived based on two modified Newton–Raphson (M1) iterations, which are described by Formula (17). In order to optimize the C implementation, two iterations are given in the following form:

$$\begin{array}{cc}\hfill z_1^{\left(M1\right)}& =z_0^{\left(M1\right)}+k_1·x·z_0^{{\left(M1\right)}^{1-n}},\hfill \end{array}$$

(22)

$$\begin{array}{cc}\hfill y_2^{\left(M1\right)}& =z_1^{\left(M1\right)}+k_2·x·z_1^{{\left(M1\right)}^{1-n}},\hfill \end{array}$$

(23)

where

$$\begin{array}{cccc}\hfill {\beta }_2& ={\left(1-{\displaystyle \frac{1}{n}}\right)}^2{\kappa }_{0,1}{\kappa }_{0,2}{\kappa }_{1,1}{\kappa }_{1,2},\hfill & \hfill z_0^{\left(M1\right)}& ={\beta }_2·y_0^{\left(M1\right)},\hfill \end{array}$$

(24)

$$\begin{array}{cccc}\hfill k_1& ={\displaystyle \frac{1}{n}}{\left(1-{\displaystyle \frac{1}{n}}\right)}^{2n-1}{\kappa }_{0,1}^{n-1}{\kappa }_{0,2}^n{\kappa }_{1,1}^n{\kappa }_{1,2}^n,\hfill & \hfill k_2& ={\displaystyle \frac{1}{n}}{\left(1-{\displaystyle \frac{1}{n}}\right)}^{n-1}{\kappa }_{0,2}^{n-1}{\kappa }_{1,2}^n.\hfill \end{array}$$

(25)

Calculation of $\sqrt[3]{\tilde{x}}$ and $\sqrt[4]{\tilde{x}}$ is implemented in the C language through the functions rt_M1_n3() and rt_M1_n4(), in that order (Algorithms 1 and 2). Magic constant tables $R3$ and $R4$ were calculated based on Formulas (10) and (6), and table $beta3$ stores the multiplication of the ${\beta }_2$ parameter and the table, the coefficients of which are computed by ${\beta }_{e_x,m}^{[n,M]}$ (see (11)) for adequate $e_{\tilde{x}}$.

Algorithm 1 rt_M1_n3

1: float rt_M1_n3(float x){// x⌃1/3 -> II iter M1   2:  static const float beta3[3] = {0.553788056219f, 0.348864614605f,   3:    0.439541871504f};   4:  static const unsigned int R3[3] = {707012356, 712604762, 709808559};   5:  float y; unsigned int i, j;   6:  j = *(unsigned int*)&x;   7:  i = j >> 23; j = j / 3; i = i - 3 * (j >> 23);   8:  j = R3[i] + j; y = *(float*)&j; y *= beta3[i];   9:  y += x * 0.0438928459199f / (y * y); //k1=0.0438928459199f 10:  y = fmaf(x, 0.148148148040f / (y * y), y); //k2=0.148148148040f 11:  return y; 12: }

Algorithm 2 rt_M1_n4

1: float rt_M1_n4(float x){ // x⌃1/4 -> II iter M1   2:  static const float beta3[4] = {0.509100911370f, 0.605426426055f,   3:   0.719977413475f, 0.428101131373f};   4:  static const unsigned int R4[4] = {799613048, 797515896,   5:   795418744, 801710200};   6:  float y; unsigned int i, j;   7:  j = *(unsigned int*)&x; i = (j >> 23) & 3; j = j >> 2;   8:  j = R4[i] + j; y = *(float*)&j; y *= beta3[i];   9:  y += x * 0.0333678322765f / (y * y * y); //k1=0.0333678322765f 10:  y = fmaf(x, 0.105468749825f / (y * y * y), y); //k2=0.105468749825f 11:  return y; 12: }

4.2. Algorithms Based on One Iteration

We present algorithms computing $\sqrt[3]{x}$ and $\sqrt[4]{x}$ derived using one M1 iteration. To ensure sufficient precision, iteration will be performed for the approximations resulting from the partition of the ranges $[2^{e_{\tilde{x}}},2^{e_{\tilde{x}}+1}]$ into $M=16$ equal sections. C-language optimized iteration takes the form

$$\begin{array}{cc}\hfill z_1^{\left(M1\right)}& =z_0^{\left(M1\right)}+k_1·x·z_0^{{\left(M1\right)}^{1-n}},\hfill \end{array}$$

(26)

where

$$\begin{array}{c}\hfill z_0^{\left(M1\right)}={\beta }_2·y_0^{\left(M1\right)},{\beta }_2=\left(1-{\displaystyle \frac{1}{n}}\right){\kappa }_{0,1}{\kappa }_{1,1},k_1={\displaystyle \frac{1}{n}}{\beta }_2^{n-1}{\kappa }_{1,1}.\end{array}$$

(27)

Cube root and fourth root approximations based on $z_0$ and $z_i$ are implemented in the functions rt_M1_n3_M16() and rt_M1_n4_M16() (Algorithms 3 and 4). Table $beta3$ stores the multiplication of the ${\beta }_2$ parameter and the table, the coefficients of which are computed by ${\beta }_{e_x,m}^{[n,M]}$ (see (11)) for adequate $e_{\tilde{x}}$.

Algorithm 3 rt_M1_n3_M16

1: float rt_M1_n3_M16(float x){ // x⌃1/3 -> I iter M1   2:  static const float beta3[48] = {   3:   1.03700808869f, 0.997092402893f, 0.960809533798f, 0.927657681256f,   4:   0.897225687452f, 0.869173170848f, 0.843215711384f, 0.819113640440f,   5:   0.796663445928f, 0.775691103009f, 0.756046842097f, 0.737601003018f,   6:   0.720240719391f, 0.703867244273f, 0.688393775961f, 0.673743677394f,   7:   0.653274159927f, 0.628128853547f, 0.605272078286f, 0.584387719855f,   8:   0.565216765063f, 0.547544786978f, 0.531192612188f, 0.516009258923f,   9:   0.501866522603f, 0.488654774449f, 0.476279665532f, 0.464659515063f, 10:   0.453723221676f, 0.443408578696f, 0.433660904475f, 0.424431920691f, 11:   0.823073865444f, 0.791392764631f, 0.762595032346f, 0.736282389546f, 12:   0.712128500057f, 0.689863202873f, 0.669260753644f, 0.650130927258f, 13:   0.632312196065f, 0.615666436459f, 0.600074776241f, 0.585434304062f, 14:   0.571655437816f, 0.558659802003f, 0.546378502065f, 0.534750711126f}; 15:  static const unsigned int R3[48] = { 16:   704815480, 705165140, 705514786, 705864419, 706214041, 706563655, 17:   706913260, 707262859, 707612452, 707962040, 708311622, 708661201, 18:   709010776, 709360347, 709709916, 710059482, 710407886, 710757546, 19:   711107191, 711456824, 711806447, 712156060, 712505666, 712855265, 20:   713204857, 713554445, 713904028, 714253606, 714603181, 714952753, 21:   715302321, 715651887, 707611683, 707961343, 708310988, 708660621, 22:   709010244, 709359857, 709709463, 710059062, 710408655, 710758242, 23:   711107825, 711457404, 711806979, 712156550, 712506119, 712855684}; 24:  float y; unsigned int i, j; 25:  j = *(unsigned int*)&x; i = j >> 19; j = j / 3; 26:  i = i - 48 * (j >> 23); 27:  j = R3[i] + j; 28:  y = *(float*)&j; 29:  y = beta3[i] * y; 30:  y = fmaf(x, 0.148148147569f / (y * y), y); //k1=0.148148147569f 31:  return y; 32: }

Algorithm 4 rt_M1_n4_M16

1: float rt_M1_n4_M16(float x){ // x⌃1/4 -> I iter M1   2:  static const float beta3[64] = {   3:   0.871769690734f, 0.834112093067f, 0.800044687381f, 0.769057226318f,   4:   0.740733518415f, 0.714730490373f, 0.690762640254f, 0.668590321642f,   5:   0.648010795939f, 0.628851315150f, 0.610963714722f, 0.594220143524f,   6:   0.578509660115f, 0.563735495983f, 0.549812837369f, 0.536667013976f,   7:   1.03671471886f, 0.991932035785f, 0.951418834553f, 0.914568325382f,   8:   0.880885570420f, 0.849962584461f, 0.821459846568f, 0.795092367519f,   9:   0.770619049129f, 0.747834458255f, 0.726562396556f, 0.706650822556f, 10:   0.687967803906f, 0.670398262803f, 0.653841338119f, 0.638208231408f, 11:   1.23286851990f, 1.17961263455f, 1.13143404740f, 1.08761115970f, 12:   1.04755538785f, 1.01078155293f, 0.976885894227f, 0.945529500538f, 13:   0.916425656181f, 0.889330058602f, 0.864033171478f, 0.840354186006f, 14:   0.818136207298f, 0.797242384011f, 0.777552771374f, 0.758961769644f, 15:   0.733068007865f, 0.701401868980f, 0.672754709661f, 0.646697464736f, 16:   0.622880160293f, 0.601014307227f, 0.580859827980f, 0.562215204742f, 17:   0.544909955351f, 0.528798816637f, 0.513757197560f, 0.499677588561f, 18:   0.486466699380f, 0.474043157724f, 0.462335644004f, 0.451281368238f}; 19:  static const unsigned int R4[64] = { 20:   797111885, 797505243, 797898586, 798291915, 798685234, 799078543, 21:   799471843, 799865137, 800258424, 800651706, 801044982, 801438254, 22:   801831523, 802224787, 802618049, 803011308, 795014733, 795408091, 23:   795801434, 796194763, 796588082, 796981391, 797374691, 797767985, 24:   798161272, 798554554, 798947830, 799341102, 799734371, 800127635, 25:   800520897, 800914156, 792917581, 793310939, 793704282, 794097611, 26:   794490930, 794884239, 795277539, 795670833, 796064120, 796457402, 27:   796850678, 797243950, 797637219, 798030483, 798423745, 798817004, 28:   799209037, 799602395, 799995738, 800389067, 800782386, 801175695, 29:   801568995, 801962289, 802355576, 802748858, 803142134, 803535406, 30:   803928675, 804321939, 804715201, 805108460}; 31:  float y; unsigned int i, j; 32:  i = *(unsigned int*)&x; j = (i >> 19) & 63; 33:  i = R4[j] + (i >> 2); y = *(float*)&i; y = beta3[j] * y; 34:  y = fmaf(x, 0.105468749413f / (y * y * y), y); //k1=0.105468749413f 35:  return y; 36: }

5. Modifications of the Householder Method

We derive equations which enable creation of the algorithms computing $\sqrt[n]{\tilde{x}}$ using iteration based on the modified Householder’s method of the second order:

$${\tilde{y}}_k^{\left(H\right)}={\tilde{y}}_{k-1}^{\left(H\right)}-{\displaystyle \frac{2{\left(1/f\left({\tilde{y}}_{k-1}^{\left(H\right)}\right)\right)}^{\prime }}{\left(1/f\left({\tilde{y}}_{k-1}^{\left(H\right)}\right)\right)″}},k\in \{1,2,\dots \},$$

(28)

where $f\left(y\right)=y^n-x$ and ${\tilde{y}}_k^{\left(H\right)}={\tilde{y}}_{k,e_x,m}^{[n·M]}\left(\tilde{x}\right)$.

The introduction of the three additional parameters $s_k$, ${\kappa }_{0,k}$, and ${\kappa }_{1,k}$ results in a modified iteration of the following form:

$$\begin{array}{cc}\hfill {\tilde{y}}_k^{\left(M2\right)}& ={\displaystyle \frac{4n{s}_k{\kappa }_{1,k}}{n^2-1}}{y}_{k-1}^{\left(M2\right)}\left({\displaystyle \frac{{\kappa }_{0,k}{(n-1)}^2}{4n}}+{\displaystyle \frac{x}{x+\frac{n+1}{n-1}{s}_k^n{y}_{k-1}^{{\left(M2\right)}^n}}}\right),\hfill \end{array}$$

(29)

$$\begin{array}{cc}\hfill {\delta }_k^{\left(M2\right)}& ={\displaystyle \frac{4n{s}_k{\kappa }_{1,k}}{n^2-1}}({\delta }_{k-1}^{\left(M2\right)}+1)\left({\displaystyle \frac{{\kappa }_{0,k}{(n-1)}^2}{4n}}+{\displaystyle \frac{x}{x+\frac{n+1}{n-1}{s}_k^n{({\delta }_{k-1}^{\left(M2\right)}+1)}^n}}\right)-1.\hfill \end{array}$$

(30)

Relative error ${\delta }_k^{\left(M2\right)}$, in addition to a pair of derived maxima and minima, respectively, from the maxima and minima of $k-1$ iteration errors, also has a new pair of extremes for

$${\delta }_{k-1}^{\left(M2\right)}={\delta }_{k-1,\mp }^{\left(M2\right)}={\displaystyle \frac{1}{s_k}}\sqrt[n]{{\displaystyle \frac{2n-{\kappa }_{0,k}(n-1)\mp 2n\sqrt{1-{\kappa }_{0,k}}}{{\kappa }_{0,k}(1+n)}}}-1.$$

(31)

We find the parameters $s_k$ and ${\kappa }_{0,k}$ by solving a system of equations:

$$\begin{array}{cc}\hfill {\delta }_k^{\left(M2\right)}{|}_{{\kappa }_{1,k}=1,{\delta }_{k-1}^{\left(M2\right)}={\delta }_{k-1,+}^{\left(M2\right)}}& ={\delta }_k^{\left(M2\right)}{|}_{{\kappa }_{1,k}=1,{\delta }_{k-1}^{\left(M2\right)}={\delta }_{k-1,min}^{\left(M2\right)}=-{\delta }_{k-1,max}^{\left(M2\right)}},\hfill \end{array}$$

(32)

$$\begin{array}{cc}\hfill {\delta }_k^{\left(M2\right)}{|}_{{\kappa }_{1,k}=1,{\delta }_{k-1}^{\left(M2\right)}={\delta }_{k-1,-}^{\left(M2\right)}}& ={\delta }_k^{\left(M2\right)}{|}_{{\kappa }_{1,k}=1,{\delta }_{k-1}^{\left(M2\right)}={\delta }_{k-1,max}^{\left(M2\right)}}.\hfill \end{array}$$

(33)

From the equation

$${\delta }_{k-1}^{\left(M2\right)}{{|}_{{\delta }_{k-1}^{\left(M2\right)}={\delta }_{k-1,+}^{\left(M2\right)}}+{\delta }_{k-1}^{\left(M2\right)}|}_{{\delta }_{k-1}^{\left(M2\right)}={\delta }_{k-1,-}^{\left(M2\right)}}=0$$

(34)

we obtain the formula for ${\kappa }_{1,k}$:

$$\begin{array}{cc}\hfill {\kappa }_{1,k}=2\sqrt[n]{{\kappa }_{0,k}}{(1+n)}^{1+1/n}& (\sqrt[n]{2n{a}_1-{\kappa }_{0,k}(n-1)}(2a_2+{\kappa }_{0,k}(n-1))+\hfill \\ & +\sqrt[n]{2n{a}_2-{\kappa }_{0,k}(n-1)}(2a_1+{\kappa }_{0,k}(n-1)))-1,\hfill \end{array}$$

(35)

where

$$a_1=1-\sqrt{1-{\kappa }_{0,k}},a_2=1+\sqrt{1-{\kappa }_{0,k}}.$$

The values of ${\delta }_{1,max}={\delta }_1^{\left(M2\right)}{|}_{{\delta }_0^{\left(M2\right)}={\delta }_{0,max}^{\left(M2\right)}}$ for $n=3$ and $n=4$ are given in

Table 4. Maximal relative errors ${\delta }_{1,max}^{\left(M2\right)}$ and their corresponding numbers of correct bits $a{c}_{\mathrm{bits},1}=\lfloor -{log}_2{\delta }_{1,max}^{\left(M2\right)}\rfloor$ for initial approximation $\sqrt[3]{\tilde{x}}\simeq {\tilde{y}}_{0,e_x,m}^{[3·M]}\left(\tilde{x}\right)$.

	$\mathit{M}=1$	$\mathit{M}=2$	$\mathit{M}=4$	$\mathit{M}=8$
${\delta }_{1,max}$	$4.88·{10}^{-8}$	$1.97·{10}^{-9}$	$5.50·{10}^{-11}$	$1.19·{10}^{-12}$
$a{c}_{\mathrm{bits},1}$	24	28	34	39

and

Table 5. Maximal relative errors ${\delta }_{1,max}^{\left(M2\right)}$ and their corresponding numbers of correct bits $a{c}_{\mathrm{bits},1}=\lfloor -{log}_2{\delta }_{1,max}^{\left(M2\right)}\rfloor$ for initial approximation $\sqrt[4]{\tilde{x}}\simeq {\tilde{y}}_{0,e_x,m}^{[4·M]}\left(\tilde{x}\right)$.

	$\mathit{M}=1$	$\mathit{M}=2$	$\mathit{M}=4$	$\mathit{M}=8$
${\delta }_{1,max}$	$5.49·{10}^{-8}$	$2.22·{10}^{-9}$	$6.20·{10}^{-11}$	$1.34·{10}^{-12}$
$a{c}_{\mathrm{bits},1}$	24	28	33	39

.

Algorithm 5 for $\sqrt[3]{x}$ and Algorithm 6 for $\sqrt[4]{x}$ implement the presented method with $M=2$, i.e., partitioning the ranges $[2^{e_{\tilde{x}}},2^{e_{\tilde{x}}+1}]$ into two equal parts.

We use the following form of iteration in the algorithms:

$$z_1^{\left(M2\right)}=z_0^{\left(M2\right)}\left(k_0+k_1·x/\left(x+z_0^{{\left(M2\right)}^n}\right)\right),\mathrm{where}{z}_0^{\left(M2\right)}={\beta }_2·y_0^{\left(M2\right)},$$

(36)

and

$${\beta }_2=\sqrt[n]{{\displaystyle \frac{n+1}{n-1}}}{s}_k,k_0={\left({\displaystyle \frac{n-1}{n+1}}\right)}^{1+1/n}{\kappa }_{0,1}{\kappa }_{1,1},k_1={\displaystyle \frac{4n}{n^2-1}}\sqrt[n]{{\displaystyle \frac{n-1}{n+1}}}{\kappa }_{1,1}.$$

(37)

Multiplications of parameters ${\beta }_2$ and coefficient tables ${\beta }_{e_x,m}^{[n,M]}$ (given by Equation (11)) for the corresponding ranges $\tilde{x}\in [2^{e_{\tilde{x}}}(1+{\displaystyle \frac{m-1}{M}}),2^{e_{\tilde{x}}}(1+{\displaystyle \frac{m}{M}})]$ result in tables $beta3$.

Algorithm 5 rt_M2_n3_M2_H

1: float rt_M2_n3_M2_H(float x){ // x⌃1/3, I iter M2   2:  static const float beta3[6] = {   3:   1.74053475068f, 1.38407386750f, 1.09646818523f,   4:   0.871911900134f, 1.38146334711f, 1.09854015663f};   5:  static const unsigned int R3[6] = {705915582, 708748133,   6:   711507987, 714340538, 708711784, 711544336};   7:  float y; unsigned int i, j;   8:  j = *(unsigned int*)&x; i = j >> 22; j = j / 3; i = i - 6 * (j >> 23);   9:  j = R3[i] + j; y = *(float*)&j; y = beta3[i] * y; 10:  y *= fmaf(x, 1.19055388160f / (x + y * y * y), 0.396849232120f); 11:  return y; 12: }

Algorithm 6 rt_M2_n4_M2_H

1: float rt_M2_n4_M2_H(float x){ // x⌃1/4, I iter M2   2:  static const float beta3[8] = {   3:   1.15540928653f, 0.892930883379f, 1.37402094428f, 1.06187975972f,   4:   1.63399548310f, 1.26279496554f, 0.971579527194f, 0.750862378903f};   5:  static const unsigned int R4[8] = {   6:   798358146, 801542222, 796260994, 799445070,   7:   794163842, 797347918, 800455298, 803639374};   8:  float y, c; unsigned int i, j;   9:  i = *(unsigned int*)&x; j = (i >> 22) & 7; i = R4[j] + (i >> 2); 10:  y = *(float*)&i; y = beta3[j] * y; c = y * y; 11:  y *= fmaf(x, 0.938789107238f / (x + c * c), 0.528065821580f); 12:  return y; 13: }

6. Approximation with a Single Magic Constant

Modified iterations M2 do not provide sufficient precision when they are used as the last step. However, when used before iteration of the M1 type, they can be used when we want to introduce only one magic constant. We calculate constant R (see (6)), for roots of the n-th order, by finding constant c (see (7)), solving the following equation:

$${\delta }_0\left(1\right)={\delta }_0\left(2^n\right)$$

(38)

where ${\delta }_0\left(\tilde{x}\right)$ is described by Formulas (7) and (8). We get (for any value of $\beta$)

$$c=1-1/n.$$

(39)

Parameter $\beta$ is given by the formula

$$\beta ={\displaystyle \frac{2}{2+{\delta }_0\left(1\right){{|}_{\beta =1}+{\delta }_0\left(2^{e_{\tilde{x},max}}\right)|}_{\beta =1}}},\mathrm{where}{e}_{\tilde{x},max}=\underset{e_{\tilde{x}}\in \{1,\dots ,n-1\}}{argmax}{\delta }_0\left(2^{e_{\tilde{x}}}\right){|}_{\beta =1}.$$

(40)

where the subscript $\beta =1$ means that we compute ${\delta }_0$ from Equation (8) with $\beta =1$. Values of the parameters $e_{\tilde{x},max}$ and $\beta$ and relative errors ${\delta }_{0,max}={\delta }_0\left(2^{e_{\tilde{x},max}}\right)$ for the initial approximation, for $n\in \{2,3,4,5\}$, are given in

Table 6. Values of the parameters $e_{\tilde{x},max}$ and $\beta$ and maximal relative errors for approximation $\sqrt[n]{x}$ ($n\in \{2,3,4,5\}$) with a single magic constant: ${\delta }_{0,max}={\delta }_0\left(2^{e_{\tilde{x},max}}\right)$, ${\delta }_{1,max}={\delta }_{1,max}^{\left(M2\right)}$, and ${\delta }_{2,max}={\delta }_{1,max}^{\left(M1\right)}$.

	$\mathit{n}=2$	$\mathit{n}=3$	$\mathit{n}=4$	$\mathit{n}=5$
$e_{\tilde{x},max}$	1	1	2	2
$\beta$	$0.9705627485$	$0.9716910597$	$0.9705627485$	$0.9704019654$
${\delta }_{0,max}$	$2.94·{10}^{-2}$	$2.83·{10}^{-2}$	$2.94·{10}^{-2}$	$2.96·{10}^{-2}$
${\delta }_{1,max}$	$1.60·{10}^{-6}$	$3.78·{10}^{-6}$	$7.97·{10}^{-6}$	$1.30·{10}^{-5}$
${\delta }_{2,max}$	$2.55·{10}^{-12}$	$1.43·{10}^{-11}$	$6.35·{10}^{-11}$	$1.68·{10}^{-10}$

. Figure 3 presents the relative error plots for the output approximations of the cube root and fourth root.

To achieve higher accuracy, we perform two iterations. They correspond (in this order) to the modified Householder method (29) and the modified Newton–Raphson method (17). Table 6 presents a comparison of the maximal relative errors ${\delta }_0\left(2^{e_{\tilde{x},max}}\right)$, initial approximation, and errors obtained after applying iterations M2 and M1, respectively.

To implement the discussed method as a program, we need to represent each iteration in the following form:

$$z_0={\beta }_2{y}_0,z_1={\displaystyle \frac{n-1}{n}}{\kappa }_{1,2}{\kappa }_{0,2}{y}_1^{\left(M2\right)}=k_{1,1}{z}_0\left(k_{0,1}+{\displaystyle \frac{x}{x+z_0^n}}\right),z_2=y_2^{\left(M1\right)}=z_1+{\displaystyle \frac{k_{1,2}x}{z_1^{n-1}}},$$

where

$$\begin{array}{cccc}\hfill {\beta }_2& =\sqrt[n]{{\displaystyle \frac{n+1}{n-1}}}{s}_1,\hfill & \hfill k_{1,1}& ={\displaystyle \frac{4{\kappa }_{1,2}{\kappa }_{0,2}{\kappa }_{1,1}}{1+n}}\sqrt[n]{{\displaystyle \frac{n-1}{n+1}}},\hfill \\ \hfill k_{0,1}& ={\displaystyle \frac{{(n-1)}^2{\kappa }_{0,1}}{4n}},\hfill & \hfill k_{1,2}& ={\displaystyle \frac{1}{n}}{\left(1-{\displaystyle \frac{1}{n}}\right)}^{n-1}{\kappa }_{1,2}^n{\kappa }_{0,2}^{n-1}.\hfill \end{array}$$

We obtain parameters $s_1$, ${\kappa }_{0,1}$, and ${\kappa }_{1,1}$ using Equations (31)–(35) for $k=1$. We then compute ${\kappa }_{0,2}$ and ${\kappa }_{1,2}$ using Formulas (18) and (19) for $k=2$, with the error ${\delta }_{1,max}^{\left(M1\right)}$ replaced by ${\delta }_{1,max}^{\left(M2\right)}$. The resulting procedures for computing third and fourth roots are presented in Algorithm 7 (function rt_3_M2M1) and Algorithm 8 (function rt_4_M2M1). We use Formulas (39) and (6) to obtain magic constants R (710235477 and 799014912), while the products ${\beta }_2·\beta$ yield the constants $1.22486760675f$ and $1.10336983799f$.

Algorithm 7 rt_3_M2M1

1: float rt_3_M2M1(float x){ // x⌃(1/3) 2:  float y; 3:  unsigned int i; i=*(unsigned int*)&x; 4:  i=710235477+i/3; y=*(float*)&i; y*=1.22486760675f; 5:  y=0.794018666491f*y*(0.333066245882f+x/(x+y*y*y)); //M2 6:  y=fmaf(x, 0.148148148145f/(y*y), y);   //M1 7:  return y; 8: }

Algorithm 8 rt_4_M2M1

1: float rt_4_M2M1(float x){ // x⌃(1/4) 2:  float y, c; 3:  unsigned int i; i=*(unsigned int*)&x; 4:  i=799014912+(i>>2); y=*(float*)&i; y*= 1.10336983799f; 5:  c=y*y; 6:  y=0.704661491656f*y*(0.561738942736f+x/(x+c*c)); //M2 7:  y=fmaf(x, 0.105468749980f/(y*y*y), y);   //M1 8:  return y; 9: }

7. Numerical Tests

Tests were performed on two microcontroller systems equipped with a hardware floating-point unit (FPU):

• STM32F767ZIT6 (ARM Cortex-M7), operating at $f=216\mathrm{MHz}$. The compiler used was arm-none-eabi-gcc with the following flags: -mcpu=cortex-m7 (target core), -mfpu=fpv4-sp-d16 (single-precision FPU), -mfloat-abi=hard (hardware floating-point instructions), -mthumb (Thumb instruction set), and -O3 (maximum speed optimization).
• STM32L432KCU6 (ARM Cortex-M4), operating at $f=80\mathrm{MHz}$. The compiler used was arm-none-eabi-gcc with the following flags: -mcpu=cortex-m4, -mfpu=fpv4-sp-d16, -mfloat-abi=hard, -mthumb, and -O3.

Tests were also conducted on two systems without an FPU, performing floating-point computations using fast integer units such as MAC, DSP extensions, 8/16-bit SIMD operations, and a superscalar pipeline:

• ESP32-D0WDQ6 (Xtensa LX6), operating at $f=240\mathrm{MHz}$. The compiler used was xtensa-esp32-elf-gcc with the flag -O3.
• ESP32-S3 (Xtensa LX7), operating at $f=240\mathrm{MHz}$. The compiler used was xtensa-esp32s3-elf-gcc with the flag -O3.

Tests were also performed on one system without an FPU and without any DSP/MAC/SIMD acceleration units:

• ESP32-C3 (RISC-V RV32IMC), operating at $f=160\mathrm{MHz}$. The compiler used was riscv32-esp-elf-gcc with the flag -O3.

Extreme values of relative errors (${\delta }_{min}$, ${\delta }_{max}$) and relative mean squared errors (RMSEr) were determined by computing the errors for all float numbers $x_i$ in the intervals $[1,2^n)$:

$${\delta }_{min}=\underset{i\in \{0,1,\dots ,N\}}{min}\delta \left(x_i\right),{\delta }_{max}=\underset{i\in \{0,1,\dots ,N\}}{max}\delta \left(x_i\right),\mathrm{RMSEr}=\sqrt{{\displaystyle \frac{1}{N+1}}\sum _{i=0}^N\delta {\left(x_i\right)}^2},$$

where

$$x_i=2^{\lfloor i/2^{23}\rfloor }\left(1+{\displaystyle \frac{imod{2}^{23}}{2^{23}}}\right),N=2^{23}n-1,$$

and

$$\begin{array}{cccccc}\hfill n& =3,\hfill & \hfill \delta \left(x_i\right)& ={\displaystyle \frac{{\tilde{y}}_n\left(x_i\right)-\mathrm{cbrt}\left(\left(\mathbf{double}\right)x_i\right)}{\mathrm{cbrt}\left(\left(\mathbf{double}\right)x_i\right)}}\hfill & \hfill & \mathrm{for}\mathrm{cube}\mathrm{root},\hfill \\ \hfill n& =4,\hfill & \hfill \delta \left(x_i\right)& ={\displaystyle \frac{{\tilde{y}}_n\left(x_i\right)-\mathrm{pow}(\left(\mathbf{double}\right)x_i,0.25)}{\mathrm{pow}(\left(\mathbf{double}\right)x_i,0.25)}}\hfill & \hfill & \mathrm{for}\mathrm{fourth}\mathrm{root}.\hfill \end{array}$$

In the program that tests the accuracy of the algorithms, cbrt(∘) and pow(∘,∘) refer to functions with the same names that compute cube roots and powers of double-precision floating-point numbers (double).

Table 7. Extreme values of relative errors and execution times expressed in cycles ($c=t·f$) for cube root approximations. Extreme values of relative errors were determined for all float numbers and were identical for all tested systems.

Method	Relative Errors			Execution Times
	${\mathbf{\delta }}_{min}$	${\mathbf{\delta }}_{max}$	RMSEr	M7	M4	LX6	LX7	RISC-V
cbrtf	$-2.59·{10}^{-7}$	$2.31·{10}^{-7}$	$5.30·{10}^{-8}$	101	93	222	229	1416
rt_M1_n3	$-8.44·{10}^{-8}$	$9.39·{10}^{-8}$	$2.78·{10}^{-8}$	69	58	147	156	1616
rt_M1_n3_M16	$-8.90·{10}^{-8}$	$9.53·{10}^{-8}$	$2.78·{10}^{-8}$	48	45	83	86	1058
rt_M2_n3_M2_H	$-1.30·{10}^{-7}$	$1.79·{10}^{-7}$	$4.63·{10}^{-8}$	55	47	93	94	1394
rt_3_M2M1	$-8.88·{10}^{-8}$	$9.40·{10}^{-8}$	$2.78·{10}^{-8}$	69	54	144	154	1932

and

Table 8. Extreme values of relative errors and execution times expressed in cycles ($c=t·f$) for fourth root approximations. Extreme values of relative errors were determined for all float numbers and were identical for all tested systems.

Method	Relative Errors			Execution Times
	${\mathbf{\delta }}_{min}$	${\mathbf{\delta }}_{max}$	RMSEr	M7	M4	LX6	LX7	RISC-V
2×sqrtf	$-8.94·{10}^{-8}$	$8.93·{10}^{-8}$	$2.80·{10}^{-8}$	42	37	152	137	1532
rt_M1_n4	$-8.79·{10}^{-8}$	$8.87·{10}^{-8}$	$2.74·{10}^{-8}$	71	58	148	160	1862
rt_M1_n4_M16	$-8.85·{10}^{-8}$	$9.17·{10}^{-8}$	$2.74·{10}^{-8}$	45	43	80	81	1173
rt_M2_n4_M2_H	$-1.62·{10}^{-7}$	$1.29·{10}^{-7}$	$3.97·{10}^{-8}$	49	41	84	86	1396
rt_4_M2M1	$-8.90·{10}^{-8}$	$8.73·{10}^{-8}$	$2.74·{10}^{-8}$	70	55	146	154	2069

list the extreme relative errors and the RMSEr values. All tested configurations produced identical values.

It is worth emphasizing that the obtained values remain valid for the other intervals $A_j$ (see Equation (2)) involving float numbers, with the exception of subnormal numbers.

All data on extreme values of relative errors for cube root approximations are contained in Table 7. In the first row, we present, as a benchmark, the standard cbrtf function, as implemented on microcontrollers such as STM32 and ESP32. In the next rows of Table 7, we show the data for four codes. All of them are based on the “magic constant approach”, which consists of determining the initial approximation using a magic constant and then performing Newton–Raphson-like or Householder-like iterations. Table 8 contains data corresponding to fourth roots. Its structure mirrors that of Table 7, but instead of using cbrtf as the reference function, we apply double square rooting: sqrtf(sqrtf(∘)), denoted as 2 × sqrtf.

The numerical experiments confirm that all proposed algorithms achieve high accuracy, with relative errors largely influenced by machine precision rather than by the iterative schemes themselves. Although the observed error ranges are wider than the theoretical bounds, all cube root methods consistently outperform the standard cbrtf function in terms of precision.

The next part of the analysis focuses on the methods’ execution-time performance. All functions were tested on 1000 independently generated sets of random numbers, each consisting of 1400 elements. For each set, all functions were executed sequentially, and after a given function processed the entire set, its execution time was recorded in microseconds. The value t represents the average execution time of 1,400,000 calls of each function and is computed as the mean of 1000 such measurements. Table 7 presents these results expressed in processor cycles as $f·t$. No significant deviations from the mean value were observed in the collected measurements.

Execution times vary across processors; however, on microcontrollers equipped with an FPU or DSP/MAC/SIMD acceleration units, the proposed algorithms are considerably faster than cbrtf. On devices without acceleration units (e.g., ESP32-C3), only the single-iteration variants provide a clear performance advantage, while the double-iteration versions achieve comparable speed.

The methods from Table 8 exhibit accuracy and timing similar to their counterparts in Table 7. Their precision matches that of the double-square-root approach; however, on STM32 platforms with hardware support for sqrtf, two-iteration schemes are slower, whereas single-iteration ones reach similar performance. On ESP32-D0WDQ6 and ESP32-S3, which lack hardware support for sqrtf or reciprocal operations, the two-iteration algorithms perform comparably, while the single-iteration algorithms are markedly faster.

8. Memory Usage Analysis

The memory usage analysis was performed using identical algorithmic functions. For each of the evaluated platforms, a separate compilation was carried out using the -O3 optimization level. To enable analysis of each function individually—in terms of both its Flash code size and its generated SU stack report—the -fno-inline flag was used to prevent the compiler from inlining functions. Additionally, the -fstack-usage flag was applied to generate SU reports indicating the stack usage of each function. The distribution of program code and static data in Flash memory was analyzed based on the ELF output.

In

Table 9. Comparison of program FLASH memory (Program) and FLASH data memory (${\mathrm{DATA}}_{\mathrm{F}}$) (in bytes) for Algorithms 1–8 based on ELF analysis, on STM32F767ZIT6 and STM32L432KCU6.

Method $(\mathit{n}=3)$	Program	${\mathbf{DATA}}_{\mathbf{F}}$	Method $(\mathit{n}=4)$	Program	${\mathbf{DATA}}_{\mathbf{F}}$
rt_M1_n3	104B	24B	rt_M1_n4	96B	32B
rt_M1_n3_M16	80B	384B	rt_M1_n4_M16	68B	512B
rt_M2_n3_M2_H	100B	48B	rt_M2_n4_M2_H	80B	64B
rt_3_M2M1	112B	0B	rt_4_M2M1	104B	0B

,

Table 10. Comparison of program FLASH memory (Program) and FLASH/RAM data memory (${\mathrm{DATA}}_{\mathrm{F}/\mathrm{R}}$) (in bytes) for Algorithms 1–8 based on ELF analysis, on ESP32-D0WDQ6 (Xtensa LX6).

Method $(\mathit{n}=3)$	Program	${\mathbf{DATA}}_{\mathbf{F}/\mathbf{R}}$	Method $(\mathit{n}=4)$	Program	${\mathbf{DATA}}_{\mathbf{F}/\mathbf{R}}$
rt_M1_n3	129B	24B	rt_M1_n4	123B	32B
rt_M1_n3_M16	91B	384B	rt_M1_n4_M16	76B	512B
rt_M2_n3_M2_H	108B	48B	rt_M2_n4_M2_H	92B	64B
rt_3_M2M1	119B	0B	rt_4_M2M1	117B	0B

,

Table 11. Comparison of program FLASH memory (Program) and FLASH/RAM data memory (${\mathrm{DATA}}_{\mathrm{F}/\mathrm{R}}$) (in bytes) for Algorithms 1–8 based on ELF analysis, on ESP32-S3 (Xtensa LX7).

Method $(\mathit{n}=3)$	Program	${\mathbf{DATA}}_{\mathbf{F}/\mathbf{R}}$	Method $(\mathit{n}=4)$	Program	${\mathbf{DATA}}_{\mathbf{F}/\mathbf{R}}$
rt_M1_n3	133B	24B	rt_M1_n4	127B	32B
rt_M1_n3_M16	91B	384B	rt_M1_n4_M16	76B	512B
rt_M2_n3_M2_H	112B	48B	rt_M2_n4_M2_H	96B	64B
rt_3_M2M1	127B	0B	rt_4_M2M1	121B	0B

and

Table 12. Comparison of program FLASH memory (Program) and FLASH/RAM data memory (${\mathrm{DATA}}_{\mathrm{F}/\mathrm{R}}$) (in bytes) for Algorithms 1–8 based on ELF analysis, on ESP32-C3 (RISC-V).

Method $(\mathit{n}=3)$	Program	${\mathbf{DATA}}_{\mathbf{F}/\mathbf{R}}$	Method $(\mathit{n}=4)$	Program	${\mathbf{DATA}}_{\mathbf{F}/\mathbf{R}}$
rt_M1_n3	182B	24B	rt_M1_n4	178B	32B
rt_M1_n3_M16	124B	384B	rt_M1_n4_M16	110B	512B
rt_M2_n3_M2_H	168B	48B	rt_M2_n4_M2_H	142B	64B
rt_3_M2M1	192B	0B	rt_4_M2M1	188B	0B

, two categories of memory are distinguished: program memory (Program) and static data (Data). In the ESP32-D0WDQ6 and ESP32-S3 platforms, static data are stored in Flash memory but are copied to RAM during system startup (these entries are marked in Table 10 and Table 11 as ${\mathrm{DATA}}_{\mathrm{F}/\mathrm{R}}$). The ESP32-C3 platform uses the same mechanism, as shown in Table 12. In contrast, on STM32F7 and STM32L4, all static data remained in Flash and were not copied to RAM; hence, Table 9 uses the designation ${\mathrm{DATA}}_{\mathrm{F}}$.

The ELF analysis showed that the program code size was similar across all platforms and ranged from several dozen to slightly over one hundred bytes. Static tables ranged from a few dozen bytes to 512 B. Differences between platforms resulted solely from the different compilers (Xtensa, RISC-V, and ARM) and their optimization strategies, despite identical source code.

The stack usage analysis revealed clear differences between architectures. On ESP32-D0WDQ6 and ESP32-S3, each function used exactly 48 B of stack memory, while on ESP32-C3, the stack usage was 16 B. On both STM32 platforms, all analyzed functions reported 0 B stack usage, because all local variables were allocated in registers and no stack frame was required. As a result, STM32F7 and STM32L4 did not use RAM either for static data or for the stack in the analyzed functions.

9. Conclusions

This work presented a complete derivation, analysis, and implementation of fast algorithms for computing n-th roots, with detailed specializations for the cubic and quartic cases. The proposed framework generalizes the structural advantages of inverse-square-root methods (see, e.g., [27,29]) and provides a mathematically transparent error analysis, with theoretical bounds confirmed in practice up to machine precision. Although the observed relative errors are unavoidably affected by floating-point limitations—particularly the $2^{-24}$ granularity of single-precision arithmetic—the experimental results remain consistent with the analytical predictions. In all cases, the accuracy of the cubic root solvers clearly exceeds that of the standard library cbrtf function, and the method of [35] is less accurate by more than two orders of magnitude.

The hardware evaluation, conducted on five representative microcontroller platforms (including both FPU-equipped and non-FPU devices), confirmed the efficiency and portability of the proposed approach. In particular, on all microcontrollers except ESP32-C3 (RISC-V), every implementation from Table 7 achieves markedly better execution times than cbrtf. The quartic root implementations from Table 8 reach accuracy and speed comparable to double square rooting, with single-iteration schemes matching its performance on STM32 devices, and two-iteration variants being slower due to the availability of hardware-accelerated sqrtf.

Overall, the results demonstrate that the proposed family of algorithms provides a high-performance, low-power, and accurate solution for embedded, wearable, and real-time signal-processing systems. The combination of rigorous analysis, provable accuracy, and strong cross-platform performance suggests that these methods offer a compelling alternative to currently used root-extraction routines in resource-constrained environments.