function irfft_(input) {
    const innerDimensionSize = input.shape[input.shape.length - 1];
    const batch = input.size / innerDimensionSize;
    let ret;
    if (innerDimensionSize <= 2) {
        const complexInput = (0, _reshape.reshape)(input, [
            batch,
            innerDimensionSize
        ]);
        ret = (0, _ifft.ifft)(complexInput);
    } else {
        // The length of unique components of the DFT of a real-valued signal
        // is 2 * (input_len - 1)
        const outputShape = [
            batch,
            2 * (innerDimensionSize - 1)
        ];
        const realInput = (0, _reshape.reshape)((0, _real.real)(input), [
            batch,
            innerDimensionSize
        ]);
        const imagInput = (0, _reshape.reshape)((0, _imag.imag)(input), [
            batch,
            innerDimensionSize
        ]);
        const realConjugate = (0, _reverse.reverse)((0, _slice.slice)(realInput, [
            0,
            1
        ], [
            batch,
            innerDimensionSize - 2
        ]), 1);
        const imagConjugate = (0, _mul.mul)((0, _reverse.reverse)((0, _slice.slice)(imagInput, [
            0,
            1
        ], [
            batch,
            innerDimensionSize - 2
        ]), 1), (0, _scalar.scalar)(-1));
        const r = (0, _concat.concat)([
            realInput,
            realConjugate
        ], 1);
        const i = (0, _concat.concat)([
            imagInput,
            imagConjugate
        ], 1);
        const complexInput = (0, _reshape.reshape)((0, _complex.complex)(r, i), [
            outputShape[0],
            outputShape[1]
        ]);
        ret = (0, _ifft.ifft)(complexInput);
    }
    ret = (0, _real.real)(ret);
    // reshape the result if the input is 3D tensor.
    if (input.rank === 3 && input.shape[0] !== 0) {
        const temp = ret;
        const batch = input.shape[0];
        ret = (0, _reshape.reshape)(ret, [
            batch,
            ret.shape[0] / batch,
            ret.shape[1]
        ]);
        temp.dispose();
    }
    return ret;
}
Inversed real value input fast Fourier transform.

Computes the 1-dimensional inversed discrete Fourier transform over the
inner-most dimension of the real input.

```js
const real = tf.tensor1d([1, 2, 3]);
const imag = tf.tensor1d([0, 0, 0]);
const x = tf.complex(real, imag);

x.irfft().print();
```
@param input The real value input to compute an irfft over.

@doc {heading: 'Operations', subheading: 'Spectral', namespace: 'spectral'}