2
$\begingroup$

I'd like to sample band-limited Gaussian white noise non-uniformly. One way to approximate this would be to filter Gaussian white noise with a lower cutoff frequency and non-uniformly pick samples from this. However this approach would limit me to a fixed number of time-offsets and require many samples of noise to achieve sufficient resolution.

Is there any better way to do it?

Improve this question
$\endgroup$
2
  • 1
    $\begingroup$ I'm a little confused by what you're asking. Generally "band-limited" white noise is used in continuous-time systems. However, you seem to want a discrete-time noise (you refer to require many samples). If your system is discrete-time, then it's not clear to me how nonuniform sampling will change things. Can you expand / recast your question? Perhaps explaining why you need nonuniformly sampled white noise would help, too. $\endgroup$
    – Peter K. ♦
    Commented Apr 14, 2014 at 20:30
  • $\begingroup$ I'm refering to sampling of continous-time "band-limited" white noise. I want to simulate non-ideal time-interleaved sampling, preferably with the ability to simulate clock jitter. Right now I've solved it by generating discrete-time gaussian white noise, low pass filtering, splitting up the signal to the number of samplers and using different fractional-delay filters to approximate a small, fixed, time-delay for each sampler. $\endgroup$
    – Noiser
    Commented Apr 15, 2014 at 7:12

2 Answers 2

Reset to default
1
$\begingroup$

As you mention, you could upsample the signal to a sufficiently high rate.

An alternative would be to compute an interpolation kernel for every desired output sample. This would probably be pretty inefficient for a large number of output samples. You could tabulate many interpolation kernels. That would again leave you with a fixed set of possible offsets, but it might save you time and/or memory.

Improve this answer
$\endgroup$
4
  • $\begingroup$ When "oversampling" at a high rate I realized that there will be numerical problems with the low-pass filter since I'll need a very low cutoff frequency and very steep transition band. Is there any way around this or is this method unfeasible if e.g. need 1% clock delay resolution (which would mean reducing the cutoff frequency by 100)? I'll probably go with interpolation/fractional delay filter. $\endgroup$
    – Noiser
    Commented Apr 16, 2014 at 6:42
  • $\begingroup$ That's a perfectly feasible rate with this method. You can think of oversampling as using one very long filter with a low cutoff (relative to the output rate) or as a bank of filters each passing the entire band (at the input rate). That's the idea behind polyphase filter banks. In your case you'd only need a subset of the outputs. $\endgroup$
    – Brian Hawkins
    Commented May 4, 2014 at 3:35
  • $\begingroup$ One method is to up sample by a factor of 3 and then use spline interpolation to calculate the signal at arbitrary points in time. The filter allows direct control of the passband ripple and sidelobes levels. If needed you could upsample by a higher factor if improved performance is needed. $\endgroup$
    – David
    Commented Jan 12, 2015 at 13:45
  • $\begingroup$ Yes as Brian mentioned a polyphase bank of filters came to mind as an approach to achieve all of the interpolated samples desired. (Not just a subset) Also regarding the challenge of tight filters for high orders of interpolation consider that the interpolation can be done in stages. $\endgroup$
    – Dan Boschen
    Commented Mar 3, 2017 at 12:52
1
$\begingroup$

In case someone else has any use for it here's some MATLAB code similar to what I ended up using. It basically filters the WGN, splits it up to separate signals for each sampler, upsamples these signals and filters with a fractional delay filter approximation (truncated version of ideal step response used as FIR filter). This would approximate the effects of time-interleaved sampling with fixed time-delays for each sampler (generated randomly in the code provided). There's also a commented-out line which can be used to test with a sine-wave input.


% Number of samplers
nSamplers         = 2;

% Use 50 taps for the fractional delay filter
nSideTaps         = 50;
n                 = -nSideTaps:nSideTaps;

% Generate noise
nSamples          = 1E4*nSamplers;
whiteNoise        = randn(nSamples, 1);
% whiteNoise        = sin(2*pi*0.1*(1:numel(whiteNoise))); % Sine test

% Band-limit noise
D                 = fdesign.lowpass('Fp,Fst,Ap,Ast', 0.5, 0.65, 2, 100);
lpFilterDesign    = design(D);
blNoise           = filter(lpFilterDesign.Numerator, 1, whiteNoise);

% Reshape such that each row corresponds to a single sampler
blNoise           = reshape(blNoise, nSamplers, []);

% Initialize sampled signal
sampledSignal     = zeros(numel(blNoise), 1);
fracDelays        = 0.05 * randn(nSamplers, 1); % Randomly chose delay times, standard deviation 5%
for i = 1:nSamplers
   bFracDelay        = sin(pi*(n'-fracDelays(i)))./(pi*(n'-fracDelays(i)));
   sampledSignal     = sampledSignal + filter(bFracDelay, 1, upsample(blNoise(i,:), nSamplers, i-1))';
end

% Reshape to sub-adcs
sampledSignal     = reshape(sampledSignal, nSamplers, []);

figure()
plot(20*log10(abs(fft(sampledSignal(nSamples/2+1:end)))));
title('FFT of sampled signal')
Improve this answer
$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.