Inverse DFT: Is there a valid / intuitive interpretation of results for non-integral timestamps? I implemented the plain DTF / inverse DFT algorithm in C++ in order to help me understand the method. As a sample input I considered
f(x) = sin( x * PI / 5 )
and collected samples for x = 0, ..., 9. So my input data was (0, 0.58778, 0.951057, ...).
Computing the DFT formula gives two non-zero coefficients: c_1 = (0 - 5i) and  c_9 = (0 + 5i).
Now, I compute the inverse DFT. For x=1, these coefficients multiplied with their basis functions give
(1/10) * exp( 2 * PI * i * 1/10 ) * (0 - 5i) = (0.293893, -0.404508i)
and
(1/10) * exp( 2 * PI * i * 9/10 ) * (0 + 5i) = (0.293893, 0.404508i)
respectively which is correct as the real parts sum up to 0.58778 (thus, reconstructing the input value) and the imaginary parts sum up to 0.  This works great for integral timestamps x=0, 1, 2, ...
My question: ... but how to interpret the results if I plug in x=0.5 (result 0.000000 - 0.951057i) or x=1.5 (result 0.000000 - 0.587785i) for example? I see that it is not DFT's promise to provide a good interpolation here. But is there an intuitive interpretation?  (Came across this because I wanted to plot the DFT/IDFT result as a time-continuous graph and don't know how to deal with the complex results between)
EDIT
I add my C++ code here:
void dft( const std::vector&lt;double&gt; &amp; vInput, std::vector&lt; std::complex&lt;double&gt; &gt; &amp; vCoeff )
{
    const std::complex&lt;double&gt; i( 0., 1. );

    const int nElem = vInput.size();

    vCoeff = std::vector&lt; std::complex&lt;double&gt; &gt;( nElem, std::complex&lt;double&gt;(0., 0.) );

    for( int k = 0; k &lt; nElem; ++k )
    {
        for( int j = 0; j &lt; nElem; ++j )
        {
            vCoeff[k] += exp( -2. * M_PI * i * std::complex&lt;double&gt;( j, 0. ) * std::complex&lt;double&gt;( (double)k / nElem, 0. ) ) * vInput[j];
        }
    }
}

std::complex&lt;double&gt; inverseDft( const std::vector&lt; std::complex&lt;double&gt; &gt; &amp; vCoeffs, const double t )
{
    std::complex&lt;double&gt; result( 0., 0. );
    const std::complex&lt;double&gt; i( 0, 1 );
    const int nElem = vCoeffs.size();

    for( int j = 0; j &lt; nElem; ++j )
    {
        result += vCoeffs[j] * exp( 2. * M_PI * i * std::complex&lt;double&gt;( j, 0. ) * std::complex&lt;double&gt;( t / nElem, 0. ) );
    }

    return (result / nElem);
}

This is how I define my input:
std::vector&lt;double&gt; vInput;

for( int i = 0; i &lt; 10; ++i )
{
    vInput.push_back ( sin( i * M_PI / 5 ) );
}

And this is the output I did not expect for t=0.5, t=1.5, etc.:
inverseDft( vCoeffs, 0. );  // okay (0.000000, -0.000000)
inverseDft( vCoeffs, 0.5 ); // ?? (0.000000, -0.951057)
inverseDft( vCoeffs, 1. );  // okay (0.587785, -0.000000)
inverseDft( vCoeffs, 1.5 ); // ?? (0.000000, -0.587785)

EDIT2
Great to have these expert answers here!  I can contribute the 3D plot which supports my intuition and therefore might also be helpful for others. It shows f(t) computed by IDFT and how it travels over the original data points (crosses). In order to achieve this, it makes use of the whole space including the complex plane.
Andy Walls provided the answer with the direct interpretation of an N-point inverse DFT with fractional time stamps. However, there is a slighty different (or totally should I've said) interpretation of a non-integer IDFT argument, which reduces to a good interpolation formula from the inverse DFT.
Consider the notation with $N,M,k,n$ being integers.
$$x_i[n] = \frac{1}{N} \sum_{k} X[k] \cdot e^{ j \frac{2\pi}{N} k (n) } \tag{0} $$
Lets say Eq.0 is a valid inverse DFT for some N-point $X[k]$, and results in a sequence $x_i[n]$, we ask what happens if we evaluate the sum at $n = n/M$; i.e., can we also plug $n/M$ into RHS $x_i[n]$ as given by Eq.1 below ?
$$x_i[n/M] = \frac{1}{N} \sum_{k} X[k] \cdot e^{ j \frac{2\pi}{N} k (n/M) } \tag{1} $$
Where $X[k]$ is the $N$-point DFT of some sequence $x[n]$, and $x_i[n]$ is the time sequence that result from the inverse transform evaluated at non-integer time indices. And the range of summation is deliberately left out.
With the index notation of $n/M$ what's implied is not very clear. Plugging $n/M$ into an inverse DFT is formally not allowed as the argument $n/M$ is meaningless for the time-domain sequence. Yet it's possible to interpret the notation as an indicator of an oversampling of the implied interpolation applied on the $x[n]$ sequence.
In that sense, I would re-write the inverse DFT as
$$x_i[n] = \frac{M}{L} \sum_{k} X[k] \cdot e^{ j \frac{2\pi}{N*M} k n } \tag{2}$$
Now $x_i[n]$ looks like an $L = M \times N$ point inverse DFT of the N-point forward DFT $X[k]$ of $x[n]$. But there're two alternative interpretations; the first one is explained by Andy Walls, in which the inverse DFT is applied to the zero appended DFT $X[k]$ which looks like:
$$x_i[n] = \frac{M}{L} \sum_{k=0}^{L-1} X[k] \cdot e^{ j \frac{2\pi}{L} k n } = \frac{M}{L} \sum_{k=0}^{N-1} X[k] \cdot e^{ j \frac{2\pi}{L} k n } \tag{3}$$
Using Matlab you can implement Eq.3 as:
xi = M*ifft( fft(x,N), L );

This is a terrible interpolation, as explained in the other answer.
But I would call it terrible because of the miss-placed zeros in the inverse DFT formula. It performs zero padding by appending zeros to the tail of $X[N-1]$ until the end $k=L-1$
Now, the other alternative is to add the zeros into the middle of $X[k]$, with the following associated inverse DFT, for $N$ even :
$$x_i[n] = \frac{M}{L} \big( \sum_{k=0}^{N/2} X[k] \cdot e^{ j \frac{2\pi}{L} k n } +\sum_{k=N/2+1}^{L-N/2} 0 \cdot e^{ j \frac{2\pi}{L} k n } +  \sum_{k=L+1-N/2}^{L-1} X[k] \cdot e^{ j \frac{2\pi}{L} k n } \big) \tag{4}$$
In Eq.4, the orignal $N$-point DFT $X[k]$ is repeated $M$ times, (indicator of expanding $x[n]$ by $M$), and windowed by an $N$ point rectangular window with a symmetric placement (representing the frequency domain effect of an ideal lowpass brickwall filter applied on the expanded time-domain sequence), and then an L-point inverse DFT is performed to get the $L$-point interpolated sequence $x_i[n]$. This can be achieved in MATLAB with the following line :
xif = M*real(ifft([X(1:N/2+1), zeros(1,L-N),X(N/2+2:N)],L));

Now this is a quite good interpolator of $x[n]$ at a rate of $M$ times oversampling it...