有理数结构的默认值

Question

I'm working on a simple math library for educational purposes and I've implemented a struct that represents a Rational Number . Very basic code showing the core fields of the struct is:

public struct RationalNumber
{
    private readonly long numerator;
    private readonly long denominator;
    private bool isDefinitelyCoprime;
    private static RationalNumber zero = 0;

    public RationalNumber(long numerator, long denominator)
    {
        this.numerator = numerator;
        this.denominator = denominator;
        this.isDefinitelyCoprime = false;
    }

    ...
}

Currently I'm implementing a RationalMatrix which, as you've probably guessed, will be made up of RationalNumber typed elements.

A useful matrix that I'm creating a static builder for is the Identity matrix. Code is as follows:

public static RationalMatrix GetIdentityMatrix(int dimension)
{
    RationalNumber[,] values = new RationalNumber[dimension, dimension];

    for (int i = 0; i < dimension; i++)
       values[i, i] = 1;

    return new RationalMatrix(values);
}

The problem is that this will not work because the default value of my RationalNumber is not 0/1 but 0/0 which is a special kind of value ( Indeterminate form ).

Obviously one solution is straightforward and it is to simply change the method to:

public static RationalMatrix GetIdentityMatrix(int dimension)
{
    RationalNumber[,] values = new RationalNumber[dimension, dimension];

    for (int i = 0; i < dimension; i++)
       for (int j = i+1 ; j < dimension; j++)
       {
           values[i, i] = 1;
           values[i, j] = RationalNumber.Zero;
           values[j, i] = RationalNumber.Zero;
       }

       return new RationalMatrix(values);
}

But this somehow seems a waste of effort as I'm basically initializing the values of the whole array two times. I kind of think it would be more elegant to somehow make the default value of RationalNumber equal 0/1 . This would be easy to do if RationalNumber were a class , but I can't think of a way to do it when it's a struct . Am I missing something obvious or is there no way to avoid having 0/0 as my default value?

I'd like to point out that I am not concerned at all about code performance (if this were to be my bottleneck then I'd be far past my goals already). I'm just curious to know if there is some construct (unknown to me) that allows you to impose arbitrary default values in a struct .

EDIT : Typos

EDIT 2 : Broaden scope of question

OK, it seems there is no way to impose arbitrary default values in a struct from the input I'm getting and from my own conclusions based on my limited C# knowledge.

Can someone give me a clue as to why structs must behave this way? Is it for a reason or was it implemented this way because no one thought to specify the option to define default values?

Answer 1

If you do not have to distinguish between the indeterminate 0/0 and other 0/N values, then you can treat all your 0/N as zero. That is, all zeros are equal which makes sense (0/2 equals 0/1), and also all divisions by zero are equal, so 1/0 == 2/0.

public struct RationalNumber : IEquatable<RationalNumber>
{
    private readonly long numerator;
    private readonly long denominator;

    public RationalNumber(long numerator, long denominator)
    {
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public bool IsZero 
    { 
       get { return numerator == 0; }
    }

    public bool IsInvalid 
    { 
       get { return denominator == 0 && numerator != 0; }
    }

    public bool Equals(RationalNumber r)
    {
       if (r.IsZero && IsZero)
         return true;
       if (r.IsInvalid && IsInvalid)
         return true;
       return denominator == r.denominator && numerator == r.numerator;
    }

    public bool Equals(object o)
    {
       if (!(o is RationalNumber))
         return false;
       return Equals((RationalNumber)o);
    }

    public int GetHashCode()
    {
       if (IsZero) 
         return 0;
       if (IsInvalid)
         return Int32.MinValue;
       return ((float)numerator/denominator).GetHashCode();
    }
}   

Answer 2

You cannot have a parameterless constructor that assigns default value. The technical reason is that your struct is a subclass of System.ValueType , and System.ValueType() is protected , so cannot be overridden.

The closest you can get is probably David Hefferman's solution:

/// <summary>
/// The denominator is stored in this altered form, because all struct fields initialize to 0 - and we want newly created RationalNumbers to be 0/1 more often than 0/0.
/// </summary>
private int _denominatorMinusOne;
public int Denominator 
{ 
    get { return _denominatorMinusOne + 1; } 
    set { _denominatorMinusOne = value -1; } 
}

Then you can just reference Denominator in your code normally, and the special storage format will be transparent - you would only be able to tell by looking at the field declaration, or by scrutinizing the default constructor behavior.

You could do things like call a constructor with parameters, or create a RationalNumberFactory class to produce zeros for you - but none of these would get around your issue of looping through every element of the matrix instead of just the diagonal, because you cannot specify the constructor that an array initializer will use.

In fact, the new RationalNumber[100][100] convention is not simply a coding shorthand, but it also runs faster than calling the constructor 10,000 times. This is part of why System.ValueType() was made protected in the first place. See: Why can't I define a default constructor for a struct in .NET?

Looping through every element of the matrix provides an advantage in clarity, but using the "weird" minus one solution not only reduces how much code you have to run, but provides improvements in performance. So you could take this as a strong argument in its favor.

Answer 3

It would be nice to supply a default constructor for the struct:

public RationalNumber()
{
    this.numerator = 0;
    this.denominator = 1;
    this.isDefinitelyCoprime = false;
}

However this is not allowed. Nor can you have instance initialisers.

The answer simply is that you have to accept that the internal field must initalise to zero, but this does not mean that the behavior has to follow.

    public struct Rational
    {
        private int _numerator;
        private int _denominator;
        public Rational(int numerator, int denominator)
        {
            // Check denominator is positive.
            if(denominator < 0){
                  denominator *= -1; 
                  numerator *= -1;
            }
            _numerator = numerator;
            _denominator = denominator== 0? -1:
                denominator;
        }
        public int Numerator
        {
            get { return _numerator; }
        }
        public int Denominator
        {
            get { return 
                _denominator == 0?1:
                _denominator == -1?0:
                _denominator; }
        }
    }

(Note: I was actually very surprised to find you can't have static initalisers in structs!)

Answer 4

It is good when possible to design structures so that any combination of field values will have defined semantics. If this is not done, there will often be no way for the structure to prevent the construction of malformed instances by improperly-threaded code, and for such instances to cause improper behavior in code which is properly threaded. For example, if a rational-type storage location had numerator and denominator values which were recognized as being definitely coprime, and said location was copied in one thread while its value was changed in another thread, the thread which did the copying could receive an instance where the numerator and denominator were not coprime, but the flag said they were. Other code which received that instance could fail in weird and bizarre ways as a result of the broken invariant; such failure might occur someplace very distant from the non-threadsafe code which created the broken instance.

This situation may be remedied by using an immutable class object to hold the rational number, and having a rational-number value type which wraps a private reference to such an object. The wrapper type would use a default instance when its private reference is null, or the wrapped instance when it isn't. This approach could offer some potential efficiency improvements if the private reference was an abstract type and there were several derived types which satisfied different criteria. For example, one could have a derived RationalSmallInteger whose only field was an Int32 , and a RationalLongInteger whose only field was an Int64 (the the Denominator property of both such types would always return 1). One could have types where the denominator was non-zero but was validated as being coprime with the numerator or types where it was not; the latter kind of type could hold an initially-null reference to an instance where the numerator and denominator were guaranteed to be coprime. Such behavior could improve efficiency in cases like:

RationalNumber r1 = new RationalNumber(4,6);
RationalNumber r2 = r1;
RationalNumber r3 = r1.ReducedForm();
RationalNumber r4 = r2.ReducedForm();

The first statement would set the private field of r1 to refer to a RationalNumber.Int32by32Nonreduced instance. The second would set r2's private field to point to that same instance. The third statement would generate a new Int32by32Reduced instance and store a reference to that in the former Int32by32Nonreduced instance, and also in r3's private field. The fourth would fetch the aforementioned reference from the former Int32by32Reduced and store it into r4's private field. Note that only one reduction operation would be necessary. By contrast, if RationalNumber were a struct which held its values internally, the fourth statement would have no way of re-using the result of the reduction performed by the third.