Как получить доступ к предыдущему члену в буфере?

Работаем над трансформированием:

yl(n) = F1yb(n) + yl(n − 1)

yb(n) = F1yh(n) + yb(n − 1)

yh(n) = x(n) − yl(n − 1) − Q1yb(n − 1)

в C ++, и я пытаюсь получить доступ к предыдущему члену в буфере, чтобы использовать его, однако это уравнение кажется довольно проблематичным само по себе. Есть идеи? Я также могу представить код, если кто-нибудь, конечно, захочет его прочитать.
С уважением!

Сам код:

{
fSamplingFreq = getSampleRate(); /*Get system sample rate*/
N = (int)fSamplingFreq; /*Size of buffer - 1 second of audio*/
inputBuffer = new float[N]; /*Create a new buffer for input of size N*/
cutOffBuffer = new float[N]; /*Create a new buffer for values of cut off frequency of size N*/
yhBuffer = new float[N];
ybBuffer = new float[N];
ylBuffer = new float[N];
ridx = widx = 0; /*Read and write indices*/
fCutOff = 30; /*Initialises parameters*/
fGain = 0.5;

setCutOff(fCutOff); /*Set cut off frequency to initial value*/

setNumInputs(1); /*Mono in*/
setNumOutputs(1); /*Mono out*/

//setNumInputs(2); /*Stereo in*/
//setNumOutputs(2); /*Stereo out*/

resume(); /*Flush buffer*/
}

Wobble :: ~Wobble()
{
/*delete buffer memory*/
delete inputBuffer;
delete cutOffBuffer;
delete yhBuffer;
delete ybBuffer;
delete ylBuffer;
}

/*Called every time the plug-in is switched on (in this case to reset the memory to zero)*/
void Wobble::resume()
{
/*Flush the buffers*/
memset(inputBuffer, 0, N * sizeof(float));
memset(cutOffBuffer, 0, N * sizeof(float));
memset(yhBuffer, 0, N * sizeof(float));
memset(ybBuffer, 0, N * sizeof(float));
memset(ylBuffer, 0, N * sizeof(float));
AudioEffectX::resume();
}

/*This sets the cut off frequency of low-pass*/
void Wobble::setCutOff(int widx)
{
int fw = 500;
float centre = fw / fSamplingFreq;

do
{
if (fLFOFreqMin = 30, fCutOff <= fLFOFreqMax, fLFOFreqMin + centre)
{
fCutOff = fLFOFreqMin + centre;
cutOffBuffer[widx] = fCutOff;
}
if (fLFOFreqMax = 180, fCutOff >= fLFOFreqMin, fLFOFreqMax - centre)
{
fCutOff = fLFOFreqMax - centre;
cutOffBuffer[widx] = fCutOff;
}
} while (cutOffBuffer[N] < inputBuffer[N]);
}

/*Main processing loop, DSP code goes here*/
void Wobble::processReplacing(float** inputs, float** outputs, VstInt32 sampleFrames)
{
/*Pointers to input and output sampleframe*/
float *in = inputs[0];
float *out = outputs[0];

/*Variables used within processing loop*/
float x, y, xM, cutM, yh, yhM, yb, ybM, yl, ylM, F1, Q1, d, fc, fs, pi;

/*Processing Loop*/
while (--sampleFrames >= 0)
{
d = 0.01;
Q1 = 2 * d;
pi = 3.14;

setCutOff(widx);

x = *in; /*Get current sample*/
inputBuffer[widx] = x; /*write current sample into buffer at position*/

xM = inputBuffer[ridx] * fGain; /*Get sample from buffer at position ridx*/
cutM = cutOffBuffer[ridx];

if (ridx == 0)
{
F1 = 2 * sin((pi * cutM) / fs);

yh = x;
yhBuffer[widx] = yh;
yhM = yhBuffer[ridx];

yb = F1 * yh;
ybBuffer[widx] = yb;
ybM = ybBuffer[ridx];

yl = F1 * yb;
ylBuffer[widx] = yl;
ylM = ylBuffer[ridx];
}
if (ridx != 0)
{
yhM = x - yl(n - 1) - Q1 * yb(n - 1);
ybM = F1 * yhM + yb(n - 1);
ylM = F1 * ybM + yl(n - 1);

F1 = 2 * sin((pi * cutM) / fs);
}

*out = ylM + xM; /*Output the sample*/

in++; /*Increase input sample by one*/
out++; /*Increase output sample by one*/
ridx++; /*Increase read pointer by one*/
widx++; /*Increase write pointer by one*/

if (widx >= N)
widx -= N; /*Wrap write index*/
if (ridx >= N)
ridx -= N; /*Wrap read index*/
}
}