<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE article PUBLIC "-//NLM//DTD JATS (Z39.96) Journal Publishing DTD v1.2 20190208//EN" "http://jats.nlm.nih.gov/publishing/1.2/JATS-journalpublishing1.dtd"><article xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink" article-type="research-article" dtd-version="1.2" xml:lang="en">
    <front>
        <journal-meta>
            <journal-id journal-id-type="pmc">F1000Research</journal-id>
            <journal-title-group>
                <journal-title>F1000Research</journal-title>
            </journal-title-group>
            <issn pub-type="epub">2046-1402</issn>
            <publisher>
                <publisher-name>F1000 Research Limited</publisher-name>
                <publisher-loc>London, UK</publisher-loc>
            </publisher>
        </journal-meta>
        <article-meta>
            <article-id pub-id-type="doi">10.12688/f1000research.126067.1</article-id>
            <article-categories>
                <subj-group subj-group-type="heading">
                    <subject>Research Article</subject>
                </subj-group>
                <subj-group>
                    <subject>Articles</subject>
                </subj-group>
            </article-categories>
            <title-group>
                <article-title>Implementation of distributed arithmetic-based symmetrical 2-D block finite impulse response filter architectures</article-title>
                <fn-group content-type="pub-status">
                    <fn>
                        <p>[version 1; peer review: 2 approved]</p>
                    </fn>
                </fn-group>
            </title-group>
            <contrib-group>
                <contrib contrib-type="author" corresp="yes">
                    <name>
                        <surname>Chowdari Ch</surname>
                        <given-names>Pratyusha</given-names>
                    </name>
                    <role content-type="http://credit.niso.org/">Conceptualization</role>
                    <role content-type="http://credit.niso.org/">Data Curation</role>
                    <role content-type="http://credit.niso.org/">Formal Analysis</role>
                    <role content-type="http://credit.niso.org/">Investigation</role>
                    <role content-type="http://credit.niso.org/">Methodology</role>
                    <role content-type="http://credit.niso.org/">Resources</role>
                    <role content-type="http://credit.niso.org/">Validation</role>
                    <role content-type="http://credit.niso.org/">Writing &#x2013; Original Draft Preparation</role>
                    <role content-type="http://credit.niso.org/">Writing &#x2013; Review &amp; Editing</role>
                    <uri content-type="orcid">https://orcid.org/0000-0001-5444-5302</uri>
                    <xref ref-type="corresp" rid="c1">a</xref>
                    <xref ref-type="aff" rid="a1">1</xref>
                </contrib>
                <contrib contrib-type="author" corresp="no">
                    <name>
                        <surname>Seventline</surname>
                        <given-names>J.B.</given-names>
                    </name>
                    <role content-type="http://credit.niso.org/">Formal Analysis</role>
                    <role content-type="http://credit.niso.org/">Methodology</role>
                    <role content-type="http://credit.niso.org/">Resources</role>
                    <role content-type="http://credit.niso.org/">Supervision</role>
                    <role content-type="http://credit.niso.org/">Validation</role>
                    <role content-type="http://credit.niso.org/">Writing &#x2013; Review &amp; Editing</role>
                    <xref ref-type="aff" rid="a2">2</xref>
                </contrib>
                <aff id="a1">
                    <label>1</label>Department of Electronics and Communications Engineering, Gokaraju Rangaraju Institute of Engineering and Technology, Hyderabad, 500090, India</aff>
                <aff id="a2">
                    <label>2</label>Department of Electrical, Electronics and Communication Engineering, GITAM University, Visakhaptnam, Andhra Pradesh, 530045, India</aff>
            </contrib-group>
            <author-notes>
                <corresp id="c1">
                    <label>a</label>
                    <email xlink:href="mailto:pratyushachowdarich@gmail.com">pratyushachowdarich@gmail.com</email>
                </corresp>
                <fn fn-type="conflict">
                    <p>No competing interests were disclosed.</p>
                </fn>
            </author-notes>
            <pub-date pub-type="epub">
                <day>21</day>
                <month>9</month>
                <year>2023</year>
            </pub-date>
            <pub-date pub-type="collection">
                <year>2023</year>
            </pub-date>
            <volume>12</volume>
            <elocation-id>1182</elocation-id>
            <history>
                <date date-type="accepted">
                    <day>17</day>
                    <month>2</month>
                    <year>2023</year>
                </date>
            </history>
            <permissions>
                <copyright-statement>Copyright: &#x00a9; 2023 Chowdari Ch P and Seventline JB</copyright-statement>
                <copyright-year>2023</copyright-year>
                <license xlink:href="https://creativecommons.org/licenses/by/4.0/">
                    <license-p>This is an open access article distributed under the terms of the Creative Commons Attribution Licence, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.</license-p>
                </license>
            </permissions>
            <self-uri content-type="pdf" xlink:href="https://f1000research.com/articles/12-1182/pdf"/>
            <abstract>
                <p>
                    <bold>Background:</bold> This paper presents an efficient two-dimensional (2-D) finite impulse response (FIR) filter using block processing for two different symmetries. Architectures for a general filter (without symmetry) and two symmetrical filters (diagonal and quadrantal symmetry) are implemented. The proposed architectures need fewer multipliers because of the symmetry of the filter coefficients.</p>
                <p>
                    <bold>Methods:</bold> A distributed arithmetic (DA)- based multiplication method is used in the proposed architecture. A dual-port memory-based lookup table (DP-MLUT) is used in the multiplication instead of lookup-table (LUT) to reduce the area and power of the FIR filter. The filter's throughput is increased by using block processing. Memory reuse and memory sharing methods are introduced, which reduces the need for many registers and hence the circuit complexity. The architectures are written in Verilog Hardware Description Language and synthesized using Genus Synthesis tool-19.1 in 45nm technology with a generic library of Cadence vendor constraints. The synthesis tool generates the area, delay, and power reports. Power consumption of architectures is calculated with an image size of 64 X 64 and at 20 MHz frequency.</p>
                <p>
                    <bold>Results:</bold> Compared to existing architectures, the synthesis results show improvements in power, area, area delay product (ADP), and power delay product (PDP). The proposed MLUT-based 2-D block Quadrantal Symmetry Filter (QSF) for length 8 with block size 4 consumes 58.94% less power, occupies 59.5% less area, 48.44% less ADP and 47.78% less PDP compared to best existing methods.</p>
                <p>
                    <bold>Conclusions:</bold> A novel DA-based 2-D block FIR filter architecture with various symmetries is realized. Symmetry is incorporated into the filter coefficients to minimize the number of multipliers. The LUT size is optimized by odd multiples or even multiples storage techniques. Also, the overall area of the architecture is decreased by DP-LUT-based multipliers. The proposed filter architecture is area-power-efficient. It is best suited for applications that have fixed coefficients.</p>
            </abstract>
            <kwd-group kwd-group-type="author">
                <kwd>Systolic architecture</kwd>
                <kwd>block processing</kwd>
                <kwd>distributed arithmetic</kwd>
                <kwd>2-D finite impulse response</kwd>
                <kwd>symmetries in FIR filter</kwd>
            </kwd-group>
            <funding-group>
                <award-group id="fund-1">
                    <funding-source>No</funding-source>
                    <award-id>No</award-id>
                </award-group>
                <funding-statement>The author(s) declared that no grants were involved in supporting this work.</funding-statement>
            </funding-group>
        </article-meta>
    </front>
    <body>
        <sec id="sec1" sec-type="intro">
            <title>Introduction</title>
            <p>Many image and video processing applications, including image enhancement, template matching, image restoration, and video communication, use 2-D digital filters.
                <sup>
                    <xref ref-type="bibr" rid="ref1">1</xref>
                </sup>
                <sup>,</sup>
                <sup>
                    <xref ref-type="bibr" rid="ref2">2</xref>
                </sup> Finite impulse response (FIR) filters are preferred over infinite impulse response (IIR) filter when the numerical stability, ease of design and linear phase are the primary concerns.
                <sup>
                    <xref ref-type="bibr" rid="ref1">1</xref>
                </sup> Because 2-D FIR filters need numerous computations, the efficient structure design is challenging for researchers. In,
                <sup>
                    <xref ref-type="bibr" rid="ref1">1</xref>
                </sup> Parhi proposed a systolic structure for a 2-D FIR filter and suggested many techniques to optimize the implementation of 1-D and 2-D FIR and IIR filter architectures with more computational blocks. The block-based 2-D FIR filter banks consisting of separable and non-separable architectures with a significant reduction in memory are described.
                <sup>
                    <xref ref-type="bibr" rid="ref3">3</xref>
                </sup>
                <sup>,</sup>
                <sup>
                    <xref ref-type="bibr" rid="ref4">4</xref>
                </sup> In,
                <sup>
                    <xref ref-type="bibr" rid="ref3">3</xref>
                </sup> conventional multipliers, which consume power, are used for the convolution of input samples and filter coefficients, and there is no consideration of the internal architectures of symmetry filters.</p>
            <p>The power-efficient and memory-efficient 2-D FIR filter architectures (FIRAs) are constructed with high-speed multipliers and parallel prefix modified carry look ahead adder (MCLAA).
                <sup>
                    <xref ref-type="bibr" rid="ref5">5</xref>
                </sup> The low area-memory-based non-symmetry type 2-D FIRA is proposed with a new multiplication technique.
                <sup>
                    <xref ref-type="bibr" rid="ref6">6</xref>
                </sup> In the above works, no symmetry concept is considered. The arithmetic computations are decreased by coefficient symmetry in the systolic filter architecture.
                <sup>
                    <xref ref-type="bibr" rid="ref7">7</xref>
                </sup>
                <sup>,</sup>
                <sup>
                    <xref ref-type="bibr" rid="ref8">8</xref>
                </sup> The low-power multimode architectures for 2-D IIR filters are designed and implemented with four symmetries. The critical path analysis is addressed for symmetry filters, but the architectures are implemented only for single input processing. Another single input processing-based quadrantal symmetry is implemented using the 2-D L
                <sub>1</sub>- technique to minimize the filter coefficients and hardware blocks.
                <sup>
                    <xref ref-type="bibr" rid="ref9">9</xref>
                </sup> Recently, Chowdari 
                <italic toggle="yes">et al.</italic>
                <sup>
                    <xref ref-type="bibr" rid="ref24">24</xref>
                </sup>
                <sup>&#x2013;</sup>
                <sup>
                    <xref ref-type="bibr" rid="ref26">26</xref>
                </sup> have proposed efficient implementation of DA based adaptive filter.</p>
            <p>Mohanty 
                <italic toggle="yes">et al</italic>.
                <sup>
                    <xref ref-type="bibr" rid="ref10">10</xref>
                </sup> proposed a 1-D block filter for narrowband applications using a Distributed Arithmetic (DA)-based reconfigurable filter for the software define radio SDR channelizer. Introduced the memory sharing concept to implement a 1-D finite impulse response (FIR) filter with a low area-power-delay. Several authors have implemented only DA-based 1-D filters. In recent years, DA techniques have attained great importance in FIR filter implementation to reduce the complexity of the architecture with high throughput and regularity. Kumar 
                <italic toggle="yes">et al</italic>.
                <sup>
                    <xref ref-type="bibr" rid="ref11">11</xref>
                </sup>
                <sup>,</sup>
                <sup>
                    <xref ref-type="bibr" rid="ref12">12</xref>
                </sup> recently proposed block-based 2-D FIR and IIR filter architectures using DA with a memory-sharing approach but did not discuss the symmetry of coefficients. DA-based FIRAs are described in,
                <sup>
                    <xref ref-type="bibr" rid="ref13">13</xref>
                </sup>
                <sup>,</sup>
                <sup>
                    <xref ref-type="bibr" rid="ref14">14</xref>
                </sup> and the review of DA methods for cost-effective and efficient FIRAs is summarized. Park 
                <italic toggle="yes">et al</italic>.
                <sup>
                    <xref ref-type="bibr" rid="ref15">15</xref>
                </sup> have suggested reconfigurable FIR architecture using DA.</p>
            <p>In all the DA-based filter implementation schemes, the authors focused only on the decreasing adders' quantity and multiplier complexity. Memory complexity is one of the key factors while designing the filter, affecting power consumption and area. Many researchers have addressed the 1-D and 2-D filters using symmetry or block processing in filters.
                <sup>
                    <xref ref-type="bibr" rid="ref16">16</xref>
                </sup>
                <sup>,</sup>
                <sup>
                    <xref ref-type="bibr" rid="ref17">17</xref>
                </sup> Few researchers have realized the filter structures with Lookup Table (LUT)-based or DA multipliers without block processing or symmetry.</p>
            <p>A new approach to memory-based DA multiplication is proposed by Meher 
                <italic toggle="yes">et al</italic>.
                <sup>
                    <xref ref-type="bibr" rid="ref18">18</xref>
                </sup>
                <sup>,</sup>
                <sup>
                    <xref ref-type="bibr" rid="ref19">19</xref>
                </sup> This memory-based LUT (MLUT) multiplication approach is used to realize the 1-D FIR filters. The comparison analysis is presented with conventional multiplier-based filter architectures. Vinitha 
                <italic toggle="yes">et al.</italic>
                <sup>
                    <xref ref-type="bibr" rid="ref6">6</xref>
                </sup>
                <sup>,</sup>
                <sup>
                    <xref ref-type="bibr" rid="ref20">20</xref>
                </sup> also developed the LUT-based multiplication and incorporated it into the filer architectures with fewer hardware blocks. Chiper 
                <italic toggle="yes">et al</italic>.
                <sup>
                    <xref ref-type="bibr" rid="ref21">21</xref>
                </sup> suggested the dual-port concept in the MLUT-based DA multiplication rather than Single-Port LUT (SPLUT) multipliers. The modified memory-based multipliers are realized to implement an efficient filter architecture by Sharma 
                <italic toggle="yes">et al</italic>.
                <sup>
                    <xref ref-type="bibr" rid="ref22">22</xref>
                </sup> Alawad 
                <italic toggle="yes">et al</italic>.
                <sup>
                    <xref ref-type="bibr" rid="ref23">23</xref>
                </sup> presented a stochastic-based 2-D FIRA with low hardware complexity and high throughput. The probabilistic convolution theorem is used for the proposed non-separable systolic 2-D FIRA. The proposed work solves this problem within a predetermined accuracy range. The probability density function represents the 2-D input signal kernels by exploiting the convolution theorem. This well-known probabilistic convolution theorem replaces the expensive multipliers with simple adders. The memory storage complexity is also reduced by memory sharing and memory reuse. This work is more suitable for applications like perception-based image processing, which can inherently tolerate some computing inaccuracy.</p>
            <p>The addressed points motivate developing and implementing the block-based 2-D FIRAs using various symmetries and multiplier-less DA-based approaches. In this research, two types of symmetries, diagonal symmetry and quadrantal symmetry, are considered to reduce the multipliers. The hardware in adders is increased by block processing in symmetry filters, although multipliers are more complex than adders. A novel MLUT multiplication approach is introduced in the 2-D block FIRAs. Two types of symmetries for 2-D FIRA and one non-symmetry filter are explored to decrease the number of multipliers. Conventional multipliers are replaced with MLUT multipliers to decrease each symmetry filter's power consumption, delay, and area.</p>
            <p>The paper is organized as follows: The novel approach to designing the two types of symmetries and an optimized memory-based multiplication approach for 2-D FIRAs are discussed in background section. The next section describes the proposed 2-D FIRAs, and the individual symmetry filter architectures are explored according to the block processing using enhanced Dual-Port Memory-based LUT (DP-MLUT)-based multipliers.</p>
        </sec>
        <sec id="sec2">
            <title>Background: Block-based design and symmetry of 2-D FIR filters</title>
            <p>This section explains the various coefficient symmetry concepts and the MLUT multiplication approach to replacing normal multipliers.</p>
            <sec id="sec3">
                <title>Block processing and memory reuse</title>
                <p>In the digital filters, the block processing concept increases the throughput of the architecture. If the input block size is &#x2018;
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula>&#x2019;, the filter produces &#x2018;
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula>&#x2019; outputs per one iteration, which means 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula>-times throughput increases. The input matrix 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>X</mml:mi>
                            <mml:mfenced close=")" open="(" separators=",">
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>1</mml:mn>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msub>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> is needed at different systolic stages to generate a 2-D filter output 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>Y</mml:mi>
                            <mml:mfenced close=")" open="(" separators=",">
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>1</mml:mn>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msub>
                            </mml:mfenced>
                            <mml:mspace width="0.25em"/>
                        </mml:math>
                    </inline-formula>is of the length of the filter (
                    <italic toggle="yes">L</italic>).
                    <sup>
                        <xref ref-type="bibr" rid="ref3">3</xref>
                    </sup>
                    <disp-formula id="e1">
                        <mml:math display="block">
                            <mml:mi>X</mml:mi>
                            <mml:mfenced close=")" open="(" separators=",">
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>1</mml:mn>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msub>
                            </mml:mfenced>
                            <mml:mo>=</mml:mo>
                            <mml:mfenced close="]" open="[">
                                <mml:mtable>
                                    <mml:mtr>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:msub>
                                                                <mml:mi>n</mml:mi>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:msub>
                                                            <mml:msub>
                                                                <mml:mi>n</mml:mi>
                                                                <mml:mn>2</mml:mn>
                                                            </mml:msub>
                                                        </mml:mfenced>
                                                        <mml:mspace width="0.5em"/>
                                                        <mml:mspace width="0.25em"/>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:msub>
                                                                <mml:mi>n</mml:mi>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:msub>
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>2</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mtable>
                                                            <mml:mtr>
                                                                <mml:mtd>
                                                                    <mml:mi>x</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mrow>
                                                                            <mml:msub>
                                                                                <mml:mi>n</mml:mi>
                                                                                <mml:mn>1</mml:mn>
                                                                            </mml:msub>
                                                                            <mml:mo>&#x2212;</mml:mo>
                                                                            <mml:mn>1</mml:mn>
                                                                        </mml:mrow>
                                                                        <mml:msub>
                                                                            <mml:mi>n</mml:mi>
                                                                            <mml:mn>2</mml:mn>
                                                                        </mml:msub>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                                <mml:mtd>
                                                                    <mml:mspace width="0.25em"/>
                                                                    <mml:mi>x</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mrow>
                                                                            <mml:msub>
                                                                                <mml:mi>n</mml:mi>
                                                                                <mml:mn>1</mml:mn>
                                                                            </mml:msub>
                                                                            <mml:mo>&#x2212;</mml:mo>
                                                                            <mml:mn>1</mml:mn>
                                                                        </mml:mrow>
                                                                        <mml:mrow>
                                                                            <mml:msub>
                                                                                <mml:mi>n</mml:mi>
                                                                                <mml:mn>2</mml:mn>
                                                                            </mml:msub>
                                                                            <mml:mo>&#x2212;</mml:mo>
                                                                            <mml:mn>1</mml:mn>
                                                                        </mml:mrow>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                            </mml:mtr>
                                                        </mml:mtable>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mtable>
                                                            <mml:mtr>
                                                                <mml:mtd>
                                                                    <mml:mo>.</mml:mo>
                                                                </mml:mtd>
                                                                <mml:mtd>
                                                                    <mml:mo>.</mml:mo>
                                                                </mml:mtd>
                                                            </mml:mtr>
                                                        </mml:mtable>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:msub>
                                                                <mml:mi>n</mml:mi>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:msub>
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>2</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>L</mml:mi>
                                                                <mml:mo>+</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>1</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>2</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>L</mml:mi>
                                                                <mml:mo>+</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                    </mml:mtr>
                                    <mml:mtr>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mo>.</mml:mo>
                                            <mml:mo>.</mml:mo>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mo>.</mml:mo>
                                        </mml:mtd>
                                    </mml:mtr>
                                    <mml:mtr>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>1</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>L</mml:mi>
                                                                <mml:mo>+</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                            <mml:msub>
                                                                <mml:mi>n</mml:mi>
                                                                <mml:mn>2</mml:mn>
                                                            </mml:msub>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>1</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>L</mml:mi>
                                                                <mml:mo>+</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>2</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mo>.</mml:mo>
                                            <mml:mo>.</mml:mo>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mi>x</mml:mi>
                                            <mml:mfenced close=")" open="(" separators=",">
                                                <mml:mrow>
                                                    <mml:msub>
                                                        <mml:mi>n</mml:mi>
                                                        <mml:mn>1</mml:mn>
                                                    </mml:msub>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mi>L</mml:mi>
                                                    <mml:mo>+</mml:mo>
                                                    <mml:mn>1</mml:mn>
                                                </mml:mrow>
                                                <mml:mrow>
                                                    <mml:msub>
                                                        <mml:mi>n</mml:mi>
                                                        <mml:mn>2</mml:mn>
                                                    </mml:msub>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mi>L</mml:mi>
                                                    <mml:mo>+</mml:mo>
                                                    <mml:mn>1</mml:mn>
                                                </mml:mrow>
                                            </mml:mfenced>
                                        </mml:mtd>
                                    </mml:mtr>
                                </mml:mtable>
                            </mml:mfenced>
                        </mml:math>
                        <label>(Eq. 1)</label>
                    </disp-formula>
                </p>
                <p>Let us consider 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>x</mml:mi>
                            <mml:mfenced close=")" open="(" separators=",">
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>1</mml:mn>
                                </mml:msub>
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>n</mml:mi>
                                        <mml:mn>2</mml:mn>
                                    </mml:msub>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mi>m</mml:mi>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> is the 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:msup>
                                <mml:mfenced close=")" open="(">
                                    <mml:mrow>
                                        <mml:mi>m</mml:mi>
                                        <mml:mo>+</mml:mo>
                                        <mml:mn>1</mml:mn>
                                    </mml:mrow>
                                </mml:mfenced>
                                <mml:mi mathvariant="italic">th</mml:mi>
                            </mml:msup>
                        </mml:math>
                    </inline-formula> input of the 2-D FIR filter, 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>w</mml:mi>
                            <mml:mfenced close=")" open="(" separators=",">
                                <mml:mi>p</mml:mi>
                                <mml:mi>q</mml:mi>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> represents filter coefficients. The 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:msup>
                                <mml:mfenced close=")" open="(">
                                    <mml:mrow>
                                        <mml:mi>m</mml:mi>
                                        <mml:mo>+</mml:mo>
                                        <mml:mn>1</mml:mn>
                                    </mml:mrow>
                                </mml:mfenced>
                                <mml:mi mathvariant="italic">th</mml:mi>
                            </mml:msup>
                        </mml:math>
                    </inline-formula>output of the filter is expressed as
                    <sup>
                        <xref ref-type="bibr" rid="ref3">3</xref>
                    </sup>:
                    <disp-formula id="e2">
                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>Y</mml:mi>
                                <mml:mi>m</mml:mi>
                            </mml:msub>
                            <mml:mfenced close=")" open="(" separators=",">
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>1</mml:mn>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msub>
                            </mml:mfenced>
                            <mml:mo>=</mml:mo>
                            <mml:msubsup>
                                <mml:mrow>
                                    <mml:mfenced close="}" open="{">
                                        <mml:msubsup>
                                            <mml:mfenced close="}" open="{">
                                                <mml:mrow>
                                                    <mml:mi>x</mml:mi>
                                                    <mml:mfenced close=")" open="(" separators=",">
                                                        <mml:mrow>
                                                            <mml:msub>
                                                                <mml:mi>n</mml:mi>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:msub>
                                                            <mml:mo>&#x2212;</mml:mo>
                                                            <mml:mi>p</mml:mi>
                                                        </mml:mrow>
                                                        <mml:mrow>
                                                            <mml:msub>
                                                                <mml:mi>n</mml:mi>
                                                                <mml:mn>2</mml:mn>
                                                            </mml:msub>
                                                            <mml:mo>&#x2212;</mml:mo>
                                                            <mml:mi>m</mml:mi>
                                                            <mml:mo>&#x2212;</mml:mo>
                                                            <mml:mi>q</mml:mi>
                                                        </mml:mrow>
                                                    </mml:mfenced>
                                                    <mml:mo>.</mml:mo>
                                                    <mml:mi>w</mml:mi>
                                                    <mml:mfenced close=")" open="(" separators=",">
                                                        <mml:mi>p</mml:mi>
                                                        <mml:mi>q</mml:mi>
                                                    </mml:mfenced>
                                                </mml:mrow>
                                            </mml:mfenced>
                                            <mml:mrow>
                                                <mml:mi>p</mml:mi>
                                                <mml:mo>=</mml:mo>
                                                <mml:mn>0</mml:mn>
                                            </mml:mrow>
                                            <mml:mrow>
                                                <mml:mi>L</mml:mi>
                                                <mml:mo>&#x2212;</mml:mo>
                                                <mml:mn>1</mml:mn>
                                            </mml:mrow>
                                        </mml:msubsup>
                                    </mml:mfenced>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>q</mml:mi>
                                    <mml:mo>=</mml:mo>
                                    <mml:mn>0</mml:mn>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mn>1</mml:mn>
                                </mml:mrow>
                            </mml:msubsup>
                        </mml:math>
                        <label>(Eq. 2)</label>
                    </disp-formula>
                </p>
                <p>
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>w</mml:mi>
                            <mml:mfenced close=")" open="(" separators=",">
                                <mml:mi>p</mml:mi>
                                <mml:mi>q</mml:mi>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> is expressed as 
                    <xref ref-type="disp-formula" rid="e3">equation (3)</xref>.
                    <sup>
                        <xref ref-type="bibr" rid="ref3">3</xref>
                    </sup>
                    <disp-formula id="e3">
                        <mml:math display="block">
                            <mml:mi>w</mml:mi>
                            <mml:mfenced close=")" open="(" separators=",">
                                <mml:mi>p</mml:mi>
                                <mml:mi>q</mml:mi>
                            </mml:mfenced>
                            <mml:mo>=</mml:mo>
                            <mml:mfenced close="]" open="[">
                                <mml:mtable>
                                    <mml:mtr>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mtable>
                                                            <mml:mtr>
                                                                <mml:mtd>
                                                                    <mml:mi>w</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mn>0</mml:mn>
                                                                        <mml:mn>0</mml:mn>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                                <mml:mtd>
                                                                    <mml:mi>w</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mn>0</mml:mn>
                                                                        <mml:mn>1</mml:mn>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                            </mml:mtr>
                                                        </mml:mtable>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mtable>
                                                            <mml:mtr>
                                                                <mml:mtd>
                                                                    <mml:mi>w</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mn>1</mml:mn>
                                                                        <mml:mn>0</mml:mn>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                                <mml:mtd>
                                                                    <mml:mspace width="0.25em"/>
                                                                    <mml:mi>w</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mn>1</mml:mn>
                                                                        <mml:mn>1</mml:mn>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                            </mml:mtr>
                                                        </mml:mtable>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mtable>
                                                            <mml:mtr>
                                                                <mml:mtd>
                                                                    <mml:mo>.</mml:mo>
                                                                </mml:mtd>
                                                                <mml:mtd>
                                                                    <mml:mo>.</mml:mo>
                                                                </mml:mtd>
                                                            </mml:mtr>
                                                        </mml:mtable>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>w</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mn>0</mml:mn>
                                                            <mml:mrow>
                                                                <mml:mi>L</mml:mi>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>w</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mn>1</mml:mn>
                                                            <mml:mrow>
                                                                <mml:mi>L</mml:mi>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                    </mml:mtr>
                                    <mml:mtr>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mo>.</mml:mo>
                                            <mml:mo>.</mml:mo>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mo>.</mml:mo>
                                        </mml:mtd>
                                    </mml:mtr>
                                    <mml:mtr>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>w</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mrow>
                                                                <mml:mi>L</mml:mi>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                            <mml:mn>0</mml:mn>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                    <mml:mtd>
                                                        <mml:mi>w</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mrow>
                                                                <mml:mi>L</mml:mi>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                            <mml:mn>1</mml:mn>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mo>.</mml:mo>
                                            <mml:mo>.</mml:mo>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mi>w</mml:mi>
                                            <mml:mfenced close=")" open="(" separators=",">
                                                <mml:mrow>
                                                    <mml:mi>L</mml:mi>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mn>1</mml:mn>
                                                </mml:mrow>
                                                <mml:mrow>
                                                    <mml:mi>L</mml:mi>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mn>1</mml:mn>
                                                </mml:mrow>
                                            </mml:mfenced>
                                        </mml:mtd>
                                    </mml:mtr>
                                </mml:mtable>
                            </mml:mfenced>
                        </mml:math>
                        <label>(Eq. 3)</label>
                    </disp-formula>
                </p>
                <p>Thus, the 2-D FIR filter block output at each systolic stage is expressed as
                    <sup>
                        <xref ref-type="bibr" rid="ref11">11</xref>
                    </sup>:
                    <disp-formula id="e4">
                        <mml:math display="block">
                            <mml:mi>Y</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:msubsup>
                                <mml:mfenced close="}" open="{">
                                    <mml:mrow>
                                        <mml:mi>G</mml:mi>
                                        <mml:mfenced close=")" open="(" separators=",">
                                            <mml:msub>
                                                <mml:mi>n</mml:mi>
                                                <mml:mn>1</mml:mn>
                                            </mml:msub>
                                            <mml:msub>
                                                <mml:mi>n</mml:mi>
                                                <mml:mn>2</mml:mn>
                                            </mml:msub>
                                        </mml:mfenced>
                                        <mml:mo>.</mml:mo>
                                        <mml:msubsup>
                                            <mml:mi>w</mml:mi>
                                            <mml:mi>p</mml:mi>
                                            <mml:mi>T</mml:mi>
                                        </mml:msubsup>
                                    </mml:mrow>
                                </mml:mfenced>
                                <mml:mrow>
                                    <mml:mi>p</mml:mi>
                                    <mml:mo>=</mml:mo>
                                    <mml:mn>0</mml:mn>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mn>1</mml:mn>
                                </mml:mrow>
                            </mml:msubsup>
                            <mml:mspace width="0.25em"/>
                        </mml:math>
                        <label>(Eq. 4)</label>
                    </disp-formula>
                </p>
                <p>The filter coefficient vector required at each stage is expressed as
                    <sup>
                        <xref ref-type="bibr" rid="ref11">11</xref>
                    </sup>:
                    <disp-formula id="e5">
                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>w</mml:mi>
                                <mml:mi>p</mml:mi>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mfenced close="]" open="[">
                                    <mml:mrow>
                                        <mml:mi>w</mml:mi>
                                        <mml:mfenced close=")" open="(" separators=",">
                                            <mml:mi>p</mml:mi>
                                            <mml:mn>0</mml:mn>
                                        </mml:mfenced>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi>w</mml:mi>
                                        <mml:mfenced close=")" open="(" separators=",">
                                            <mml:mi>p</mml:mi>
                                            <mml:mn>1</mml:mn>
                                        </mml:mfenced>
                                        <mml:mspace width="0.25em"/>
                                        <mml:mi>w</mml:mi>
                                        <mml:mfenced close=")" open="(" separators=",">
                                            <mml:mi>p</mml:mi>
                                            <mml:mn>2</mml:mn>
                                        </mml:mfenced>
                                        <mml:mo>&#x2026;</mml:mo>
                                        <mml:mi>w</mml:mi>
                                        <mml:mfenced close=")" open="(" separators=",">
                                            <mml:mi>p</mml:mi>
                                            <mml:mrow>
                                                <mml:mi>L</mml:mi>
                                                <mml:mo>&#x2212;</mml:mo>
                                                <mml:mn>1</mml:mn>
                                            </mml:mrow>
                                        </mml:mfenced>
                                    </mml:mrow>
                                </mml:mfenced>
                                <mml:mrow>
                                    <mml:mn>1</mml:mn>
                                    <mml:mi mathvariant="italic">XL</mml:mi>
                                </mml:mrow>
                            </mml:msub>
                        </mml:math>
                        <label>(Eq. 5)</label>
                    </disp-formula>
                </p>
                <p>Each iteration of the 2-D block FIRA needs the parallel calculation of a block of input samples and produces a block of output. At each systolic stage, a set of 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                            <mml:mo>&#x2212;</mml:mo>
                            <mml:mn>1</mml:mn>
                        </mml:math>
                    </inline-formula> delayed inputs is required to generate a block of input. The input pixels at 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:msup>
                                <mml:mfenced close=")" open="(">
                                    <mml:mrow>
                                        <mml:mi>p</mml:mi>
                                        <mml:mo>+</mml:mo>
                                        <mml:mn>1</mml:mn>
                                    </mml:mrow>
                                </mml:mfenced>
                                <mml:mi mathvariant="italic">th</mml:mi>
                            </mml:msup>
                        </mml:math>
                    </inline-formula> the stage is represented by 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>G</mml:mi>
                            <mml:mfenced close=")" open="(" separators=",">
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>1</mml:mn>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msub>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula>, which is given in matrix form as
                    <sup>
                        <xref ref-type="bibr" rid="ref11">11</xref>
                    </sup>:
                    <disp-formula id="e6">
                        <mml:math display="block">
                            <mml:mi>G</mml:mi>
                            <mml:mfenced close=")" open="(" separators=",">
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>1</mml:mn>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msub>
                            </mml:mfenced>
                            <mml:mo>=</mml:mo>
                            <mml:mfenced close="]" open="[">
                                <mml:mtable>
                                    <mml:mtr>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mtable>
                                                            <mml:mtr>
                                                                <mml:mtd>
                                                                    <mml:mi>x</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mrow>
                                                                            <mml:msub>
                                                                                <mml:mi>n</mml:mi>
                                                                                <mml:mn>1</mml:mn>
                                                                            </mml:msub>
                                                                            <mml:mo>&#x2212;</mml:mo>
                                                                            <mml:mi>p</mml:mi>
                                                                        </mml:mrow>
                                                                        <mml:msub>
                                                                            <mml:mi>n</mml:mi>
                                                                            <mml:mn>2</mml:mn>
                                                                        </mml:msub>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                                <mml:mtd>
                                                                    <mml:mspace width="0.25em"/>
                                                                    <mml:mi>x</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mrow>
                                                                            <mml:msub>
                                                                                <mml:mi>n</mml:mi>
                                                                                <mml:mn>1</mml:mn>
                                                                            </mml:msub>
                                                                            <mml:mo>&#x2212;</mml:mo>
                                                                            <mml:mi>p</mml:mi>
                                                                        </mml:mrow>
                                                                        <mml:mrow>
                                                                            <mml:msub>
                                                                                <mml:mi>n</mml:mi>
                                                                                <mml:mn>2</mml:mn>
                                                                            </mml:msub>
                                                                            <mml:mo>&#x2212;</mml:mo>
                                                                            <mml:mn>1</mml:mn>
                                                                        </mml:mrow>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                            </mml:mtr>
                                                        </mml:mtable>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mtable>
                                                            <mml:mtr>
                                                                <mml:mtd>
                                                                    <mml:mi>x</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mrow>
                                                                            <mml:msub>
                                                                                <mml:mi>n</mml:mi>
                                                                                <mml:mn>1</mml:mn>
                                                                            </mml:msub>
                                                                            <mml:mo>&#x2212;</mml:mo>
                                                                            <mml:mi>p</mml:mi>
                                                                        </mml:mrow>
                                                                        <mml:mrow>
                                                                            <mml:msub>
                                                                                <mml:mi>n</mml:mi>
                                                                                <mml:mn>2</mml:mn>
                                                                            </mml:msub>
                                                                            <mml:mo>&#x2212;</mml:mo>
                                                                            <mml:mn>1</mml:mn>
                                                                        </mml:mrow>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                                <mml:mtd>
                                                                    <mml:mspace width="0.25em"/>
                                                                    <mml:mi>x</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mrow>
                                                                            <mml:msub>
                                                                                <mml:mi>n</mml:mi>
                                                                                <mml:mn>1</mml:mn>
                                                                            </mml:msub>
                                                                            <mml:mo>&#x2212;</mml:mo>
                                                                            <mml:mi>p</mml:mi>
                                                                        </mml:mrow>
                                                                        <mml:mrow>
                                                                            <mml:msub>
                                                                                <mml:mi>n</mml:mi>
                                                                                <mml:mn>2</mml:mn>
                                                                            </mml:msub>
                                                                            <mml:mo>&#x2212;</mml:mo>
                                                                            <mml:mn>2</mml:mn>
                                                                        </mml:mrow>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                            </mml:mtr>
                                                        </mml:mtable>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mtable>
                                                            <mml:mtr>
                                                                <mml:mtd>
                                                                    <mml:mo>.</mml:mo>
                                                                </mml:mtd>
                                                                <mml:mtd>
                                                                    <mml:mo>.</mml:mo>
                                                                </mml:mtd>
                                                            </mml:mtr>
                                                        </mml:mtable>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>1</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>p</mml:mi>
                                                            </mml:mrow>
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>2</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>L</mml:mi>
                                                                <mml:mo>+</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>1</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>p</mml:mi>
                                                            </mml:mrow>
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>2</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>L</mml:mi>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                    </mml:mtr>
                                    <mml:mtr>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mo>.</mml:mo>
                                            <mml:mo>.</mml:mo>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mo>.</mml:mo>
                                        </mml:mtd>
                                    </mml:mtr>
                                    <mml:mtr>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>1</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>p</mml:mi>
                                                            </mml:mrow>
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>2</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>N</mml:mi>
                                                                <mml:mo>+</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>1</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>p</mml:mi>
                                                            </mml:mrow>
                                                            <mml:mrow>
                                                                <mml:msub>
                                                                    <mml:mi>n</mml:mi>
                                                                    <mml:mn>2</mml:mn>
                                                                </mml:msub>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>N</mml:mi>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mo>.</mml:mo>
                                            <mml:mo>.</mml:mo>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mi>x</mml:mi>
                                            <mml:mfenced close=")" open="(" separators=",">
                                                <mml:mrow>
                                                    <mml:msub>
                                                        <mml:mi>n</mml:mi>
                                                        <mml:mn>1</mml:mn>
                                                    </mml:msub>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mi>p</mml:mi>
                                                </mml:mrow>
                                                <mml:mrow>
                                                    <mml:msub>
                                                        <mml:mi>n</mml:mi>
                                                        <mml:mn>2</mml:mn>
                                                    </mml:msub>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mi>N</mml:mi>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mi>L</mml:mi>
                                                    <mml:mo>+</mml:mo>
                                                    <mml:mn>2</mml:mn>
                                                </mml:mrow>
                                            </mml:mfenced>
                                        </mml:mtd>
                                    </mml:mtr>
                                </mml:mtable>
                            </mml:mfenced>
                        </mml:math>
                        <label>(Eq. 6)</label>
                    </disp-formula>
                </p>
                <p>To facilitate parallelism, we further decompose the input pixel matrix 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>G</mml:mi>
                            <mml:mfenced close=")" open="(" separators=",">
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>1</mml:mn>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msub>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> and coefficient vector by a factor of s. The input pixel matrix 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>G</mml:mi>
                            <mml:mfenced close=")" open="(" separators=",">
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>1</mml:mn>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>n</mml:mi>
                                    <mml:mn>2</mml:mn>
                                </mml:msub>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> is decomposed into 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfrac>
                                <mml:mi>L</mml:mi>
                                <mml:mi>S</mml:mi>
                            </mml:mfrac>
                        </mml:math>
                    </inline-formula>sub matrices represented as 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:msubsup>
                                <mml:mi>X</mml:mi>
                                <mml:mi>p</mml:mi>
                                <mml:mi>q</mml:mi>
                            </mml:msubsup>
                        </mml:math>
                    </inline-formula> of dimension 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>G</mml:mi>
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mi>N</mml:mi>
                                    <mml:mspace width="0.25em"/>
                                    <mml:mi>X</mml:mi>
                                    <mml:mspace width="0.25em"/>
                                    <mml:mi>S</mml:mi>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula>, and also the coefficient vector 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:msubsup>
                                <mml:mi>w</mml:mi>
                                <mml:mi>p</mml:mi>
                                <mml:mi>q</mml:mi>
                            </mml:msubsup>
                        </mml:math>
                    </inline-formula>of dimension 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mn>1</mml:mn>
                                    <mml:mspace width="0.25em"/>
                                    <mml:mi>X</mml:mi>
                                    <mml:mspace width="0.25em"/>
                                    <mml:mi>S</mml:mi>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula>; 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mn>0</mml:mn>
                            <mml:mo>&#x2264;</mml:mo>
                            <mml:mi mathvariant="normal">q</mml:mi>
                            <mml:mo>&#x2264;</mml:mo>
                            <mml:mfenced close=")" open="(">
                                <mml:mfrac>
                                    <mml:mi>L</mml:mi>
                                    <mml:mi>S</mml:mi>
                                </mml:mfrac>
                            </mml:mfenced>
                            <mml:mo>&#x2212;</mml:mo>
                            <mml:mn>1</mml:mn>
                            <mml:mo>.</mml:mo>
                        </mml:math>
                    </inline-formula> 
                    <xref ref-type="disp-formula" rid="e4">Equation (4)</xref> is modified as
                    <sup>
                        <xref ref-type="bibr" rid="ref11">11</xref>
                    </sup>
                    <disp-formula id="e7">
                        <mml:math display="block">
                            <mml:msub>
                                <mml:mfenced close="]" open="[">
                                    <mml:mi>Y</mml:mi>
                                </mml:mfenced>
                                <mml:mrow>
                                    <mml:mi mathvariant="italic">NX</mml:mi>
                                    <mml:mspace width="0.25em"/>
                                    <mml:mn>1</mml:mn>
                                </mml:mrow>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:msubsup>
                                <mml:mfenced close="}" open="{">
                                    <mml:msubsup>
                                        <mml:mfenced close="}" open="{">
                                            <mml:mrow>
                                                <mml:msubsup>
                                                    <mml:mi>X</mml:mi>
                                                    <mml:mi>p</mml:mi>
                                                    <mml:mi>q</mml:mi>
                                                </mml:msubsup>
                                                <mml:mspace width="0.25em"/>
                                                <mml:msup>
                                                    <mml:mfenced close=")" open="(">
                                                        <mml:msubsup>
                                                            <mml:mi>w</mml:mi>
                                                            <mml:mi>p</mml:mi>
                                                            <mml:mi>q</mml:mi>
                                                        </mml:msubsup>
                                                    </mml:mfenced>
                                                    <mml:mi>T</mml:mi>
                                                </mml:msup>
                                            </mml:mrow>
                                        </mml:mfenced>
                                        <mml:mrow>
                                            <mml:mi>q</mml:mi>
                                            <mml:mo>=</mml:mo>
                                            <mml:mn>0</mml:mn>
                                        </mml:mrow>
                                        <mml:mrow>
                                            <mml:mfenced close=")" open="(">
                                                <mml:mfrac>
                                                    <mml:mi>L</mml:mi>
                                                    <mml:mi>s</mml:mi>
                                                </mml:mfrac>
                                            </mml:mfenced>
                                            <mml:mo>&#x2212;</mml:mo>
                                            <mml:mn>1</mml:mn>
                                        </mml:mrow>
                                    </mml:msubsup>
                                </mml:mfenced>
                                <mml:mrow>
                                    <mml:mi>p</mml:mi>
                                    <mml:mo>=</mml:mo>
                                    <mml:mn>0</mml:mn>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mn>1</mml:mn>
                                </mml:mrow>
                            </mml:msubsup>
                        </mml:math>
                        <label>(Eq. 7)</label>
                    </disp-formula>
                </p>
                <p>Where
                    <sup>
                        <xref ref-type="bibr" rid="ref11">11</xref>
                    </sup>
                    <disp-formula id="e8">
                        <mml:math display="block">
                            <mml:msubsup>
                                <mml:mi>X</mml:mi>
                                <mml:mi>p</mml:mi>
                                <mml:mi>q</mml:mi>
                            </mml:msubsup>
                            <mml:mo>=</mml:mo>
                            <mml:mfenced close="]" open="[">
                                <mml:mtable>
                                    <mml:mtr>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mtable>
                                                            <mml:mtr>
                                                                <mml:mtd>
                                                                    <mml:mi>x</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mi>u</mml:mi>
                                                                        <mml:mi>v</mml:mi>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                                <mml:mtd>
                                                                    <mml:mspace width="0.25em"/>
                                                                    <mml:mi>x</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mi>u</mml:mi>
                                                                        <mml:mrow>
                                                                            <mml:mi>v</mml:mi>
                                                                            <mml:mo>&#x2212;</mml:mo>
                                                                            <mml:mn>1</mml:mn>
                                                                        </mml:mrow>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                            </mml:mtr>
                                                        </mml:mtable>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mtable>
                                                            <mml:mtr>
                                                                <mml:mtd>
                                                                    <mml:mi>x</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mi>u</mml:mi>
                                                                        <mml:mrow>
                                                                            <mml:mi>v</mml:mi>
                                                                            <mml:mo>&#x2212;</mml:mo>
                                                                            <mml:mn>1</mml:mn>
                                                                        </mml:mrow>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                                <mml:mtd>
                                                                    <mml:mi>x</mml:mi>
                                                                    <mml:mfenced close=")" open="(" separators=",">
                                                                        <mml:mi>u</mml:mi>
                                                                        <mml:mrow>
                                                                            <mml:mi>v</mml:mi>
                                                                            <mml:mo>&#x2212;</mml:mo>
                                                                            <mml:mn>2</mml:mn>
                                                                        </mml:mrow>
                                                                    </mml:mfenced>
                                                                </mml:mtd>
                                                            </mml:mtr>
                                                        </mml:mtable>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mtable>
                                                            <mml:mtr>
                                                                <mml:mtd>
                                                                    <mml:mo>.</mml:mo>
                                                                </mml:mtd>
                                                                <mml:mtd>
                                                                    <mml:mo>.</mml:mo>
                                                                </mml:mtd>
                                                            </mml:mtr>
                                                        </mml:mtable>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mi>u</mml:mi>
                                                            <mml:mrow>
                                                                <mml:mi>v</mml:mi>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mn>2</mml:mn>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mi>u</mml:mi>
                                                            <mml:mrow>
                                                                <mml:mi>v</mml:mi>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mn>3</mml:mn>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mi>u</mml:mi>
                                                            <mml:mrow>
                                                                <mml:mi>v</mml:mi>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mn>3</mml:mn>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mi>u</mml:mi>
                                                            <mml:mrow>
                                                                <mml:mi>v</mml:mi>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mn>4</mml:mn>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                    </mml:mtr>
                                    <mml:mtr>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                    <mml:mtd>
                                                        <mml:mo>.</mml:mo>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mo>.</mml:mo>
                                            <mml:mo>.</mml:mo>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mo>.</mml:mo>
                                        </mml:mtd>
                                    </mml:mtr>
                                    <mml:mtr>
                                        <mml:mtd>
                                            <mml:mtable>
                                                <mml:mtr>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mi>u</mml:mi>
                                                            <mml:mrow>
                                                                <mml:mi>v</mml:mi>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>N</mml:mi>
                                                                <mml:mo>+</mml:mo>
                                                                <mml:mn>1</mml:mn>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                        <mml:mo stretchy="true">)</mml:mo>
                                                    </mml:mtd>
                                                    <mml:mtd>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mfenced close=")" open="(" separators=",">
                                                            <mml:mi>u</mml:mi>
                                                            <mml:mrow>
                                                                <mml:mi>v</mml:mi>
                                                                <mml:mo>&#x2212;</mml:mo>
                                                                <mml:mi>N</mml:mi>
                                                            </mml:mrow>
                                                        </mml:mfenced>
                                                    </mml:mtd>
                                                </mml:mtr>
                                            </mml:mtable>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mi>x</mml:mi>
                                            <mml:mfenced close=")" open="(" separators=",">
                                                <mml:mi>u</mml:mi>
                                                <mml:mrow>
                                                    <mml:mi>v</mml:mi>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mi>N</mml:mi>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mn>1</mml:mn>
                                                </mml:mrow>
                                            </mml:mfenced>
                                        </mml:mtd>
                                        <mml:mtd>
                                            <mml:mi>x</mml:mi>
                                            <mml:mfenced close=")" open="(" separators=",">
                                                <mml:mi>u</mml:mi>
                                                <mml:mrow>
                                                    <mml:mi>v</mml:mi>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mi>N</mml:mi>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mn>2</mml:mn>
                                                </mml:mrow>
                                            </mml:mfenced>
                                        </mml:mtd>
                                    </mml:mtr>
                                </mml:mtable>
                            </mml:mfenced>
                        </mml:math>
                        <label>(Eq. 8)</label>
                    </disp-formula>
                </p>
                <p>
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:msubsup>
                                <mml:mi>w</mml:mi>
                                <mml:mi>p</mml:mi>
                                <mml:mi>q</mml:mi>
                            </mml:msubsup>
                            <mml:mo>=</mml:mo>
                            <mml:mfenced close="]" open="[">
                                <mml:mrow>
                                    <mml:mi>w</mml:mi>
                                    <mml:mfenced close=")" open="(" separators=",">
                                        <mml:mi>p</mml:mi>
                                        <mml:mi mathvariant="italic">sq</mml:mi>
                                    </mml:mfenced>
                                    <mml:mspace width="0.25em"/>
                                    <mml:mi>w</mml:mi>
                                    <mml:mfenced close=")" open="(" separators=",">
                                        <mml:mi>p</mml:mi>
                                        <mml:mrow>
                                            <mml:mi mathvariant="italic">sq</mml:mi>
                                            <mml:mo>+</mml:mo>
                                            <mml:mn>1</mml:mn>
                                        </mml:mrow>
                                    </mml:mfenced>
                                    <mml:mo>&#x2026;</mml:mo>
                                    <mml:mi>w</mml:mi>
                                    <mml:mfenced close=")" open="(" separators=",">
                                        <mml:mi>p</mml:mi>
                                        <mml:mrow>
                                            <mml:mi mathvariant="italic">sq</mml:mi>
                                            <mml:mo>+</mml:mo>
                                            <mml:mi>q</mml:mi>
                                            <mml:mo>&#x2212;</mml:mo>
                                            <mml:mn>1</mml:mn>
                                        </mml:mrow>
                                    </mml:mfenced>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula>, 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>u</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>n</mml:mi>
                                        <mml:mn>1</mml:mn>
                                    </mml:msub>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mi>p</mml:mi>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> and 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>v</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:mo stretchy="true">(</mml:mo>
                            <mml:msub>
                                <mml:mi>n</mml:mi>
                                <mml:mn>2</mml:mn>
                            </mml:msub>
                            <mml:mo>&#x2212;</mml:mo>
                            <mml:mi mathvariant="italic">sq</mml:mi>
                        </mml:math>
                    </inline-formula>). 
                    <xref ref-type="disp-formula" rid="e7">Equation (7)</xref> is re-writtenas
                    <disp-formula id="e9">
                        <mml:math display="block">
                            <mml:mspace width="0.25em"/>
                            <mml:msub>
                                <mml:mfenced close="]" open="[">
                                    <mml:mi>Y</mml:mi>
                                </mml:mfenced>
                                <mml:mrow>
                                    <mml:mi mathvariant="italic">NX</mml:mi>
                                    <mml:mspace width="0.25em"/>
                                    <mml:mn>1</mml:mn>
                                </mml:mrow>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:msubsup>
                                <mml:mfenced close="}" open="{">
                                    <mml:msubsup>
                                        <mml:mi>y</mml:mi>
                                        <mml:mi>p</mml:mi>
                                        <mml:mi>q</mml:mi>
                                    </mml:msubsup>
                                </mml:mfenced>
                                <mml:mrow>
                                    <mml:mi>q</mml:mi>
                                    <mml:mo>=</mml:mo>
                                    <mml:mn>0</mml:mn>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mfenced close=")" open="(">
                                        <mml:mfrac>
                                            <mml:mi>L</mml:mi>
                                            <mml:mi>S</mml:mi>
                                        </mml:mfrac>
                                    </mml:mfenced>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mn>1</mml:mn>
                                </mml:mrow>
                            </mml:msubsup>
                        </mml:math>
                        <label>(Eq. 9)</label>
                    </disp-formula>
                </p>
                <p>Where
                    <disp-formula id="e10">
                        <mml:math display="block">
                            <mml:msubsup>
                                <mml:mi>y</mml:mi>
                                <mml:mi>p</mml:mi>
                                <mml:mi>q</mml:mi>
                            </mml:msubsup>
                            <mml:mo>=</mml:mo>
                            <mml:msubsup>
                                <mml:mfenced close="}" open="{">
                                    <mml:mrow>
                                        <mml:msubsup>
                                            <mml:mi>X</mml:mi>
                                            <mml:mi>p</mml:mi>
                                            <mml:mi>q</mml:mi>
                                        </mml:msubsup>
                                        <mml:mspace width="0.25em"/>
                                        <mml:msup>
                                            <mml:mfenced close=")" open="(">
                                                <mml:msubsup>
                                                    <mml:mi>w</mml:mi>
                                                    <mml:mi>p</mml:mi>
                                                    <mml:mi>q</mml:mi>
                                                </mml:msubsup>
                                            </mml:mfenced>
                                            <mml:mi>T</mml:mi>
                                        </mml:msup>
                                    </mml:mrow>
                                </mml:mfenced>
                                <mml:mrow>
                                    <mml:mi>p</mml:mi>
                                    <mml:mo>=</mml:mo>
                                    <mml:mn>0</mml:mn>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mn>1</mml:mn>
                                </mml:mrow>
                            </mml:msubsup>
                        </mml:math>
                        <label>(Eq. 10)</label>
                    </disp-formula>
                </p>
            </sec>
            <sec id="sec4">
                <title>Symmetry concepts of 2-D FIR filter structure</title>
                <p>The symmetry concept is considered for the reduction of complex multipliers. In this paper, two types of symmetry, Diagonal Symmetry Filter (DSF) and Quadrantal Symmetry Filter (QSF)
                    <sup>
                        <xref ref-type="bibr" rid="ref7">7</xref>
                    </sup>
                    <sup>,</sup>
                    <sup>
                        <xref ref-type="bibr" rid="ref8">8</xref>
                    </sup> for 2-D FIRAs, are studied and explored. The following transfer functions are used to design the two types of symmetries in the 2-D FIRA.
                    <sup>
                        <xref ref-type="bibr" rid="ref7">7</xref>
                    </sup>
                    <sup>,</sup>
                    <sup>
                        <xref ref-type="bibr" rid="ref8">8</xref>
                    </sup>
                    <list list-type="alpha-upper">
                        <list-item>
                            <label>A)</label>
                            <p>DSF 2-D FIR Filter: The transfer functions of DSF in magnitude response as 
                                <inline-formula>
                                    <mml:math display="inline">
                                        <mml:mfenced close="|" open="|">
                                            <mml:mrow>
                                                <mml:mi mathvariant="normal">H</mml:mi>
                                                <mml:mfenced close=")" open="(" separators=",">
                                                    <mml:msub>
                                                        <mml:mi mathvariant="normal">z</mml:mi>
                                                        <mml:mn>1</mml:mn>
                                                    </mml:msub>
                                                    <mml:msub>
                                                        <mml:mi mathvariant="normal">z</mml:mi>
                                                        <mml:mn>2</mml:mn>
                                                    </mml:msub>
                                                </mml:mfenced>
                                            </mml:mrow>
                                        </mml:mfenced>
                                        <mml:mo>=</mml:mo>
                                        <mml:mfenced close="|" open="|">
                                            <mml:mrow>
                                                <mml:mi mathvariant="normal">H</mml:mi>
                                                <mml:mfenced close=")" open="(" separators=",">
                                                    <mml:msub>
                                                        <mml:mi mathvariant="normal">z</mml:mi>
                                                        <mml:mn>2</mml:mn>
                                                    </mml:msub>
                                                    <mml:msub>
                                                        <mml:mi mathvariant="normal">z</mml:mi>
                                                        <mml:mn>1</mml:mn>
                                                    </mml:msub>
                                                </mml:mfenced>
                                            </mml:mrow>
                                        </mml:mfenced>
                                        <mml:mo>,</mml:mo>
                                    </mml:math>
                                </inline-formula> where 
                                <inline-formula>
                                    <mml:math display="inline">
                                        <mml:msub>
                                            <mml:mi mathvariant="normal">z</mml:mi>
                                            <mml:mn>1</mml:mn>
                                        </mml:msub>
                                        <mml:mo>=</mml:mo>
                                        <mml:msup>
                                            <mml:mi mathvariant="normal">e</mml:mi>
                                            <mml:mrow>
                                                <mml:mi mathvariant="normal">j</mml:mi>
                                                <mml:msub>
                                                    <mml:mi mathvariant="normal">&#x03b8;</mml:mi>
                                                    <mml:mn>1</mml:mn>
                                                </mml:msub>
                                            </mml:mrow>
                                        </mml:msup>
                                    </mml:math>
                                </inline-formula>and 
                                <inline-formula>
                                    <mml:math display="inline">
                                        <mml:msub>
                                            <mml:mi mathvariant="normal">z</mml:mi>
                                            <mml:mn>2</mml:mn>
                                        </mml:msub>
                                        <mml:mo>=</mml:mo>
                                        <mml:msup>
                                            <mml:mi mathvariant="normal">e</mml:mi>
                                            <mml:mrow>
                                                <mml:mi mathvariant="normal">j</mml:mi>
                                                <mml:msub>
                                                    <mml:mi mathvariant="normal">&#x03b8;</mml:mi>
                                                    <mml:mn>2</mml:mn>
                                                </mml:msub>
                                            </mml:mrow>
                                        </mml:msup>
                                    </mml:math>
                                </inline-formula>, 
                                <inline-formula>
                                    <mml:math display="inline">
                                        <mml:mo>&#x2200;</mml:mo>
                                        <mml:mfenced close=")" open="(">
                                            <mml:mrow>
                                                <mml:msub>
                                                    <mml:mi mathvariant="normal">&#x03b8;</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mn>1</mml:mn>
                                                        <mml:mo>,</mml:mo>
                                                    </mml:mrow>
                                                </mml:msub>
                                                <mml:msub>
                                                    <mml:mi mathvariant="normal">&#x03b8;</mml:mi>
                                                    <mml:mn>2</mml:mn>
                                                </mml:msub>
                                            </mml:mrow>
                                        </mml:mfenced>
                                    </mml:math>
                                </inline-formula>. The filter coefficients are related as
                                <inline-formula>
                                    <mml:math display="inline">
                                        <mml:msub>
                                            <mml:mi>h</mml:mi>
                                            <mml:mi mathvariant="italic">ij</mml:mi>
                                        </mml:msub>
                                        <mml:mo>=</mml:mo>
                                        <mml:msub>
                                            <mml:mi>h</mml:mi>
                                            <mml:mi mathvariant="italic">ji</mml:mi>
                                        </mml:msub>
                                    </mml:math>
                                </inline-formula> for all 
                                <inline-formula>
                                    <mml:math display="inline">
                                        <mml:mi>i</mml:mi>
                                        <mml:mo>,</mml:mo>
                                        <mml:mi>j</mml:mi>
                                        <mml:mo>.</mml:mo>
                                    </mml:math>
                                </inline-formula> 
                                <xref ref-type="disp-formula" rid="e11">Equation (11)</xref> expresses the transfer function of diagonal symmetry.
                                <sup>
                                    <xref ref-type="bibr" rid="ref17">17</xref>
                                </sup>
                            </p>
                        </list-item>
                    </list>
                    <disp-formula id="e11">
                        <mml:math display="block">
                            <mml:mfrac>
                                <mml:mrow>
                                    <mml:mspace width="0.25em"/>
                                    <mml:mi>Y</mml:mi>
                                </mml:mrow>
                                <mml:mi>X</mml:mi>
                            </mml:mfrac>
                            <mml:mo>=</mml:mo>
                            <mml:munderover>
                                <mml:mo>&#x2211;</mml:mo>
                                <mml:mrow>
                                    <mml:mi>i</mml:mi>
                                    <mml:mo>=</mml:mo>
                                    <mml:mn>0</mml:mn>
                                </mml:mrow>
                                <mml:mi>L</mml:mi>
                            </mml:munderover>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mi mathvariant="italic">ii</mml:mi>
                            </mml:msub>
                            <mml:msubsup>
                                <mml:mi>z</mml:mi>
                                <mml:mn>1</mml:mn>
                                <mml:mrow>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mi>i</mml:mi>
                                </mml:mrow>
                            </mml:msubsup>
                            <mml:msubsup>
                                <mml:mi>z</mml:mi>
                                <mml:mn>2</mml:mn>
                                <mml:mrow>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mi>i</mml:mi>
                                </mml:mrow>
                            </mml:msubsup>
                            <mml:mo>+</mml:mo>
                            <mml:munderover>
                                <mml:mo>&#x2211;</mml:mo>
                                <mml:mrow>
                                    <mml:mi>i</mml:mi>
                                    <mml:mo>=</mml:mo>
                                    <mml:mn>0</mml:mn>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mn>1</mml:mn>
                                </mml:mrow>
                            </mml:munderover>
                            <mml:munderover>
                                <mml:mo>&#x2211;</mml:mo>
                                <mml:mrow>
                                    <mml:mi>j</mml:mi>
                                    <mml:mo>=</mml:mo>
                                    <mml:mi>i</mml:mi>
                                    <mml:mo>+</mml:mo>
                                    <mml:mn>1</mml:mn>
                                </mml:mrow>
                                <mml:mi>L</mml:mi>
                            </mml:munderover>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mi mathvariant="italic">ij</mml:mi>
                            </mml:msub>
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:msubsup>
                                        <mml:mi>z</mml:mi>
                                        <mml:mn>1</mml:mn>
                                        <mml:mrow>
                                            <mml:mo>&#x2212;</mml:mo>
                                            <mml:mi>i</mml:mi>
                                        </mml:mrow>
                                    </mml:msubsup>
                                    <mml:msubsup>
                                        <mml:mi>z</mml:mi>
                                        <mml:mn>2</mml:mn>
                                        <mml:mrow>
                                            <mml:mo>&#x2212;</mml:mo>
                                            <mml:mi>j</mml:mi>
                                        </mml:mrow>
                                    </mml:msubsup>
                                    <mml:mo>+</mml:mo>
                                    <mml:msubsup>
                                        <mml:mi>z</mml:mi>
                                        <mml:mn>1</mml:mn>
                                        <mml:mrow>
                                            <mml:mo>&#x2212;</mml:mo>
                                            <mml:mi>j</mml:mi>
                                        </mml:mrow>
                                    </mml:msubsup>
                                    <mml:msubsup>
                                        <mml:mi>z</mml:mi>
                                        <mml:mn>2</mml:mn>
                                        <mml:mrow>
                                            <mml:mo>&#x2212;</mml:mo>
                                            <mml:mi>i</mml:mi>
                                        </mml:mrow>
                                    </mml:msubsup>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                        <label>(Eq. 11)</label>
                    </disp-formula>
                    <list list-type="alpha-upper">
                        <list-item>
                            <label>B)</label>
                            <p>QSF 2-D FIR Filter: The QSF&#x2019;s magnitude response is
                                <inline-formula>
                                    <mml:math display="inline">
                                        <mml:mfenced close="|" open="|">
                                            <mml:mrow>
                                                <mml:mi>H</mml:mi>
                                                <mml:mfenced close=")" open="(" separators=",">
                                                    <mml:msub>
                                                        <mml:mi>z</mml:mi>
                                                        <mml:mn>1</mml:mn>
                                                    </mml:msub>
                                                    <mml:msub>
                                                        <mml:mi>z</mml:mi>
                                                        <mml:mn>2</mml:mn>
                                                    </mml:msub>
                                                </mml:mfenced>
                                            </mml:mrow>
                                        </mml:mfenced>
                                        <mml:mo>=</mml:mo>
                                        <mml:mfenced close="|" open="|">
                                            <mml:mrow>
                                                <mml:mi>H</mml:mi>
                                                <mml:mfenced close=")" open="(" separators=",">
                                                    <mml:msubsup>
                                                        <mml:mi>z</mml:mi>
                                                        <mml:mn>1</mml:mn>
                                                        <mml:mrow>
                                                            <mml:mo>&#x2212;</mml:mo>
                                                            <mml:mn>1</mml:mn>
                                                        </mml:mrow>
                                                    </mml:msubsup>
                                                    <mml:msub>
                                                        <mml:mi>z</mml:mi>
                                                        <mml:mn>2</mml:mn>
                                                    </mml:msub>
                                                </mml:mfenced>
                                            </mml:mrow>
                                        </mml:mfenced>
                                    </mml:math>
                                </inline-formula>, where 
                                <inline-formula>
                                    <mml:math display="inline">
                                        <mml:msub>
                                            <mml:mi>z</mml:mi>
                                            <mml:mn>1</mml:mn>
                                        </mml:msub>
                                        <mml:mo>=</mml:mo>
                                        <mml:msup>
                                            <mml:mi>e</mml:mi>
                                            <mml:mrow>
                                                <mml:mi>j</mml:mi>
                                                <mml:msub>
                                                    <mml:mi>&#x03b8;</mml:mi>
                                                    <mml:mn>1</mml:mn>
                                                </mml:msub>
                                            </mml:mrow>
                                        </mml:msup>
                                    </mml:math>
                                </inline-formula>and 
                                <inline-formula>
                                    <mml:math display="inline">
                                        <mml:msub>
                                            <mml:mi>z</mml:mi>
                                            <mml:mn>2</mml:mn>
                                        </mml:msub>
                                        <mml:mo>=</mml:mo>
                                        <mml:msup>
                                            <mml:mi>e</mml:mi>
                                            <mml:mrow>
                                                <mml:mi>j</mml:mi>
                                                <mml:msub>
                                                    <mml:mi>&#x03b8;</mml:mi>
                                                    <mml:mn>2</mml:mn>
                                                </mml:msub>
                                            </mml:mrow>
                                        </mml:msup>
                                    </mml:math>
                                </inline-formula>, 
                                <inline-formula>
                                    <mml:math display="inline">
                                        <mml:mo>&#x2200;</mml:mo>
                                        <mml:mfenced close=")" open="(">
                                            <mml:mrow>
                                                <mml:msub>
                                                    <mml:mi>&#x03b8;</mml:mi>
                                                    <mml:mrow>
                                                        <mml:mn>1</mml:mn>
                                                        <mml:mo>,</mml:mo>
                                                    </mml:mrow>
                                                </mml:msub>
                                                <mml:msub>
                                                    <mml:mi>&#x03b8;</mml:mi>
                                                    <mml:mn>2</mml:mn>
                                                </mml:msub>
                                            </mml:mrow>
                                        </mml:mfenced>
                                    </mml:math>
                                </inline-formula>. The filter coefficient symmetry is given by 
                                <inline-formula>
                                    <mml:math display="inline">
                                        <mml:msub>
                                            <mml:mi>h</mml:mi>
                                            <mml:mi mathvariant="italic">ij</mml:mi>
                                        </mml:msub>
                                        <mml:mo>=</mml:mo>
                                        <mml:msub>
                                            <mml:mi>h</mml:mi>
                                            <mml:mrow>
                                                <mml:mfenced close=")" open="(">
                                                    <mml:mrow>
                                                        <mml:mi>L</mml:mi>
                                                        <mml:mo>&#x2212;</mml:mo>
                                                        <mml:mi>i</mml:mi>
                                                    </mml:mrow>
                                                </mml:mfenced>
                                                <mml:mi>j</mml:mi>
                                            </mml:mrow>
                                        </mml:msub>
                                    </mml:math>
                                </inline-formula> for all 
                                <inline-formula>
                                    <mml:math display="inline">
                                        <mml:mi>i</mml:mi>
                                        <mml:mo>,</mml:mo>
                                        <mml:mi>j</mml:mi>
                                        <mml:mo>.</mml:mo>
                                    </mml:math>
                                </inline-formula> 
                                <xref ref-type="disp-formula" rid="e12">Equation (12)</xref> expresses the transfer function of the filter.
                                <sup>
                                    <xref ref-type="bibr" rid="ref17">17</xref>
                                </sup>
                            </p>
                        </list-item>
                    </list>
                    <disp-formula id="e12">
                        <mml:math display="block">
                            <mml:mi>Y</mml:mi>
                            <mml:mo>/</mml:mo>
                            <mml:mi>X</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:munderover>
                                <mml:mo>&#x2211;</mml:mo>
                                <mml:mrow>
                                    <mml:mi>j</mml:mi>
                                    <mml:mo>=</mml:mo>
                                    <mml:mn>0</mml:mn>
                                </mml:mrow>
                                <mml:mi>L</mml:mi>
                            </mml:munderover>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mi mathvariant="italic">uj</mml:mi>
                            </mml:msub>
                            <mml:msubsup>
                                <mml:mi>z</mml:mi>
                                <mml:mn>1</mml:mn>
                                <mml:mrow>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mi>u</mml:mi>
                                </mml:mrow>
                            </mml:msubsup>
                            <mml:msubsup>
                                <mml:mi>z</mml:mi>
                                <mml:mn>2</mml:mn>
                                <mml:mrow>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mi>j</mml:mi>
                                </mml:mrow>
                            </mml:msubsup>
                            <mml:mo>+</mml:mo>
                            <mml:munderover>
                                <mml:mo>&#x2211;</mml:mo>
                                <mml:mrow>
                                    <mml:mi>i</mml:mi>
                                    <mml:mo>=</mml:mo>
                                    <mml:mn>0</mml:mn>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mn>1</mml:mn>
                                </mml:mrow>
                            </mml:munderover>
                            <mml:munderover>
                                <mml:mo>&#x2211;</mml:mo>
                                <mml:mrow>
                                    <mml:mi>j</mml:mi>
                                    <mml:mo>=</mml:mo>
                                    <mml:mn>0</mml:mn>
                                </mml:mrow>
                                <mml:mi>L</mml:mi>
                            </mml:munderover>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mi mathvariant="italic">ij</mml:mi>
                            </mml:msub>
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:msubsup>
                                        <mml:mi>z</mml:mi>
                                        <mml:mn>1</mml:mn>
                                        <mml:mrow>
                                            <mml:mo>&#x2212;</mml:mo>
                                            <mml:mi>i</mml:mi>
                                        </mml:mrow>
                                    </mml:msubsup>
                                    <mml:msubsup>
                                        <mml:mi>z</mml:mi>
                                        <mml:mn>2</mml:mn>
                                        <mml:mrow>
                                            <mml:mo>&#x2212;</mml:mo>
                                            <mml:mi>j</mml:mi>
                                        </mml:mrow>
                                    </mml:msubsup>
                                    <mml:mo>+</mml:mo>
                                    <mml:msubsup>
                                        <mml:mi>z</mml:mi>
                                        <mml:mn>1</mml:mn>
                                        <mml:mrow>
                                            <mml:mo>&#x2212;</mml:mo>
                                            <mml:mfenced close=")" open="(">
                                                <mml:mrow>
                                                    <mml:mi>L</mml:mi>
                                                    <mml:mo>&#x2212;</mml:mo>
                                                    <mml:mi>i</mml:mi>
                                                </mml:mrow>
                                            </mml:mfenced>
                                        </mml:mrow>
                                    </mml:msubsup>
                                    <mml:msubsup>
                                        <mml:mi>z</mml:mi>
                                        <mml:mn>2</mml:mn>
                                        <mml:mrow>
                                            <mml:mo>&#x2212;</mml:mo>
                                            <mml:mi>j</mml:mi>
                                        </mml:mrow>
                                    </mml:msubsup>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                        <label>(Eq. 12)</label>
                    </disp-formula>
                </p>
                <p>The general filter coefficients and two types of symmetry coefficient matrices are shown in 
                    <xref ref-type="fig" rid="f1">Figure 1</xref>.</p>
                <fig fig-type="figure" id="f1" orientation="portrait" position="float">
                    <label>Figure 1. </label>
                    <caption>
                        <title>Filter coefficient matrices of (a) General filter (b) Diagonal Symmetry Filter (c) Quadrantal Symmetry Filter.</title>
                    </caption>
                    <graphic id="gr1" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/138442/9d2c3c82-ee89-4898-a013-b5648a69aa72_figure1.gif"/>
                </fig>
                <p>The proposed work implements two efficient symmetrical 2-D FIRAs and one generic filter architecture. Because of the symmetry of the filter coefficient, fewer multipliers are needed to design the filter.</p>
            </sec>
            <sec id="sec5">
                <title>The LUT-DA multiplication process</title>
                <p>A LUT is treated as memory in memory-based multiplication, and the precomputed outputs of filter coefficients are saved in the LUT. DA multiplication is the process of shifting and accumulating LUT output values. The input sample and coefficient are multiplied in the process of memory-based multiplication. The LUT memory can save 2
                    <sup>w</sup> possible values for the binary input of word length of 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>w</mml:mi>
                        </mml:math>
                    </inline-formula> bits and a coefficient of bit length of 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>c</mml:mi>
                        </mml:math>
                    </inline-formula> bits. In the process of standard LUT-based multiplication, it requires 2
                    <sup>w</sup> words to save the precomputed partial products in LUT.</p>
                <p>Even multiples can be obtained from memory using left shift operations on odd multiples. This work uses (2
                    <sup>w</sup>/2) words to save the odd multiples of coefficient C. This approach is shown for 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>w</mml:mi>
                        </mml:math>
                    </inline-formula> = 4-bits of input sample in 
                    <xref ref-type="table" rid="T1">Table 1</xref>. In this table, the 8-address locations are stored by odd multiples of coefficient C, such as C, 3C, 5C, 7C, 9C, 11C, 13C, and 15C. Even multiples are evaluated using left shift operations of C, such as 2C, 4C, and 8C by 1-, 2-, and 3-times left shift operation to C, respectively. Next, 6C and 12C products are produced by a left shift of 3C; the remaining 10C is derived from 5C, and 14C is derived from 7C, respectively. The product output for the input sample consists of all zeros 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>x</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:mn>0000</mml:mn>
                        </mml:math>
                    </inline-formula> produced by resetting the LUT.</p>
                <table-wrap id="T1" orientation="portrait" position="float">
                    <label>Table 1. </label>
                    <caption>
                        <title>Memory-based Lookup Table &#x2013; Distributed Arithmetic (MLUT-DA) multiplication approach.
                            <sup>
                                <xref ref-type="bibr" rid="ref17">17</xref>
                            </sup>
                        </title>
                    </caption>
                    <table content-type="article-table" frame="hsides">
                        <thead>
                            <tr>
                                <th align="left" colspan="1" rowspan="1" valign="top">Address A
                                    <sub>2</sub> A
                                    <sub>1</sub> A
                                    <sub>0</sub>
                                </th>
                                <th align="left" colspan="1" rowspan="1" valign="top">Name of the Word</th>
                                <th align="left" colspan="1" rowspan="1" valign="top">Value to be stored in LUT</th>
                                <th align="left" colspan="1" rowspan="1" valign="top">Input bits (w) x
                                    <sub>3</sub> x
                                    <sub>2</sub> x
                                    <sub>1</sub> x
                                    <sub>0</sub>
                                </th>
                                <th align="left" colspan="1" rowspan="1" valign="top">Result</th>
                                <th align="left" colspan="1" rowspan="1" valign="top">Number of shifts required</th>
                                <th align="left" colspan="1" rowspan="1" valign="top">Control lines S
                                    <sub>1</sub> S
                                    <sub>0</sub>
                                </th>
                            </tr>
                        </thead>
                        <tbody>
                            <tr>
                                <td align="left" colspan="1" rowspan="4" valign="top">0 0 0</td>
                                <td align="left" colspan="1" rowspan="4" valign="top">W0</td>
                                <td align="left" colspan="1" rowspan="4" valign="top">C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 0 0 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 0</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 0 1 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">2
                                    <sup>1</sup>
                                    <inline-formula>
                                        <mml:math display="inline">
                                            <mml:mo>&#x00d7;</mml:mo>
                                        </mml:math>
                                    </inline-formula> C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 1</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 1 0 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">2
                                    <sup>2</sup>
                                    <inline-formula>
                                        <mml:math display="inline">
                                            <mml:mo>&#x00d7;</mml:mo>
                                        </mml:math>
                                    </inline-formula> C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">2</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 0</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 0 0 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">2
                                    <sup>3</sup>
                                    <inline-formula>
                                        <mml:math display="inline">
                                            <mml:mo>&#x00d7;</mml:mo>
                                        </mml:math>
                                    </inline-formula> C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">3</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 1</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="3" valign="top">0 0 1</td>
                                <td align="left" colspan="1" rowspan="3" valign="top">W1</td>
                                <td align="left" colspan="1" rowspan="3" valign="top">3C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 0 1 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">3C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 0</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 1 1 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">2
                                    <sup>1</sup>
                                    <inline-formula>
                                        <mml:math display="inline">
                                            <mml:mo>&#x00d7;</mml:mo>
                                        </mml:math>
                                    </inline-formula> 3C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 1</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 1 0 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">2
                                    <sup>2</sup> 
                                    <inline-formula>
                                        <mml:math display="inline">
                                            <mml:mo>&#x00d7;</mml:mo>
                                        </mml:math>
                                    </inline-formula> 3C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">2</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 0</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="2" valign="top">0 1 0</td>
                                <td align="left" colspan="1" rowspan="2" valign="top">W2</td>
                                <td align="left" colspan="1" rowspan="2" valign="top">5C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 1 0 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">5C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 0</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 0 1 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">2
                                    <sup>1</sup>
                                    <inline-formula>
                                        <mml:math display="inline">
                                            <mml:mo>&#x00d7;</mml:mo>
                                        </mml:math>
                                    </inline-formula> 5C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 1</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="2" valign="top">0 1 1</td>
                                <td align="left" colspan="1" rowspan="2" valign="top">W3</td>
                                <td align="left" colspan="1" rowspan="2" valign="top">7C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 1 1 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">7C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 0</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 1 1 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">2
                                    <sup>1</sup>
                                    <inline-formula>
                                        <mml:math display="inline">
                                            <mml:mo>&#x00d7;</mml:mo>
                                        </mml:math>
                                    </inline-formula> 7C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 1</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 0 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">W4</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">9C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 0 0 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">9C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 0</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 0 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">W5</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">11C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 0 1 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">11C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 0</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 1 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">W6</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">13C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 1 0 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">13C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 0</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 1 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">W7</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">15C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">1 1 1 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">15C</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">0 0</td>
                            </tr>
                        </tbody>
                    </table>
                </table-wrap>
                <p>The single-port MLUT-DA multiplier is realized with reference to 
                    <xref ref-type="table" rid="T1">Table 1</xref>, as shown in 
                    <xref ref-type="fig" rid="f2">Figure 2A</xref>. The structure has one 4-to-3 encoder block, one 3-to-8 decoder block, one control logic to produce Reset (RST), and control lines {S0, S1} to accommodate the shifts required for the computation of even multiples of coefficients such as 2C, 4C, 8C, 10C, 12C, and 14C. A maximum of three shifts are required, so two bits of control signals are contemplated in the structure.</p>
                <fig fig-type="figure" id="f2" orientation="portrait" position="float">
                    <label>Figure 2. </label>
                    <caption>
                        <title>(A) Structure of conventional Memory-based Lookup Table (MLUT) multiplier for odd multiples (B) Modified MLUT multiplier for even multiples.</title>
                        <p>Where MUX is multiplexer and RST is reset.</p>
                    </caption>
                    <graphic id="gr2" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/138442/9d2c3c82-ee89-4898-a013-b5648a69aa72_figure2.gif"/>
                </fig>
                <p>Using a control logic block, the RST is formed from the applied input sample. It results in eight odd multiples of coefficients with 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mi>c</mml:mi>
                                    <mml:mo>+</mml:mo>
                                    <mml:mn>4</mml:mn>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> bits. An extra 4 bits are essential to computing the highest odd multiple value 15C is precomputed and stored in the LUT. The decoder output corresponding location is read and fed to the NOR cell, which is made up of 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mi>c</mml:mi>
                                    <mml:mo>+</mml:mo>
                                    <mml:mn>4</mml:mn>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> NOR gates with one common input of RST. The NOR cell outputs are shifted by a barrel shifter based upon the control signals {S0, S1} coming from the control logic. The barrel shifter has 2
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mo>&#x00d7;</mml:mo>
                        </mml:math>
                    </inline-formula>(c + 4) AOI (AND_OR_INVERT) gates or 2
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mo>&#x00d7;</mml:mo>
                        </mml:math>
                    </inline-formula>1 multiplexers (MUXs). Finally, the barrel shifter output is the multiplication result of the input sample and coefficient.</p>
                <p>The combinational logic expression of the 4-to-3 encoder, employed in the LUT multiplier, is indicated in 
                    <xref ref-type="disp-formula" rid="e13">equations (13)</xref>, 
                    <xref ref-type="disp-formula" rid="e14">(14)</xref>, and 
                    <xref ref-type="disp-formula" rid="e15">(15)</xref>.
                    <disp-formula id="e13">
                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>A</mml:mi>
                                <mml:mn>0</mml:mn>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mover accent="true">
                                <mml:mrow>
                                    <mml:mover accent="true">
                                        <mml:mrow>
                                            <mml:mover accent="true">
                                                <mml:mfenced close=")" open="(">
                                                    <mml:mrow>
                                                        <mml:msub>
                                                            <mml:mi>x</mml:mi>
                                                            <mml:mn>0</mml:mn>
                                                        </mml:msub>
                                                        <mml:msub>
                                                            <mml:mi>x</mml:mi>
                                                            <mml:mn>1</mml:mn>
                                                        </mml:msub>
                                                    </mml:mrow>
                                                </mml:mfenced>
                                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                                            </mml:mover>
                                            <mml:mo>.</mml:mo>
                                            <mml:mover accent="true">
                                                <mml:mfenced close=")" open="(">
                                                    <mml:mrow>
                                                        <mml:msub>
                                                            <mml:mi>x</mml:mi>
                                                            <mml:mn>1</mml:mn>
                                                        </mml:msub>
                                                        <mml:msub>
                                                            <mml:mi>x</mml:mi>
                                                            <mml:mn>2</mml:mn>
                                                        </mml:msub>
                                                    </mml:mrow>
                                                </mml:mfenced>
                                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                                            </mml:mover>
                                        </mml:mrow>
                                        <mml:mo stretchy="true">&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo>.</mml:mo>
                                    <mml:mo stretchy="false">(</mml:mo>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mn>0</mml:mn>
                                    </mml:msub>
                                    <mml:mo>+</mml:mo>
                                    <mml:mover accent="true">
                                        <mml:mfenced close=")" open="(">
                                            <mml:mrow>
                                                <mml:msub>
                                                    <mml:mi>x</mml:mi>
                                                    <mml:mn>2</mml:mn>
                                                </mml:msub>
                                                <mml:msub>
                                                    <mml:mi>x</mml:mi>
                                                    <mml:mn>3</mml:mn>
                                                </mml:msub>
                                                <mml:mo>)</mml:mo>
                                            </mml:mrow>
                                        </mml:mfenced>
                                        <mml:mo stretchy="true">&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                            </mml:mover>
                        </mml:math>
                        <label>(Eq. 13)</label>
                    </disp-formula>
                    <disp-formula id="e14">
                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>A</mml:mi>
                                <mml:mn>1</mml:mn>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mover accent="true">
                                <mml:mrow>
                                    <mml:mover accent="true">
                                        <mml:mrow>
                                            <mml:mover accent="true">
                                                <mml:mfenced close=")" open="(">
                                                    <mml:mrow>
                                                        <mml:msub>
                                                            <mml:mi>x</mml:mi>
                                                            <mml:mn>0</mml:mn>
                                                        </mml:msub>
                                                        <mml:msub>
                                                            <mml:mi>x</mml:mi>
                                                            <mml:mn>2</mml:mn>
                                                        </mml:msub>
                                                    </mml:mrow>
                                                </mml:mfenced>
                                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                                            </mml:mover>
                                            <mml:mo>.</mml:mo>
                                        </mml:mrow>
                                        <mml:mo stretchy="true">&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo stretchy="false">(</mml:mo>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mn>0</mml:mn>
                                    </mml:msub>
                                    <mml:mo>+</mml:mo>
                                    <mml:mover accent="true">
                                        <mml:mfenced close=")" open="(">
                                            <mml:mrow>
                                                <mml:msub>
                                                    <mml:mi>x</mml:mi>
                                                    <mml:mn>1</mml:mn>
                                                </mml:msub>
                                                <mml:msub>
                                                    <mml:mi>x</mml:mi>
                                                    <mml:mn>3</mml:mn>
                                                </mml:msub>
                                                <mml:mo>)</mml:mo>
                                            </mml:mrow>
                                        </mml:mfenced>
                                        <mml:mo stretchy="true">&#x00af;</mml:mo>
                                    </mml:mover>
                                </mml:mrow>
                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                            </mml:mover>
                        </mml:math>
                        <label>(Eq. 14)</label>
                    </disp-formula>
                    <disp-formula id="e15">
                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>A</mml:mi>
                                <mml:mn>2</mml:mn>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:msub>
                                <mml:mi>x</mml:mi>
                                <mml:mn>0</mml:mn>
                            </mml:msub>
                            <mml:mo>.</mml:mo>
                            <mml:msub>
                                <mml:mi>x</mml:mi>
                                <mml:mn>3</mml:mn>
                            </mml:msub>
                        </mml:math>
                        <label>(Eq. 15)</label>
                    </disp-formula>where A
                    <sub>2</sub> A
                    <sub>1</sub> A
                    <sub>0</sub> are address bits derived from the actual input bits x
                    <sub>3</sub> x
                    <sub>2</sub> x
                    <sub>1</sub> x
                    <sub>0</sub>. The control logic signals (RST and S0, S1) are given by 
                    <xref ref-type="disp-formula" rid="e16">equations (16)</xref>, 
                    <xref ref-type="disp-formula" rid="e17">(17)</xref>, and 
                    <xref ref-type="disp-formula" rid="e18">(18)</xref>.
                    <disp-formula id="e16">
                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>S</mml:mi>
                                <mml:mn>0</mml:mn>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mover accent="true">
                                <mml:mrow>
                                    <mml:mo stretchy="false">(</mml:mo>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mn>0</mml:mn>
                                    </mml:msub>
                                    <mml:mo>+</mml:mo>
                                    <mml:mover accent="true">
                                        <mml:mfenced close=")" open="(">
                                            <mml:mrow>
                                                <mml:msub>
                                                    <mml:mi>x</mml:mi>
                                                    <mml:mn>1</mml:mn>
                                                </mml:msub>
                                                <mml:mo>+</mml:mo>
                                                <mml:mover accent="true">
                                                    <mml:msub>
                                                        <mml:mi>x</mml:mi>
                                                        <mml:mn>2</mml:mn>
                                                    </mml:msub>
                                                    <mml:mo stretchy="true">&#x00af;</mml:mo>
                                                </mml:mover>
                                            </mml:mrow>
                                        </mml:mfenced>
                                        <mml:mo stretchy="true">&#x00af;</mml:mo>
                                    </mml:mover>
                                    <mml:mo>)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                            </mml:mover>
                        </mml:math>
                        <label>(Eq. 16)</label>
                    </disp-formula>
                    <disp-formula id="e17">
                        <mml:math display="block">
                            <mml:msub>
                                <mml:mi>S</mml:mi>
                                <mml:mn>1</mml:mn>
                            </mml:msub>
                            <mml:mo>=</mml:mo>
                            <mml:mover accent="true">
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mn>0</mml:mn>
                                    </mml:msub>
                                    <mml:mo>+</mml:mo>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mn>1</mml:mn>
                                    </mml:msub>
                                    <mml:mo>)</mml:mo>
                                </mml:mrow>
                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                            </mml:mover>
                        </mml:math>
                        <label>(Eq. 17)</label>
                    </disp-formula>
                    <disp-formula id="e18">
                        <mml:math display="block">
                            <mml:mi mathvariant="italic">RST</mml:mi>
                            <mml:mo>=</mml:mo>
                            <mml:mover accent="true">
                                <mml:mrow>
                                    <mml:mo stretchy="true">(</mml:mo>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mn>0</mml:mn>
                                    </mml:msub>
                                    <mml:mo>+</mml:mo>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mn>1</mml:mn>
                                    </mml:msub>
                                </mml:mrow>
                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                            </mml:mover>
                            <mml:mo stretchy="true">)</mml:mo>
                            <mml:mo>.</mml:mo>
                            <mml:mover accent="true">
                                <mml:mfenced close=")" open="(">
                                    <mml:mrow>
                                        <mml:msub>
                                            <mml:mi>x</mml:mi>
                                            <mml:mn>2</mml:mn>
                                        </mml:msub>
                                        <mml:mo>+</mml:mo>
                                        <mml:msub>
                                            <mml:mi>x</mml:mi>
                                            <mml:mn>3</mml:mn>
                                        </mml:msub>
                                    </mml:mrow>
                                </mml:mfenced>
                                <mml:mo stretchy="true">&#x00af;</mml:mo>
                            </mml:mover>
                        </mml:math>
                        <label>(Eq. 18)</label>
                    </disp-formula>
                </p>
                <p>In very large scale integration (VLSI) design, the conventional multipliers consume more power and occupy more area, whereas the LUT-based multipliers save area and power consumption. Hence, a further reduction in the hardware is achieved by LUT-DA multipliers.</p>
                <p>In the LUT, only the even multiples of the coefficients are saved. Hence, only 2
                    <sup>w</sup>/2 words are required instead of all 2
                    <sup>w</sup> words. Even multiples can be translated into odd multiples by adding one filter coefficient magnitude. The barrel shifter and encoder blocks are not required for this modified multiplier, and one 2 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mo>&#x00d7;</mml:mo>
                        </mml:math>
                    </inline-formula> 1 MUX is required to choose the odd or even-multiple coefficients. 
                    <xref ref-type="table" rid="T2">Table 2</xref> depicts the even multiples storing technique for 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>w</mml:mi>
                        </mml:math>
                    </inline-formula> = 4. The even values of constant-coefficient 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close="}" open="{" separators=",,,,,">
                                <mml:mn>0</mml:mn>
                                <mml:mrow>
                                    <mml:mn>2</mml:mn>
                                    <mml:mi>C</mml:mi>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mn>4</mml:mn>
                                    <mml:mi>C</mml:mi>
                                </mml:mrow>
                                <mml:mo>&#x2026;</mml:mo>
                                <mml:mrow>
                                    <mml:mn>12</mml:mn>
                                    <mml:mi>C</mml:mi>
                                </mml:mrow>
                                <mml:mrow>
                                    <mml:mn>14</mml:mn>
                                    <mml:mi>C</mml:mi>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> are precomputed corresponding to 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close="}" open="{">
                                <mml:mrow>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mn>3</mml:mn>
                                    </mml:msub>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mn>2</mml:mn>
                                    </mml:msub>
                                    <mml:mspace width="0.25em"/>
                                    <mml:msub>
                                        <mml:mi>x</mml:mi>
                                        <mml:mn>1</mml:mn>
                                    </mml:msub>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> using the 3-to-8 decoder and saved in the 8-LUT locations. The other input for the 2 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mo>&#x00d7;</mml:mo>
                        </mml:math>
                    </inline-formula> 1 MUX is the LUT even output, and the other input is the odd output from the adder. The selection lines of the MUX are the least significant bit LSB-bits of the input sample 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>x</mml:mi>
                                <mml:mn>0</mml:mn>
                            </mml:msub>
                        </mml:math>
                    </inline-formula>. Whether the coefficients are even or odd multiples depends on the input sample&#x2019;s LSB bit. 
                    <xref ref-type="fig" rid="f2">Figure 2B</xref> represents the modified LUT-based multiplier.</p>
                <table-wrap id="T2" orientation="portrait" position="float">
                    <label>Table 2. </label>
                    <caption>
                        <title>The Memory-based Lookup Table (MLUT) multiplier using even multiples.</title>
                    </caption>
                    <table content-type="article-table" frame="hsides">
                        <thead>
                            <tr>
                                <th align="left" colspan="1" rowspan="1" valign="top">Name of the Word</th>
                                <th align="left" colspan="1" rowspan="1" valign="top">Address x
                                    <sub>3</sub> x
                                    <sub>2</sub> x
                                    <sub>1</sub>
                                </th>
                                <th align="left" colspan="1" rowspan="1" valign="top">Value to be stored in LUT</th>
                                <th align="left" colspan="1" rowspan="1" valign="top">input bits (w) x
                                    <sub>3</sub> x
                                    <sub>2</sub> x
                                    <sub>1</sub> x
                                    <sub>0</sub>
                                </th>
                                <th align="left" colspan="1" rowspan="1" valign="top">Result</th>
                            </tr>
                        </thead>
                        <tbody>
                            <tr>
                                <td align="left" colspan="1" rowspan="2" valign="middle">W0</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">0 0 0</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">0</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">0 0 0 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">0</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="middle">0 0 0 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">1C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="2" valign="middle">W1</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">0 0 1</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">2C</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">0 0 1 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">2C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="middle">0 0 1 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">3C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="2" valign="middle">W2</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">0 1 0</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">4C</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">0 1 0 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">4C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="middle">0 1 0 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">5C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="2" valign="middle">W3</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">0 1 1</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">6C</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">0 1 1 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">6C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="middle">0 1 1 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">7C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="2" valign="middle">W4</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">1 0 0</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">8C</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">1 0 0 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">8C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="middle">1 0 0 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">9C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="2" valign="middle">W5</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">1 0 1</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">10C</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">1 0 1 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">10C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="middle">1 0 1 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">11C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="2" valign="middle">W6</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">1 1 0</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">12C</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">1 1 0 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">12C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="middle">1 1 0 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">13C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="2" valign="middle">W7</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">1 1 1</td>
                                <td align="left" colspan="1" rowspan="2" valign="middle">14C</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">1 1 1 0</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">14C</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="middle">1 1 1 1</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">15C</td>
                            </tr>
                        </tbody>
                    </table>
                </table-wrap>
                <p>Likewise, odd multiples of the coefficient can be saved in an improved LUT-DA multiplier by using a subtractor to generate the required even multiples. In the proposed work, the SPLUT multiplier is converted into a DPLUT multiplier using the DA approach. When the input sample bits are more, the dual-port memory helps decrease the LUT size. The common filter coefficient is multiplied simultaneously with two separate input samples using a DPMLUT-based multiplier. The following section explains how the proposed filters use an improved MLUT-DA multiplier with even multiples storage.</p>
            </sec>
        </sec>
        <sec id="sec6" sec-type="methods">
            <title>Methods</title>
            <sec id="sec7">
                <title>Proposed architectures of block-based 2-D FIR filters</title>
                <p>The block-based 2-D FIRA is shown in 
                    <xref ref-type="fig" rid="f3">Figure 3</xref> for 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula> = 4, with 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> = 2 without any symmetry, and is considered a general filter. The input samples {x
                    <sub>k</sub>
                    <sup>0</sup>, x
                    <sub>k</sub>
                    <sup>1</sup>} are from the same row of the image input matrix given to the shift register unit (SRU) array, and input samples are given in serial order, block by block and row by row. The SRU array contains 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mn>1</mml:mn>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> SRUs, each with 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula> shift registers with 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>M</mml:mi>
                        </mml:math>
                    </inline-formula> words. Here, SRU1 is termed as {SR1, SR2}. Likewise, SRU2 and SRU3 are placed in an array form considered the SRU array for order 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula> = 4. Each 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula> - Delay Unit Block (DUB) produces 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi mathvariant="italic">NL</mml:mi>
                        </mml:math>
                    </inline-formula> samples by applying each set of past 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> and present samples to the total 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula> sets.</p>
                <fig fig-type="figure" id="f3" orientation="portrait" position="float">
                    <label>Figure 3. </label>
                    <caption>
                        <title>Conventional 2-D finite impulse response filter architecture (FIRA) for 
                            <inline-formula>
                                <mml:math display="inline">
                                    <mml:mi>L</mml:mi>
                                </mml:math>
                            </inline-formula> = 4 with 
                            <inline-formula>
                                <mml:math display="inline">
                                    <mml:mi>N</mml:mi>
                                </mml:math>
                            </inline-formula> = 2.</title>
                        <p>Where PU is Processing Unit, 
                            <inline-formula>
                                <mml:math display="inline">
                                    <mml:msub>
                                        <mml:mi>X</mml:mi>
                                        <mml:msup>
                                            <mml:mi>k</mml:mi>
                                            <mml:mi>m</mml:mi>
                                        </mml:msup>
                                    </mml:msub>
                                </mml:math>
                            </inline-formula> is input and 
                            <inline-formula>
                                <mml:math display="inline">
                                    <mml:msub>
                                        <mml:mi>Y</mml:mi>
                                        <mml:msup>
                                            <mml:mi>k</mml:mi>
                                            <mml:mi>m</mml:mi>
                                        </mml:msup>
                                    </mml:msub>
                                </mml:math>
                            </inline-formula> is output.</p>
                    </caption>
                    <graphic id="gr3" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/138442/9d2c3c82-ee89-4898-a013-b5648a69aa72_figure3.gif"/>
                </fig>
                <p>The input block of 
                    <italic toggle="yes">L</italic> input samples from the image matrix 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mi>M</mml:mi>
                                    <mml:mo>&#x00d7;</mml:mo>
                                    <mml:mi>M</mml:mi>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> are applied as present inputs. The 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mo stretchy="true">(</mml:mo>
                            <mml:mi>L</mml:mi>
                            <mml:mo>&#x2212;</mml:mo>
                            <mml:mn>1</mml:mn>
                        </mml:math>
                    </inline-formula>) SRU array receives these parallel inputs. 
                    <xref ref-type="fig" rid="f4">Figure 4A</xref> represents the structure of SRU using the 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula> number of registers. The present input sample and the past input sample blocks are applied to the 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula>
                    <italic toggle="yes">-</italic>DUBs of the DUB array. Each DUB consists of 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mo stretchy="true">(</mml:mo>
                            <mml:mi>L</mml:mi>
                            <mml:mo>&#x2212;</mml:mo>
                            <mml:mn>1</mml:mn>
                        </mml:math>
                    </inline-formula>) flipflops. It produces the present and past samples required for block processing. As shown in 
                    <xref ref-type="fig" rid="f4">Figure 4B</xref>, each DUB generates 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi mathvariant="italic">LN</mml:mi>
                        </mml:math>
                    </inline-formula> samples. The 
                    <italic toggle="yes">L</italic>-DUBs give the 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                            <mml:mo>&#x00d7;</mml:mo>
                            <mml:mi mathvariant="italic">LN</mml:mi>
                        </mml:math>
                    </inline-formula> of input samples to the filter&#x2019;s arithmetic module.</p>
                <fig fig-type="figure" id="f4" orientation="portrait" position="float">
                    <label>Figure 4. </label>
                    <caption>
                        <title>(A) Shift register unit (SRU) Array 2 (B) Delay Unit Block for 
                            <inline-formula>
                                <mml:math display="inline">
                                    <mml:mi>L</mml:mi>
                                </mml:math>
                            </inline-formula> = 4 with 
                            <inline-formula>
                                <mml:math display="inline">
                                    <mml:mi>N</mml:mi>
                                </mml:math>
                            </inline-formula>= 2.</title>
                    </caption>
                    <graphic id="gr4" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/138442/9d2c3c82-ee89-4898-a013-b5648a69aa72_figure4.gif"/>
                </fig>
                <p>
                    <italic toggle="yes">Structures of block-based symmetric 2-D FIR filter arithmetic modules</italic>
                </p>
                <p>This section explores two symmetry-type 2-D FIR filters and one general filter of 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula> = 4 with 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> = 2.</p>
                <p>
                    <italic toggle="yes">General filter structure with MLUT multipliers</italic>
                </p>
                <p>The arithmetic module of the general filter architecture is realized by the 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula> number of Processing Units (PU) and an Adder Tree (AT) block, which receives 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi mathvariant="italic">LN</mml:mi>
                        </mml:math>
                    </inline-formula> samples from DUB.</p>
                <p>Each PU block is constructed by 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> number of Product Cells (PC), which are used to multiply the input sample by the corresponding filter coefficients. Generally, the product is done by conventional multipliers. MLUT multipliers are used in place of these power-hungry conventional multipliers. At last, the AT adds the outputs of the PU block and generates the 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula>filter outputs corresponding to the 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> block of inputs.</p>
                <p>This general filter architecture is modified by DPMLUT multipliers, as presented in 
                    <xref ref-type="fig" rid="f5">Figure 5</xref>. In this architecture, the inputs multiplied with the common filter coefficients are given to a DPLUT-multiplier. Hence, a total of 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>&#x00d7;</mml:mo>
                                    <mml:mi>L</mml:mi>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> DPLUT multipliers are needed to process the complete multiplication of input samples of 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula>= 4 and filter coefficients. 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mn>2</mml:mn>
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>&#x00d7;</mml:mo>
                                    <mml:mi>L</mml:mi>
                                </mml:mrow>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> multipliers are needed if SPLUT-based multipliers are used. The DPLUT-based multipliers save 50% of the area compared to SPLUT multipliers. Each DPLUT-based multiplier produces the 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula> number of filter outputs. Total 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula> memory multipliers generate 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>&#x00d7;</mml:mo>
                                    <mml:mi>L</mml:mi>
                                </mml:mrow>
                            </mml:mfenced>
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> number of outputs, and these are parallelly added by 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> -AT blocks and give 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> outputs with a size of 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mo stretchy="true">(</mml:mo>
                            <mml:mi>c</mml:mi>
                            <mml:mo>+</mml:mo>
                            <mml:mn>4</mml:mn>
                        </mml:math>
                    </inline-formula>
                    <italic toggle="yes">)-</italic>bits.</p>
                <fig fig-type="figure" id="f5" orientation="portrait" position="float">
                    <label>Figure 5. </label>
                    <caption>
                        <title>General 2-D filter architectures (FIRA) with dual-port look-up table (DPLUT) multipliers.</title>
                        <p>SRU, shaft register unit; DUB, Delay Unit Block; LUT, look up table.</p>
                    </caption>
                    <graphic id="gr5" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/138442/9d2c3c82-ee89-4898-a013-b5648a69aa72_figure5.gif"/>
                </fig>
                <p>In this work, the multiplier quantity is decreased by symmetry in the filter coefficients. Two different symmetries are described in this section, and these symmetry filters can be used to design circular symmetry, fan-type and diamond filters.</p>
                <p>
                    <italic toggle="yes">Structure of 2-D FIR Diagonal Symmetry Filter (DSF)</italic>
                </p>
                <p>In the DSF coefficient matrix, the sixteen coefficients are reduced to ten, such as {
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>00</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>01</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>02</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>03</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>11</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>12</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>13</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>22</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>23</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>33</mml:mn>
                            </mml:msub>
                            <mml:mo stretchy="true">}</mml:mo>
                        </mml:math>
                    </inline-formula> for 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula> = 4 as shown in 
                    <xref ref-type="fig" rid="f1">Figure 1B</xref>. 
                    <xref ref-type="fig" rid="f6">Figure 6</xref> represents the arithmetic module of the DSF-based 2-D FIRA, and it is designed by diagonal symmetry. Before the multiplication process, the input samples to be multiplied with common filter coefficients are added.</p>
                <fig fig-type="figure" id="f6" orientation="portrait" position="float">
                    <label>Figure 6. </label>
                    <caption>
                        <title>Structure of a diagonal symmetry 2-D Finite Impulse Response (FIR) filter with dual-port look-up table (DPLUT) multipliers.</title>
                        <p>SRU, shaft register unit; DUB, Delay Unit Block; LUT, look up table.</p>
                    </caption>
                    <graphic id="gr6" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/138442/9d2c3c82-ee89-4898-a013-b5648a69aa72_figure6.gif"/>
                </fig>
                <p>For the one input of 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> = 2, seven adders are required to accumulate symmetry input samples. The seven highlighted colored adders indicate the adders for the other input sample. The adder is a simple block than the multiplier. The diagonal symmetry filter requires 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mn>2</mml:mn>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>+</mml:mo>
                                    <mml:mn>2</mml:mn>
                                </mml:mrow>
                            </mml:mfenced>
                            <mml:mi>N</mml:mi>
                            <mml:mspace width="0.25em"/>
                        </mml:math>
                    </inline-formula>multipliers instead of 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>&#x00d7;</mml:mo>
                                    <mml:mi>L</mml:mi>
                                </mml:mrow>
                            </mml:mfenced>
                            <mml:mi>N</mml:mi>
                            <mml:mo>,</mml:mo>
                        </mml:math>
                    </inline-formula>but extra 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>&#x2212;</mml:mo>
                                    <mml:mn>1</mml:mn>
                                </mml:mrow>
                            </mml:mfenced>
                            <mml:mi>N</mml:mi>
                            <mml:mspace width="0.25em"/>
                        </mml:math>
                    </inline-formula>adders are required. Next, these
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mspace width="0.25em"/>
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mn>2</mml:mn>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>+</mml:mo>
                                    <mml:mn>2</mml:mn>
                                </mml:mrow>
                            </mml:mfenced>
                            <mml:mi>N</mml:mi>
                            <mml:mspace width="0.25em"/>
                        </mml:math>
                    </inline-formula>multipliers are only designed for 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close=")" open="(">
                                <mml:mrow>
                                    <mml:mn>2</mml:mn>
                                    <mml:mi>L</mml:mi>
                                    <mml:mo>+</mml:mo>
                                    <mml:mn>2</mml:mn>
                                </mml:mrow>
                            </mml:mfenced>
                            <mml:mi>N</mml:mi>
                            <mml:mo>/</mml:mo>
                            <mml:mn>2</mml:mn>
                        </mml:math>
                    </inline-formula> DPLUT-based multipliers. Hence, half of the area is optimized. Finally, all the multiplier output samples are accumulated by 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula>- AT blocks to produce 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> outputs.</p>
                <p>Because multipliers are responsible for most of the power consumption, DPLUT-based multipliers are used to optimize them. Hence, ten DPMLUT multipliers are needed to produce the 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> = 2 outputs from the diagonal symmetry filter. The DSF architecture for 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula> = 4 with 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> = 2 needed 20 individual SPLUT multipliers.</p>
                <p>DPLUT decreases the LUT size for input samples with greater bit lengths by adding an additional shifter. Because of parallel block processing, two inputs are multiplied with the common filter coefficient in a 2-D FIR filter. This concept can be used to replace two SPLUT multipliers with a single DPLUT multiplier. The internal structure of the conventional DPLUT-based multiplier and the modified DPLUT-based multiplier are shown in 
                    <xref ref-type="fig" rid="f7">Figure 7A</xref> and 
                    <xref ref-type="fig" rid="f7">B</xref>.</p>
                <fig fig-type="figure" id="f7" orientation="portrait" position="float">
                    <label>Figure 7. </label>
                    <caption>
                        <title>(A) Conventional dual-port look-up table (DPLUT) multiplier (B) Modified DPLUT multiplier.</title>
                        <p>RST, reset.</p>
                    </caption>
                    <graphic id="gr7" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/138442/9d2c3c82-ee89-4898-a013-b5648a69aa72_figure7.gif"/>
                </fig>
                <p>The common filter odd coefficient multiples are precomputed and placed in the LUT memory. According to the input bits, the address of the location in the LUT is determined by the address encoder and address decoder. DPLUT fetches the corresponding locations based on the given addresses of two ports and provides two parallel outputs. Furthermore, each output is shifted by barrel shifters after passing through the corresponding NOR gate. The control lines for shifting are generated from the input sample bits handled by some control circuit logic, as explained earlier.</p>
                <p>This conventional DPLUT-DA multiplier has been revised, shown in 
                    <xref ref-type="fig" rid="f7">Figure 7B</xref> for 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>w</mml:mi>
                        </mml:math>
                    </inline-formula> = 4 bits of input sample using even multiples storage in LUT. It can be observed that the modified even multiples storage LUT-DA multipliers need less memory and area. Control logic for RST, barrel shifter, NOR cell, 4-to-3 encoder, and control signals of barrel shifter 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mfenced close="}" open="{" separators=",">
                                <mml:msub>
                                    <mml:mi>s</mml:mi>
                                    <mml:mi>o</mml:mi>
                                </mml:msub>
                                <mml:msub>
                                    <mml:mi>s</mml:mi>
                                    <mml:mn>1</mml:mn>
                                </mml:msub>
                            </mml:mfenced>
                        </mml:math>
                    </inline-formula> are not needed to enhance the DPLUT multiplier, and this feature reduces area further.</p>
                <p>The conversion of SPLUT into DPLUT is a critical task. The common filter coefficients stored in the LUT must be shared by two inputs simultaneously. For this, the control logic is introduced related to the clock signal to choose the address locations with a slight delay. 
                    <xref ref-type="fig" rid="f8">Figure 8</xref> represents the control logic using multiplexers for a DPLUT-DA multiplier.</p>
                <fig fig-type="figure" id="f8" orientation="portrait" position="float">
                    <label>Figure 8. </label>
                    <caption>
                        <title>Dual-port look-up table (DPLUT) control logic.</title>
                        <p>MUX. Multiplexer; LUT, look up table.</p>
                    </caption>
                    <graphic id="gr8" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/138442/9d2c3c82-ee89-4898-a013-b5648a69aa72_figure8.gif"/>
                </fig>
                <p>
                    <italic toggle="yes">Structure of a 2-D FIR Quadrantal Symmetry Filter (QSF)</italic>
                </p>
                <p>The QSF consists of eight unique filter coefficients are given as {
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mo>.</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>00</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>01</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>02</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>03</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>10</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>11</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mn>12</mml:mn>
                            </mml:msub>
                            <mml:mo>,</mml:mo>
                            <mml:msub>
                                <mml:mi>h</mml:mi>
                                <mml:mrow>
                                    <mml:mn>13</mml:mn>
                                    <mml:mo>.</mml:mo>
                                </mml:mrow>
                            </mml:msub>
                        </mml:math>
                    </inline-formula>}. 
                    <xref ref-type="fig" rid="f9">Figure 9</xref> represents the architecture of QSF for 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula> = 4 with 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> = 2. A total of 16 SPLUT multipliers are needed for this structure, and it is modified with eight DPLUT multipliers to produce 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula> -block outputs.</p>
                <fig fig-type="figure" id="f9" orientation="portrait" position="float">
                    <label>Figure 9. </label>
                    <caption>
                        <title>Structure of 2-D Finite Impulse Response (FIR) Quadrantal Symmetry Filter (QSF) with dual-port look-up table (DPLUT) multipliers.</title>
                        <p>DUB, Delay Unit Block; SRU, shaft register unit; LUT, look up table.</p>
                    </caption>
                    <graphic id="gr9" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/138442/9d2c3c82-ee89-4898-a013-b5648a69aa72_figure9.gif"/>
                </fig>
                <p>The summary of the number of single-port and dual-port multipliers needed for each symmetry is presented in 
                    <xref ref-type="table" rid="T3">Table 3</xref>.</p>
                <table-wrap id="T3" orientation="portrait" position="float">
                    <label>Table 3. </label>
                    <caption>
                        <title>The multipliers count for constructing various symmetry filters for 
                            <inline-formula>
                                <mml:math display="inline">
                                    <mml:mi>L</mml:mi>
                                </mml:math>
                            </inline-formula> = 4 with 
                            <inline-formula>
                                <mml:math display="inline">
                                    <mml:mi>N</mml:mi>
                                </mml:math>
                            </inline-formula> =2.</title>
                    </caption>
                    <table content-type="article-table" frame="hsides">
                        <thead>
                            <tr>
                                <th align="left" colspan="1" rowspan="1" valign="top">Name of the filter</th>
                                <th align="left" colspan="1" rowspan="1" valign="top">Single-port look-up table (SPLUT) multipliers</th>
                                <th align="left" colspan="1" rowspan="1" valign="top">Dual-port look-up table (DPLUT) multipliers</th>
                            </tr>
                        </thead>
                        <tbody>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="middle">General filter</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">32</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">16</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="middle">Diagonal Symmetry Filter DSF</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">20</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">10</td>
                            </tr>
                            <tr>
                                <td align="left" colspan="1" rowspan="1" valign="middle">Quadrantal Symmetry Filter QSF</td>
                                <td align="left" colspan="1" rowspan="1" valign="middle">16</td>
                                <td align="left" colspan="1" rowspan="1" valign="top">8</td>
                            </tr>
                        </tbody>
                    </table>
                </table-wrap>
                <p>
                    <italic toggle="yes">Experiment/validation</italic>
                </p>
                <p>This section analyzes the implementation and results for the proposed 2-D FIRAs. Multipliers, registers, and adders construct the architecture of the proposed filters. The hardware block's complexity depends on the filter input sample bits, length 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>L</mml:mi>
                        </mml:math>
                    </inline-formula>, input block size 
                    <inline-formula>
                        <mml:math display="inline">
                            <mml:mi>N</mml:mi>
                        </mml:math>
                    </inline-formula>, and filter coefficients. Hence, DSF and QSF symmetry-based 2-D FIR filters are designed and explored to reduce the quantity of the multipliers. Next, the multiplier architectures are optimized by dual-port even multiples storage LUT- based multipliers. The architectures are synthesized using the 
                    <ext-link ext-link-type="uri" xlink:href="https://www.cadence.com/ko_KR/home/tools/digital-design-and-signoff/synthesis/genus-synthesis-solution.html">Genus Synthesis</ext-link> tool-19.1 in 45nm technology with a generic library of 
                    <ext-link ext-link-type="uri" xlink:href="https://www.cadence.com/en_US/home.html">Cadence</ext-link> vendor constraints. There is a free synthesis tools available like 
                    <ext-link ext-link-type="uri" xlink:href="https://www.xilinx.com/support/download/index.html/content/xilinx/en/downloadNav/vivado-design-tools/archive-ise.html">Xilinx Integrated Synthesis Environment</ext-link>, which can be used instead of Genus Synthesis tool in Cadence to replicate our methods. Power consumption of architectures is calculated with an image size of 64 X 64 and at 20 MHz frequency. The synthesized results (reports in 
                    <italic toggle="yes">Underlying data</italic>
                    <sup>
                        <xref ref-type="bibr" rid="ref27">27</xref>
                    </sup>) have been analyzed and compared with the existing architecture&#x2019;s results. All Verilog code associated with the work is available in 
                    <italic toggle="yes">Software availability.</italic>
                    <sup>
                        <xref ref-type="bibr" rid="ref28">28</xref>
                    </sup>
                </p>
            </sec>
        </sec>
        <sec id="sec8" sec-type="results|discussion">
            <title>Results and discussion</title>
            <p>The data associated with the results is available in 
                <italic toggle="yes">Underlying data.</italic>
                <sup>
                    <xref ref-type="bibr" rid="ref27">27</xref>
                </sup> 
                <xref ref-type="table" rid="T4">Table 4</xref> presents synthesis results of two individual types of symmetry 2-D FIR filters and general filters for 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>L</mml:mi>
                    </mml:math>
                </inline-formula> = 4 with 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>N</mml:mi>
                    </mml:math>
                </inline-formula> = 2.</p>
            <table-wrap id="T4" orientation="portrait" position="float">
                <label>Table 4. </label>
                <caption>
                    <title>Power, delay, and area parameters of different multipliers for various symmetry filters for 
                        <inline-formula>
                            <mml:math display="inline">
                                <mml:mi>L</mml:mi>
                            </mml:math>
                        </inline-formula> = 4, 
                        <inline-formula>
                            <mml:math display="inline">
                                <mml:mi>N</mml:mi>
                            </mml:math>
                        </inline-formula> = 2 and 
                        <inline-formula>
                            <mml:math display="inline">
                                <mml:mi>w</mml:mi>
                            </mml:math>
                        </inline-formula> = 4.</title>
                    <p>SPLUT, Single-port look-up table; DPLUT, Dual-port look-up table; DSF, Diagonal Symmetry Filter; QSF, Quadrantal Symmetry Filter.</p>
                </caption>
                <table content-type="article-table" frame="hsides">
                    <thead>
                        <tr>
                            <th align="left" colspan="1" rowspan="2" valign="top">Name of the Filter</th>
                            <th align="left" colspan="3" rowspan="1" valign="top">Normal Multipliers</th>
                            <th align="left" colspan="3" rowspan="1" valign="top">SPLUT Multipliers</th>
                            <th align="left" colspan="3" rowspan="1" valign="top">DPLUT Multipliers</th>
                        </tr>
                        <tr>
                            <th align="left" colspan="1" rowspan="1" valign="top">Power (mW)</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">Delay (ns)</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">Area (&#x03bc;m
                                <sup>2</sup>)</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">Power (mW)</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">Delay (ns)</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">Area (&#x03bc;m
                                <sup>2</sup>)</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">Power (mW)</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">Delay (ns)</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">Area (&#x03bc;m
                                <sup>2</sup>)</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td align="left" colspan="1" rowspan="1" valign="middle">General Filter</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">1.2815</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">14.601</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">29711</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">0.9972</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">11.875</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">26122</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">0.775</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">10.22</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">23722</td>
                        </tr>
                        <tr>
                            <td align="left" colspan="1" rowspan="1" valign="middle">DSF</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">1.0624</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">14.209</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">22652</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">0.7212</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">11.432</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">19116</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">0.6981</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">10.238</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">17999</td>
                        </tr>
                        <tr>
                            <td align="left" colspan="1" rowspan="1" valign="middle">QSF</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">1.0103</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">14.112</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">21764</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">0.6996</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">11.228</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">17694</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">0.5591</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">10.623</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">14389</td>
                        </tr>
                    </tbody>
                </table>
            </table-wrap>
            <p>The power consumption, delay, and area results are represented in graphs, as shown in 
                <xref ref-type="fig" rid="f10">Figures 10</xref>, 
                <xref ref-type="fig" rid="f11">11</xref>, and 
                <xref ref-type="fig" rid="f12">12</xref>, respectively. The proposed DPLUT-based 2-D FIR DSF-filter architecture needs 20.54% and 5.84% less area than normal and SPLUT multiplier-based filter architectures. 34.2% and 3.2% of power savings are obtained by the proposed filter architecture compared to the normal and single-port multiplier-based filter architectures, respectively. The proposed DSF architecture is 27.9%, and 10.4% has less delay than normal multiplier and SPLUT-based architectures. Similarly, the proposed QSF 2-D FIRA power is decreased by 44%, 20%, than normal and SPLUT multipliers, the area is decreased by 33%, 18.6%, and delay is decreased by 24.7%, 5.3% than normal and SPLUT multipliers, respectively.</p>
            <fig fig-type="figure" id="f10" orientation="portrait" position="float">
                <label>Figure 10. </label>
                <caption>
                    <title>The power consumption comparison of different proposed 2-D Finite Impulse Response filters with different multiplier techniques.</title>
                    <p>Where DSF is diagonal symmetry filter, QSF is quadrantal symmetry filter and LUT is look up table.</p>
                </caption>
                <graphic id="gr10" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/138442/9d2c3c82-ee89-4898-a013-b5648a69aa72_figure10.gif"/>
            </fig>
            <fig fig-type="figure" id="f11" orientation="portrait" position="float">
                <label>Figure 11. </label>
                <caption>
                    <title>The delay comparison of different proposed 2-D Finite Impulse Response filters with different multiplier techniques.</title>
                    <p>Where DSF is diagonal symmetry filter, QSF is quadrantal symmetry filter and LUT is look up table.</p>
                </caption>
                <graphic id="gr11" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/138442/9d2c3c82-ee89-4898-a013-b5648a69aa72_figure11.gif"/>
            </fig>
            <fig fig-type="figure" id="f12" orientation="portrait" position="float">
                <label>Figure 12. </label>
                <caption>
                    <title>The area comparison of different proposed 2-D Finite Impulse Response filters with different multiplier techniques.</title>
                    <p>Where DSF is diagonal symmetry filter, QSF is quadrantal symmetry filter and LUT is look up table.</p>
                </caption>
                <graphic id="gr12" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/138442/9d2c3c82-ee89-4898-a013-b5648a69aa72_figure12.gif"/>
            </fig>
            <p>The filter architectures of 2-D FIR with two symmetries and one general filter are implemented by block processing and dual-port memory-based multipliers. Here, the memory reuse concept is used to get the filter outputs, and memory saving is obtained. The VLSI performance metrics, such as area, delay, and power values of the proposed filters, are compared for input bits 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>w</mml:mi>
                    </mml:math>
                </inline-formula> = 4 and 8 in 
                <xref ref-type="table" rid="T5">Table 5</xref>.</p>
            <table-wrap id="T5" orientation="portrait" position="float">
                <label>Table 5. </label>
                <caption>
                    <title>Comparison of proposed architectures for 
                        <inline-formula>
                            <mml:math display="inline">
                                <mml:mi>L</mml:mi>
                            </mml:math>
                        </inline-formula> = 4, 
                        <inline-formula>
                            <mml:math display="inline">
                                <mml:mi>N</mml:mi>
                            </mml:math>
                        </inline-formula> = 2, 
                        <inline-formula>
                            <mml:math display="inline">
                                <mml:mi>w</mml:mi>
                            </mml:math>
                        </inline-formula> = 4 and 8.</title>
                </caption>
                <table content-type="article-table" frame="hsides">
                    <thead>
                        <tr>
                            <th align="left" colspan="1" rowspan="1" valign="top">Name of the Filter</th>
                            <th align="left" colspan="2" rowspan="1" valign="top">Power (mW)</th>
                            <th align="left" colspan="2" rowspan="1" valign="top">Delay (ns)</th>
                            <th align="left" colspan="2" rowspan="1" valign="top">Area (&#x03bc;m
                                <sup>2</sup>)</th>
                        </tr>
                        <tr>
                            <th align="left" colspan="1" rowspan="1" valign="top">Input bits</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">w = 4</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">w = 8</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">w = 4</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">w = 8</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">w = 4</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">w = 8</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td align="left" colspan="1" rowspan="1" valign="top">General Filter with dual port lookup table multipliers</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">0.775</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">0.854</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">10.22</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">10.22</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">23722</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">28963</td>
                        </tr>
                        <tr>
                            <td align="left" colspan="1" rowspan="1" valign="top">Diagonal symmetry filter with dual port lookup table multipliers</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">0.698</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">0.7458</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">10.238</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">10.22</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">17999</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">20186</td>
                        </tr>
                        <tr>
                            <td align="left" colspan="1" rowspan="1" valign="top">Quadrantal symmetry filter with dual port lookup table multipliers</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">0.559</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">0.6253</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">10.623</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">10.8</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">14389</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">16453</td>
                        </tr>
                    </tbody>
                </table>
            </table-wrap>
            <p>The area of the proposed DSF and QSF symmetry filter architectures is reduced by 24.1% and 39.3% to the general 2-D FIRA for 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>w</mml:mi>
                    </mml:math>
                </inline-formula> = 4. The power-saving obtained by DSF and QSF is 9.9% and 27.8% less than the general filter architecture. The delay values of DSF, QSF and general filter are almost the same. 
                <xref ref-type="fig" rid="f13">Figure 13</xref> represents the comparison of area, delay, and power consumption of the proposed DPLUT-based 2-D FIRAs for 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>w</mml:mi>
                    </mml:math>
                </inline-formula> = 4 and 8. It can observe that the VLSI performance metrics increase correspondingly when the filter's input sample bits increase.</p>
            <fig fig-type="figure" id="f13" orientation="portrait" position="float">
                <label>Figure 13. </label>
                <caption>
                    <title>The area, delay, and power consumption comparison of proposed filters.</title>
                    <p>DSF, diagonal symmetry filter; QSF, quadrantal symmetry filter; LUT, look up table.</p>
                </caption>
                <graphic id="gr13" orientation="portrait" position="float" xlink:href="9d2c3c82-ee89-4898-a013-b5648a69aa72_figure13.gif"/>
            </fig>
            <p>for 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>w</mml:mi>
                    </mml:math>
                </inline-formula> = 4 and 8. Where DSF is diagonal symmetry filter, QSF is quadrantal symmetry filter and LUT is look up table. The proposed symmetry 2-D FIR filters with DPLUT-based multipliers are compared to previous works. The performance metrics obtained from the synthesis tool are tabulated in 
                <xref ref-type="table" rid="T6">Table 6</xref>.</p>
            <table-wrap id="T6" orientation="portrait" position="float">
                <label>Table 6. </label>
                <caption>
                    <title>Comparison of the proposed filters with existing filter for 
                        <inline-formula>
                            <mml:math display="inline">
                                <mml:mi>L</mml:mi>
                            </mml:math>
                        </inline-formula> = 8 with 
                        <inline-formula>
                            <mml:math display="inline">
                                <mml:mi>N</mml:mi>
                            </mml:math>
                        </inline-formula>= 4.</title>
                    <p>DSF, Diagonal Symmetry Filter; QSF, Quadrantal Symmetry Filter; ADP, area delay product; PDP, power delay product.</p>
                </caption>
                <table content-type="article-table" frame="hsides">
                    <thead>
                        <tr>
                            <th align="left" colspan="1" rowspan="1" valign="top">Architecture</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">Area (&#x03bc;m
                                <sup>2</sup>)</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">Delay (ns)</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">Power (mW)</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">ADP (&#x03bc;m
                                <sup>2</sup>. ms)</th>
                            <th align="left" colspan="1" rowspan="1" valign="top">PDP (mW. ns)</th>
                        </tr>
                    </thead>
                    <tbody>
                        <tr>
                            <td align="left" colspan="1" rowspan="1" valign="middle">Alawad et al. [44]</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">489271</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">14.16</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">7.96</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">6.928</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">112.71</td>
                        </tr>
                        <tr>
                            <td align="left" colspan="1" rowspan="1" valign="middle">Mohanty et al. [45]</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">791361</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">16.25</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">5.0934</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">12.85</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">82.76</td>
                        </tr>
                        <tr>
                            <td align="left" colspan="1" rowspan="1" valign="middle">Kumar et al. [48]</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">405825</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">8.72</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">4.13</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">3.53</td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">36.01</td>
                        </tr>
                        <tr>
                            <td align="left" colspan="1" rowspan="1" valign="middle">
                                <bold>Proposed Filter (DSF)</bold>
                            </td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">
                                <bold>183457</bold>
                            </td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">
                                <bold>11.258</bold>
                            </td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">
                                <bold>1.8793</bold>
                            </td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">
                                <bold>2.057</bold>
                            </td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">
                                <bold>21.157</bold>
                            </td>
                        </tr>
                        <tr>
                            <td align="left" colspan="1" rowspan="1" valign="middle">
                                <bold>Proposed Filter (QSF)</bold>
                            </td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">
                                <bold>164052</bold>
                            </td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">
                                <bold>11.091</bold>
                            </td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">
                                <bold>1.6955</bold>
                            </td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">
                                <bold>1.82</bold>
                            </td>
                            <td align="left" colspan="1" rowspan="1" valign="middle">
                                <bold>18.804</bold>
                            </td>
                        </tr>
                    </tbody>
                </table>
            </table-wrap>
            <p>The proposed filter architecture implementation is extended for 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>L</mml:mi>
                    </mml:math>
                </inline-formula> =8 with 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>N</mml:mi>
                    </mml:math>
                </inline-formula> = 4. The 2-D FIRA for 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>L</mml:mi>
                    </mml:math>
                </inline-formula> =8 with 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>N</mml:mi>
                    </mml:math>
                </inline-formula> = 4 is also compared with the state-of-the-art works in 
                <xref ref-type="table" rid="T6">Table 6</xref>. It can be observed that the proposed architecture is improved in terms of power, area, delay, ADP, and PDP than existing architectures.</p>
            <p>A graphical comparison of results of rea, power consumption, delay, ADP, and PDP of the proposed structure with existing filter architecture for 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>L</mml:mi>
                    </mml:math>
                </inline-formula> = 8 with 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>N</mml:mi>
                    </mml:math>
                </inline-formula> = 4 is shown in 
                <xref ref-type="fig" rid="f14">Figure 14</xref>.</p>
            <fig fig-type="figure" id="f14" orientation="portrait" position="float">
                <label>Figure 14. </label>
                <caption>
                    <title>Area, delay-power consumption, ADP, and PDP comparison of proposed DSF and QSF architectures with existing architectures for 
                        <inline-formula>
                            <mml:math display="inline">
                                <mml:mi>L</mml:mi>
                            </mml:math>
                        </inline-formula> = 8 with 
                        <inline-formula>
                            <mml:math display="inline">
                                <mml:mi>N</mml:mi>
                            </mml:math>
                        </inline-formula> = 4.</title>
                </caption>
                <graphic id="gr14" orientation="portrait" position="float" xlink:href="https://f1000research-files.f1000.com/manuscripts/138442/9d2c3c82-ee89-4898-a013-b5648a69aa72_figure14.gif"/>
            </fig>
            <p>The proposed MLUT-based 2-D block DSF filter for 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>L</mml:mi>
                    </mml:math>
                </inline-formula>= 8 with 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>N</mml:mi>
                    </mml:math>
                </inline-formula>= 4 requires 62.50%, 76.81%, and 54.79% less area compared to [23], [3], and [11], respectively. It has 20.49%, and 30.72% less delay compared to [23], and [3], respectively. It consumes 76.39%, 63.10%, and 54.49% less power than [23], [3], and [11], respectively. It has 70.3%, 83.99%, and 41.72% less ADP than [23], [3], and [11], respectively. It has 81.22%, 74.43%, and 41.24% less PDP compared to [23], [3], and [11] respectively.</p>
            <p>The proposed MLUT-based 2-D block QSF filter for 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>L</mml:mi>
                    </mml:math>
                </inline-formula>= 8 with 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>N</mml:mi>
                    </mml:math>
                </inline-formula>= 4 requires 66.47%, 79.26%, and 59.57% less area compared to [23],[3], and [11], respectively. It has 21.67%, and 31.74% less delay compared to [23], and [3], respectively. It consumes 78.69%, 66.71% and 58.94% less power than [23], [3], and [11], respectively. It has 73.72%, 85.83%, and 48.44% less ADP than [23], [3], and [11] respectively. It has 83.31%, 77.27%, and 47.78% less PDP compared to [23], [3], and [11] respectively.</p>
        </sec>
        <sec id="sec9" sec-type="conclusions">
            <title>Conclusions</title>
            <p>This paper implements two novel symmetry 2-D block FIRAs using QSF and DSF and one general filter (without symmetry) with DPMLUT-based multipliers. The conventional multipliers are replaced with the MLUT multipliers; DPMLUT-based multipliers save power and area compared to SPMLUT-based multipliers. Individual symmetry filters are implemented using fewer multipliers. Block processing is used to achieve memory reuse.</p>
            <p>The proposed MLUT-based 2-D block DSF filter for 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>L</mml:mi>
                    </mml:math>
                </inline-formula>= 8 with 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>N</mml:mi>
                    </mml:math>
                </inline-formula>= 4 requires 54.79% less area, consumes 54.49% less power, has 41.72% less ADP, and 41.24% less PDP, but has 29% more delay compared to existing HLUT-based 2-D block FIR filter.
                <sup>
                    <xref ref-type="bibr" rid="ref11">11</xref>
                </sup>
            </p>
            <p>On the other hand, the proposed MLUT-based 2-D block QSF filter for 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>L</mml:mi>
                    </mml:math>
                </inline-formula>= 8 with 
                <inline-formula>
                    <mml:math display="inline">
                        <mml:mi>N</mml:mi>
                    </mml:math>
                </inline-formula>= 4 requires 59.5% less area, consumes 58.94% less power, 48.44% less ADP and 47.78% less PDP, but has 27% more delay compared to existing HLUT-based 2-D block FIR filter.
                <sup>
                    <xref ref-type="bibr" rid="ref11">11</xref>
                </sup> The 2-D block FIRA using QSF has fewer unique coefficients than the 2-D block FIRA using DSF. Hence, QSF performs well in terms of performance metrics.</p>
        </sec>
    </body>
    <back>
        <sec id="sec13" sec-type="data-availability">
            <title>Data availability</title>
            <sec id="sec14">
                <title>Underlying data</title>
                <p>Figshare: Untitled ItemFIR FILTER. 
                    <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.6084/m9.figshare.22058801.v1">https://doi.org/10.6084/m9.figshare.22058801.v1</ext-link>.
                    <sup>

                        <xref ref-type="bibr" rid="ref27">27</xref>
</sup>
                </p>
                <p>This project contains the following underlying data:
                    <list list-type="bullet">
                        <list-item>
                            <label>-</label>
                            <p>Data set.xlsx (testbench which defines the operational relation between input and output, results for different values of block length and also the results table in which existing and proposed models be compared).</p>
                        </list-item>
                        <list-item>
                            <label>-</label>
                            <p>larea_DSF.rep (area report of DSF_2D FIR filter, a tool generated area report downloaded while executing).</p>
                        </list-item>
                        <list-item>
                            <label>-</label>
                            <p>larea_QSF.rep (area report of QSF_2D FIR filter, a tool generated area report downloaded while executing).</p>
                        </list-item>
                        <list-item>
                            <label>-</label>
                            <p>lpower_DSF.rep (power report of DSF_2D FIR filter, a tool generated area report downloaded while executing).</p>
                        </list-item>
                        <list-item>
                            <label>-</label>
                            <p>lpower_QSF.rep (power report of QSF_2D FIR filter, a tool generated area report downloaded while executing).</p>
                        </list-item>
                        <list-item>
                            <label>-</label>
                            <p>ltiming_DSF.rep (timing report of DSF_2D FIR filter, a tool generated area report downloaded while executing).</p>
                        </list-item>
                        <list-item>
                            <label>-</label>
                            <p>ltiming_QSF.rep (timing report of QSF_2D FIR filter, a tool generated area report downloaded while executing).
</p>
                        </list-item>
                    </list>
                </p>
                <p>Data are available under the terms of the 
                    <ext-link ext-link-type="uri" xlink:href="https://creativecommons.org/licenses/by/4.0/">Creative Commons Attribution 4.0 International license</ext-link> (CC-BY 4.0).</p>
            </sec>
        </sec>
        <sec id="sec10">
            <title>Software availability</title>
            <p>Source code available from: 
                <ext-link ext-link-type="uri" xlink:href="https://github.com/pratyushachowdarich/2DFIR_FILTER.git">https://github.com/pratyushachowdarich/2DFIR_FILTER.git</ext-link>
            </p>
            <p>Archived source code at time of publication: 
                <ext-link ext-link-type="uri" xlink:href="https://doi.org/10.5281/zenodo.7631743">https://doi.org/10.5281/zenodo.7631743</ext-link>.
                <sup>

                    <xref ref-type="bibr" rid="ref28">28</xref>
</sup>
            </p>
            <p>license: 
                <ext-link ext-link-type="uri" xlink:href="https://opensource.org/license/gpl-3-0/">GPL-3.0-only</ext-link>
            </p>
        </sec>
        <ref-list>
            <title>References</title>
            <ref id="ref1">
                <label>1</label>
                <mixed-citation publication-type="book">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Parhi</surname>
                            <given-names>KK</given-names>
                        </name>
</person-group>:
                    <source>

                        <italic toggle="yes">VLSI Digital Signal Processing Systems: Design and Implementation, ch. 7.</italic>
</source>
                    <publisher-loc>New York</publisher-loc>:
                    <publisher-name>Wiley</publisher-name>;<year>1999</year>.</mixed-citation>
            </ref>
            <ref id="ref2">
                <label>2</label>
                <mixed-citation publication-type="book">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Sid-Ahmed</surname>
                            <given-names>MA</given-names>
                        </name>
</person-group>:
                    <source>

                        <italic toggle="yes">Image Processing: Theory, Algorithms, and Architectures.</italic>
</source>
                    <publisher-loc>NewYork</publisher-loc>:
                    <publisher-name>McGraw-Hill</publisher-name>;<year>1995</year>.</mixed-citation>
            </ref>
            <ref id="ref3">
                <label>3</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Mohanty</surname>
                            <given-names>BK</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Meher</surname>
                            <given-names>PK</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Amira</surname>
                            <given-names>A</given-names>
                        </name>
</person-group>:
                    <article-title>Memory Footprint Reduction for Power-Efficient Realization of 2-D Finite Impulse Response Filters.</article-title>
                    <source>

                        <italic toggle="yes">IEEE Trans. Circuits Syst. I.</italic>
</source>
                    <year>2014</year>;<volume>61</volume>(<issue>1</issue>):<fpage>120</fpage>&#x2013;<lpage>133</lpage>.
                    <pub-id pub-id-type="doi">10.1109/TCSI.2013.2265953</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref4">
                <label>4</label>
                <mixed-citation publication-type="other">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Mohanty</surname>
                            <given-names>BK</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Al-Maadeed</surname>
                            <given-names>S</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Amira</surname>
                            <given-names>A</given-names>
                        </name>
</person-group>:
                    <article-title>Systolic architecture for hardware implementation of two-dimensional non-separable filter-bank.</article-title>
                    <source>

                        <italic toggle="yes">2013 8th IEEE Design and Test Symposium, IEEE.</italic>
</source>
                    <year>2013</year>; pp.<fpage>1</fpage>&#x2013;<lpage>6</lpage>.</mixed-citation>
            </ref>
            <ref id="ref5">
                <label>5</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Venkata Krishna</surname>
                            <given-names>O</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Venkata Narasimhulu</surname>
                            <given-names>C</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Satya Prasad</surname>
                            <given-names>K</given-names>
                        </name>
</person-group>:
                    <article-title>Implementation of Low Power and Memory Efficient 2D FIR Filter Architecture.</article-title>
                    <source>

                        <italic toggle="yes">Int. J. Recent Technol. Eng.</italic>
</source>
                    <year>2019</year>;<volume>8</volume>(<issue>1</issue>):<fpage>927</fpage>&#x2013;<lpage>935</lpage>.</mixed-citation>
            </ref>
            <ref id="ref6">
                <label>6</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Vinitha</surname>
                            <given-names>CS</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Sharma</surname>
                            <given-names>RK</given-names>
                        </name>
</person-group>:
                    <article-title>New approach to low-area, low-latency memory-based systolic architecture for FIR filters.</article-title>
                    <source>

                        <italic toggle="yes">J. Inf. Optim. Sci.</italic>
</source>
                    <year>2019</year>;<volume>40</volume>(<issue>2</issue>):<fpage>247</fpage>&#x2013;<lpage>262</lpage>.
                    <pub-id pub-id-type="doi">10.1080/02522667.2019.1578087</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref7">
                <label>7</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Chen</surname>
                            <given-names>PY</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Van</surname>
                            <given-names>LD</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Khoo</surname>
                            <given-names>IH</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>Power-efficient and cost-effective 2-D symmetry filter architectures.</article-title>
                    <source>

                        <italic toggle="yes">IEEE Trans. Circuits Syst. I: Regular Papers.</italic>
</source>
                    <year>2010</year>;<volume>58</volume>(<issue>1</issue>):<fpage>112</fpage>&#x2013;<lpage>125</lpage>.</mixed-citation>
            </ref>
            <ref id="ref8">
                <label>8</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Van</surname>
                            <given-names>LD</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Khoo</surname>
                            <given-names>IH</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Chen</surname>
                            <given-names>PY</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>Symmetry incorporated cost-effective architectures for two-dimensional digital filters.</article-title>
                    <source>

                        <italic toggle="yes">IEEE Circuits Syst. Mag.</italic>
</source>
                    <year>2019</year>;<volume>19</volume>(<issue>1</issue>):<fpage>33</fpage>&#x2013;<lpage>54</lpage>.
                    <pub-id pub-id-type="doi">10.1109/MCAS.2018.2872665</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref9">
                <label>9</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Aggarwal</surname>
                            <given-names>A</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Kumar</surname>
                            <given-names>M</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Rawat</surname>
                            <given-names>TK</given-names>
                        </name>
</person-group>:
                    <article-title>Design of two-dimensional FIR filters with quadrantally symmetric properties using the 2D L 1-method.</article-title>
                    <source>

                        <italic toggle="yes">IET Signal Processing.</italic>
</source>
                    <year>2018</year>;<volume>13</volume>(<issue>3</issue>):<fpage>262</fpage>&#x2013;<lpage>272</lpage>.</mixed-citation>
            </ref>
            <ref id="ref10">
                <label>10</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Mohanty</surname>
                            <given-names>BK</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Meher</surname>
                            <given-names>PK</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Singhal</surname>
                            <given-names>SK</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>A high-performance VLSI architecture for reconfigurable FIR using distributed arithmetic.</article-title>
                    <source>

                        <italic toggle="yes">Integration.</italic>
</source>
                    <year>2016</year>;<volume>54</volume>:<fpage>37</fpage>&#x2013;<lpage>46</lpage>.
                    <pub-id pub-id-type="doi">10.1016/j.vlsi.2016.01.006</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref11">
                <label>11</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Kumar</surname>
                            <given-names>P</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Shrivastava</surname>
                            <given-names>PC</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Tiwari</surname>
                            <given-names>M</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>High-throughput, area-efficient architecture of 2-D block FIR filter using distributed arithmetic algorithm.</article-title>
                    <source>

                        <italic toggle="yes">Circuits, systems, and signal processing.</italic>
</source>
                    <year>2019</year>;<volume>38</volume>(<issue>3</issue>):<fpage>1099</fpage>&#x2013;<lpage>1113</lpage>.
                    <pub-id pub-id-type="doi">10.1007/s00034-018-0897-2</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref12">
                <label>12</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Kumar</surname>
                            <given-names>P</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Shrivastava</surname>
                            <given-names>PC</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Tiwari</surname>
                            <given-names>M</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>ASIC implementation of area-efficient, high-throughput 2-D IIR filter using distributed arithmetic.</article-title>
                    <source>

                        <italic toggle="yes">Circuits, Systems, and Signal Processing.</italic>
</source>
                    <year>2018</year>;<volume>37</volume>(<issue>7</issue>):<fpage>2934</fpage>&#x2013;<lpage>2957</lpage>.
                    <pub-id pub-id-type="doi">10.1007/s00034-017-0698-z</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref13">
                <label>13</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>NagaJyothi</surname>
                            <given-names>G</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Sridevi</surname>
                            <given-names>S</given-names>
                        </name>
</person-group>:
                    <article-title>High speed and low area decision feed-back equalizer with novel memoryless distributed arithmetic filter.</article-title>
                    <source>

                        <italic toggle="yes">Multimed. Tools Appl.</italic>
</source>
                    <year>2019</year>;<volume>78</volume>(<issue>23</issue>):<fpage>32679</fpage>&#x2013;<lpage>32693</lpage>.
                    <pub-id pub-id-type="doi">10.1007/s11042-018-7038-6</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref14">
                <label>14</label>
                <mixed-citation publication-type="other">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>NagaJyothi</surname>
                            <given-names>G</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Sridevi</surname>
                            <given-names>S</given-names>
                        </name>
</person-group>:
                    <article-title>Distributed arithmetic architectures for fir filters-a comparative review.</article-title>
                    <source>

                        <italic toggle="yes">2017 International conference on wireless communications, signal processing and networking (WiSPNET), IEEE.</italic>
</source>
                    <year>2017</year>; pp.<fpage>2684</fpage>&#x2013;<lpage>2690</lpage>.</mixed-citation>
            </ref>
            <ref id="ref15">
                <label>15</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Park</surname>
                            <given-names>SY</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Meher</surname>
                            <given-names>PK</given-names>
                        </name>
</person-group>:
                    <article-title>Efficient FPGA and ASIC realizations of a DA-based reconfigurable FIR digital filter.</article-title>
                    <source>

                        <italic toggle="yes">IEEE Trans. Circuits Syst. II Exp. Briefs.</italic>
</source>
                    <year>2014</year>;<volume>61</volume>(<issue>7</issue>):<fpage>511</fpage>&#x2013;<lpage>515</lpage>.</mixed-citation>
            </ref>
            <ref id="ref16">
                <label>16</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Venkata Krishna</surname>
                            <given-names>O</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Venkata Narasimhulu</surname>
                            <given-names>C</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Satya Prasad</surname>
                            <given-names>K</given-names>
                        </name>
</person-group>:
                    <article-title>Efficient VLSI architectures for FIR Filters.</article-title>
                    <source>

                        <italic toggle="yes">IOSR Journal of VLSI and Signal Processing.</italic>
</source>
                    <year>2016</year>;<volume>6</volume>(<issue>6</issue>):<fpage>37</fpage>&#x2013;<lpage>44</lpage>.</mixed-citation>
            </ref>
            <ref id="ref17">
                <label>17</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Odugu</surname>
                            <given-names>VK</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Venkata Narasimhulu</surname>
                            <given-names>C</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Satya Prasad</surname>
                            <given-names>K</given-names>
                        </name>
</person-group>:
                    <article-title>Implementation of Low Power Generic 2D FIR Filter Bank Architecture Using Memory-based Multipliers.</article-title>
                    <source>

                        <italic toggle="yes">J. Mob. Multimed.</italic>
</source>
                    <year>2022</year>;<fpage>583</fpage>&#x2013;<lpage>602</lpage>.
                    <pub-id pub-id-type="doi">10.13052/jmm1550-4646.1836</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref18">
                <label>18</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Meher</surname>
                            <given-names>PK</given-names>
                        </name>
</person-group>:
                    <article-title>New approach to look-up-table design and memory-based realization of FIR digital filter.</article-title>
                    <source>

                        <italic toggle="yes">IEEE Trans. Circuits Syst. I: Regular Papers.</italic>
</source>
                    <year>2009</year>;<volume>57</volume>(<issue>3</issue>):<fpage>592</fpage>&#x2013;<lpage>603</lpage>.
                    <pub-id pub-id-type="doi">10.1109/TCSI.2009.2026683</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref19">
                <label>19</label>
                <mixed-citation publication-type="other">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Meher</surname>
                            <given-names>PK</given-names>
                        </name>
</person-group>:
                    <article-title>New look-up-table optimizations for memory-based multiplication.</article-title>
                    <source>

                        <italic toggle="yes">Proceedings of the 2009 12th International Symposium on Integrated Circuits. IEEE.</italic>
</source>
                    <year>2009</year>; pp.<fpage>663</fpage>&#x2013;<lpage>666</lpage>.</mixed-citation>
            </ref>
            <ref id="ref20">
                <label>20</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Vinitha</surname>
                            <given-names>CS</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Sharma</surname>
                            <given-names>RK</given-names>
                        </name>
</person-group>:
                    <article-title>An efficient LUT design on FPGA for memory-based multiplication.</article-title>
                    <source>

                        <italic toggle="yes">Iran. J. Electr. Electron. Eng.</italic>
</source>
                    <year>2019</year>;<volume>15</volume>(<issue>4</issue>):<fpage>462</fpage>&#x2013;<lpage>476</lpage>.</mixed-citation>
            </ref>
            <ref id="ref21">
                <label>21</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Chiper</surname>
                            <given-names>DF</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Swamy</surname>
                            <given-names>MS</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Ahmad</surname>
                            <given-names>MO</given-names>
                        </name>

                        <etal/>
</person-group>:
                    <article-title>Systolic algorithms and a memory-based design approach for a unified architecture for the computation of DCT/DST/IDCT/IDST.</article-title>
                    <source>

                        <italic toggle="yes">IEEE Trans. Circuits Syst. I: Regular Papers.</italic>
</source>
                    <year>2005</year>;<volume>52</volume>(<issue>6</issue>):<fpage>1125</fpage>&#x2013;<lpage>1137</lpage>.
                    <pub-id pub-id-type="doi">10.1109/TCSI.2005.849109</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref22">
                <label>22</label>
                <mixed-citation publication-type="book">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Sharma</surname>
                            <given-names>D</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Johnson</surname>
                            <given-names>J</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Sharma</surname>
                            <given-names>A</given-names>
                        </name>
</person-group>:
                    <chapter-title>Memory-based FIR digital filter using modified OMS-LUT design</chapter-title>.
                    <source>

                        <italic toggle="yes">Applications of Computing, Automation and Wireless Systems in Electrical Engineering.</italic>
</source>
                    <publisher-loc>Singapore</publisher-loc>:
                    <publisher-name>Springer</publisher-name>;<year>2019</year>; pp.<fpage>1007</fpage>&#x2013;<lpage>1017</lpage>.
                    <pub-id pub-id-type="doi">10.1007/978-981-13-6772-4_88</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref23">
                <label>23</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Alawad</surname>
                            <given-names>M</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Lin</surname>
                            <given-names>M</given-names>
                        </name>
</person-group>:
                    <article-title>Memory-Efficient Probabilistic 2-D Finite Impulse Response (FIR) Filter.</article-title>
                    <source>

                        <italic toggle="yes">IEEE Transactions on Multi-Scale Computing Systems.</italic>
</source>
                    <year>2017</year>;<volume>4</volume>(<issue>1</issue>):<fpage>69</fpage>&#x2013;<lpage>82</lpage>.</mixed-citation>
            </ref>
            <ref id="ref24">
                <label>24</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Chowdari</surname>
                            <given-names>CP</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Seventline</surname>
                            <given-names>JB</given-names>
                        </name>
</person-group>:
                    <article-title>An efficient FIR Filter Architecture Implementation using Distributed Arithmetic (DA) for DSP Applications.</article-title>
                    <source>

                        <italic toggle="yes">International journal of Innovative Technology and Exploring Engineering.</italic>
</source>
                    <year>2019</year>.</mixed-citation>
            </ref>
            <ref id="ref25">
                <label>25</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Chowdari</surname>
                            <given-names>CP</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Seventline</surname>
                            <given-names>JB</given-names>
                        </name>
</person-group>:
                    <article-title>Systolic architecture for adaptive block FIR filter for throughput using distributed arithmetic.</article-title>
                    <source>

                        <italic toggle="yes">Int. J. Speech Technol.</italic>
</source>
                    <year>2020</year>;<volume>23</volume>(<issue>3</issue>):<fpage>549</fpage>&#x2013;<lpage>557</lpage>.
                    <pub-id pub-id-type="doi">10.1007/s10772-020-09745-4</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref26">
                <label>26</label>
                <mixed-citation publication-type="journal">
                    <person-group person-group-type="author">

                        <name name-style="western">
                            <surname>Chowdari</surname>
                            <given-names>CP</given-names>
                        </name>

                        <name name-style="western">
                            <surname>Seventline</surname>
                            <given-names>JB</given-names>
                        </name>
</person-group>:
                    <article-title>VLSI implementation of distributed arithmetic-based block adaptive finite impulse response filter.</article-title>
                    <source>

                        <italic toggle="yes">Materials Today: Proceedings.</italic>
</source>
                    <year>2020</year>;<volume>33</volume>:<fpage>3757</fpage>&#x2013;<lpage>3762</lpage>.</mixed-citation>
            </ref>
            <ref id="ref27">
                <label>27</label>
                <mixed-citation publication-type="data">
                    <collab>ch, pratyushachowdari</collab>:
                    <data-title>Untitled ItemFIR FILTER.</data-title>[Dataset].
                    <source>

                        <italic toggle="yes">figshare.</italic>
</source>
                    <year>2023</year>.
                    <pub-id pub-id-type="doi">10.6084/m9.figshare.22058801.v1</pub-id>
                </mixed-citation>
            </ref>
            <ref id="ref28">
                <label>28</label>
                <mixed-citation publication-type="other">
                    <collab>pratyusha chowdari ch</collab>:
                    <article-title>FIR filter [Software].</article-title>
                    <source>

                        <italic toggle="yes">Zenodo.</italic>
</source>
                    <year>2023</year>.
                    <pub-id pub-id-type="doi">10.5281/zenodo.7631743</pub-id>
                </mixed-citation>
            </ref>
        </ref-list>
    </back>
    <sub-article article-type="reviewer-report" id="report242160">
        <front-stub>
            <article-id pub-id-type="doi">10.5256/f1000research.138442.r242160</article-id>
            <title-group>
                <article-title>Reviewer response for version 1</article-title>
            </title-group>
            <contrib-group>
                <contrib contrib-type="author">
                    <name>
                        <surname>Balaji</surname>
                        <given-names>M</given-names>
                    </name>
                    <xref ref-type="aff" rid="r242160a1">1</xref>
                    <role>Referee</role>
                    <uri content-type="orcid">https://orcid.org/0000-0002-7693-581X</uri>
                </contrib>
                <aff id="r242160a1">
                    <label>1</label>Department of ECE, Sree Vidyanikethan Engineering College, Tirupati, Andhra Pradesh, India</aff>
            </contrib-group>
            <author-notes>
                <fn fn-type="conflict">
                    <p>
                        <bold>Competing interests: </bold>No competing interests were disclosed.</p>
                </fn>
            </author-notes>
            <pub-date pub-type="epub">
                <day>29</day>
                <month>2</month>
                <year>2024</year>
            </pub-date>
            <permissions>
                <copyright-statement>Copyright: &#x00a9; 2024 Balaji M</copyright-statement>
                <copyright-year>2024</copyright-year>
                <license xlink:href="https://creativecommons.org/licenses/by/4.0/">
                    <license-p>This is an open access peer review report distributed under the terms of the Creative Commons Attribution Licence, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.</license-p>
                </license>
            </permissions>
            <related-article ext-link-type="doi" id="relatedArticleReport242160" related-article-type="peer-reviewed-article" xlink:href="10.12688/f1000research.126067.1"/>
            <custom-meta-group>
                <custom-meta>
                    <meta-name>recommendation</meta-name>
                    <meta-value>approve</meta-value>
                </custom-meta>
            </custom-meta-group>
        </front-stub>
        <body>
            <p>This study focuses on symmetry-based optimizations and offers a well-organized and very effective method for designing 2-D finite impulse response (FIR) filters. It is a good method to decrease multipliers by incorporating different symmetries. One notable innovation is the multiplication process that uses distributed arithmetic (DA) and the dual-port memory-based lookup table (DP-MLUT). It increases the FIR filter's overall efficiency while also consuming less space and power.</p>
            <p> </p>
            <p> One ingenious way to lower the requirement for registers and, hence, circuit complexity is to implement memory reuse and memory sharing solutions. The suggested architectures' practicality is greatly enhanced by this method. The benefits of the suggested designs in terms of power, area, area delay product (ADP), and power delay product (PDP) are well demonstrated by the comparison data presented in the study. These are significant advancements that have potential for many different uses.</p>
            <p> The synthesis produces a 45 nm technological environment that demonstrates how the suggested designs may be used in practical settings. Particularly with the Quadrantal Symmetry Filter (QSF), the power and area savings are very noteworthy. The appropriateness of the suggested filter design for applications with fixed coefficients is emphasized in the paper's conclusion. This understanding of possible uses gives the research more usefulness.</p>
            <p> </p>
            <p> Request the Corresponding author to provide justifications for these queries.</p>
            <p> 1) Please explain how the area (micrometers square) was calculated.</p>
            <p> 2) The proposed filter was designed with L=8 and N=4, it can be further extended to 32-bit with 64 taps.</p>
            <p> 3) If the comparisons of your proposed results with existing results within a table format is appreciable."</p>
            <p>Is the work clearly and accurately presented and does it cite the current literature?</p>
            <p>Yes</p>
            <p>If applicable, is the statistical analysis and its interpretation appropriate?</p>
            <p>Yes</p>
            <p>Are all the source data underlying the results available to ensure full reproducibility?</p>
            <p>Yes</p>
            <p>Is the study design appropriate and is the work technically sound?</p>
            <p>Yes</p>
            <p>Are the conclusions drawn adequately supported by the results?</p>
            <p>Yes</p>
            <p>Are sufficient details of methods and analysis provided to allow replication by others?</p>
            <p>Yes</p>
            <p>Reviewer Expertise:</p>
            <p>FIR FIlter Design, Distributed Arithmetic, Residue Number System, VLSI Signal Processing</p>
            <p>I confirm that I have read this submission and believe that I have an appropriate level of expertise to confirm that it is of an acceptable scientific standard.</p>
        </body>
        <back>
            <ref-list>
                <title>References</title>
                <ref id="rep-ref-242160-1">
                    <label>1</label>
                    <mixed-citation publication-type="journal">
                        <person-group person-group-type="author"/>:
                        <article-title>Area and delay efficient RNS-based FIR filter design using fast multipliers</article-title>.
                        <source>
                            <italic>Measurement: Sensors</italic>
                        </source>.<year>2024</year>;<volume>31</volume>:
                        <elocation-id>10.1016/j.measen.2023.101014</elocation-id>
                        <pub-id pub-id-type="doi">10.1016/j.measen.2023.101014</pub-id>
                    </mixed-citation>
                </ref>
                <ref id="rep-ref-242160-2">
                    <label>2</label>
                    <mixed-citation publication-type="journal">
                        <person-group person-group-type="author"/>:
                        <article-title>Low power residue number system using lookup table decomposition and finite state machine based post computation</article-title>.
                        <source>
                            <italic>Indonesian Journal of Electrical Engineering and Computer Science</italic>
                        </source>.<year>2022</year>;<volume>26</volume>(<issue>1</issue>) :
                        <elocation-id>10.11591/ijeecs.v26.i1.pp127-134</elocation-id>
                        <pub-id pub-id-type="doi">10.11591/ijeecs.v26.i1.pp127-134</pub-id>
                    </mixed-citation>
                </ref>
                <ref id="rep-ref-242160-3">
                    <label>3</label>
                    <mixed-citation publication-type="journal">
                        <person-group person-group-type="author"/>:
                        <article-title>High-Speed DSP Pipelining and Retiming techniques for Distributed-Arithmetic RNS-based FIR Filter Design</article-title>.
                        <source>
                            <italic>WSEAS TRANSACTIONS ON SYSTEMS AND CONTROL</italic>
                        </source>.<year>2022</year>;<volume>17</volume>:
                        <elocation-id>10.37394/23203.2022.17.60</elocation-id>
                        <fpage>549</fpage>-<lpage>556</lpage>
                        <pub-id pub-id-type="doi">10.37394/23203.2022.17.60</pub-id>
                    </mixed-citation>
                </ref>
                <ref id="rep-ref-242160-4">
                    <label>4</label>
                    <mixed-citation publication-type="journal">
                        <person-group person-group-type="author"/>:
                        <article-title>A low power transistor level FIR filter implementation using CMOS 45 nm technology</article-title>.
                        <source>
                            <italic>International Journal of Nanotechnology</italic>
                        </source>.<year>2023</year>;<volume>20</volume>(<issue>1/2/3/4</issue>) :
                        <elocation-id>10.1504/IJNT.2023.131120</elocation-id>
                        <fpage>390</fpage>-<lpage>409</lpage>
                        <pub-id pub-id-type="doi">10.1504/IJNT.2023.131120</pub-id>
                    </mixed-citation>
                </ref>
            </ref-list>
        </back>
    </sub-article>
    <sub-article article-type="reviewer-report" id="report208433">
        <front-stub>
            <article-id pub-id-type="doi">10.5256/f1000research.138442.r208433</article-id>
            <title-group>
                <article-title>Reviewer response for version 1</article-title>
            </title-group>
            <contrib-group>
                <contrib contrib-type="author">
                    <name>
                        <surname>Pagoti</surname>
                        <given-names>Sirish Kumar</given-names>
                    </name>
                    <xref ref-type="aff" rid="r208433a1">1</xref>
                    <role>Referee</role>
                    <uri content-type="orcid">https://orcid.org/0000-0002-5676-7185</uri>
                </contrib>
                <aff id="r208433a1">
                    <label>1</label>Department of ECE, Aditya Institute of Technology and Management, Srikakulam, Andhra Pradesh, India</aff>
            </contrib-group>
            <author-notes>
                <fn fn-type="conflict">
                    <p>
                        <bold>Competing interests: </bold>No competing interests were disclosed.</p>
                </fn>
            </author-notes>
            <pub-date pub-type="epub">
                <day>1</day>
                <month>11</month>
                <year>2023</year>
            </pub-date>
            <permissions>
                <copyright-statement>Copyright: &#x00a9; 2023 Pagoti SK</copyright-statement>
                <copyright-year>2023</copyright-year>
                <license xlink:href="https://creativecommons.org/licenses/by/4.0/">
                    <license-p>This is an open access peer review report distributed under the terms of the Creative Commons Attribution Licence, which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.</license-p>
                </license>
            </permissions>
            <related-article ext-link-type="doi" id="relatedArticleReport208433" related-article-type="peer-reviewed-article" xlink:href="10.12688/f1000research.126067.1"/>
            <custom-meta-group>
                <custom-meta>
                    <meta-name>recommendation</meta-name>
                    <meta-value>approve</meta-value>
                </custom-meta>
            </custom-meta-group>
        </front-stub>
        <body>
            <p>1. This paper presents a well-structured and highly efficient approach to 2-D finite impulse response (FIR) filter design, focusing on symmetry-based optimizations. The incorporation of various symmetries to minimize multipliers is a commendable strategy.</p>
            <p> </p>
            <p> 2. The utilization of distributed arithmetic (DA) and the dual-port memory-based lookup table (DP-MLUT) in multiplication is a noteworthy innovation. It not only reduces area and power consumption but also enhances the overall efficiency of the FIR filter.</p>
            <p> </p>
            <p> 3. The introduction of memory reuse and memory sharing methods is a clever technique to reduce the need for registers and, consequently, circuit complexity. This approach contributes significantly to the practicality of the proposed architectures.</p>
            <p> </p>
            <p> 4. The comparative results provided in the paper clearly demonstrate the advantages of the proposed architectures in terms of power, area, area delay product (ADP), and power delay product (PDP). These improvements are substantial and hold promise for a wide range of applications.</p>
            <p> </p>
            <p> 5. The synthesis results in a 45nm technology environment showcase the real-world applicability of the proposed architectures. The power and area savings, especially in the Quadrantal Symmetry Filter (QSF), are quite impressive.</p>
            <p> </p>
            <p> 6. The paper's conclusion emphasizes the suitability of the proposed filter architecture for applications with fixed coefficients. This insight into potential applications adds practical value to the research.</p>
            <p> </p>
            <p> 7. Overall, this paper offers a valuable contribution to the field of FIR filter design. The innovative approaches, clear presentation, and substantial improvements in efficiency make it a significant advancement in the area of signal processing.</p>
            <p>Is the work clearly and accurately presented and does it cite the current literature?</p>
            <p>Yes</p>
            <p>If applicable, is the statistical analysis and its interpretation appropriate?</p>
            <p>Yes</p>
            <p>Are all the source data underlying the results available to ensure full reproducibility?</p>
            <p>Yes</p>
            <p>Is the study design appropriate and is the work technically sound?</p>
            <p>Yes</p>
            <p>Are the conclusions drawn adequately supported by the results?</p>
            <p>Yes</p>
            <p>Are sufficient details of methods and analysis provided to allow replication by others?</p>
            <p>Yes</p>
            <p>Reviewer Expertise:</p>
            <p>Communication, signal processing, wireless networks, embedded system</p>
            <p>I confirm that I have read this submission and believe that I have an appropriate level of expertise to confirm that it is of an acceptable scientific standard.</p>
        </body>
    </sub-article>
</article>
