An example should make things clearer. Computers deal in integers and floating point numbers, but there may be an occasion for you to need to use good old fashioned fractions. So how about we create aTFractiontype, overloading the general mathematical operators that allow us to add, subtract, multiply, divide and compare fractions? Sounds good, right?
Okay, so let’s start out with a simple definition ofTFraction:
type
TFraction = record strict private
FNumerator: Integer;
FDenominator: Integer;
class function GCD(a, b: Integer): Integer; static;
function Reduced: TFraction;
public
class function CreateFrom(aNumerator: Integer; aDenominator: Integer): TFraction; static;
property Numerator: Integer read FNumerator;
property Denominator: Integer read FDenominator;
end;
It’s a simple record withNumeratorandDenominatorproperties. It also has a constructor of sorts called
CreateFromthat allows you to initialize aTFraction. That function is probably a little more complicated that you might think:
class function TFraction.CreateFrom(aNumerator, aDenominator: Integer): TFraction;
begin
if aDenominator = 0 then begin
raise EZeroDivide.CreateFmt(‘Invalid fraction %d/%d, numerator cannot be zero’, [aNumerator, aDenominator]\
);
end;
if (aDenominator < 0) then begin
Assert(Result.Denominator > 0); // needed for comparisons end;
First, since we are dealing only with rational numbers, you can’t have aDenominator that is zero, so an exception is raised if you try to create a fraction with a zero on the bottom. Next, in order to allow for better code when doing the comparison operators a little later, if the denominator is negative, we move the sign to the numerator.
Now we can create a fraction like so:
var
OneThird: TFraction;
begin
OneThird := TFraction.CreateFrom(1, 3);
end;
But what good is that? Wouldn’t it be better if we could do math on these fractions? Well, we could do it this way:
function AddFractions(a, b: TFraction): TFraction;
but that would be clumsy and no fun. It would be much better to be able to do:
var
A, B, C: TFraction;
begin
A := TFraction.Create(1, 2);
B := TFraction.Create(1, 3);
C := A + B;
end;
Well, lets make that happen. In order to do that, we need to add someclass operatormethods to the
TFractionrecord. We want to be able to add fractions together, so in order to do addition, we’ll need this method:
class operator Add(const Left, Right: TFraction): TFraction;
Theclass operatordeclaration is a special class method that indicates that an operator is to be overloaded.
In this case, we are overloading addition, as indicated by the method nameAdd. The compiler recognizesAdd
as a special method name and uses it to override the ‘+’ operator. Aclass operatormust be followed by a specific operator name as defined in the documentation link above. For instance, if you declare
class operator FooBar(const AValue: TFraction): TFraction;
you’ll get an error like this one:
[dcc32 Error] uFractions.pas(36): E2393 Invalid operator declaration
In other words, you need to have a correct, valid operator name for the class operatordeclaration to compile. Here we haveAdd, but in a minute we’ll add more, likeSubtractandNegative.
However, there are no restrictions on parameters and return value types. You can provide overloads and converters for any Delphi type if it is appropriate for your overload.
So, how do you add two fractions?
class operator TFraction.Add(const Left, Right: TFraction): TFraction;
begin
Result := CreateFrom(Left.Numerator * Right.Denominator + Left.Denominator * Right.Numerator, Left.Denominat\
or * Right.Denominator).Reduced;
end;
This code creates a new instance ofTFraction, and performs the formula for adding two fractions together.
And finally, it callsReducedto reduce the resulting fraction to have the least common denominator.Reduced
is declared as follows:
function TFraction.Reduced: TFraction;
var
LGCD: Integer;
begin
LGCD := GCD(Numerator, Denominator);
Result := CreateFrom(Numerator div LGCD, Denominator div LGCD);
end;
andGCDis declared as:
class function TFraction.GCD(a, b: Integer): Integer;
var
rem: Integer;
begin
rem := a mod b;
if rem = 0 then Result := b;
else
Result := GCD(b, rem) end;
I’m no mathematician, but I understand that theGCDfunction is a recursive implementation of the Euclidean Greatest Common Denominator algorithm. Impressive, eh?
In any event, the code ensures that all results are properly reduced, and you’ll see the call toReducedon the end of any method that returns aTFraction.
Okay, so that’s the implementation for adding two fractions together. The code for adding a fraction to an integer is very similar, as an integer is just a fraction with a denominator of 1, so I won’t show it here. (You can check it out on theBitBucket²⁰repository for the book’s code).
How about subtraction? Well, before we look at subtraction, we need to look at another operator:
class operator Negative(const AValue: TFraction): TFraction;
This is the overload for the minus sign in front of a fraction, which of course makes it negative. It’s implemented as follows:
²⁰https://bitbucket.org/NickHodges/nickdemocode/src/11f331ec18dc0f2f4f6ade17153bff0b31ab13cf/MoreCodingInDelphi/?at=default
class operator TFraction.Negative(const AValue: TFraction): TFraction;
begin
Result := CreateFrom(-aValue.Numerator, AValue.Denominator);
end;
It’s implementation is pretty obvious – it just creates a negative version of theTFractionpassed to it by making the numerator negative. I showed it to you first before looking at theSubtractionmethod, because theSubtractionmethod uses it. Here’s the implementation for subtracting one fraction from another:
class operator TFraction.Subtract(const Left, Right: TFraction): TFraction;
begin
Result := Left + (-Right);
end;
Note that the class operators can build on one another. The subtraction uses the Add operator and the
Negativeoperator together to createSubtraction, resulting in easier code to read and maintain.
TheMultiplyandDividemethods are implemented exactly like you would think, so I won’t cover them here.
The next set of operators that we’ll look at are the comparison operators, that is,=,<>,>,<,<=, and>=. Again, they’ll build on each other, so we’ll start withEqualandNotEqual.
class operator TFraction.Equal(const Left, Right: TFraction): Boolean;
begin
Result := Left.Numerator * Right.Denominator = Right.Numerator * Left.Denominator;
end;
class operator TFraction.NotEqual(const Left, Right: TFraction): Boolean;
begin
Result := not (Left = Right);
end;
Note that the Equal method uses the classic algorithm you learned in fourth grade to determine if two fractions are equal, but theNotEqualmethod simply takes advantage of theEqualoperator by usingnotto get the proper result.
Naturally following from that is the greater than/less than operators, including the equals. And guess what, they build on each other as well:
class operator TFraction.LessThan(const Left, Right: TFraction): Boolean;
begin
Result := Left.Numerator * Right.Denominator < Right.Numerator * Left.Denominator;
end;
class operator TFraction.GreaterThan(const Left, Right: TFraction): Boolean;
begin
Result := Left.Numerator * Right.Denominator > Right.Numerator * Left.Denominator;
end;
class operator TFraction.LessThanOrEqual(const Left, Right: TFraction): Boolean;
begin
Result := (Left < Right) or (Left = Right);
end;
class operator TFraction.GreaterThanOrEqual(const Left, Right: TFraction): Boolean;
begin
Result := (Left = Right) or (Left > Right);
end;
Again, the code is quite simple and pretty much what you’d expect. Note that GreatThanOrEqual and
LessThanOrEqualboth use existing functionality to do their work.
Assignments
So now we have aTFractionthat can perform basic math and do comparisons. But what if you want to assign aTFractionto another type, say, a Double, or if you want to assign an integer to aTFraction? Well, you can do that by using a call toclass operator Implicit.Implicitis the operator that allows you to write code that assigns one type to another. ForTFraction, we’ll declare two of them:
class operator Implicit(const aValue: Integer): TFraction;
class operator Implicit(const aValue: TFraction): Double;
One will allow anintegerto be turned into aTFractionand the other will convert aTFractioninto a double. The implementations are simple:
class operator TFraction.Implicit(const AValue: Integer): TFraction;
begin
Result := TFraction.CreateFrom(aValue, 1);
end;
class operator TFraction.Implicit(const aValue: TFraction): Double;
begin
Result := aValue.Numerator/aValue.Denominator;
end;
Delphi’s strong typing prevents me from wanting to allowTFractionto be assignable to a string, but I have provided aToStringmethod that turns the fraction into something readable:
function TFraction.ToString: string;
begin
Result := Format('%d/%d', [Numerator, Denominator]);
end;
In addition, I’ve used theclass operator Explicitmethod to allow hard casting of aTFractionto a
string. This operator allows code like the following:
SomeString := string(TFraction.CreateFrom(1, 3));