A class for solving a system of linear equations using Gaussian Elimination
Enumerable.Count() vs count access

One problem that slows your program's performance is that you call 

Coefficients.Count()


In a few places while you are using array instead of an IEnumerable&lt;T&gt; where this is the only way to count the elements and as you can see this is a method rather than being a property. Instead you should simply call Coefficients.Length.

Edit

As @t3chb0t pointed in the comments and discussed here C# will simply return the Count property of the collection even when you call the method .Count() which means Coefficients.Count() &amp; Coefficients.Length are almost equivalent in performance since the method has to do a type checking. 

Nevertheless when possible, you should always prefer using your collection's specific functions and properties, rather than the generic ones. In your case Coefficients.Length.

Properties vs fields

Ideally you should always use properties instead of fields 


public decimal[] Coefficients;
public decimal Result;



Can become

public decimal[] Coefficients { get; }
public decimal Result { get; set; }


You properties should be as restrictive as possible the less your class exposes the better.

Indexer with public backing collection ?

This doesn't makes much sense. Usually when a class has a indexer it's used internally with a private backing collection, but you have an iterator + a public collection.

In your case I don't see any reason why would you use an indexer here the public array Coefficients is more than enough and it's a lot more readable, so you should remove that indexer and just access the array like this :


public void AddCoefficients(LinearEquation pivotEquation, decimal factor)
{
    for (int i = 0; i &lt; this.Coefficients.Length; i++)
    {
        Coefficients[i] += pivotEquation.Coefficients[i]*factor;
        if (Math.Abs(Coefficients[i]) &lt; 0.000000001M)
            //Because sometimes rounding errors mean it's not quite zero, and it needs to be
        {
            Coefficients[i] = 0;
        }
    }
    this.Result += pivotEquation.Result*factor;
}



Redundant this qualifier

While I do agree that this is up to a personal preference I don't like it. You don't need a single this qualifier in your code it would be better to remove it it's just extra text to read..

Expression bodied properties + LINQ


public int IndexOfFirstNonZero
{
    get
    {
        for (int i = 0; i &lt; Coefficients.Length; i++)
        {
            if (Coefficients[i] != 0)
            {
                return i;
            }
        }
        return -1;
    }
}


public int NonZeroCount
{
    get
    {
        int count = 0;
        for (int i = 0; i &lt; Coefficients.Length; i++)
        {
            if (Coefficients[i] != 0) count++;
        }
        return count;
    }
}



You can really shorten those get only properties using LINQ :

public int IndexOfFirstNonZero
{
    get
    {
        int value = (int) Coefficients.FirstOrDefault(x =&gt; x != 0);
        return value == default(int) ? -1 : value;
    }
}

public int NonZeroCount =&gt; Coefficients.Count(t =&gt; t != 0);