Is there a faster way to compare these decimals?

I have a stream of decimals and I am trying to compare the most recent decimal to the difference of the last 6 decimals, I may increase this number

I have the following class

public class CompareRandom
{
    private const decimal DIFFERENCE = 1.8m;

    public decimal a;
    public decimal b;
    public decimal c;
    public decimal d;
    public decimal e;
    public decimal f;
    public decimal g;

    public bool Compare(decimal num)
    {
        this.g = this.f;
        this.f = this.e;
        this.e = this.d;
        this.d = this.c;
        this.c = this.b;
        this.b = this.a;
        this.a = num;

        if (b != decimal.Zero && b / DIFFERENCE > a)
        {
            return true;
        }

        if (c != decimal.Zero && c / DIFFERENCE > a)
        {

            return true;
        }

        if (d != decimal.Zero && d / DIFFERENCE > a)
        {
            return true;
        }

        if (e != decimal.Zero && e / DIFFERENCE > a)
        {
            return true;
        }

        if (f != decimal.Zero && f / DIFFERENCE > a)
        {
            return true;
        }

        if (g != decimal.Zero && g / DIFFERENCE > a)
        {
            return true;
        }

        return false;
    }
}

Then I initialize it as volatile

volatile static CompareRandom CompareRandom = new CompareRandom();

Then I call CompareRandom.Compare(value) synchronously as part of a loop that updates every 1ms to compare the values.

The part I am the most interested in knowing if there is a faster way to do is this part

    this.g = this.f;
    this.f = this.e;
    this.e = this.d;
    this.d = this.c;
    this.c = this.b;
    this.b = this.a;
    this.a = num;

A successful answer will demonstrate a faster execution of the method Compare

See if you can make it faster:

https://dotnetfiddle.net/tLw8qM

https://dotnetfiddle.net/jd0bSF

You don't need to perform the division every time. Instead, multiply a by DIFFERENCE to obtain a threshold:

// Name changed to be more conventional
private const decimal Difference = 1.8m;

public bool Compare(decimal num)
{
    g = f;
    f = e;
    e = d;
    d = c;
    c = b;
    b = a;
    a = num;
    var threshold = num * Difference;
    return (b != decimal.Zero && b > threshold) ||
           (c != decimal.Zero && c > threshold) ||
           (d != decimal.Zero && d > threshold) ||
           (e != decimal.Zero && e > threshold) ||
           (f != decimal.Zero && f > threshold) ||
           (g != decimal.Zero && g > threshold);
};

As asides:

• It's odd for a Compare method to return bool rather than an integer; given that it's not the "common" meaning of Compare, it's probably worth renaming it for clarity
• It's very odd for a comparison method to change the state of an object, as this is doing (assigning to a) - another good reason to change the name.

Using a collection instead of separate variables would make all of this more maintainable, but I'd be surprised if it improved the speed.

I also really like the idea of eliminating the division, but I don't like the way you're handling booleans: the original question says something like:

if condition1 then return true;
if condition2 then return true;
if condition3 then return true;

If condition1 is true, then the code does not bother about the calculation of the other conditions (why would it, when one condition is true, then the OR of all conditions also is true).

The proposal from Jon looks as follows:

return (condition1 || condition2 || condition3)

This does exactly the same thing, but the fact if the calculation of the OR equation is determined by the compiler: if you're dealing with an older compiler, not performing optimsation, then the entire calculation is done, even if condition1 is true.