function rfft_(input, fftLength) {
    (0, _util.assert)(input.dtype === "float32", ()=>`The dtype for rfft() must be real value but got ${input.dtype}`);
    let innerDimensionSize = input.shape[input.shape.length - 1];
    const batch = input.size / innerDimensionSize;
    let adjustedInput;
    if (fftLength != null && fftLength < innerDimensionSize) {
        // Need to crop
        const begin = input.shape.map((v)=>0);
        const size = input.shape.map((v)=>v);
        size[input.shape.length - 1] = fftLength;
        adjustedInput = (0, _slice.slice)(input, begin, size);
        innerDimensionSize = fftLength;
    } else if (fftLength != null && fftLength > innerDimensionSize) {
        // Need to pad with zeros
        const zerosShape = input.shape.map((v)=>v);
        zerosShape[input.shape.length - 1] = fftLength - innerDimensionSize;
        adjustedInput = (0, _concat.concat)([
            input,
            (0, _zeros.zeros)(zerosShape)
        ], input.shape.length - 1);
        innerDimensionSize = fftLength;
    } else adjustedInput = input;
    // Complement the input with zero imaginary numbers.
    const zerosInput = (0, _zerosLike.zerosLike)(adjustedInput);
    const complexInput = (0, _reshape.reshape)((0, _complex.complex)(adjustedInput, zerosInput), [
        batch,
        innerDimensionSize
    ]);
    const ret = (0, _fft.fft)(complexInput);
    // Exclude complex conjugations. These conjugations are put symmetrically.
    const half = Math.floor(innerDimensionSize / 2) + 1;
    const realValues = (0, _real.real)(ret);
    const imagValues = (0, _imag.imag)(ret);
    const realComplexConjugate = (0, _split.split)(realValues, [
        half,
        innerDimensionSize - half
    ], realValues.shape.length - 1);
    const imagComplexConjugate = (0, _split.split)(imagValues, [
        half,
        innerDimensionSize - half
    ], imagValues.shape.length - 1);
    const outputShape = adjustedInput.shape.slice();
    outputShape[adjustedInput.shape.length - 1] = half;
    return (0, _reshape.reshape)((0, _complex.complex)(realComplexConjugate[0], imagComplexConjugate[0]), outputShape);
}
Real value input fast Fourier transform.

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

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

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

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