An Explainable Machine Learning Framework for Adaptive Multi-Mode CORDIC Iteration Optimization and Hardware-Efficient Computation

Abstract

The Coordinate Rotation Digital Computer (CORDIC) algorithm is widely employed in digital signal processing and hardware accelerators because it computes a broad range of elementary functions using iterative shift-and-add operations. Conventional CORDIC implementations, however, execute a fixed number of iterations irrespective of the input characteristics or the precision required, resulting in unnecessary computational overhead and increased execution latency. This work presents an explainable machine learning framework for adaptive iteration optimization in a multi-mode CORDIC architecture supporting circular, hyperbolic, and linear operating modes. A unified prediction framework for calculating the optimal number of iterations is made possible by the developing a generic feature representation to describe the numerical behavior of CORDIC computations across various modes. We systematically evaluated eight regression models, including Linear Regression, Decision Tree, Random Forest, Extra Trees, Support Vector Regression, Multi-Layer Perceptron, and Extreme Gradient Boosting (XGBoost) and LightGBM. Among the models evaluated, the Decision Tree achieved the best performance on an independent test set of 2305 samples from 461 previously unseen input groups, with a MAE of 0.9160 iterations, RMSE of 1.9671, and $R^2$ of 0.6076. Predictions were within one and two iterations of the reference value for 80.26% and 90.07% of the test samples, respectively. Since prediction accuracy alone does not guarantee that the required numerical tolerance will be satisfied, the predicted iteration count was further evaluated using the actual CORDIC error, followed by a safety-correction procedure. The safety-corrected approach achieved 100% tolerance satisfaction on the independent test set, reducing the mean number of iterations from 20 to 11.739, corresponding to a 41.31% reduction in iterations. Model behavior was further interpreted using feature importance analysis, permutation importance, and feature ablation studies to examine the contribution of individual features to iteration prediction. Statistical robustness is established using bootstrap confidence intervals, the Friedman test, and Holm-corrected Wilcoxon signed-rank tests.

1. Introduction

The effective estimation of elementary mathematical functions has historically been a crucial issue in numerical analysis, scientific computing, and digital hardware design. Many algorithms have been developed for computing transcendental functions with high precision and low computer overhead. The Coordinate Rotation Digital Computer (CORDIC) algorithm is a widely known iterative numerical algorithm for the computation of several elementary functions. It employs only additions, subtractions, binary shifts, and pre-computed lookup tables, therefore avoiding the use of hardware multipliers [1]. The CORDIC approach still remains a preferred choice for implementing mathematical functions in resource-constrained digital systems, where hardware utilization and computational efficiency are the major driving factors, due to its simple arithmetic structure and regular computation pattern.

The CORDIC algorithm was first proposed by Volder [1] for calculating trigonometric functions in real time by repeated vector rotations. Walther further refined the original formulation into a consistent computational framework operating in circular, linear, and hyperbolic coordinate systems and supporting rotation and vectoring modes [2]. This extension greatly increased the mathematical power of the algorithm. It allowed the algorithm to compute the trigonometric, inverse trigonometric, hyperbolic, exponential, logarithmic, multiplication, division, and square root functions through the same iterative computing technique [2]. Due to its adaptability, CORDIC has transformed from a specialized trigonometric algorithm into a general-purpose numerical technique for computing elementary functions.

The mathematical simplicity and hardware efficiency of CORDIC have led to its extensive utilization in various scientific and engineering applications. Digital signal processing, wireless communication systems, computer graphics, robotics, navigation, image processing, digital phase-locked loops, direct digital frequency synthesizers, FPGA-based accelerators, ASIC implementations, and embedded processors all use it as a basic computational kernel [3,4]. In contrast to traditional arithmetic algorithms that depend significantly on multiplication and division, CORDIC executes iterative coordinate transformations through basic shift-add operations, rendering it especially advantageous for applications where silicon area, power consumption, and computational latency are critical design considerations; however, its dependence on fixed iterative execution often results in unnecessary computations, increased latency, and inefficient hardware utilization when high numerical precision is required [5,6,7,8].

For the past sixty years, much research has concentrated on enhancing multiple facets of CORDIC implementation. Numerous architectural improvements, such as high-radix formulations [9], scaling-free algorithms [10], angle recoding techniques, pipelined architectures [11], redundant arithmetic, and reconfigurable hardware implementations, have been suggested to augment computational speed, diminish hardware complexity, and enhance numerical precision [3,4]. Such developments have greatly expanded the scope of CORDIC applications in modern digital systems, and they made it a preferred computational technique for hardware implementation of elementary mathematical functions [3].

The efficacy of the CORDIC algorithm has led to several improvements over the years to boost its performance. The first attempts to increase throughput were mostly focused on pipelined VLSI architectures [12]. Over time, innovations like hybrid architectures and improved pipeline phases made it possible to design more resource-efficient real-time embedded systems [13]. Researchers have also proposed scale-free solutions to remove the typical scaling factor at the end of iterations, thereby improving hardware efficiency by not carrying out unnecessary multiplications [14].

Such advances notwithstanding, a long-standing limitation of many classical CORDIC designs is their dependence on a fixed number of repetitions to reach the desired precision. This static approach sometimes ends up with too many calculations, especially on inputs that naturally do not need such precision, wasting energy and computing power. A first approach is based on variable iterations depending on the target accuracy, leading to a significant improvement in efficiency as compared to fixed-iteration settings. Furthermore, a low-latency CORDIC based on greedy algorithms has been shown to reduce the average number of iterations [15]. In [16], a hybrid model is proposed that combines the classic CORDIC algorithm with the Variable Scaling Factor (VSF) approach. This architecture is implemented in a Cyclone IV FPGA. It reduces the number of iterations efficiently, with an optimal use of hardware. Advanced reconfigurable CORDIC architectures with circular and hyperbolic modes enhance power and latency parameters [17,18]. High radix and hybrid computing approaches reduce the computational cycles. Hardware-level improvements, for example, the use of carry-select adders and canonical signed-digit representations, have been proven to be effective in reducing power consumption and increasing processing speed. In [8], the specialized pre-rotation and comparison procedures were employed, and the iteration count was decreased.

Despite these significant improvements, there still remains a major limitation in most existing CORDIC implementations. In traditional architectures, a fixed number of iterations is usually performed, regardless of the numerical nature of the input or the precision required for a particular computation. This conservative method guarantees convergence but often results in superfluous iterations, because the desired accuracy may be reached before the maximum iteration limit is reached. This leads to additional calculations being performed without any improvement in the numerical result, and hence to longer computation time, increased energy consumption, and suboptimal utilization of computational resources. With the increasing demand for adaptive computation, a major research challenge in modern embedded and real-time systems is the determination of the minimum number of iterations to meet a given error tolerance.

Several solutions have been considered to solve this problem. Computational redundancy has been reduced by adopting analytical error models, adaptive stopping criteria, lookup-table-based techniques, and modified convergence schemes, all while preserving numerical accuracy [3]. Many methodologies improve some aspects of algorithmic efficiency, while some methodologies require additional control logic, are based on mode-dependent mathematical frameworks, or are increasingly difficult to generalize over different CORDIC working modes. Analytical determination of the number of iterations is not possible for general CORDIC implementations due to the nonlinear relation between input parameters, operating mode, numerical accuracy, and convergence behavior.

In a recent study, the feasibility of using machine learning for adaptive iteration prediction in the circular CORDIC algorithm has been demonstrated [19]. The study shows that regression models can efficiently predict near-optimal iteration numbers with computational accuracy maintained. The proposed method was limited to circular CORDIC operations, a small dataset was used for simulations, a limited number of regression models were evaluated and model interpretability, and statistical robustness and hardware-oriented performance were not investigated. Therefore, the application of the method to more general CORDIC designs and to the real hardware implementation is mostly uncharted.

These constraints motivated this work, which presents an explainable machine learning framework for adaptive iteration selection in a multi-mode CORDIC system. Unlike previous techniques, the proposed framework supports circular, hyperbolic, and linear CORDIC operations in a unified prediction model by leveraging an extended feature representation characterizing the numerical properties of CORDIC convergence. Eight regression algorithms are carefully examined by grouped cross-validation and improved hyperparameter setups in an effort to find the most acceptable prediction model. To obtain a reliable estimate of generalization performance, grouped validation is used during model development, while the final models are evaluated on an independent test set containing 2305 samples from 461 previously unseen input groups. The model behavior is further analyzed using feature importance, permutation importance, and feature ablation analyses. Bootstrap confidence intervals, Friedman statistical testing, and Holm-adjusted Wilcoxon signed-rank analysis further corroborate the prediction performance. The predicted iteration counts are further verified using the actual CORDIC error to ensure that the required numerical tolerance is satisfied. A safety-correction mechanism is incorporated to address under-prediction of the required iterations. The framework is then evaluated through independent testing, mode-wise and tolerance-wise analyses, statistical testing, and explainability analysis. The overall architecture of the proposed explainable ML-based adaptive CORDIC framework, including the ML-based iteration prediction, post-processing, safety correction, and CORDIC execution stages, is shown in Figure 1.

Main Contributions

The major contributions of this work are summarized below:

• We propose an explainable machine learning framework for adaptive iteration optimization of multi-mode CORDIC systems that enables unified iteration prediction for circular, hyperbolic, and linear operating modes.
• An efficient and mode-agnostic feature representation is proposed to characterize the numerical convergence behavior of CORDIC computations, which is then employed to predict the optimal number of iterations for different operating modes with high accuracy.
• Eight regression models are considered: Linear Regression, Decision Tree, Random Forest, Extra Trees, Support Vector Regression, Multi-Layer Perceptron, Light GBM, and XGBoost. Grouped validation is used during model development, followed by evaluation on an independent test set containing previously unseen input groups.
• The predicted iteration count is checked against the actual CORDIC error to determine whether the required tolerance is achieved. A safety-correction step is used when the predicted number of iterations is too low, and the resulting performance is examined for different CORDIC modes and tolerance levels.
• The robustness of the proposed framework is confirmed by extensive statistical validation with the use of bootstrap confidence intervals, the Friedman test, and Holm-corrected Wilcoxon signed-rank post hoc analysis.

This paper’s remaining sections are structured as follows. Section 2 delineates the mathematical foundation of the multi-mode CORDIC algorithm, encompassing its operational principles, coordinate systems, convergence behavior, and iteration characteristics. The suggested explainable machine learning framework for adaptive multi-mode CORDIC iteration optimization, which includes feature engineering, regression models, and the prediction technique, is explained in Section 3. In Section 4 we present the experimental methodology, including dataset generation, model training, hyperparameter optimization, grouped validation, independent testing, and evaluation metrics. In Section 5, we provide the experimental results, including explainability analysis, statistical validation, and tolerance-aware performance evaluation to demonstrate the effectiveness of the proposed framework. The work is concluded in Section 6, which summarizes the key findings and discusses possible options for future research.

2. Proposed Methodology

2.1. Unified Multi-Mode CORDIC Formulation

The Coordinate Rotation Digital Computer (CORDIC) algorithm is an iterative numerical technique used to compute elementary mathematical functions with only shift-and-add arithmetic. In this work, circular, hyperbolic, and linear CORDIC operations are mathematically modeled in a unified way, yielding a common computational framework for adaptive iteration prediction for multiple operation modes. This unified representation enables the proposed learning framework to estimate the minimum number of iterations to achieve a given numerical accuracy while preserving the mathematical characteristics of each CORDIC mode.

The CORDIC state of the ith iteration is given by

$${\mathbf{s}}_i={[x_i,y_i,z_i]}^T,$$

(1)

where $x_i$ and $y_i$ are the Cartesian coordinates and $z_i$ is the residual rotation parameter.

The generalized iterative update is expressed as

$$\begin{array}{l}{x}_{i+1}=x_i-m{d}_i{y}_i{2}^{-i},\\ y_{i+1}=y_i+d_i{x}_i{2}^{-i},\\ z_{i+1}=z_i-d_i{\varphi }_i,\end{array}$$

(2)

where $d_i\in \{-1,+1\}$ denotes the direction of rotation, m denotes the CORDIC mode, and ${\varphi }_i$ is the elementary rotation angle. The parameter m is 1, $-1$, and 0 for circular, hyperbolic, and linear modes, respectively. This formulation yields a unified mathematical representation with characteristics of each operational mode preserved.

2.2. Circular CORDIC

The trigonometric functions $\sin \left(\theta \right)$ and $\cos \left(\theta \right)$ are computed in the circular mode by successive elementary rotations. To ensure convergence over the entire angular domain, the input angle is first normalized and then mapped to the principal convergence interval $-{\displaystyle \frac{\pi }{2}}\le \theta \le {\displaystyle \frac{\pi }{2}}$ by quadrant reduction.

The effective rotation angle is therefore confined to

$$-{\displaystyle \frac{\pi }{2}}\le \theta \le {\displaystyle \frac{\pi }{2}},$$

while the corresponding sign corrections are applied after convergence to recover the trigonometric values over the complete angular range.

The CORDIC gain compensates for the accumulated scaling due to successive rotations

$$K_N={\displaystyle \prod _{i=0}^{N-1}}{\displaystyle \frac{1}{\sqrt{1+2^{-2i}}}},$$

(3)

which converges to approximately $0.607252935$ as N increases.

The algorithm is initialized as

$$x_0=K_N,y_0=0,z_0=\theta .$$

(4)

The rotation direction is selected according to

$$d_i=\left\{\begin{array}{cc}+1,\hfill & z_i\ge 0,\hfill \\ -1,\hfill & z_i<0.\hfill \end{array}\right.$$

(5)

The iterative updates are

$$\begin{array}{l}{x}_{i+1}=x_i-d_i{y}_i{2}^{-i},\\ y_{i+1}=y_i+d_i{x}_i{2}^{-i},\\ z_{i+1}=z_i-d_i{\tan }^{-1}\left(2^{-i}\right).\end{array}$$

(6)

After N iterations, the estimates of $\cos \left(\theta \right)$ and $\sin \left(\theta \right)$ are obtained from the final values of $x_N$ and $y_N$, respectively.

2.3. Hyperbolic CORDIC

The hyperbolic mode evaluates the hyperbolic functions $\cosh \left(v\right)$ and $\sinh \left(v\right)$ through iterative hyperbolic rotations.

The update equations are

$$\begin{array}{l}{x}_{i+1}=x_i+d_i{y}_i{2}^{-i},\\ y_{i+1}=y_i+d_i{x}_i{2}^{-i},\\ z_{i+1}=z_i-d_i{\tanh }^{-1}\left(2^{-i}\right).\end{array}$$

(7)

The associated gain factor is

$$K_H={\displaystyle \prod _{i=1}^{N-1}}{\displaystyle \frac{1}{\sqrt{1-2^{-2i}}}}.$$

(8)

Unlike circular CORDIC, hyperbolic CORDIC requires repeated elementary iterations to satisfy its convergence conditions. For the adopted iteration depth, the fourth elementary iteration is repeated to ensure numerical stability. In addition, the input is verified to remain within the convergence interval before execution.

2.4. Linear CORDIC

Linear mode performs successive linear transformations without geometric rotation and is commonly employed for multiplication, division, and other linear numerical operations. The iterative process progressively reduces the residual coordinate while accumulating the corresponding linear transformation.

The iterative equations are

$$\begin{array}{l}{x}_{i+1}=x_i,\\ y_{i+1}=y_i-d_i{x}_i{2}^{-i},\\ z_{i+1}=z_i+d_i{2}^{-i},\end{array}$$

(9)

where

$$d_i=\left\{\begin{array}{cc}+1,\hfill & y_i>0,\hfill \\ -1,\hfill & y_i\le 0.\hfill \end{array}\right.$$

(10)

Unlike the circular and hyperbolic modes, no gain compensation factor is required because the transformation does not introduce rotational scaling. The residual value of y after the final iteration is used as the convergence error.

2.5. Numerical Error Evaluation

The numerical accuracy is evaluated by comparing the CORDIC output with the corresponding analytical solution. For circular mode, the error at iteration i is defined as

$$E_i=\max \left(|x_i-\cos \theta |,|y_i-\sin \theta |\right).$$

(11)

Similarly, hyperbolic mode compares the iterative estimates with the analytical values of $\cosh \left(v\right)$ and $\sinh \left(v\right)$, while linear mode evaluates the residual magnitude of the transformed coordinate.

The required iteration count is defined as

$$N^{\ast }=\min \left\{i:E_i\le \epsilon \right\},$$

(12)

where $\epsilon$ denotes the prescribed numerical tolerance. The search is carried out up to the maximum allowed iteration count $N_{\max }$.

2.6. Adaptive Iteration Learning Framework

The convergence data generated from circular, hyperbolic, and linear CORDIC executions are used to construct a supervised learning dataset. Each sample consists of the input characteristics together with the corresponding optimal iteration count $N^{\ast }$.

The learning problem is formulated as

$$f\left(\mathbf{x}\right)\to N^{\ast },$$

(13)

where $\mathbf{x}$ denotes the feature vector describing the numerical characteristics of the CORDIC input.

In the inference phase, the trained regression model predicts the minimum number of iterations needed to reach the desired numerical accuracy. This enables the elimination of redundant iterations occurring in conventional fixed-iteration CORDIC implementations with specified numerical tolerance. This adaptive strategy allows us to use the computational resources for each input in accordance with the numerical complexity of it, and it thus improves the efficiency of the computation without deteriorating the solution accuracy. In the inference phase, the trained regression model calculates the number of iterations for the input and tolerance. The expected number is converted into an integer number of iterations and then compared with the actual CORDIC error. Because direct forecasts can underestimate the number of iterations needed, a precautionary adjustment strategy is undertaken when appropriate. The resulting iteration count is then used for the adaptive CORDIC process. This approach allows us to minimize the number of unnecessary iterations and to confirm the specified numerical tolerance immediately.

3. Dataset Generation and Feature Engineering

3.1. Simulation-Based Multi-Mode Dataset Generation

In contrast to traditional machine learning research that uses publicly accessible datasets, the suggested framework uses a simulation-driven methodology where the training dataset is produced directly from the multi-mode CORDIC algorithm’s numerical behavior. The goal is to generate a supervised learning dataset that captures the mapping between input features of a CORDIC operation and the minimal number of iterations needed to meet a certain numerical accuracy.

For the dataset construction, three CORDIC computational frameworks for circular, hyperbolic, and linear operating modes were developed considering the mathematical formulation shown in Section 2. Each model was iterated up to a maximum of 20 iterations and the convergence of the numerical solution was checked at each iteration. The complete CORDIC simulation is used during dataset construction to determine the reference iteration count. During inference, the trained regression model estimates the required number of iterations without executing the complete iterative CORDIC sequence.

A systematic sampling of the input space was used to explore a large range of operating conditions for all supported CORDIC modes. We studied the circular mode over the angular range $[-{180}^{\circ },{180}^{\circ }]$, the hyperbolic mode over the convergence interval $[-1.0,1.0]$, and the linear mode over a set of pre-defined input combinations corresponding to linear transformations. Furthermore, a number of numerical tolerance levels were integrated to accommodate for various precision requirements, allowing the resulting dataset to span different convergence conditions encountered in practical applications.

After each iteration, the numerical error for each simulation sample was computed using the analytical reference solution as detailed in Section 2. The optimal number of iterations was then determined as the first iteration satisfying the given error tolerance and used as the target variable for supervised regression. Therefore, each example in the dataset contains the input descriptors and its best iteration number, providing the ground-truth information necessary for adaptive iteration selection.

3.2. Feature Engineering

The quality and representativeness of the input features have a significant impact on the predictive power of a machine learning model. The proposed framework employs a compact feature representation that only uses the quantities known before execution, instead of the large number of intermediate variables produced by the iterative CORDIC computation. The design enables the regression model to estimate the needed iteration number using only information available before the CORDIC iterations begin, without relying on intermediate values generated during the iterative computation.

The final feature vector consists of six predictors selected to describe the main factors affecting the convergence behavior of the CORDIC algorithm across the three operating modes. These predictors are the operating mode, input value, absolute input magnitude, input sign, quadrant information, and logarithmic inverse tolerance as shown in

Table 1. Input features used for adaptive CORDIC iteration prediction.

Feature	Description
Mode	Indicates the CORDIC operating mode (Circular, Hyperbolic, or Linear).
Input Value	Original numerical input supplied to the CORDIC algorithm.
Absolute Input	Absolute magnitude of the input value, independent of its sign.
Sign Input	Sign of the original input value, indicating its positive or negative direction.
Quadrant	Identifies the input region or quadrant, providing additional geometric information for convergence.
$\log (1/\delta )$	Logarithmic inverse of the prescribed error tolerance, representing the required numerical precision.

. The resulting feature representation is compact and uses only quantities available before the CORDIC iterations begin.

The final feature representation deliberately excludes mathematical function values such as $\sin \left(x\right)$, $\cos \left(x\right)$, $\sinh \left(x\right)$, and $\cosh \left(x\right)$ from the prediction inputs. Since they are the outputs of the CORDIC computation and are used only as analytical reference values during numerical error evaluation, using these values from the predictor set avoids a circular dependency between feature generation and CORDIC execution.

3.3. Dataset Characteristics

The simulation procedure presented in the previous subsection produced a single regression dataset with samples for circular, hyperbolic, and linear CORDIC operations under different numerical precision requirements. Each record includes the engineered feature vector and the corresponding optimal iteration count obtained by iterative numerical simulation. Thus, the dataset describes the relation between the operating mode, the input properties, the convergence tolerance, and the minimum number of iterations needed to obtain the specified numerical accuracy.

Figure 2 summarizes the characteristics of the generated simulation dataset. As shown in Figure 2a, the dataset includes samples from circular, hyperbolic, and linear CORDIC modes, with circular mode contributing the largest number of samples due to its wider operating range. Figure 2b shows that the optimal iteration count is primarily distributed between 8 and 14 iterations, although the required iterations vary with the input conditions and prescribed numerical tolerance. This variability highlights the limitations of fixed-iteration CORDIC implementations and motivates the proposed adaptive iteration prediction framework. The produced dataset consists of 11,505 simulation samples with input parameters, tolerance information, auxiliary simulation variables, and the reference optimal iteration count. For model development, only the six final predictors listed in Table 1 and the optimal iteration count are retained, while the auxiliary simulation variables are used for convergence and validation analysis.

The regression dataset used for training the final model consisted of the engineered predictor variables and the optimal number of iterations, whereas the auxiliary variables generated during simulation were only kept for validation and convergence analysis, see (

Table 2. Representative samples from the generated simulation dataset.

Mode	Input Value	Abs. Input	Quadrant	$\mathit{\delta }$	$\log (1/\mathit{\delta })$	Mode-Dependent Descriptor 1	Mode-Dependent Descriptor 2	Optimal Iteration	Residual Error
0	−3.141593	3.141593	1	0.0001	4.00000	−1.224647 × 10−16	−1.0000	14	0.000048
0	−3.141593	3.141593	1	0.0005	3.30103	−1.224647 × 10−16	−1.0000	12	0.000196
0	−3.141593	3.141593	1	0.0010	3.00000	−1.224647 × 10−16	−1.0000	8	0.000780
0	−3.141593	3.141593	1	0.0050	2.30103	−1.224647 × 10−16	−1.0000	8	0.000780
0	−3.141593	3.141593	1	0.0100	2.00000	−1.224647 × 10−16	−1.0000	8	0.000780

).

Figure 3 shows the Pearson correlation among the final predictor features. Some association is observed between input_value and sign_input, as well as between mode and quadrant. In contrast, log_inverse_delta shows negligible linear correlation with the remaining predictors. The correlation analysis was used as an exploratory assessment of feature relationships and was not used as the basis for removing predictors, since nonlinear dependencies may not be captured by pairwise correlation alone.

4. Explainable Machine Learning Framework

4.1. Problem Formulation

The objective of the proposed framework is to predict the minimum number of CORDIC iterations required to satisfy a prescribed numerical tolerance without executing the complete fixed-iteration CORDIC algorithm. Unlike conventional implementations that employ a predetermined number of iterations irrespective of the input characteristics, the proposed approach formulates adaptive iteration estimation as a supervised regression problem.

Let

$$\mathbf{x}={[x_1,x_2,\dots ,x_d]}^T,$$

(14)

denote the feature vector extracted from the simulation dataset, where $d=6$ represents the number of input features described in Section 4. These features characterize the operating mode, input properties, and the required numerical precision using quantities available before the iterative CORDIC execution.

For every input sample, the corresponding target variable is the optimal iteration count,

$$N^{\ast }\in \mathbb{N},$$

(15)

obtained through numerical simulation using the convergence criterion presented in Section 2. The learning objective is therefore to estimate the nonlinear mapping

$$f:\mathbf{x}\to N^{\ast },$$

(16)

where $f(·)$ denotes the regression model learned from the simulation dataset.

Given a training dataset

$$\mathcal{D}={\left\{({\mathbf{x}}_i,N_i^{\ast })\right\}}_{i=1}^M,$$

(17)

where M denotes the total number of simulation samples, the regression model is trained to minimize the discrepancy between the predicted iteration count

$${\widehat{N}}_i=f\left({\mathbf{x}}_i\right),$$

(18)

and the corresponding optimal iteration count $N_i^{\ast }$.

During inference, only the engineered feature vector is required as input, enabling the trained regression model to directly estimate the required number of CORDIC iterations without performing iterative convergence analysis. The predicted iteration count is subsequently supplied to the adaptive CORDIC engine, which executes only the estimated number of iterations instead of a fixed maximum iteration depth. Consequently, unnecessary computations are eliminated while preserving the desired numerical accuracy. The continuous regression output is converted to an integer iteration count and checked against the actual CORDIC error. If the predicted iteration count is insufficient to satisfy the prescribed tolerance, a safety-correction procedure increases the iteration count until the tolerance condition is satisfied or the maximum iteration limit is reached. The resulting safe iteration count is then supplied to the adaptive CORDIC engine. Algorithm 1 summarizes the proposed adaptive iteration selection framework.

Algorithm 1: Explainable adaptive multi-mode CORDIC framework.
	Input: Input parameters $(m,x,\delta )$
	Output: Adaptive CORDIC output
1.	Extract the six pre-execution features;
2.	Construct the feature vector $\mathbf{x}$;
3.	Load the trained machine learning model;
4.	Predict the optimal iteration count $$\widehat{N}=f\left(\mathbf{x}\right)$$
5.	Convert $\widehat{N}$ to an integer iteration count using the ceiling operation and constrain it to $[1,N_{\max }]$;
6.	Evaluate the CORDIC error at the predicted iteration count;
7.	If the error exceeds the prescribed tolerance, increase the iteration count until the tolerance is satisfied or $N_{\max }$ is reached;
8.	Execute the CORDIC operation using the resulting safe iteration count and return the output;

4.2. Regression Models and Hyperparameter Optimization

To address the adaptive iteration prediction problem, we use supervised regression approaches that can learn the nonlinear relationship between the engineering feature vector and the ideal iteration count. To examine the different learning paradigms in a thorough manner, eight regression algorithms were investigated, Linear Regression (LR), Decision Tree (DT), Random Forest (RF), Extra Trees (ET), Support Vector Regression (SVR), Multi-Layer Perceptron (MLP), Light Gradient Boosting Machine (LightGBM), and Extreme Gradient Boosting (XGBoost). These models include linear, tree-based, ensemble, kernel-based, neural network and gradient boosting methods, giving a wide-ranging evaluation of regression methods for adaptive multi-mode CORDIC iteration prediction. Model development was performed using grouped validation to reduce the effect of similar input configurations appearing across training and validation sets. Hyperparameter selection was performed only on the development data, and the final model performance was assessed separately on an independent test set.

The resulting optimal hyperparameter settings are presented in

Table 3. Optimal hyperparameters selected for the classical regression models using GridSearchCV.

Model	Hyperparameters
Decision Tree	criterion = squared_error
	max_depth = None
	min_samples_split = 2
	min_samples_leaf = 1
	max_features = None
	random_state = 42
Random Forest	n_estimators = 300
	criterion = squared_error
	max_depth = 20
	min_samples_split = 2
	min_samples_leaf = 1
	max_features = sqrt
	bootstrap = True
Extra Trees	n_estimators = 300
	criterion = squared_error
	max_depth = None
	min_samples_split = 2
	min_samples_leaf = 1
	max_features = sqrt
	bootstrap = False
SVR	kernel = RBF
	$C=100$
	$\gamma =$ scale
	$\epsilon =0.1$

and

Table 4. Hyperparameter settings of the selected regression models.

Model	Hyperparameters
MLP	hidden_layer_sizes = (128, 64)
	activation = ReLU
	solver = Adam
	$\alpha ={10}^{-4}$
	learning_rate = adaptive
	max_iter = 1000
	early_stopping = True
XGBoost	n_estimators = 300
	learning_rate = 0.05
	max_depth = 6
	min_child_weight = 2
	subsample = 0.8
	colsample_bytree = 0.8
LightGBM	n_estimators = 300
	learning_rate = 0.05
	num_leaves = 31
	max_depth = −1
	min_child_samples = 20
	subsample = 0.8
	colsample_bytree = 0.8

. For tree-based models, parameters controlling the depth of trees, the splitting of nodes, and the size of the ensemble were tuned to find an appropriate balance between predictive accuracy and model complexity. For kernel and neural network models, the optimization was on the parameters that control the nonlinear learning process, such as the kernel function, regularization coefficient, network architecture and learning rate. Similarly, the gradient boosting models were tuned by selecting the appropriate values for the number of boosting iterations, learning rate, tree depth, and sampling ratios. We then used the optimized configurations found by GridSearchCV for all experimental evaluations reported in this paper.

4.3. Experimental Setup

The suggested adaptive multi-mode CORDIC framework was developed in Python 3.14.7 and operated on the Google Colaboratory cloud computing platform. Numerical computations and data preprocessing were executed with NumPy 2.5.2 and Pandas 3.0.5, while visualization was conducted using Matplotlib 3.11.1. The regression models were executed with the Scikit-learn 1.9.0 and XGBoost 3.4.1 libraries. The software documentation was accessed on 25 February 2026. All experiments used the simulation dataset described in Section 4, with the six-feature representation as the model input and the optimal iteration count as the target variable (

Table 5. Experimental setup used in this study.

Parameter	Specification
Programming Language	Python 3.x
Execution Platform	Google Colaboratory
Libraries	NumPy, Pandas, Scikit-learn,
	XGBoost, LightGBM, Matplotlib
Learning Task	Supervised Regression
Target Variable	Optimal Iteration Count

). Model development and hyperparameter selection were performed using the development data, while the final model comparison was carried out on an independent test set that was not used for training or hyperparameter tuning.

4.4. Evaluation Metrics

The regression models’ predictive performance was assessed using standard statistical measures and application-specific metrics related to adaptive CORDIC iteration prediction. Mean Absolute Error (MAE), Root Mean Square Error (RMSE), coefficient of determination ($R^2$), Mean Absolute Percentage Error (MAPE), Median Absolute Error (MedAE), Maximum Error (MaxError), and Explained Variance Score (EVS) were all included in the evaluation. We also report the percentage of predictions within $\pm 1$ and $\pm 2$ iterations of the optimal solution to evaluate the practical usefulness of the proposed framework. The computational efficiency was measured by the training time, prediction time, and average inference time per sample.

The Mean Absolute Error (MAE) is computed as

$$\mathrm{MAE}={\displaystyle \frac{1}{N}}{\displaystyle \sum _{i=1}^N}|y_i-{\widehat{y}}_i|,$$

(19)

where $y_i$ and ${\widehat{y}}_i$ denote the actual and predicted iteration counts, respectively, and N is the total number of samples.

The Root Mean Square Error (RMSE), which assigns greater weight to larger prediction errors, is given by

$$\mathrm{RMSE}=\sqrt{{\displaystyle \frac{1}{N}}\sum _{i=1}^N{(y_i-{\widehat{y}}_i)}^2}.$$

(20)

The coefficient of determination is calculated as

$$R^2=1-{\displaystyle \frac{{\sum }_{i=1}^N{(y_i-{\widehat{y}}_i)}^2}{{\sum }_{i=1}^N{(y_i-\overline{y})}^2}},$$

(21)

where $\overline{y}$ is the mean of the observed values.

Since the number of predictor variables influences the coefficient of determination, the Adjusted $R^2$ is computed as

$$\mathrm{Adjusted}{R}^2=1-(1-R^2)\left({\displaystyle \frac{N-1}{N-p-1}}\right),$$

(22)

where p denotes the number of predictor variables.

The Mean Absolute Percentage Error (MAPE) is defined as

$$\mathrm{MAPE}={\displaystyle \frac{100}{N}}{\displaystyle \sum _{i=1}^N}\left|{\displaystyle \frac{y_i-{\widehat{y}}_i}{y_i}}\right|.$$

(23)

$${\mathrm{Accuracy}}_{\pm k}={\displaystyle \frac{1}{N}}{\displaystyle \sum _{i=1}^N}\mathbf{1}\left(|y_i-{\widehat{y}}_i|\le k\right)\times 100,k\in \{1,2\},$$

(24)

Since a small prediction error does not necessarily mean that the required numerical tolerance will be achieved, the predicted iteration count was further checked against the actual error produced by the CORDIC computation. For each test sample, tolerance satisfaction was determined as

$$S_i=\left\{\begin{array}{cc}1,\hfill & E_{{\widehat{N}}_i}\le {\epsilon }_i,\hfill \\ 0,\hfill & E_{{\widehat{N}}_i}>{\epsilon }_i,\hfill \end{array}\right.$$

(25)

where ${\widehat{N}}_i$ represents the predicted integer number of iterations, $E_{{\widehat{N}}_i}$ denotes the CORDIC error obtained after ${\widehat{N}}_i$ iterations, and ${\epsilon }_i$ is the required tolerance for the corresponding sample. The overall tolerance satisfaction rate is calculated as

$$\mathrm{TSR}={\displaystyle \frac{1}{N}}{\displaystyle \sum _{i=1}^N}{S}_i\times 100.$$

(26)

In addition to the tolerance satisfaction rate, the prediction errors were examined according to their direction to distinguish between under-prediction and over-prediction. The results were also analyzed separately for the three CORDIC modes and for each tolerance level to assess the reliability of the adaptive iteration strategy under different operating conditions.

Median Absolute Error, Maximum Error, and Explained Variance Score were also computed to provide additional information on prediction stability and robustness. Since the proposed framework predicts the optimal CORDIC iteration count, two application-oriented measures, Accuracy ± 1 and Accuracy ± 2, were introduced. These represent the percentage of predictions lying within one and two iterations of the corresponding optimal iteration count, respectively. Finally, the computational cost of each regression model was evaluated using the training time, prediction time, and average inference time per sample.

4.5. Explainability Framework

Understanding the factors that influence the predicted CORDIC iteration count is essential for assessing the reliability of the proposed adaptive framework. To provide a transparent interpretation of the regression models, both model-specific and model-agnostic explainability techniques were employed. These analyses were performed after model training and were used to investigate the contribution of each engineered feature to the predicted iteration count. For the tree-based ensemble models, feature importance scores were obtained directly from the trained models to quantify the relative contribution of each predictor during the learning process. Since impurity-based feature importance may be affected by feature interactions, permutation importance was additionally computed by randomly shuffling each feature and measuring the resulting degradation in prediction accuracy. This approach provides a model-agnostic estimate of feature relevance.

To further interpret individual model predictions, SHapley Additive exPlanations (SHAP) were employed. SHAP assigns a contribution value to every feature for each prediction based on cooperative game theory, enabling both global and local interpretation of the regression model. The global SHAP summary identifies the most influential predictors across the entire dataset, while the local explanations illustrate how individual feature values increase or decrease the predicted iteration count.

Finally, an ablation analysis was conducted to evaluate the importance of each engineered feature. In this analysis, one feature was removed at a time, and the regression models were retrained using the remaining predictors. The resulting variation in prediction performance provides additional evidence regarding the contribution of individual features to adaptive iteration prediction and validates the effectiveness of the proposed feature engineering strategy.

5. Results and Analysis

5.1. Overall Performance Comparison of ML Models

Eight regression models were evaluated for predicting the CORDIC iteration requirement: Linear Regression, Decision Tree, Random Forest, Extra Trees, XGBoost, LightGBM, Support Vector Regression, and Multi-Layer Perceptron. Model development was carried out using grouped cross-validation, while the final performance was assessed on an independent test set that was not used during model training or hyperparameter selection. This separation was used to provide a more realistic assessment of the ability of the models to generalize to previously unseen input configurations.

Table 6. Performance of the regression models on the independent test set.

Model	MAE ↓	RMSE ↓	${\mathit{R}}^2$↑	Accuracy ± 1 (%) ↑	Accuracy ± 2 (%) ↑
Decision Tree	0.9160	1.9671	0.6076	80.26	90.07
SVR	1.2573	2.1849	0.5158	78.48	89.33
LightGBM	1.2680	2.0441	0.5762	76.40	90.11
Random Forest	1.2759	2.0819	0.5604	73.67	88.68
XGBoost	1.2805	2.0516	0.5731	76.75	90.11
Extra Trees	1.2826	2.1044	0.5508	69.67	88.24
MLP	1.3311	2.0991	0.5531	75.88	89.11
Linear Regression	1.3974	2.3189	0.4546	75.31	89.80

Note: ↓ indicates that lower values are better, whereas ↑ indicates that higher values are better. Bold represents the best performance-highest accuracy or lowest error.

presents the performance obtained on the independent test set. Among the evaluated models, the Decision Tree achieved the lowest MAE of 0.9160 and RMSE of 1.9671, together with an $R^2$ value of 0.6076. It also predicted the required iteration count within $\pm 1$ iteration for 80.26% of the test samples and within $\pm 2$ iterations for 90.07%. The remaining models produced MAE values between 1.2573 and 1.3974, with $R^2$ values ranging from 0.4546 to 0.5762. The Decision Tree therefore provided the best overall performance on the independent test set and was selected as the final prediction model for the subsequent reliability, tolerance-aware, and interpretability analyses.

Figure 4 compares the eight regression models on the independent test set using MAE, MSE, and $R^2$. The Decision Tree achieved the lowest MAE, indicating the smallest average absolute deviation between the predicted and target CORDIC iteration counts. In terms of MSE, LightGBM and XGBoost provided slightly better regression fit, with LightGBM obtaining the lowest MSE. However, the Decision Tree achieved the highest R² among the evaluated models. The results therefore show that the models exhibit different strengths depending on the evaluation criterion. Since the Decision Tree produced the lowest MAE and provides a direct and interpretable iteration prediction, it was selected for the subsequent adaptive CORDIC evaluation, feature-importance analysis, and explainability analysis.

The independent-test results also show that the Decision Tree achieved the highest $R^2$ value among the evaluated models, with an $R^2$ of 0.6076. LightGBM and XGBoost obtained $R^2$ values of 0.5762 and 0.5731, respectively. The results indicate that the nonlinear relationship between the input characteristics and the required iteration count is not fully captured by a simple linear model, while the tree-based Decision Tree provides the strongest overall predictive performance on the independent test data.

5.2. Bootstrap Confidence Interval Analysis

To quantify the uncertainty of the final model performance, group-level bootstrap resampling was performed on the independent test set. A total of 5000 bootstrap replications were generated by resampling the 461 independent test groups while retaining all five tolerance-level observations within each group. The resulting 95% confidence interval was obtained using the percentile bootstrap method.

Figure 5 presents the group-level bootstrap distribution of the mean absolute error (MAE) for the final Decision Tree, together with its 95% percentile bootstrap confidence interval. The analysis was performed exclusively on the independent test set, comprising 461 previously unseen input groups with five tolerance-level observations per group. The Decision Tree was not retrained, and the independent test data were not used for model training or hyperparameter selection. Across 5000 group-level bootstrap replications, the observed test-set MAE was 0.9160, with a bootstrap mean MAE of 0.9151 (SD = 0.0776) and a 95% confidence interval of [0.7708, 1.0701]. This analysis provides an uncertainty estimate for the independent-test performance and complements the point estimates reported in Table 6, providing additional evidence regarding the stability of the final model on previously unseen input groups.

5.3. Statistical Significance Analysis

The independent-test results identified the Decision Tree as the best-performing model based on the lowest MAE. To examine whether the observed differences among the eight regression models were statistically significant, a Friedman test was first performed using the paired prediction errors obtained from the independent test set. The Friedman test yielded a statistic of $957.623553$ with a p-value of $1.721045\times {10}^{-202}$, indicating a statistically significant difference among the evaluated models.

Following the overall Friedman test, pairwise Wilcoxon signed-rank tests were performed to compare the Decision Tree with each of the other regression models. The paired observations corresponded to the prediction errors obtained for the same independent test samples, allowing the models to be compared under identical input conditions. Since seven pairwise comparisons were performed, the resulting p-values were adjusted using the Holm procedure. Statistical significance was considered at the 5% level.

The pairwise results are summarized in

Table 7. Wilcoxon signed-rank comparison of the Decision Tree with the other regression models on the independent test set.

Compared Model	Statistic	Holm-p	Rank-Biserial Effect
Linear Regression	363,352.5	<$0.001$	$-0.4527$
Random Forest	114,106.0	<$0.001$	$-0.5759$
Extra Trees	81,495.0	<$0.001$	$-0.6420$
XGBoost	199,980.0	<$0.001$	$-0.5544$
LightGBM	200,793.0	<$0.001$	$-0.5530$
SVR	294,886.0	<$0.001$	$-0.4514$
MLP	278,654.5	<$0.001$	$-0.5116$

. After Holm correction, the Decision Tree showed a statistically significant difference in prediction error compared with all seven competing models ($p<0.05$). The largest rank-biserial effect was observed for the comparison with Extra Trees ($-0.6420$), followed by Random Forest ($-0.5759$), XGBoost ($-0.5544$), and LightGBM ($-0.5530$). Comparisons with Linear Regression and SVR also showed moderate effects, while the comparison with MLP indicated a large effect according to the magnitude of the rank-biserial coefficient.

These statistical findings are consistent with the independent-test performance, where the Decision Tree obtained the lowest MAE among the eight models. The statistical analysis therefore provides additional evidence supporting the selection of the Decision Tree as the final prediction model. The statistical significance is considered together with the magnitude of the prediction errors and the tolerance-aware evaluation presented in the subsequent sections.

5.4. Feature Importance and Explainability Analysis

To understand which input characteristics influence the predicted CORDIC iteration count, the final Decision Tree model was examined using its feature importance and SHAP-based explanations. Figure 6 presents the feature importance obtained from the final Decision Tree. The results show that log_inverse_delta is the most influential feature, followed by abs_input and mode. Their respective importance values are 0.5815, 0.2476, and 0.1217. The remaining features, namely, input_value, quadrant, and sign_input, have considerably smaller contributions, with importance values of 0.0331, 0.0161, and 0.0001, respectively.

The importance of log_inverse_delta is consistent with the expected behavior of the CORDIC algorithm, since the required number of iterations is strongly related to the desired error tolerance. The influence of abs_input and mode further indicates that the iteration requirement depends not only on the target tolerance but also on the magnitude and operating mode of the input. In contrast, the very small contribution of sign_input suggests that the sign of the input has limited influence on the predicted iteration count within the evaluated dataset.

To obtain a more detailed view of how individual features affect the model predictions, SHAP (SHapley Additive exPlanations) analysis was performed on the final Decision Tree. The resulting SHAP summary plot is shown in Figure 7. The global SHAP analysis produced a similar ranking to the Decision Tree feature importance, with log_inverse_delta contributing the most to the model output. Its mean absolute SHAP value was 1.7637, corresponding to 57.95% of the total SHAP contribution. It was followed by abs_input with 23.14% and mode with 10.15%. The contributions of quadrant, input_value, and sign_input were comparatively smaller.

The SHAP distribution also provides information beyond the overall feature ranking. For log_inverse_delta, the SHAP values span a wide range, indicating that changes in the requested tolerance have a substantial effect on the predicted iteration count. Higher values of this feature correspond to stricter error requirements and are generally associated with positive contributions to the predicted number of iterations. The distributions for abs_input and mode show that the effect of these variables depends on their values and their interaction with the other predictors. The SHAP results therefore support the feature-importance analysis while providing a more detailed view of how the predictors influence individual model outputs.

Overall, both analyses identify log_inverse_delta as the dominant predictor, followed by abs_input and mode. The agreement between the model-based feature importance and the SHAP analysis provides consistent evidence that the predicted iteration count is primarily determined by the required numerical precision, while the input magnitude and CORDIC operating mode provide additional information for adapting the iteration count.

5.5. Feature Ablation Study

A feature ablation analysis was conducted to examine the contribution of the final predictors to the iteration prediction task. Each feature was evaluated by removing it from the final six-feature representation and assessing the resulting model behavior. The analysis was used to identify the predictors that have the greatest influence on the prediction of the optimal CORDIC iteration count and to complement the feature-importance and permutation-importance result.

The feature-importance analysis identifies log_inverse_delta as the dominant predictor of the required CORDIC iteration count. Its contribution is followed by abs_input and mode, while sign_input provides negligible contribution. The ablation results are subsequently used to examine whether the observed feature-importance ranking is reflected in the predictive performance when individual predictors are removed shown in Figure 8.

5.6. Adaptive CORDIC Iteration Efficiency and Tolerance-Aware Evaluation

To evaluate the practical computational benefit of the proposed adaptive iteration strategy, the final Decision Tree predictions were evaluated on the independent test set and compared with a conventional fixed-20-iteration CORDIC implementation. The analysis focuses on the number of iterations executed, the resulting reduction in iterative computation, and the ability of the predicted iteration count to satisfy the prescribed numerical tolerance. Since no FPGA or ASIC implementation is performed in this study, the analysis is reported as an iteration-efficiency evaluation rather than a measured hardware performance evaluation.

Table 8. Iteration-efficiency and tolerance-aware performance of the fixed and adaptive CORDIC strategies on the independent test set.

Metric	Value
Fixed CORDIC Iterations	20.000
ML Adaptive Mean Iterations	9.757
Safety-Corrected Mean Iterations	11.739
Iteration Reduction	8.261
Iteration Reduction (%)	41.31
Fixed-20 Tolerance Satisfaction (%)	95.14
Adaptive Tolerance Satisfaction (%)	100.00
Independent Test Samples	2305
Independent Test Groups	461
Group Overlap	0

summarizes the iteration-efficiency and tolerance-aware results obtained on the independent test set. The conventional implementation executes 20 iterations for every input, whereas the machine learning model predicts an average of 9.757 iterations. Because prediction error alone does not guarantee that the required numerical tolerance will be satisfied, a safety-correction mechanism was subsequently applied to the predicted iteration count. The correction mechanism verifies the numerical error associated with the predicted iteration count and incrementally increases the iteration count when the specified tolerance is not satisfied, subject to the maximum allowable limit of $N_{\max }=20$. Thus, samples for which the initial prediction is insufficient are corrected using additional iterations, while samples that already satisfy the tolerance remain unchanged. This ensures that all test samples satisfy the prescribed tolerance, resulting in a 100% tolerance-satisfaction rate. The safety-corrected strategy required an average of 11.739 iterations, corresponding to a reduction of 8.261 iterations, or 41.31%, relative to the fixed-20-iteration implementation.

5.7. Comparison with Conventional Non-ML Adaptive CORDIC

The proposed iteration prediction approach was further compared with a conventional tolerance-driven CORDIC implementation using the same independent test set of 2305 samples from 461 unseen input groups. The conventional method selected an average of 9.7124 iterations, corresponding to a reduction of 10.2876 iterations, or 51.44%, compared with the fixed 20-iteration implementation. The selected iteration counts showed 100% agreement with the optimal-iteration targets used during dataset generation, confirming that the conventional baseline is consistent with the target-generation procedure.

Figure 9 illustrates the effect of the prescribed tolerance on the number of CORDIC iterations required by the conventional non-ML adaptive strategy. As the tolerance is relaxed from ${10}^{-4}$ to ${10}^{-2}$, the mean number of iterations decreases from approximately 12.96 to 7.02, while the fixed-20 implementation remains unchanged. This demonstrates the expected reduction in iterative computation for less stringent accuracy requirements. The tolerance-satisfaction rate remains above 93% for the stricter tolerance levels and increases to approximately 97.8% for the relaxed tolerance levels. The figure therefore provides a tolerance-wise view of the computational savings obtained by replacing the fixed iteration count with a tolerance-driven stopping criterion.

The Decision Tree predicted an average of 9.7575 iterations on the same test samples. The difference between the two adaptive approaches was only 0.0451 iterations on average, corresponding to a negligible difference in iteration reduction. Thus, the proposed model provides an iteration requirement very close to that obtained by the conventional adaptive procedure. While the conventional procedure may achieve a marginally lower iteration count, it requires an explicit adaptive search during operation. In contrast, the proposed Decision Tree provides a direct prediction of the required iteration count from the input features, avoiding such an explicit iteration-by-iteration search during prediction. However, the practical advantage of the ML-based approach should be considered together with the computational cost of model inference and the additional control logic required for integrating the predictor with the CORDIC datapath.The comparison is summarized in

Table 9. Overall comparison of fixed, conventional non-ML, and Decision Tree-based adaptive CORDIC iteration requirements on the independent test set.

Approach	Mean Iterations	Iterations Saved	Reduction (%)
Fixed CORDIC	20.0000	–	–
Conventional Non-ML	9.7124	10.2876	51.44
Decision Tree	9.7575	10.2425	51.21

.

The results demonstrate that adaptive iteration selection can substantially reduce unnecessary CORDIC iterations relative to a fixed 20-iteration implementation. The conventional reference and the Decision Tree require nearly the same number of iterations on average, indicating that the learned model closely approximates the iteration requirements determined by the conventional adaptive procedure. From a hardware-efficiency perspective, this reduction in iteration count can potentially decrease computational activity and latency. However, actual reductions in hardware area, power, or energy depend on the target architecture and implementation technology and are not directly quantified in this study.

6. Conclusions

This paper proposed an AI-assisted adaptive CORDIC framework, which can dynamically predict the optimal number of CORDIC iterations based on machine learning, and it addresses the inefficiencies of the conventional fixed-iteration implementations. We generated a comprehensive dataset with 11,505 samples by simulating circular, hyperbolic, and linear CORDIC operations for a host of different numerical precision requirements. Six engineered features detailing the operating mode, input characteristics, and numerical precision requirements were extracted and used for training several regression models including the following: Linear Regression, Decision Tree, Random Forest, Extra Trees, Support Vector Regression, Light GBM, Multi-Layer Perceptron, and XGBoost.

Extensive experimental evaluation showed that Decision Tree achieved the lowest MAE on the independent test set and was therefore selected as the final prediction model. Statistical comparison using the Wilcoxon signed-rank test showed significant differences between the Decision Tree and the other evaluated regression models after Holm correction. Feature-importance, permutation-importance, and SHAP analyses consistently identified log_inverse_delta as the dominant predictor, followed by abs_input and mode. The SHAP analysis further showed that log_inverse_delta accounted for 57.95% of the mean absolute SHAP contribution.

The practical effectiveness of the adaptive strategy was evaluated on the independent test set through comparison with a conventional fixed-20-iteration CORDIC implementation. The conventional non-ML tolerance-driven reference reduced the mean iteration count from 20 to 9.7124, corresponding to a 51.44% reduction. The Decision Tree predicted an average of 9.7575 iterations, corresponding to a 51.21% reduction relative to the fixed-20 implementation. The conventional reference showed 100% agreement with the stored target-generation results, confirming the consistency of the baseline. These results demonstrate that the learned model can closely reproduce the iteration requirements of the conventional adaptive strategy while reducing the number of CORDIC iterations.

Future work will focus on implementing the proposed adaptive strategy on FPGA and ASIC platforms to experimentally validate its effects on latency, power consumption, area utilization, and energy efficiency. In addition, future research will investigate lightweight regression models suitable for embedded implementations, online adaptive learning strategies capable of dynamically updating iteration predictions during operation, and the integration of the proposed framework into advanced digital signal processing, wireless communication, robotics, computer graphics, and edge AI accelerators. The proposed methodology can also be generalized to other iterative numerical algorithms where adaptive computation can improve computational efficiency without compromising numerical precision.