Next Article in Journal
High-Quality and Reproducible Automatic Drum Transcription from Crowdsourced Data
Previous Article in Journal
Restoration for Intensity Nonuniformities with Discontinuities in Whole-Body MRI
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

Radix-22 Algorithm for the Odd New Mersenne Number Transform (ONMNT)

1
School of Engineering, Newcastle University, Newcastle NE1 7RU, UK
2
Department of Electrical Engineering, University of Tikrit, Tikrit P.O. Box 42, Iraq
*
Author to whom correspondence should be addressed.
Signals 2023, 4(4), 746-767; https://doi.org/10.3390/signals4040041
Submission received: 31 August 2023 / Revised: 10 October 2023 / Accepted: 19 October 2023 / Published: 23 October 2023

Abstract

:
This paper introduces a new derivation of the radix- 2 2 fast algorithm for the forward odd new Mersenne number transform (ONMNT) and the inverse odd new Mersenne number transform (IONMNT). This involves introducing new equations and functions in finite fields, bringing particular challenges unlike those in other fields. The radix- 2 2 algorithm combines the benefits of the reduced number of operations of the radix-4 algorithm and the simple butterfly structure of the radix-2 algorithm, making it suitable for various applications such as lightweight ciphers, authenticated encryption, hash functions, signal processing, and convolution calculations. The multidimensional linear index mapping technique is the conventional method used to derive the radix- 2 2 algorithm. However, this method does not provide clear insights into the underlying structure and flexibility of the radix- 2 2 approach. This paper addresses this limitation and proposes a derivation based on bit-unscrambling techniques, which reverse the ordering of the output sequence, resulting in efficient calculations with fewer operations. Butterfly and signal flow diagrams are also presented to illustrate the structure of the fast algorithm for both ONMNT and IONMNT. The proposed method should pave the way for efficient and flexible implementation of ONMNT and IONMNT in applications such as lightweight ciphers and signal processing. The algorithm has been implemented in C and is validated with an example.

1. Introduction

Number theoretic transforms (NTTs) [1] have many applications [2] in signal processing and cryptography [1]. Two well-known NTTs are the Mersenne number transform (MNT) [3,4] and the Fermat number transform (FNT) [5,6], which are based on Mersenne numbers and Fermat numbers, respectively. MNT has been given particular attention as it has simple arithmetic and favorable reduction operations compared to FNT. However, MNT has limitations in terms of its transform length, which is short and has limited factorability, making it unfeasible to use the fast algorithm.
To address the limitations of MNT, Bousssakta and Holt introduced the new Mersenne number transform (NMNT) [7]. Later, two new variants named the odd new Mersenne number transform (ONMNT) and the odd square new Mersenne number transform (O2NMNT) were proposed; these are known as generalized new Mersenne number transforms (GNMNTs) [8]. These two transforms have shown promising results in signal processing, image processing, and cryptography [9]. Parameterized implementation, strong diffusion performance, and simple arithmetic operations are critical advantages of NMNT-based cryptographic ciphers over conventional ciphers.
One of the advantages of the NMNT family of transforms is their suitability for fast algorithms, as their transform length is always a power of 2. A detailed discussion on different fast algorithms such as radix-2, radix-4, and split-radix for NMNT and GNMNT can be found in [9,10]. Hue et al. [11] presented a realization of NMNT using the Walsh–Hadamard Transform (WHT) to speed up the calculation. The split-radix algorithm has the lowest arithmetic complexity. It avoids the limitation of the radix-4 algorithm, which can only be applied for a transform length N with an odd power of 4. However, the structure of the split-radix algorithm is highly complex, and its implementation in a simple hardware system is challenging. A new class of fast algorithms called radix- 2 2 [12] algorithms has been proposed, incorporating a twiddle factor decomposition technique in an efficient divide and conquer method, which leads to a regular signal flow graph structure. The structure of the radix is a crucial factor in determining the architecture of the fast Fourier transform (FFT) [13] processor. A simple and regular radix structure allows for an efficient implementation of the architecture [14]. The radix- 2 2 algorithm retains both the low multiplicative complexity of the radix-4 algorithm and the simple structure of the radix-2 algorithm. Thus, it solves both these limitations. This algorithm can be used directly for even values of n, where N = 2 n , and for odd values of n simply by utilizing a mixed-radix algorithm at the beginning or end of the radix- 2 2 algorithm. The radix- 2 2 algorithm can, therefore, be implemented for any value of N that is a power of 2. Moreover, significant memory savings have been achieved using this algorithm [15]. Therefore, multiple efficient implementations of the radix- 2 2 FFT algorithm have been proposed for application-specific integrated circuits (ASIC) [16] and field-programmable gate arrays (FPGA) [16,17,18], primarily in the field of wireless communication.
Lightweight cryptography [19] is another area of research that can benefit from the efficient implementation of radix- 2 2 algorithms in resource-constrained devices, such as in radio frequency identification (RFID), sensors, wireless Internet of Things (IoT) devices [20], smart home automation, telemedicine, smart money [21], healthcare, and military applications. Efficient hardware implementations [22] are important in lightweight cryptography. In recent years, number theoretic transform-based cryptographic systems have been proposed, especially for the IoT [23,24,25]. One of the advantages of number theoretic transforms such as ONMNT is the ability to use fast algorithms. As the radix- 2 2 fast algorithm offers a simple butterfly structure while maintaining the multiplicative complexity of the radix-4 algorithm, the derivation of the radix- 2 2 fast algorithm for ONMNT will improve the efficiency for ONMNT-based lightweight ciphers. In the literature, there are two main approaches to implementing the radix- 2 2 algorithm. The first approach is based on multidimensional index mapping [26], while the second is the twiddle factor unscrambling technique [27]. In conventional multidimensional index mapping, the transform length N is mapped onto a multidimensional array, following a similar approach to the Cooley–Tukey algorithm. In the twiddle factor unscrambling technique [28], the segment is divided into N / 4 equal segments, and each smaller butterfly is rearranged to be in base 2 or bit-reversed order rather than in base 4 or in word-reversed order, which is typical for the general radix-4 algorithm. This technique is comparatively efficient, and in this paper, we use the twiddle factor unscrambling technique to derive a radix- 2 2 algorithm for ONMNT. The benefit of using the bit-unscrambling technique is that a higher-order radix, such as 4, 8, 16 or 2 i , can use the same bit-unscrambling counter, which speeds up the calculation [29] without needing extra calculations and data processing. This fast algorithm can be used in a lightweight cipher, in which reducing the number of operations leads to a compact implementation and efficient convolution calculations in signal processing applications. In [30], the authors presented promising results on using the bit-unscrambling technique for radix 2 2 . It showed the dual advantages of a simpler structure and a reduced number of calculations. However, the paper was limited to NMNT. ONMNT is a more recent GNMNT, and it offers strong diffusion performance [9]. Unlike NMNT and O2NMNT, the kernel matrix for ONMNT is transposed in the inverse transform. Moreover, the derivation of the ONMNT fast algorithm requires considering retrograde points. Fast algorithms for ONMNT using radix 2 2 have not been explored yet. Therefore, the aim of this paper is to develop the radix- 2 2 fast algorithm for the calculation of the ONMNMT and IONMNT.
The original contributions of this paper are as follows:
  • A novel mathematical derivation of a radix- 2 2 algorithm for ONMNT and the inverse ONMNT (IONMNT) using the radix- 2 2 bit-unscrambling technique.
  • A detailed derivation of the transform kernel relationships incorporating retrograde points.
  • Butterfly diagrams and signal flow graphs of the Radix- 2 2 algorithm for ONMNT and IONMNT.
Regarding the rest of the paper, Section 2 describes the most common fast algorithms. Section 3 and Section 4 provide a detailed derivation of the radix- 2 2 algorithm for the forward and inverse ONMNT with a butterfly diagram and a signal flow diagram, respectively. Section 5 discusses the arithmetic complexity of the proposed fast algorithm and compares it with direct calculation and radix- 2 2 . Section 6 presents an example to demonstrate the accuracy of the proposed fast algorithm. Section 7 concludes the paper and provides suggestions for future work.

2. Odd New Mersenne Number Transform

ONMNT is the first of the two new NMNT-based transforms introduced by Boussakta et al. [8]. An odd member of the transform parameter is chosen to form the kernel matrix.
The ONMNT of an integer sequence x ( n ) , where n = 0 , 1 , 2 , 3 , , N 1 with transform length N = 2 m for m = 1 , 2 , 3 , , p 1 , is defined as follows:
X o ( k ) = n = 0 N 1 x ( n ) β n ( 2 k + 1 ) 2 M p
where k = 0 , 1 , 2 , , N 1 , . M p represents modulo M p where M p = 2 p 1 is a Mersenne prime for p = 2 , 3 , 5 , 7 , 13 , 17 , 19 , and β n ( 2 k + 1 ) 2 is the transform kernel. For the ONMNT, the transform kernel can be expressed by the following matrix:
M o f = β ( 0 ) β ( 0 ) β ( 0 ) β 1 2 β 3 2 β 2 N 1 2 β ( 1 ) β ( 3 ) β 2 ( N 1 ) β 3 2 β 9 2 β 3 ( 2 N 1 ) 2 β N 1 2 β 3 ( N 1 ) 2 β ( 2 N 1 ) ( N 1 ) 2
The IONMNT is defined as follows:
x ( n ) = N 1 k = 0 N 1 X 0 ( k ) β k 2 n + 1 2 M p
where n = 0 , 1 , 2 , 3 , , N 1 , X 0 ( k ) is the input sequence and β k 2 n + 1 2 is the kernel parameter for IONMNT. When comparing (1) and (3), the IONMNT differs from the ONMNT in two ways: it has a scaling factor N 1 and the transform matrix is transposed (i.e., M o i = M o f T ) to let the kernel matrix be orthogonal. Therefore, the following is the kernel matrix of the inverse ONMNT:
M o i = β ( 0 ) β 1 2 β N 1 2 β ( 0 ) β 3 2 β 3 ( N 1 ) 2 β ( 0 ) β 5 2 β 5 ( 2 N 1 ) 2 β ( 0 ) β 2 N 1 2 β ( N 1 ) ( 2 N 1 ) 2
The maximum transform length for ONMNT is N max = 2 p 1 .

3. Derivation of Radix- 2 2 Algorithm for ONMNT

An ONMNT radix- 2 2 algorithm can be developed by decomposing (1) into 2 2 = 4 equal partial sums of transform length N 4 , where n = 0 , 1 , 2 , N 4 1 , and by replacing n with 4 n + l , where l = 0 , 1 , 2 , N 4 1 . Therefore, (1) can be written as follows:
X o ( k ) = l = 0 3 n = 0 N 1 x ( 4 n + l ) . β ( 4 n + l ) 2 k + 1 2 M p
where x ( 4 n + l ) is the input sequence of each segment, β ( 4 n + l ) 2 k + 1 2 is the kernel parameter of ONMNT and . M p means that the calculation is modulo a Mersenne prime. From the above equation, it can be seen that the output X o ( k ) of the ONMNT is the summation of four equal segments X o k + λ N 4 with N 4 consecutive elements indexed by λ and where 0 λ 3 . A general equation for each partial sum or segment is
X o k + λ N 4 = l = 0 3 n = 0 N 4 1 x ( 4 n + l ) β ( 4 n + l ) 2 k + 1 2 + λ N 4 M p .
In the next step of the derivation, the twiddle factor, β ( . ) from (3), is simplified as follows:
β ( 4 n + l ) 2 k + 1 2 + λ N 4 = β 2 k + 1 2 l + λ l N 4 + 4 n 2 k + 1 2 + λ n N .
Equation (7) can be expanded using the β properties of β ( m + n ) = β 1 ( m ) β ( n ) + β 2 ( m ) β ( n ) from [31] as follows:
β 2 k + 1 2 l + λ l N 4 + 4 n 2 k + 1 2 + λ n N = β 1 2 k + 1 2 l + λ l N 4 β 4 n 2 k + 1 2 + λ n N + β 2 2 k + 1 2 l + λ l N 4 β 4 n 2 k + 1 2 + λ n N }
where, using the periodic property of β ( n ) , i.e., β ( a N + m ) = β ( m ) [30], (8) can be written as follows:
β 2 k + 1 2 l + λ l N 4 + 4 n 2 k + 1 2 + λ n N = β 1 2 k + 1 2 l + λ l N 4 β 4 n 2 k + 1 2 + β 2 2 k + 1 2 l + λ l N 4 β 4 n 2 k + 1 2 .
Substituting β 1 ( . ) and β 2 ( . ) with the relations β 1 ( m + n ) = β 1 ( m ) β 1 ( n ) β 2 ( m ) β 2 ( n ) and β 2 ( m + n ) = β 1 ( m ) β 2 ( n ) + β 2 ( m ) β 1 ( n ) from (9) into (7) yields the following:
β ( 4 n + l ) 2 k + 1 2 + λ N 4 = β 1 2 k + 1 2 l β 1 λ l N 4 β 2 2 k + 1 2 l β 2 λ l N 4 β 4 n 2 k + 1 2 + β 1 2 k + 1 2 l β 2 λ l N 4 + β 2 2 k + 1 2 l β 1 λ l N 4 β 4 n 2 k + 1 2 .
Substituting the values from (10) into (3), ignoring the modulo operator M p and rearranging yields
X o k + λ N 4 = l = 0 3 [ [ n = 0 N 4 1 x ( 4 n + l ) β 4 n 2 k + 1 2 β 1 λ l N 4 + n = 0 N 4 1 x ( 4 n + l ) β 4 n 2 k + 1 2 β 2 λ l N 4 ] β 1 2 k + 1 2 l + [ n = 0 N 4 1 x ( 4 n + l ) β 4 n 2 k + 1 2 β 1 λ l N 4 n = 0 N 4 1 x ( 4 n + l ) β 4 n 2 k + 1 2 β 2 λ l N 4 ] β 2 2 k + 1 2 l ]
The following two sequences, where l = 0 , 1 , 2 and 3, can be defined:
X l o ( k ) = n = 0 N 4 1 x ( 4 n + l ) β 4 n 2 k + 1 2 ,
X l o N 4 k 1 = n = 0 N 4 1 x ( 4 n + l ) β 4 n 2 k + 1 2 .
Substituting X l o ( k ) and X l o N 4 k 1 from (12) and (13) into (11), and rearranging and applying re-indexing l of β 1 2 k + 1 2 l and β 2 2 k + 1 2 l from (11) according to the bit reverse order, yields the following:
X o k + λ N 4 = X 0 o ( k ) + X 1 o ( k ) β 1 λ N 4 + X 1 o N 4 k 1 β 2 λ N 4 β 1 2 2 k + 1 2 + X 1 o N 4 k 1 β 1 λ N 4 X 1 o ( k ) β 2 λ N 4 β 2 2 2 k + 1 2 + X 2 o ( k ) β 1 λ N 2 + X 2 o N 4 k 1 β 2 λ N 2 β 1 2 k + 1 2 + X 2 o N 4 k 1 β 1 λ N 2 X 2 o ( k ) β 2 λ N 2 β 2 2 k + 1 2 + X 3 o ( k ) β 1 λ 3 N 4 + X 3 o N 4 k 1 β 2 λ 3 N 4 β 1 3 2 k + 1 2 + X 3 o N 4 k 1 β 1 λ 3 N 4 X 3 o ( k ) β 2 λ 3 N 4 β 2 3 2 k + 1 2 .
Equation (14) is the general decomposition equation. The four main points for radix 2 2 are X o ( k ) , X o k + N 4 , X o k + N 2 and X o k + 3 N 4 , which are derived by setting λ = 0 , 1 , 2 , 3 in (14) and using the following beta relationships:
β 1 ( 0 ) = 1
β 2 ( 0 ) = 0
β 1 a N 4 = ( 1 ) a 2 , a is even 0 , a is odd
β 2 a N 4 = 0 , a is even ( 1 ) a 1 2 , a is odd
β 1 a N 2 = ( 1 ) a
β 2 a N 2 = 0 .
Then, the following mapping relations are applied:
X 0 o ( k ) = X o ( k )
X 1 o ( k ) = X o k + N 4
X 1 o N 4 k 1 = X o N 2 k 1
X 2 o ( k ) = X o k + N 2
X 2 o N 4 k 1 = X o 3 N 4 k 1
X 3 o ( k ) = X o k + 3 N 4
X 3 o ( k ) = X o N k 1
X o ( k ) = X o ( k ) + X o k + N 4 β 1 2 2 k + 1 2 + X o N 2 k 1 β 2 2 2 k + 1 2 + X o k + N 2 β 1 2 k + 1 2 + X o 3 N 4 k 1 β 2 2 k + 1 2 + X o k + 3 N 4 β 1 3 2 k + 1 2 + X o ( N k 1 ) β 2 3 2 k + 1 4
X o k + N 4 = X o ( k ) + X o k + N 4 β 1 2 2 k + 1 2 + X o N 2 k 1 β 2 2 2 k + 1 2 X o 3 N 4 k 1 β 1 2 k + 1 2 X o k + N 2 β 2 2 k + 1 2 X o N k 1 β 1 3 2 k + 1 2 X o k + 3 N 4 β 2 3 2 k + 1 2
X o k + N 2 = X o ( k ) + X o k + N 4 β 1 2 2 k + 1 2 X o N 2 k 1 β 2 2 2 k + 1 2 + X o k + N 2 β 1 2 k + 1 2 + X o 3 N 4 k 1 β 2 2 k + 1 2 + X o 3 N 4 + k β 1 3 2 k + 1 2 X o N k 1 β 2 3 2 k + 1 2
X o k + 3 N 4 = X o ( k ) X o k + N 4 β 1 2 2 k + 1 2 + X 0 N 2 k 1 β 2 2 2 k + 1 2 X o 3 N 4 k 1 β 1 2 k + 1 2 X o k + N 2 β 2 2 k + 1 2 + X o ( N k 1 ) β 1 3 2 k + 1 2 X o 3 N 4 + k β 2 3 2 k + 1 2 .
There are also four retrograde points. The butterfly diagram consists of all eight points. For ONMNT, the four retrograde points, X o N 4 k 1 , X o N 2 k 1 , X o 3 N 4 k 1 and X o N k 1 , can be derived by replacing k with k , where k = N 4 k 1 , in (28)–(31) and using the following beta relations:
β 1 2 N 4 k 1 + 1 2 = β 2 2 k + 1 2
β 2 2 N 4 k 1 + 1 2 = β 1 2 k + 1 2
β 1 2 2 N 4 k 1 + 1 2 = β 1 2 2 k + 1 2
β 2 2 2 N 4 k 1 + 1 2 = β 2 2 2 k + 1 2
β 1 3 2 N 4 k 1 + 1 2 = β 2 3 2 k + 1 2
β 2 3 2 N 4 k 1 + 1 2 = β 1 3 2 k + 1 2
The proof of the beta relations (32)–(37) is given in Appendix A.
Figure 1 shows the butterfly diagram for radix- 2 2 ONMNT using the four main points and the four retrograde points. The signal flow graph (SFG) for different transform lengths can be drawn using the ONMNT butterfly diagram presented in Figure 1. For example, SFG for N = 16 using the ONMNT butterfly diagram is shown in Figure 2.

4. Derivation of Radix- 2 2 Algorithm for IONMNT

The derivation of the radix- 2 2 algorithm starts by replacing 2 k + 1 2 with 2 k + 1 2 + λ N 4 and n with 4 n + l in ( 2 ) , where λ = 0 , 1 , 2 , 3 and l = 0 , 1 , 2 , 3 , ignoring ( N 1 ) in (3):
x ( 4 n + l ) = k = 0 N 4 1 X o ( k ) λ = 0 3 β ( 4 n + l ) 2 k + 1 2 + λ N 4 M p .
The twiddle factor from (38) can be written as follows:
β ( 4 n + l ) 2 k + 1 2 + λ N 4 = β 4 n 2 k + 1 2 + λ n N 2 k + 1 2 l + λ l N 4 = β 2 k + 1 2 l + λ l N 4 4 n 2 k + 1 2 + λ n N
Using the relationship β ( m + n ) = β 1 ( m ) . β ( n ) + β 2 ( m ) . β ( n ) and the periodic properties of β ( . ) , (39) can be written as follows:
β 2 k + 1 2 l + λ l N 4 4 n 2 k + 1 2 + λ n N = β 1 2 k + 1 2 l + λ l N 4 β 4 n 2 k + 1 2 + β 2 2 k + 1 2 l + λ l N 4 β 4 n 2 k + 1 2
β 1 ( m + n ) = β 1 ( m ) β 1 ( n ) β 2 ( m ) β 2 ( n )
β 2 ( m + n ) = β 1 ( m ) β 2 ( n ) + β 2 ( m ) β 1 ( n ) .
Using the relationships (41) and (42) yields
β 1 2 k + 1 2 l + λ l N 4 = β 1 2 k + 1 2 l β 1 λ l N 4 β 2 2 k + 1 2 l β 2 λ l N 4
and
β 2 2 k + 1 2 l + λ l N 4 = β 1 2 k + 1 2 l β 2 λ l N 4 + β 2 2 k + 1 2 l β 1 λ l N 4 .
Substituting (43) and (44) into (40) gives the updated values of β ( . ) :
β 2 k + 1 2 l + λ l N 4 4 n 2 k + 1 2 + λ n N = β 1 2 k + 1 2 l β 1 λ l N 4 β 2 2 k + 1 2 l β 2 λ l N 4 β 4 n 2 k + 1 2 + β 1 2 k + 1 2 l β 2 λ l N 4 + β 2 2 k + 1 2 l β 1 λ l N 4 β 4 n 2 k + 1 2 = β 1 2 k + 1 2 l β 1 λ l N 4 β 4 n 2 k + 1 2 β 2 2 k + 1 2 l β 2 λ l N 4 β 4 n 2 k + 1 2 + β 1 2 k + 1 2 l β 2 λ l N 4 β 4 n 2 k + 1 2 + β 2 2 k + 1 2 l β 1 λ l N 4 β 4 n 2 k + 1 2 .
Rearranging and simplifying (45) results in the following:
β 2 k + 1 2 l + λ l N 4 4 n 2 k + 1 2 + λ n N = β 4 n 2 k + 1 2 β 1 λ l N 4 + β 4 n 2 k + 1 2 β 2 λ l N 4 β 1 2 k + 1 2 l + β 4 n 2 k + 1 2 β 1 λ l N 4 β 4 n 2 k + 1 2 β 2 λ l N 4 β 2 2 k + 1 2 l .
Substituting the value from (46) into (38) and ignoring M p for the derivation,
x ( 4 n + l ) = k = 0 N 4 1 λ = 0 3 X o k + λ N 4 [ { β 4 n 2 k + 1 2 β 1 λ l N 4 + β 4 n 2 k + 1 2 β 2 λ l N 4 } β 1 2 k + 1 2 l + { β 4 n 2 k + 1 2 β 1 λ l N 4 β 4 n 2 k + 1 2 β 2 λ l N 4 } β 2 2 k + 1 2 l ] .
Reorganizing the equation and factoring out the shared summation term λ = 0 3 from (47) yields the following result:
x ( 4 n + l ) = λ = 0 3 [ k = 0 N 4 1 X o k + λ N 4 β 1 2 k + 1 2 l β 4 n 2 k + 1 2 β 1 λ l N 4 + k = 0 N 4 1 X o k + λ N 4 β 1 2 k + 1 2 l β 4 n 2 k + 1 2 β 2 λ l N 4 + k = 0 N 4 1 X o k + λ N 4 β 2 2 k + 1 2 l β 4 n 2 k + 1 2 β 1 λ l N 4 k = 0 N 4 1 X o k + λ N 4 β 2 2 k + 1 2 l β 4 n 2 k + 1 2 β 2 λ l N 4 ] .
Let us define the two following terms:
k = 0 N 4 1 X o k + λ N 4 β 1 2 k + 1 2 l β 4 n 2 k + 1 2 = k = 0 N 4 1 X o λ N 4 k 1 β 1 2 k + 1 2 l β 4 n 2 k + 1 2 ,
k = 0 N 4 1 X o k + λ N 4 β 2 2 k + 1 2 l β 4 n 2 k + 1 2 = k = 0 N 4 1 X o λ N 4 k 1 β 2 2 k + 1 2 l β 4 n 2 k + 1 2 .
Substituting the relations (49) and (50) into (48) leads to
x ( 4 n + l ) = λ = 0 3 [ k = 0 N 4 1 X o λ N 4 + k β 1 2 k + 1 2 l β 4 n 2 k + 1 2 β 1 λ l N 4 + k = 0 N 4 1 X o λ N 4 k 1 β 1 2 k + 1 2 l β 4 n 2 k + 1 2 β 2 λ l N 4 k = 0 N 4 1 X o λ N 4 k 1 β 2 2 k + 1 2 l β 4 n 2 k + 1 2 β 1 λ l N 4 k = 0 N 4 1 X o λ N 4 + k β 2 2 k + 1 2 l β 4 n 2 k + 1 2 β 2 λ l N 4 ] .
Upon reorganizing the terms and isolating the common summation term k = 0 N 4 1 ( . ) and β 4 n 2 k + 1 2 from Equation (51), the result is as follows:
x ( 4 n + l ) = k = 0 N 4 1 [ λ = 0 3 [ { X o k + λ N 4 β 1 λ l N 4 + X o λ N 4 k 1 β 2 λ l N 4 } β 1 l 2 k + 1 2 { X o λ N 4 k 1 β 1 λ l N 4 + X o k + λ N 4 β 2 λ l N 4 β 2 l 2 k + 1 2 } ] ] β 4 n 2 k + 1 2 .
Equation (52) can be rewritten as follows:
x ( 4 n + l ) = k = 0 N 4 1 y ( l , k ) β 4 n 2 k + 1 2
where
y ( l , k ) = λ = 0 3 [ X o k + λ N 4 β 1 λ l N 4 + X o λ N 4 k 1 β 2 λ l N 4 β 1 l 2 k + 1 2 X o λ N 4 k 1 β 1 λ l N 4 + X o k + λ N 4 β 2 λ l N 4 β 2 l 2 k + 1 2 ] .
Expanding λ , substituting β 2 a N 2 = 0 and rearranging (54) leads to the following:
y ( l , k ) = { X o ( k ) + X o k + N 4 β 1 l N 4 + X o N 4 k 1 β 2 l N 4 + X o k + N 2 β 1 l N 2 + X o k + 3 N 4 β 1 l 3 N 4 + X 0 3 N 4 k 1 β 2 l 3 N 4 } β 1 l 2 k + 1 2 { X o N k 1 + X o N 4 k 1 β 1 l N 4 + X o k + N 4 β 2 l N 4 + X o N 2 k 1 β 1 l N 2 + X o 3 N 4 k 1 β 1 l 3 N 4 + X o k + 3 N 4 β 2 l 3 N 4 } β 2 l 2 k + 1 2
By substituting l = 0 , 1 , 2 and 3 in (55) using the β relationships from (15)–(20) and applying the bit-unscrambling technique, the temporary main points are found as follows:
y ( 0 , k ) = X o ( k ) + X o k + N 4 + X o k + N 2 + X o k + 3 N 4
y ( 1 , k ) = X o ( k ) X o k + N 4 + X o k + N 2 X o k + 3 N 4 β 1 2 2 k + 1 2 X o N k 1 X o N 4 k 1 + X o N 2 k 1 X o 3 N 4 k 1 β 2 2 2 k + 1 2
y ( 2 , k ) = X o ( k ) + X o N 4 k 1 X o k + N 2 X o 3 N 4 k 1 β 1 2 k + 1 2 X o N k 1 + X o k + N 4 X o N 2 k 1 X o k + 3 N 4 β 2 2 k + 1 2
y ( 3 , k ) = X o ( k ) X o N 4 k 1 X o k + N 2 + X o 3 N 4 k 1 β 1 3 2 k + 1 2 X o N k 1 X o k + N 4 X o N 2 k 1 + X o k + 3 N 4 β 2 3 2 k + 1 2 .
By substituting k with k , where k = N 4 k 1 , in Equations (56)–(59), and employing the beta relations from (17)–(19), the outcome entails the determination of four temporary retrograde points:
y 0 , N 4 k 1 = X o N k 1 + X o N 4 k 1 + X o N 2 k 1 + X o 3 N 4 k 1
y 1 , N 4 k 1 = X o N k 1 X o N 4 k 1 + X o N 2 k 1 X o 3 N 4 k 1 β 1 2 2 k + 1 2 + X o ( k ) X o k + N 4 + X o k + N 2 X o k + 3 N 4 β 2 2 2 k + 1 2
y 2 , N 4 k 1 = X o ( k ) + X o N 4 k 1 X 0 k + N 2 X o 3 N 4 k 1 β 2 2 k + 1 2 + X o N k 1 + X o k + N 4 + X o N 2 k 1 + X o k + 3 N 4 β 1 2 k + 1 2
y 3 , N 4 k 1 = X o ( k ) X o N 4 k 1 X o k + N 2 + X o 3 N 4 k 1 β 2 3 2 k + 1 2 + X o N k 1 X o k + N 4 X o N 2 k 1 + X o k + 3 N 4 β 1 3 2 k + 1 2 .
Substituting the temporary points from (56)–(59) into (53) for the main four points is carried out as follows:
x ( 4 n ) = k = 0 N 4 1 X o ( k ) + X o k + N 4 + X o k + N 2 + X o k + 3 N 4 β 4 n 2 k + 1 2
x ( 4 n + 1 ) = k = 0 N 4 1 [ X o ( k ) X o k + N 4 + X o k + N 2 X o k + 3 N 4 β 1 2 2 k + 1 2 { X o N k 1 X o N 4 k 1 + X o N 2 k 1 X o 3 N 4 k 1 } β 2 1 2 k + 1 2 ] β 4 n 2 k + 1 2
x ( 4 n + 2 ) = k = 0 N 4 1 [ X o ( k ) + X o N 4 k 1 X o k + N 2 X 0 3 N 4 k 1 β 1 2 k + 1 2 { X o N k 1 + X o k + N 4 X o N 2 k 1 X o k + 3 N 4 } β 2 2 2 k + 1 2 ] β 4 n 2 k + 1 2 x ( 4 n + 3 ) = k = 0 N 4 1 [ X o ( k ) X o N 4 k 1 X o k + N 2 + X o 3 N 4 k 1 β 1 3 2 k + 1 2 X o N k 1 X o k + N 4 X o N 2 k 1 + X o k + 3 N 4 β 2 3 2 k + 1 2 ] β 4 n 2 k + 1 2
Like ONMNT, the butterfly diagram for IONMNT consists of eight points. Figure 3 presents the butterfly diagram for IONMNT.
Using the butterfly diagram given in Figure 3, the signal flow diagram can be drawn for any length of N. For example, Figure 4 presents a signal flow diagram of radix- 2 2 IONMNT for the transform length N = 16 .

5. Arithmetic Complexity of Radix- 2 2 Algorithm

There are two general formulas for computing complexity: the closed formula used for single-butterfly implementation and the recursive formula used for multiple-butterfly implementation. In this paper, we used single-butterfly implementation for simplicity in calculation. The arithmetic complexity is a summation of the number of initial additions and multiplications in a single butterfly, along with the number of stages and points. A comparison of arithmetic complexity for ONMNT using direct calculations for the radix-2 and radix- 2 2 algorithms is presented below. In the direct calculation of the transform, the numbers of addition and multiplication operations are N ( N 1 ) and N 2 , respectively, where N is the transform length. The number of stages in the radix-2 fast algorithm is log 2 ( N ) . Each butterfly processes N / 4 points and requires 6 additions and 4 multiplications using the single-butterfly implementation. Therefore, the number of additions A ( N ) and multiplications M ( N ) for radix 2 can be calculated using the following equations:
A ( N ) = N 4 6 log 2 ( N ) = 3 N 2 log 2 ( N )
M ( N ) = N 4 4 log 2 ( N ) = N log 2 ( N )
In the radix- 2 2 algorithm, the number of stages S is log 4 ( N ) or 1 2 log 2 ( N ) , where N is the number of points in each butterfly. The numbers of multiplication and addition operations required in each stage are 12 and 22, respectively. As the radix- 2 2 butterfly has eight points—four main points and four retrograde points—the number of points to calculate at each stage is N 8 . Therefore, the arithmetic complexity can be calculated in terms of the number of additions A ( N ) and the number of multiplications M ( N ) using the following equations:
A ( N ) = N 8 × 22 × 1 2 log 2 N = 11 N 8 log 2 ( N )
M ( N ) = N 8 × 12 × 1 2 log 2 N = 3 N 4 log 2 ( N )
Figure 5 shows the total calculations for direct calculations, radix-2, and radix- 2 2 , in a graph where the x-axis shows the transform length in the logarithm scale and the y-axis shows the total number of calculations, including addition and multiplication. As can be seen from the figure, both the radix-2 and radix- 2 2 algorithms require significantly fewer calculations than the direct method. Moreover, the total number of calculations increases exponentially as the transform length increases.
Table 1 presents the number of additions, multiplications, and total calculation required for ONNMT using a direct calculation as well as the radix-2 and radix- 2 2 algorithms for transform length N = 8 , 16 , 32 , 64 , 128 and 256. Comparing (67) and (68) with (69) and (70) for direct calculations, the numbers of saved operations in the radix- 2 2 algorithm relative to radix 2 can be written as follows:
Δ A ( N ) = N 8 log 2 ( N )
Δ M ( N ) = N 4 log 2 ( N )
The radix- 2 2 algorithm offers an 8.55 % reduction in the number of additions and a 25 % reduction in the number of multiplications compared to radix 2. It is important to note that the multiplication operation is more CPU-intensive than the addition operation, so a 25 % saving in the number of multiplications in the radix- 2 2 algorithm is notable and makes it more suitable for a lightweight cipher application. Overall, this algorithm achieves a 15 % reduction in total calculations. The number of calculations for radix-4 and split radix is not included in the comparison because the transform length of radix-4 [32] fast algorithm is only limited to the power of 4, and it has more complex implementations than radix- 2 2 . Radix- 2 2 has the same non-trivial multiplicative complexity of radix-4, but it retains the butterfly structure of radix-2 [33]. The saving percentage will be higher as the transform length increases.

6. An Example of the Proposed Fast Algorithm

To validate the accuracy of the derived algorithm, a short data packet was transformed using the radix- 2 2 fast algorithm for the ONMNT forward transform. Then, IONMNT was applied to the transformed data using the radix- 2 2 algorithm to recover the original data. The experiment was implemented in the C programming language. Moreover, the outputs of the proposed fast algorithm for forward ONMNT and IONMNT were compared with the direct calculations and verified. A brief description of the experiment and the results are presented below:

6.1. Forward ONMNT Transform

First, the text “Encryption story” was converted into ASCII values and transformed using the proposed algorithm with transform parameters α 1 = 2 , α 2 = 3 , N = 16 , p = 7 , M p = 127 , n = { 0 , 1 , 2 , , 15 } , and k = { 0 , 1 , 2 , , 15 } . The original and transformed values are as follows:
x[n]:691109911412111211610511111032115116111114121
X[k]:565233525335838085821463211137976

6.2. IONMNT Transform

IONMNT was applied to the transformed data X [ k ] using the same transform parameters, recovering the original data. Moreover, the results match with the direct calculations.
X[k]:565243525335838085821463211137976
x[n]:691109911412111211610511111032115116111114121
Therefore, this experiment confirms the proposed solution’s validity and shows no rounding or truncation errors, which is a good attribute of the ONMNT.

7. Conclusions

An efficient derivation of a radix- 2 2 fast algorithm for both ONMNT and IONMNT has been presented in this paper. A bit-unscrambling technique provides a more straightforward implementation of the radix- 2 2 algorithm compared to traditional multidimensional index mapping. The butterfly and signal flow diagrams presented in the paper offer flexibility in implementing ONMNT using the radix 2 2 algorithm. The proposed fast algorithm offers an 8.55 % reduction in the number of additions, a 25 % reduction in the CPU-intensive multiplication operations, and an overall reduction of 15 % compared to radix-2 while retaining the butterfly structure of radix-2. This efficient and fast algorithm can be used for lightweight ciphers and hash functions to take advantage of both the reduced number of calculations offered by the radix-4 algorithm and the simple butterfly structure of the radix-2 fast algorithm. In future research, the proposed algorithm could be implemented in multiple hardware platforms and used in real-life applications to understand its performance better. Moreover, the derivation could also be extended to O2NMNT.

Author Contributions

Conceptualization, Y.A.-A. and S.B.; methodology, Y.A.-A., M.T.H. and S.B; software, Y.A.-A., M.T.H. and S.B.; validation, Y.A.-A., M.T.H. and S.B.; writing—original draft preparation, Y.A.-A. and S.B.; writing—review and editing, Y.A.-A., M.T.H. and S.B.; visualization, Y.A.-A., M.T.H. and S.B.; supervision, S.B. and M.T.H. All authors have read and agreed to the published version of the manuscript.

Funding

This research is a continuation of previously funded research by EPSRC under grant number GR/S98160/02.

Data Availability Statement

No new data were created or analyzed in this study. Data sharing is not applicable to this article.

Conflicts of Interest

The authors declare no conflict of interest.

Abbreviations

The following abbreviations are used in this manuscript:
ASICApplication-Specific Integrated Circuit
GNMNTGeneralized New Mersenne Number Transform
IONMNTInverse Odd New Mersenne Number Transform
WHTWalsh–Hadamard Transform
FFTFast Fourier Transform
FPGAField-Programmable Gate Array
NMNTNew Mersenne Number Transform
NTTNumber Theoretic Transform
ONMNTOdd New Mersenne Number Transform
O2NMNTOdd Squared New Mersenne Number Transform

Appendix A

Appendix A.1. Beta Relationships

In the following proof, β 1 ( . ) and β 2 ( . ) are two components of the kernel parameter of the ONMNT β ( . ) , i.e., β ( . ) = β 2 ( . ) + β 2 ( . ) , and N is the transform length.
β 1 2 N 4 k 1 + 1 2 = β 2 2 k + 1 2 .
β 2 2 N 4 k 1 + 1 2 = β 1 2 k + 1 2 .
β 1 2 N 4 k 1 + 1 2 × 2 = β 1 2 k + 1 2 × 2 .
β 2 2 N 4 k 1 + 1 2 × 2 = β 2 2 k + 1 2 × 2 .
β 1 2 N 4 k 1 + 1 2 × 3 = β 2 2 k + 1 2 × 3 .
β 2 2 N 4 k 1 + 1 2 × 3 = β 1 2 k + 1 2 × 3 .

Appendix A.2. Proof of (A1)(A6)

β 1 2 N 4 k 1 + 1 2 × a = β 1 N 2 ( 2 k + 1 ) 2 × a = β 1 N 4 ( 2 k + 1 ) 2 × a = β 1 N 4 × a ( 2 k + 1 ) 2 × a
β 2 2 N 4 k 1 + 1 2 × a = β 2 N 2 ( 2 k + 1 ) 2 × a = β 2 N 4 ( 2 k + 1 ) 2 × a = β 2 N 4 × a ( 2 k + 1 ) 2 × a .
The following beta properties are required below:
β 1 ( m n ) = β 1 ( m ) β 1 ( n ) + β 2 ( m ) β 2 ( n )
β 2 ( m n ) = β 2 ( m ) β 1 ( n ) β 1 ( m ) β 2 ( n )
Using (A9) and (A10), (A8) can be written as follows:
β 1 N 4 × a ( 2 k + 1 ) 2 × a = β 1 N 4 × a β 1 ( 2 k + 1 ) 2 × a + β 2 N 4 × a β 2 ( 2 k + 1 ) 2 × a
β 2 N 4 × a ( 2 k + 1 ) 2 × a = β 2 N 4 × a β 1 ( 2 k + 1 ) 2 × a β 1 N 4 × a β 2 ( 2 k + 1 ) 2 × a
β 1 a N 4 = ( 1 ) a 2 a = even 0 a = odd β 2 a N 4 = 0 a = even ( 1 ) a 1 2 a = odd
Substituting a = 1 in (A13) leads to the following:
β 1 N 4 = 0 , and β 2 N 4 = 1 .
Substituting the values of β 1 N 4 and β 2 N 4 from (A14) and setting a = 1 in (A11) and (A12),
β 1 N 4 ( 2 k + 1 ) 2 = β 2 ( 2 k + 1 ) 2
β 1 2 N 4 k 1 + 1 2 × 2 = β 1 ( 2 k + 1 ) 2 × 2
β 2 2 N 4 k 1 + 1 2 × 2 = β 2 ( 2 k + 1 ) 2 × 2 .
When a = 3 in (A13),
β 1 N 4 × 3 = 0 β 2 N 4 × 3 = 1 .
Substituting the values of β 1 N 4 and β 2 N 4 from (A13) and setting a = 3 in (A11) and (A12),
β 1 N 4 × 3 ( 2 k + 1 ) 2 × 3 = β 2 ( 2 k + 1 ) 2 × 3
β 2 N 4 × 3 ( 2 k + 1 ) 2 × 3 = β 1 ( 2 k + 1 ) 2 × 3
β 1 2 N 4 k 1 + 1 2 × 3 = β 2 ( 2 k + 1 ) 2 × 3
β 2 2 N 4 k 1 + 1 2 × 3 = β 1 ( 2 k + 1 ) 2 × 3 .

References

  1. Nussbaumer, H.J. Number Theoretic Transforms, 2nd ed.; Springer: Berlin/Heidelberg, Germany, 1982; pp. 211–240. [Google Scholar] [CrossRef]
  2. Yan, K. A Review of the Development and Applications of Number Theory. J. Phys. Conf. Ser. 2019, 1325, 012128. [Google Scholar] [CrossRef]
  3. Rader, C.M. Discrete convolutions via Mersenne transforms. IEEE Trans. Comput. 1972, C-21, 1269–1273. [Google Scholar] [CrossRef]
  4. Kehil, D.; Ferdi, Y. Signal encryption using new Mersenne number transform. In Proceedings of the 2010 7th International Symposium on Communication Systems, Networks Digital Signal Processing (CSNDSP 2010), Newcastle Upon Tyne, UK, 21–23 July 2010; pp. 736–740. [Google Scholar] [CrossRef]
  5. Křížek, M.; Luca, F.; Somer, L. Fermat number transform and other applications. In 17 Lectures on Fermat Numbers: From Number Theory to Geometry; Springer: New York, NY, USA, 2001; pp. 165–186. [Google Scholar] [CrossRef]
  6. Agarwal, R.C.; Burrus, C.S. Fast convolution using Fermat number transforms with applications to digital filtering. IEEE Trans. Acoust. 1974, 22, 87–97. [Google Scholar] [CrossRef]
  7. Boussakta, S.; Holt, A.G.J. New number theoretic transform. Electron. Lett. 1992, 28, 1683–1684. [Google Scholar] [CrossRef]
  8. Boussakta, S.; Hamood, M.T.; Rutter, N. Generalized new Mersenne number transforms. IEEE Trans. Signal Process. 2012, 60, 2640–2647. [Google Scholar] [CrossRef]
  9. Rutter, N. Implementation and Analysis of the Generalised New Mersenne Number Transforms for Encryption. Ph.D. Thesis, Newcastle University, Newcastle upon Tyne, UK, 2015. Available online: http://theses.ncl.ac.uk/jspui/handle/10443/3236 (accessed on 25 July 2023).
  10. Hamood, M.T. Development of Efficient Algorithms for Fast Compution of Discrete Transforms. Ph.D. Thesis, Newcastle University, Newcastle upon Tyne, UK, 2012. [Google Scholar]
  11. Hua, J.; Liu, F.; Xu, Z.; Li, F.; Wang, D. A fast realization of new Mersenne number transformation and its applications. Int. J. Circuit Theory Appl. 2019, 47, 738–752. [Google Scholar] [CrossRef]
  12. He, S.; Torkelson, M. New approach to pipeline FFT processor. In Proceedings of the International Conference on Parallel Processing, Honolulu, HI, USA, 15–19 April 1996; pp. 766–770. [Google Scholar] [CrossRef]
  13. Pollard, J.M. The Fast Fourier Transform in a Finite Field. Math. Compulation 1971, 25, 365–374. [Google Scholar] [CrossRef]
  14. Cortés, A.; Vélez, I.; Sevillano, J.F. Radix rk FFTs: Matricial representation and SDC/SDF pipeline implementation. IEEE Trans. Signal Process. 2009, 57, 2824–2839. [Google Scholar] [CrossRef]
  15. Anguraj, P.; Krishnan, T.; Natesan, K. Design of an area-efficient various N-point support radix-2/22 FFT using modified butterfly units. Int. J. Recent Tech. Eng. 2019, 8, 10189–10198. [Google Scholar] [CrossRef]
  16. Samir Algnabi, Y.; Teymourzadeh, R.; Othman, M.; Shabiul Islam, M. FPGA implementation of pipeline digit-slicing multiplier-less radix 22 DIF SDF butterfly for fast Fourier transform structure. arXiv 2018, arXiv:1806.04570. [Google Scholar]
  17. Santhosh, L.; Thomas, A. Implementation of radix 2 and radix 22 FFT algorithms on Spartan6 FPGA. In Proceedings of the 2013 Fourth International Conference on Computing, Communications and Networking Technologies (ICCCNT), Tiruchengode, India, 4–6 July 2013; pp. 1–4. [Google Scholar] [CrossRef]
  18. Li, N.; Van Der Meijs, N.P. A radix 22 based parallel pipeline FFT processor for MB-OFDM UWB system. In Proceedings of the 2009 IEEE International SOC Conference (SOCC), Belfast, UK, 9–11 September 2009; pp. 383–385. [Google Scholar] [CrossRef]
  19. Eisenbarth, T.; Kumar, S.; Paar, C.; Poschmann, A.; Uhsadel, L. A Survey of Lightweight-Cryptography Implementations. IEEE Des. Test Comput. 2007, 24, 522–533. [Google Scholar] [CrossRef]
  20. Philip, M.A.; Vaithiyanathan. A survey on lightweight ciphers for IoT devices. In Proceedings of the 2017 International Conference on Technological Advancements in Power and Energy (TAP Energy), Kollam, India, 21–23 December 2017; pp. 1–4. [Google Scholar] [CrossRef]
  21. Fragkos, G.; Minwalla, C.; Plusquellic, J.; Tsiropoulou, E.E. Artificially Intelligent Electronic Money. IEEE Consum. Electron. Mag. 2021, 10, 81–89. [Google Scholar] [CrossRef]
  22. Parvatham, N.; Professor, A. LEA-SIoT: Hardware Architecture of Lightweight Encryption Algorithm for Secure IoT on FPGA Platform. (IJACSA) Int. J. Adv. Comput. Sci. Appl. 2020, 11, 720–725. [Google Scholar] [CrossRef]
  23. Nabeel, N.; Habaebi, M.H.; Rafiqul Islam, M. LNMNT—New Mersenne number based lightweight crypto hash function for IoT. In Proceedings of the 8th International Conference on Computer and Communication Engineering, ICCCE 2021, Kuala Lumpur, Malaysia, 22–23 June 2021; pp. 68–71. [Google Scholar] [CrossRef]
  24. Maetouq, A.; Daud, S.M. HMNT: Hash function based on new Mersenne number transform. IEEE Access 2020, 8, 80395–80407. [Google Scholar] [CrossRef]
  25. Nabeel, N.; Habaebi, M.H.; Islam, M.D.R. Security analysis of LNMNT-lightweight crypto hash function for IoT. IEEE Access 2021, 9, 165754–165765. [Google Scholar] [CrossRef]
  26. Burrus, C. Index mappings for multidimensional formulation of the DFT and convolution. IEEE Trans. Acoust. Speech Signal Process. 1977, 25, 239–242. [Google Scholar] [CrossRef]
  27. Burrus, C. Bit reverse unscrambling for a radix-2M FFT. In Proceedings of the ICASSP ’87, IEEE International Conference on Acoustics, Speech, and Signal Processing, Dallas, TX, USA, 6–9 April 1987; Volume 12, pp. 1809–1810. [Google Scholar] [CrossRef]
  28. Burrus, C.S. Unscrambling for fast DFT algorithms. IEEE Trans. Acoust. Speech Signal Process. 1988, 36, 1086–1087. [Google Scholar] [CrossRef]
  29. Papamichalis, P.E.; Burrus, C.S. Conversion of digit-reversed to bit-reversed order in FFT algorithms. In Proceedings of the International Conference on Acoustics, Speech, and Signal Processing, Glasgow, UK, 23–26 May 1989; Volume 2, pp. 984–987. [Google Scholar] [CrossRef]
  30. Hamood, M.T.; Boussakta, S. Efficient algorithms for computing the new Mersenne number transform. Digit. Signal Process. 2014, 25, 280–288. [Google Scholar] [CrossRef]
  31. Agarwal, R.C.; Burrus, C.S. Number theoretic transforms to implement fast digital convolution. Proc. IEEE Inst. Electr. Electron. Eng. 1975, 63, 550–560. [Google Scholar] [CrossRef]
  32. Chu, E.; George, A. Inside the FFT Black Box—Serial and Parallel Fast the Serial and Parallel Fast Algorithms; CRC Press: Boca Raton, FL, USA, 2000; pp. 109–117. [Google Scholar]
  33. Selvakumar, S.; Stephy Jasmine Rani, L.; Vijayalakshmi, G.; Vishnudevi, N.; Janakiraman, N. Radix 25 Fft Architecture Implementation In Xilinx Fpga. In Proceedings of the 2014 International Conference on Innovations in Engineering and Technology, Tamil Nadu, India, 21–22 March 2014; pp. 1507–1511. [Google Scholar]
Figure 1. An in-place butterfly diagram of the radix- 2 2 ONMNT algorithm; solid lines and dashed lines represent addition and subtraction operations, respectively.
Figure 1. An in-place butterfly diagram of the radix- 2 2 ONMNT algorithm; solid lines and dashed lines represent addition and subtraction operations, respectively.
Signals 04 00041 g001
Figure 2. A signal flow graph of radix- 2 2 ONMNT for the transform length N = 16 ; solid lines and dashed lines represent addition and subtraction operations, respectively.
Figure 2. A signal flow graph of radix- 2 2 ONMNT for the transform length N = 16 ; solid lines and dashed lines represent addition and subtraction operations, respectively.
Signals 04 00041 g002
Figure 3. An in-place butterfly diagram of the radix- 2 2 IONMNT algorithm; solid lines and dashed lines represent addition and subtraction operations, respectively.
Figure 3. An in-place butterfly diagram of the radix- 2 2 IONMNT algorithm; solid lines and dashed lines represent addition and subtraction operations, respectively.
Signals 04 00041 g003
Figure 4. Signal flow graph of radix- 2 2 IONMNT for the transform length N = 16; solid lines and dashed lines represent addition and subtraction operations, respectively.
Figure 4. Signal flow graph of radix- 2 2 IONMNT for the transform length N = 16; solid lines and dashed lines represent addition and subtraction operations, respectively.
Signals 04 00041 g004
Figure 5. Comparison of total calculations for direct calculations, radix-2 and radix- 2 2 .
Figure 5. Comparison of total calculations for direct calculations, radix-2 and radix- 2 2 .
Signals 04 00041 g005
Table 1. Comparison of arithmetic complexity for ONMNT using a single butterfly.
Table 1. Comparison of arithmetic complexity for ONMNT using a single butterfly.
DirectRadix-2Radix-22
N Add. Multi. Total Add. Multi. Total Add. Multi. Total
85664120362460331851
1624025649696641608848136
3299210242016240160400220120340
64403240968128576384960528288816
12816,25616,38432,6401344896224012326721904
25665,28065,536130,816307220485120281615364352
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Share and Cite

MDPI and ACS Style

Al-Aali, Y.; Hamood, M.T.; Boussakta, S. Radix-22 Algorithm for the Odd New Mersenne Number Transform (ONMNT). Signals 2023, 4, 746-767. https://doi.org/10.3390/signals4040041

AMA Style

Al-Aali Y, Hamood MT, Boussakta S. Radix-22 Algorithm for the Odd New Mersenne Number Transform (ONMNT). Signals. 2023; 4(4):746-767. https://doi.org/10.3390/signals4040041

Chicago/Turabian Style

Al-Aali, Yousuf, Mounir T. Hamood, and Said Boussakta. 2023. "Radix-22 Algorithm for the Odd New Mersenne Number Transform (ONMNT)" Signals 4, no. 4: 746-767. https://doi.org/10.3390/signals4040041

Article Metrics

Back to TopTop