| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
| ///////////////////////////////////////////////////////////////////////////
// //
// Copyright (c) 2015 by Charta Software B.V. //
// All rights reserved //
// //
// Version: 1.7.0.83525 //
// Web site: https://pascal.chartasoftware.com/ //
// //
// This code and information are provided "as is" without warranty of //
// any kind. Dissemination of this information or reproduction of //
// this material is strictly forbidden unless prior written permission //
// is obtained from Charta Software B.V.. //
// //
///////////////////////////////////////////////////////////////////////////
unit Geometry._2d.Integer32.Point;
interface
uses
Boolean,
Geometry._2d.Dimension,
Integer._32;
type
TInteger32Point = record
private
function GetDimension(Dimension: T2dDimension): TInteger32;
procedure SetDimension(Dimension: T2dDimension; const Value: TInteger32);
public
X: TInteger32;
Y: TInteger32;
function SquaredNorm(): TInteger32;
function SquaredDistanceTo(const OtherPoint: TInteger32Point): TInteger32;
property Value[Dimension: T2dDimension]: TInteger32 read GetDimension write SetDimension; default;
public
class function New(X: TInteger32; Y: TInteger32): TInteger32Point; overload; static;
class function New(Dimension: T2dDimension; Major: TInteger32; Minor: TInteger32): TInteger32Point; overload; static;
class operator Equal(const Left: TInteger32Point; const Right: TInteger32Point): TBoolean;
class operator NotEqual(const Left: TInteger32Point; const Right: TInteger32Point): TBoolean;
class operator Add(const Left: TInteger32Point; const Right: TInteger32Point): TInteger32Point;
class operator Subtract(const Left: TInteger32Point; const Right: TInteger32Point): TInteger32Point;
class operator Negative(const Value: TInteger32Point): TInteger32Point;
end;
implementation
uses
Exception.Enumeration;
{ TInteger32Point }
class operator TInteger32Point.Add(const Left: TInteger32Point; const Right: TInteger32Point): TInteger32Point;
begin
Result.X := Left.X + Right.X;
Result.Y := Left.Y + Right.Y;
end;
class operator TInteger32Point.Equal(const Left: TInteger32Point; const Right: TInteger32Point): TBoolean;
begin
Result := (Left.X = Right.X) and (Left.Y = Right.Y);
end;
function TInteger32Point.GetDimension(Dimension: T2dDimension): TInteger32;
begin
case Dimension of
T2dDimension.Horizontal:
Result := X;
T2dDimension.Vertical:
Result := Y;
else
raise EUnknownEnumerationValue.Create('Unknown dimension');
end;
end;
class operator TInteger32Point.Negative(const Value: TInteger32Point): TInteger32Point;
begin
Result.X := -Value.X;
Result.Y := -Value.Y;
end;
class function TInteger32Point.New(Dimension: T2dDimension; Major: TInteger32; Minor: TInteger32): TInteger32Point;
begin
Result[Dimension] := Major;
Result[GetOther2dDimension(Dimension)] := Minor;
end;
class function TInteger32Point.New(X: TInteger32; Y: TInteger32): TInteger32Point;
begin
Result.X := X;
Result.Y := Y;
end;
class operator TInteger32Point.NotEqual(const Left: TInteger32Point; const Right: TInteger32Point): TBoolean;
begin
Result := (Left.X <> Right.X) or (Left.Y <> Right.Y);
end;
procedure TInteger32Point.SetDimension(Dimension: T2dDimension; const Value: TInteger32);
begin
case Dimension of
T2dDimension.Horizontal:
X := Value;
T2dDimension.Vertical:
Y := Value;
else
raise EUnknownEnumerationValue.Create('Unknown dimension');
end;
end;
function TInteger32Point.SquaredDistanceTo(const OtherPoint: TInteger32Point): TInteger32;
var
Delta: TInteger32Point;
begin
Delta := Self - OtherPoint;
Result := Delta.SquaredNorm();
end;
function TInteger32Point.SquaredNorm(): TInteger32;
begin
Result := X * X + Y * Y;
end;
class operator TInteger32Point.Subtract(const Left: TInteger32Point; const Right: TInteger32Point): TInteger32Point;
begin
Result.X := Left.X - Right.X;
Result.Y := Left.Y - Right.Y;
end;
end.
|