Supported operations design pattern

Question

I have an abstract class "A" that has a property of an enum type "OutputType", and an abstract method calculation() that needs to do a certin calculation and to output the result in a double[] **according to the OutputType value.

I also have a classes defined as D1,D2,D3...D20, derive from A, Where each Di class implements A's calculation() method differently.

The problem is that not all of the OutputType values (the calculation() output types) are supported in every Di

For example:

If OutputType enum values are "Scaled", "NonScaled" and "ConstantLength",

A certin Di can support "Scaled" and "NonScaled" but not support "ConstantLength" and another Di can support all of the operation types,

My question is:

What is the right design pattern to implement this kind of behaiver?

Please avoid the obvious "Throw if the OutputType property recieves a value of a non supported operation" answers.

Edit:

Expanding the question:

Is there a way to notify the user with intellisense of all the supported operation so the user wont have to take the trial and error approach? (besides a proper documentation)

Answer 1

Note that I've edited my answer completely dropping my previous approach using a precondition with code contracts.

I've been thinking about a solution that should be more powerful.

What about an abstract class which defines a protected virtual method for each possible operation type, and a public, non-overridable Calculate method could call the overriden protected virtual method?

public abstract class Calculation
{
    public Calculation()
    {
        // I store all overridable methods in a dictionary where keys
        // are the method names
        OverridableMethods = new Dictionary<string, Func<double[]>>()
        {
            { nameof(CalculateScaled), CalculateScaled },
            { nameof(CalculateNonScaled), CalculateNonScaled },
            { nameof(CalculateConstantLength), CalculateConstantLength }
        };


        // Then we get the first overriden method. If there're more
        // than one, it will pick the first occurence and others will be
        // discarded. It's up to the developer to override just one.
        MethodInfo overridenMethod = OverridableMethods.Keys
                .Select(methodName => GetType().GetMethod(methodName, BindingFlags.Instance | BindingFlags.NonPublic))
                .FirstOrDefault(method => method.DeclaringType != typeof(Calculation));

        Contract.Assert(overridenMethod != null, "No calculation operation implementation has been provided");

        // So some method was overriden and I store the method name
        OverridenMethodName = overridenMethod.Name;
    }

    private string OverridenMethodName { get; }
    private Dictionary<string, Func<double[]>> OverridableMethods { get; }

    protected virtual double[] CalculateScaled() 
    {
        throw new NotImplementedException();
    }

    protected virtual double[] CalculateNonScaled() 
    {
        throw new NotImplementedException();
    }

    protected virtual double[] CalculateConstantLength()
    {
        throw new NotImplementedException();
    }

    // Calculate just access the overridable method dictionary
    // to get the overriden method encapsulated by a Func<double[]>
    // and I immediately call it!
    public double[] Calculate() => OverridableMethods[OverridenMethodName]();
}

public class SomeCalculation : Calculation
{
    protected override double[] CalculateScaled()
    {
        return new double[] { 22 };
    }
}

So it really works!

    Calculation calculation = new SomeCalculation();

    // Prints out 22!
    Console.WriteLine(calculation.Calculate()[0]);