VECTOR SLOT PROCESSOR FOR HIGH SPEED STREAMING INPUTS BACKGROUND Technical Field [0001] The embodiments herein generally relate to a vector slot processor, and, more particularly, to a vector slot processor that is capable of performing multiple signal processing operations of finite impulse response filters, decimators, interpolators and cubic polynomial based waveform interpolations for high speed streaming inputs. Description of the Related Art [0002] In digital communication systems, it is essential to convert an incoming intermediate frequency (IF) signal to a baseband signal before further processing. In addition, the baseband signal needs to be filtered before processing any symbol. This is very computationally intensive, especially if the incoming stream of samples is at a high speed. Current application specific hardwired architectures typically support single or very few demodulation standards. This becomes extremely challenging for a software defined radio (SDR) platform that supports multiple demodulation standards. Typical digital signal processing (DSP) CPUs do not provide an optimized and scalable solution that caters to all data rates. [0003] A demodulation chain of any digital communication receiver typically includes a first section where the intermediate frequency (IF) signal is digitized after receiving it from a tuner using an analog to digital converter (ADC). This digitized signal can be optionally converted to baseband. When there is a need to cater to a specific demodulation receiver, the design features are supported which is optimized for a combination of sample rates (as obtained from ADC) and required symbol rates. Such design features are inflexible and not scalable for higher sampling rates or multiple input streams as is the case for multiple-input and multiple-output (MIMO) communication systems. SUMMARY [0004] In view of the foregoing, an embodiment herein provides a vector slot processor that is capable of supporting multiple signal processing operations for multiple demodulation standards. The vector slot processor includes a plurality of Micro Execution Slot (MES) that performs the multiple signal processing operations on high speed streaming inputs. Each of the plurality of MES includes (i) one or more n-way signal registers that receive the high speed streaming inputs, (ii) one or more n-way coefficient registers that store filter coefficients for the multiple signal processing, and (iii) one or more n-way Multiply and Accumulate (MAC) units. A n-way Multiply and Accumulator (MAC) unit (a) receives the high speed streaming inputs from the one or more n-way signal registers, (b) receives the filter coefficients from the one or more n-way coefficient registers and (c) performs a vertical MAC (VRMAC) operation and a horizontal multiply and add (HRMAD) operation. Each of the plurality of MES may further includes (i) one or more n-way extended precision accumulators (ACCs) that receive and store an output of the n-way MAC unit and (ii) one or more n-way scaled accumulators (SACCs) that receives data from the one or more n-way ACCs and stores the data after performing a scale-down operation and a rounding operation on the data. [0005] The one or more n-way signal registers includes a programmable switch that controls a left shift operation of the high speed streaming inputs across the plurality of MES simultaneously. The multiple signal processing operations may include (i) a filtering operation, (ii) a down-sampling operation, (iii) an up-sampling operation, (iv) a waveform interpolation operation, (v) a cross-correlation and (vi) an auto-correlation operation. The one or more n-way signal registers and the one or more n-way coefficient registers may perform an indexing operation that enables each of the one or more n-way signal registers and the one or more n-way way coefficient registers to be used as a scalar register as well as a vector register. A width of the one or more n-way signal registers and a width of the one or more n-way coefficient registers may be scaled with the one or more n-way Multiply and Accumulate (MAC) units. The width of the one or more n-way signal registers and the one or more n-way coefficient register may be extendible based on a number of the plurality of MES. [0006] The vector slot processor may further include a plurality of buffer registers that are interconnected with the one or more n-way signal registers and across the plurality of MES using a programmable interconnection. In one embodiment, a vector instruction for the vector slot processor is stored in a program memory of a CPU. The plurality of MES may include a first MES that executes a first operand of the vector instruction and a second MES that executes a second operand of the vector instruction concurrently. In another embodiment, a format of the vector instruction includes a field that stores a programmable binary value. A clock of the plurality of MES is disabled or enabled based on the programmable binary value. [0007] These and other aspects of the embodiments herein will be better appreciated and understood when considered in conjunction with the following description and the accompanying drawings. It should be understood, however, that the following descriptions, while indicating preferred embodiments and numerous specific details thereof, are given by way of illustration and not of limitation. Many changes and modifications may be made within the scope of the embodiments herein without departing from the spirit thereof, and the embodiments herein include all such modifications. BRIEF DESCRIPTION OF THE DRAWINGS [0008] The embodiments herein will be better understood from the following detailed description with reference to the drawings, in which: [0009] FIG. 1 illustrates an architecture of a CPU subsystem with a vector slot processor, having K- Micro execution slots each of N-ways according to an embodiment herein; [0010] FIG. 2 illustrates an exploded view of the vector slot processor of FIG. 1 having a programmable switch showing a shift path of a N-way signal register with K/2 buffer registers, when a number of micro execution slots is equal to 8 according to an embodiment herein; [0011] FIG. 3 illustrates a vector instruction format of the vector slot processor of FIG. 1 according to an embodiment herein; [0012] FIG. 4 illustrates a vertical MAC operation for 8-way micro execution slots according to an embodiment herein; [0013] FIG. 5 illustrates horizontal multiply and add operations across 8 MESs according to an embodiment herein; [0014] FIG. 6 is a block diagram illustrating generation of polynomial interpolation coefficients using the MES of FIG. 1 according to an embodiment herein; [0015] FIG. 7 illustrates a layout of CPU control registers according to a first embodiment herein; [0016] FIG. 8 illustrates a layout of CPU control registers according to a second embodiment herein; [0017] FIG. 9 illustrates a connectivity of signal and buffer registers via programmable switches for FIR filtering according to an embodiment herein; [0018] FIG. 10 illustrates a programmable switch connectivity for two 3x interpolation filters according to an embodiment herein; [0019] FIG. 11 illustrates a programmable switch connectivity for two 4x interpolation filters according to an embodiment herein; [0020] FIG. 12 illustrates a programmable switch interconnection for one 6x Interpolation filter according to an embodiment herein; [0021] FIG. 13 illustrates a programmable switch interconnection for one 8x interpolation filter according to an embodiment herein; [0022] FIG. 14 illustrates a graphical representation of a waveform interpolation according to an embodiment herein; [0023] FIG. 15 is a flow diagram illustrating waveform interpolation using a cubic polynomial coefficient generator according to an embodiment herein; [0024] FIG. 16 illustrates an allocation of waveform interpolation on micro execution slots in the vector slot processor according to an embodiment herein; [0025] FIG. 17 illustrates an exploded view of a receiver having an a memory having a set of computer instructions, a bus, a display, a speaker, and a processor capable of processing the set of computer instructions to perform any one or more of the methodologies herein, according to an embodiment herein. DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS [0026] The embodiments herein and the various features and advantageous details thereof are explained more fully with reference to the non-limiting embodiments that are illustrated in the accompanying drawings and detailed in the following description. Descriptions of well-known components and processing techniques are omitted so as to not unnecessarily obscure the embodiments herein. The examples used herein are intended merely to facilitate an understanding of ways in which the embodiments herein may be practiced and to further enable those of skill in the art to practice the embodiments herein. Accordingly, the examples should not be construed as limiting the scope of the embodiments herein. [0027] There remains a need for implementing multiple signal processing operations such as (i) a filtering operation, (ii) a down-sampling operation, (iii) an up-sampling operation, (iv) a waveform interpolation operation, (v) a cross-correlation and (vi) an auto-correlation operation for high speed streaming inputs. The embodiments herein achieve this by providing a flexible, scalable vector slot processor is capable of receiving and processing the high speed streaming inputs from the ranges from Mega Samples per second to Giga samples per second. Referring now to the drawings, and more particularly to FIGS. 1 through 17, where similar reference characters denote corresponding features consistently throughout the figures, preferred embodiments are described herein. The vector slot processor includes one or multiple micro execution slots (MES). Each micro execution slot in turn includes one or more Multiply & Accumulate (MAC) units. [0028] A number of micro execution slots as well as a number of multipliers or MACs for each micro execution slot can be chosen based on an input sample rate that is to be processed, as well as a required output symbol rate. The number of multipliers or MACs present in a micro execution slot may be matched by the same number of signal registers (Dsx) and coefficient registers (Dcx). The signal registers may act as elements which are used for computation as well as for storage. In addition, each MES may include a same number of extended precision accumulators (ACC) and a same number of scaled accumulators (SACC) as a number of MACs. In one embodiment, a bit width of an extended precision accumulator is equal to 40, and it can be determined by the target application. [0029] FIG. 1 illustrates an architecture 100 of a CPU subsystem with a vector slot processor 108 having K- Micro execution slots 110 each of N-ways according to an embodiment herein (where the K>=1 and N>=1). Each of the K-Micro execution slots 110 includes a N-way Multiply & Accumulate (MAC) units 102, N-way signal registers 104, N-way coefficient registers 106, a N-way extended precision accumulator (ACC) 112, and a N-way scaled accumulator (SACC) 114. The vector slot processor 108 may include one or more K/2 buffer registers 116 having an equivalent width of N-ways each and the K/2 buffer registers 116 are interconnected with the N-way signal registers 104 and across the MES 110 using a programmable interconnection. The CPU subsystem includes a program memory that stores vector instructions for vector slot processor 108. The N-way signal registers 104 receives high speed streaming input for multiple signal processing and the N-way Multiply & Accumulate (MAC) units 102 perform (a) a vertical MAC (VRMAC) operation and (b) a horizontal multiply and add (HRMAD) operation on the high speed streaming inputs. The N-way coefficient registers 106 stores the filter coefficients for the multiple signal processing operations. [0030] In one embodiment, a width of the N-way signal registers 104 and a width of the N-way coefficient registers 106 may be scaled with the N-way multiply and Accumulate (MAC) units 102. The width of the N-way signal registers 104 and the N-way coefficient registers 106 may be extendible based on the K-MES 110. The N-way signal registers (Dsx) and the N-way coefficient registers (Dcx) are vector registers and have individual indexes from 1 to N inside the K-MES 110. Therefore each N-bit slice for a given K-MES 110 is also represented as Dsx[l][K], Dsx[2][K],Dsx[3][K],....upto Dsx[N][K] and Dcx[l][K], Dcx[2][K],Dcx[3][K],....upto Dcx[N][K]. Scalar instructions ADD, SUB in the vector slot may use these individual N-bit slices for performing the required operations and that enables the signal registers 104 and the coefficient registers 106 to be used as both a scalar register and a vector register. The vector slot processor 108 enables a single instruction to work on different operands in different MESs 110 at the same time. The MES 110 also includes the N-way extended precision Accumulators (ACC) 112 that receives and stores of the N-way MAC units 102 and the N-way scaled accumulators (SACC) 114 that receives from N-way ACC and stores the data after performing a scale-down operation and a rounding operation on the data. [0031] For an N-way configuration, the N slices within the signal register 104 can be left-shifted simultaneously in conjunction with multiply and accumulate functions or multiply and add functions. If the vector slot processor 108 has K - Micro execution slots (MESs) 110 then additional K/2 buffer registers (Dix) 116 are provided. The K/2 buffer registers (Dix) 116 are used for pre-loading of the high speed streaming inputs, so that there is no cycle lost when the signal registers 104 are left shifted inside a tight kernel. Each of the signal registers 104 inside the MES 110 has a programmable switch (not shown in FIG. 1) which is used to control a left shift operation of the content across the K-MES 110 simultaneously which enables an efficient execution of the multiple signal processing filtering operations. [0032] FIG. 2 illustrates an exploded view 200 of the vector slot processor 108 having a programmable switch showing a shift path of the N-way signal register 104 of FIG. 1 with K/2 buffer registers 116 of FIG. 1, when a number of micro execution slots is equal to 8 according to an embodiment herein. The same scheme can be extended to the vector slot processor 108 having arbitrary number of micro execution slots. The programmable switches 202 are included in a micro execution slot 110. The switches (SW0, SWl ...SW10) are programmed using a CPU control register (not shown). In a typical implementation, both the parameters namely the number of micro execution slots as well as the number of multipliers or MACs for each micro execution slot can be chosen based on an input sample rate and a required output symbol rate. [0033] FIG. 3 illustrates a vector instruction format 300 of the vector slot processor 108 of FIG. 1 according to an embodiment herein. The instruction format 300 of vector slot processor 108 includes a bits per clock gating of micro execution slot field 302, a scaling offset field 304, a source src2_index / mode offset field 306, an opcode field 308, a slot identification field 310 and a parallel-serial bit field 312. The vector instructions have a K-bit predicated field corresponding to bit per clock gating of micro execution slot field 302 shown in the instruction definitions, which allows a programmer to disable or shut off the clocks to any of the K-Micro execution slots. The bit per clock gating of micro execution slot field 302 is a programmable binary value. [0034] A least significant bits in the instruction format is the "bits per Clock Gating of MES" field 302. Programming a "0" value in this field will shut off or disable at least one of the clocks of MES 110 and the binary value "1" will enable the one or more clocks of MES 110. This feature is used to shut off or disable an unused MES 110 in a specific kernel for saving power. However, this gating does not affect the interconnection path of the signal register 104 across multiple MES. The scaling offset field 304 is used in all arithmetic instructions for post-scaling the results. The source src2_index / mode offset field 306 is used for scalar addressing of coefficient registers within a MES for vertical MAC instructions (e.g., VRMACB and VRMACBsh). The source src2_index / mode offset field 306 is especially used for vertical multiply and horizontal multiply and add instructions. [0035] FIG. 4 illustrates a vertical MAC operation for 8-way micro execution slots according to an embodiment herein. This scheme can be extended for any arbitrary number (N-way) of Micro execution slots. The vertical MAC operations for N-way micro execution slots includes the N-way multiply and accumulate (MAC) units 102, the signal registers 104, the coefficient register 106, the scaled accumulators 114, the accumulators 112, and a vector accumulators (VACC) 402. The different possible vertical MAC instructions supported on the vector slot processor 108 having K-Micro Execution Slots (MES) are described as follows. The signal registers (Dsx) 104 and the coefficient registers (Dcx) 106 are implied sources in all these instructions. Assuming a Q.15 format is sufficient for source operands, the functions are described as follows: In a vertical multiply ([PRED] VRMUL #offset) mode, if (#offset = 0): This mode performs 16x16 multiplications slice-wise. Assume, each N slice of 16 bit is computed from the Dsx 104 and the Dcx 106 per MES in accordance with the following relation: ACC[n][31:0] <= {Dsx[n][15:0] * Dcx[n][15:0]}. The intermediate result is sign-extended to an extended precision of 40 bits and updated in the accumulator (ACC) 112 pertaining to each slice. A rounding operation is performed on the contents of the accumulators 112 and is updated in the destination SACC 114 or general purpose register in a regfile). SACC[n][15:0] = Round {ACC[n][39:0] for n=0 to N.}. All the N-slices of the SACC 114 and the ACC 112 get updated. If (#offset =1): then the mode performs 32x16 multiplications slice-wise. In this instruction, the MES is to be divided into N/2 slices. Each of N/2 slices generate an intermediate 48 bits result by multiplying 32 bits obtained by combining 2 slices of the Dsx 104 and 16 bits from the Dcx 106. This is rounded down to 32 bits and then stored into the accumulator 112 of the lower slice (i.e., n = 0, 1,2, 3 ... N/2 of the corresponding MES). The 16 bits second source is present in the Dcx 106 in the alternate slices 0, 2, 4, and 6. Hence, the result is computed in accordance with the following relation: ACC[n][31:0] <= Round {Dsx[n][31:0] * Dcx[n][15:0]}. In this case, the intermediate result is assumed to be in a Q.47 format and scaled down with rounding to a Q.31 format. A scaled accumulator pair or a 32 bits destination general Purpose Register is updated with the same value as the ACC 112. Hence, SACC [n: n+l][31:0] = ACC[n][31:0]. All the N slices of the SACC 114 and the ACC 112 get updated. Individual SACC's 114 or ACC's 112 get updated in the respective MES's, if the operations are enabled. [0036] The vertical multiply and accumulate function (VRMAC) performs slice-wise multiplication and accumulation for each of the 16 bit slices per MES. Each slice of 16 bit is computed from the Dsx 104 and the Dcx 106 in accordance with the following relation: ACC(new)[n][39:0]<=(Dsx[n][15:0]*Dcx[n][15:0])+ACC(previous)[n][39:0]; SACC[n][15:0] <= Round {ACC(new)[n][39:0]}. In the above equation, the ACC 112 is the accumulator per slice of each MES. The contents of the scaled accumulator 114 are subsequently added and the summation value VACC 402 is generated. This is stored back in ACC 112 to be used for further processing. [0037] A Vertical MAC with a broadcasted Coefficient function ([PRED] VRMACB src2_index) is similar to the vertical multiply and accumulate (VRMAC) excepting that the Dcx 106 value used is the same across all the N slices/per MES for all operations and equal to the slice number pointed by the srcindex i.e. Dcx [src2_index]. Each slice of 16bit is computed using Dsx and Dcx [src2_index] as follows: ACC(new)[n][39:0] <= (Dsx[n][15:0] * Dcx[src2_index]) + ACC(previous)[n][39:0] SACC[n][15:0] <= Round {ACC(new)[n][39:0} In the above equation, the ACC 112 is the accumulator per slice and the SACC 114 is the scaled accumulator per slice of each MES. The contents of the scaled accumulator are subsequently added and the summation value VACC 402 is generated. This is stored back in the ACC 112 to be used for further processing. [0038] The Vertical MAC with broadcasted coefficient and sample shift function ([PRED] VRMACB src2_index) instruction performs the same operation as VRMACB and the results are the contents of the ACC 112 and the SACC 114. In addition to the operation in VRMACB, this instruction performs the additional function of replacing the Dsx 104 contents by a sample (i.e. 16 bit) left shifted version of the Dsx (having N- slices). The Dsx 104 register moves uniformly across all the N-MESs based on an interconnect programmed in the CPU control register. [0039] FIG. 5 illustrates a horizontal multiply and add operations ([PRED] HRMAD #offset) across 8 MESs according to an embodiment herein. This scheme can be extended for any arbitrary number (N-way) of Micro execution slots. The horizontal multiply and add across 8 MESs includes the signal register 104, the coefficient register 106, the accumulator 112, the scaled accumulator 114, and a rounding operation block 502. In the horizontal multiply and add mode, if (#offset = 0), then this mode performs slice-wise multiplication per MES and adds the results. Assuming, each of the N slices of 16 bit from the signal register (Dsx) 104 and the coefficient register (Dcx) 106 is used for computation as follows: ACC [N*n][39:0] <= £{Sum over all N slices}(Dsx[n][15:0] * Dcx[n][15:0]). Hence this operation is referred as horizontal accumulation. The scaled accumulator 114 contains the 16 bits results per slice as per the following relation: SACC [N*n][15:0] <= Round {ACC[N*n] [39:0]}. The accumulator 112 and scaled accumulator 114 registers mentioned above are on a per slice basis (for each MES).} If (#offset = 1): this mode performs slice-wise 32x16 multiplications, rounds the intermediate result back to 32 bits and then adds them. In this instruction, the MES is to be divided into N/2 slices. Each of N/2 slices generate an intermediate 48 bit result by multiplying 32 bits obtained by combining 2 slices of the Dsx 104 and 16 bits from the Dcx 106. This is rounded down to 32 bits using the rounding operation block 502 and then stored into the accumulator (ACC) 112 of a lower slice. Hence the result is computed in accordance with the following relation: ACC[n][31:0] <= Round {Dsx[n][31:0] * Dcx[n][15:0]}. In this case, the intermediate result is assumed to be in a Q.47 format and scaled down with rounding 502 to a Q.31 format. The scaled accumulator (SACC) 114 is updated with the same value as the ACC 112. Hence, SACC [n:n+l][31:0] = I{Sum over all N/2 slices}ACC[n][31:0]. All the N/2- SACC pairs and the ACC 112 get updated. Individual SACC's 114 or ACC's 112 get updated in the respective MES's if the operations are enabled using the predication field. [0040] The horizontal multiply and add with shift ([PRED] HRMAD #offset) is similar to the HRMAD instruction and the results are the contents of the ACC 112 and the SACC 114. In addition to the above, these instructions perform the additional function of replacing the Dsx 104 contents by a one sample (16 bits) shifted version, or a two sample shifted or a four sample shifted version of the Dsx 104 (having N-samples). The Dsx 104 moves uniformly across all the N-MESs based on the programmed interconnect in the CPU control register. The vector shift instruction ([PRED] VSHL #offsetl) is used to shift the contents of the Dsx 104 (Signal registers) by one sample (16bits), two samples (32bits) or four samples (64bits). The two bits #offset field specifies the shift accordingly: #offsetl = 2'bOO => Shift by 16bits, #offsetl = 2'b01, => Shift by 32bits, #offsetl = 2'blO => Shift by 64 bits. [0041] The result of instructions (i) VRMUL, (ii) VRMAC, (iii) VRMACB, (iv) VRMACBsh, (v) HRMAD, (vi) HRMADsh, (vii) HRMADsh2 and (viii) HRMADsh4 is a 40 bit value and stored in an extended precision accumulator (ACC) 112. Scaled accumulators (SACC) 114 receives the 40 bit value from the accumulators (ACC) 112 and perform a scale-down operation and a rounding operation based on an immediate scaling offset using simple arithmetic rounding or convergent rounding to 16-bits. The below example shows what is extracted from the extended precision accumulator (ACC) 112 for different values of scaling offset field for some representative values. The possible value of the 5-bit scaling offset field is from 0 to 24. Assume that the accumulator result before doing this scale down operation is operation is represented as {s.g7_g6_g5_g4_g3_g2_gl_g0_f0_fl_f2_f3_...._G0} scaling offset field = 0; Rx = {S.[g7_g6_g5_g4_g3_g2_gl_g0_f0_fl_f2_f3_f4_f5_f6]}; scaling offset field = 1; Rx = {S.[g6_g5_g4_g3_g2_gl_g0_f0_fl_f2_0_f4_f5_f6_f7]}; scaling offset field = 2; Rx = {S.[g5_g4_g3_g2_gl_g0_f0_fl_f2_f3_f4_f5_f6_f7_f8]}; similarly values can be derived for other offset values also. scaling offset field = 7; Rx = {s.[g0_f0_fl_f2_D_f4_f5_f6_f7_f8_f9_fl0_fl I_fl2_fl3]}; scaling offset field = 8; Rx = {S.[f0_fl_0_fi_f4_f5_f6_f7_f8_f9_fl0_fl I_fl2_fl3_fl4]}; scaling offset field = 9; Rx = {S.[f1_f2_f3_f4_f5_f6_f7_f8_f9_fl0_f11_fl2__fl4_f15]}; scaling offset field = 24; Rx = {S.[fl6_fl7_fl8_fl9_f20_f21_f22_f23_f24_f25_f26_f27_f28_f29_f30]}; The notation [ ] means that the 16 bit-value finally stored in destination SACC 114 is rounded depending the contents of discarded Least Significant Bits (LSB's) from the extended precision accumulator (ACC) 112 and depending on whether convergent or arithmetic rounding is performed. The final result should be saturated if there is an overflow in the higher significant bits. [0042] FIG. 6 is a block diagram illustrating generation of polynomial interpolation coefficients using the MES 110 of FIG. 1 according to an embodiment herein. MES 110 includes one or more multipliers 602, and one or more adders 604 which are reused in different cycles to perform the function. The cubic polynomial basis equation instruction ([PRED] PolyCoeffGen #offset(2bit), Dcx) is used to generate one or more coefficients (e.g., four coefficients) corresponding to cubic polynomial basis equations which are required for waveform interpolation. The input argument "frac" is present in the lower 16 bits of an Rsrc register and is indicated using the #offset (2bits). The equations corresponding to the different basis equations are as follows, CO = (a4+ a3*frac+a2*fracA2 + al *fracA3) (1) CI = (b4+ b3*frac+b2*fracA2 + bl *fracA3) (2) C2 = (c4+ c3*frac+c2*fracA2 + cl *fracA3) (3) C3 = (d4+ d3*frac+d2*fracA2 + dl *fracA3) (4) The Coefficients a4, a3, a2, al, b4, b3, b2, bl, c4, c3, c2, cl, d4, d3, d2, dl are stored as Q.15 formatted numbers in the CPU Control Registers. The outputs generated are stored in the destination register as follows in the Dcx. C0=Dcx [0]; Cl=Dcx[l]; C2 =Dcx[2]; C3 = Dcx[3]. [0043] The remaining Dcx are cleared to zeros. This above instruction completes in four cycles. These operations are non-pipelined. The destination of this instruction is Dcx which is the coefficient register. Basic equations of the cubic polynomials used for Interpolation are as follows: PI =al*x[0]+bl*x[l]+cl*x[2]+dl*x[3] (1) P2 = a2*x[0]+b2*x[l]+c2*x[2]+d2*x[3] (2) P3 = a3*x[0]+b3*x[l]+c3*x[2]+d3*x[3] (3) P4 = a4*x[0]+b4*x[l]+c4*x[2]+d4*x[3] (4) Y[n] = P4 + frac* (P3 + frac * (P2 + frac * PI); (5) Substituting PI, P2, P3 and P4 in the above equation (5), the resultant equations are follows: Y[n] = (a4+ a3*frac+a2*fracA2 + al *fracA3)*x[0] + (b4+ b3*frac+b2*fracA2 + bl*fracA3)*x[l] + (c4+ c3*frac+c2*fracA2 + cl*fracA3)*x[2] + (d4+ d3*frac+d2*fracA2 + dl*fracA3)*x[3]. Hence, the required coefficients are of the form: C[0] = (a4+ a3*frac+a2*fracA2 + al*fracA3) C[l] = (b4+ b3*frac+b2*fracA2 + bl*fracA3) C[2] = (c4+ c3*frac+c2*fracA2 + cl*fracA3) C[3] = (d4+ d3*frac+d2*fracA2 + dl*fracA3) [0044] The generation of polynomial interpolation coefficients in the MES 110 makes use of two multipliers 602 and one adder 604 to complete the operation in four cycles. In one embodiment, the operation is non-pipelined as there is no need to generate coefficients at a constant rate most of the times. However, a pipelined operation can be easily crafted using similar techniques. In addition to the above, the vector slot processor 108 implements vector addition, vector subtraction, vector minus scalar and vector plus scalar operations. The vector slot processor 108 also allows purely scalar operations such as scalar addition, scalar subtraction, extraction, left shift and sign extended right shift. [0045] FIG. 7 illustrates a layout 700 of the CPU control registers according to a first embodiment herein. The layout of the CPU control registers is used for programmable switch interconnection control for shifting the samples of the signal register 104. In this example, eight MESs 110 are shown. There are eight switches for each of the eight MESs 110 and three additional switches for the additional buffer registers. [0046] FIG. 8 illustrates a layout 800 of CPU control registers according to a second embodiment herein. The layout 800 of the CPU control registers is used for programming the polynomial coefficients (a4, a3, a2, al, b4, b3, b2, bl, c4, c3, c2, cl, d4, d3, d2, dl), which are stored as Q. 15 formatted numbers. This is done by using eight CPU control registers. [0047] A pseudo code of FIR filtering for a first method according to an embodiment herein, is shown below for (n=0, n < K, n+=kdelta) for (k=0; k < N; k+=N_delta) { output [n] += coef[k] * input [n+k] + coef[k+l] * input [n+k+1] + coef[k+2]*input[n+k+2] + .... output [n+1] 4= coef[k] * input [n+k+1] + coef[k+l] * input [n+k+2] + coef[k+2]*input[n+k+3] +.... output [n+2] += coef[k] * input [n+k+2] + coef[k+l] * input [n+k+3] + coef[k+2]*input[n+k+4] +.... output [n+kdelta-1] += coeffk] * input [n+k+kdelta-1] + coef[k+l] * input [n+k+kdelta] + coef[k+2]*input[n+k+kdelta+l] +.... } The above first method is used if the number of tap coefficients are less than or equal to K x N (i.e., product of number of micro-execution slots and number of MACs per micro execution slot). All the different coefficients are loaded completely into the Dcx (Coefficient Register) of N-MAC units per MES. Once the coefficients are loaded they need not be reloaded for different cycles. Now, the signal register 104 are loaded initially to start with and subsequently shifted concurrently with the completion of each horizontal multiply and add operation (HRMAD instruction). The outputs of the horizontal multiply and additions are summed up to generate a single filter output per cycle. This operation is performed in a software pipelined loop to obtain a block of data which is subsequently stored into a memory. [0048] A pseudo code of FIR filtering for a second method according to an embodiment herein, is shown below. for (n=0, n < K, n+=kdelta) for(k=0;k