Skip to content

rifft

Complex-to-real Inverse Fast Fourier Transform.

Applies an Inverse Fast Fourier Transform to a complex-value input 1-dimensional array producing a real-valued output. The output is another array containing the real-valued signal. The k-rate input expects a packed input (see rfft).

The Complex-array version, on the other hand, expects an array size that is one unit longer than the output (output size + 1 complex numbers), containing the Nyquist frequency coefficient in the last position of the Complex array.

Non-power-of-two transforms are limited to even sizes with not too many factors.

Syntax

out:k[] = rifft(in:k[])
out:k[] = rifft(in:Complex[])    

kout[] rifft kin[]
kout[] rifft in:Complex[]

Performance

out -- output array containing the real-valued output. It will be created if it does not exist.

in -- input array containing the complex input.

Examples

Here is an example of the rifft opcode. It uses the file irfft.csd.

Example of the rifft opcode.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
<CsoundSynthesizer>

<CsOptions>
-d -o dac
</CsOptions>

<CsInstruments>
;ksmps needs to be an integer div of hopsize 
ksmps = 64

instr 1

 ihopsize = 256   ; hopsize
 ifftsize = 1024  ; FFT size 
 iolaps = ifftsize/ihopsize ; overlaps
 ibw = sr/ifftsize ; bin bandwidth
 kcnt init 0    ; counting vars
 krow init 0

 kOla[] init ifftsize ; overlap-add buffer
 kIn[] init ifftsize  ; input buffer
 kOut[][] init iolaps, ifftsize ; output buffers

 a1 diskin2 "fox.wav",1,0,1 ; audio input

 /* every hopsize samples */
 if kcnt == ihopsize then  
   /* window and take FFT */
   kWin[] window kIn,krow*ihopsize
   kSpec[] rfft kWin

   /* filter between high and low freqs */
   ilow = 0
   ihigh = 1000
   ki = int(ilow/ibw)
   until ki == int(ihigh/ibw) do
     kSpec[ki] = 0
     ki += 1
   od

   /* IFFT + window */
   kRow[] rifft kSpec
   kWin window kRow, krow*ihopsize
   /* place it on out buffer */
   kOut setrow kWin, krow

   /* zero the ola buffer */
   kOla = 0
   /* overlap-add */
   ki = 0
   until ki == iolaps do
     kRow getrow kOut, ki
     kOla = kOla + kRow
     ki += 1
   od

  /* update counters */ 
  krow = (krow+1)%iolaps
  kcnt = 0
 endif

 /* shift audio in/out of buffers */
 kIn shiftin a1
 a2 shiftout kOla
    out a2/iolaps

 /* increment counter */
 kcnt += ksmps

endin

</CsInstruments>

<CsScore>
i1 0 10
</CsScore>

</CsoundSynthesizer>

Another example of the rifft opcode, now using a Complex-type array. It uses the file rfft_complex_type.csd.

Example of the rfft opcode (Complex array.
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<CsoundSynthesizer>
<CsOptions>
-odac
</CsOptions>
<CsInstruments>
ksmps = 1024 // sets transform size
nchnls = 1
0dbfs = 1

instr 1
 Params:i[] = array(p4, p5)
 Audio:k[] = array(oscili(Params[0],Params[1]))
 Spec:Complex[] = rfft(Audio)
 Wave:k[] = rifft(Spec)
 out a(Wave)
endin
schedule(1,0,2,0.5,440)
event_i("e",0,2)

</CsInstruments>
<CsScore>
</CsScore>
</CsoundSynthesizer>

See Also

Vectorial opcodes

array opcodes

Array-based spectral opcodes

Credits

Author: Victor Lazzarini
NUI Maynooth
2014, 2025

New in version 6.04
Complex type introduced in version 7.