Книга программиста/Структуры данных в PascalABC.Net

К оглавлению

Все программы, код которых выложен здесь, являются работоспособными. На момент написания программ использовалась среда PascalABC.Net 3.0.

Структура кода класса

1. Приватные переменные
2. Свойства
3. Методы
4. Clone(), CloneAs(), Readln()
5. Классовые методы
6. Операторы
7. ToString(), Print(), Println()

Классы без свойств

type
  TPoint = class
  public 
    X, Y: integer;
    
    constructor(cx, cy: integer);
    begin
      X := cx;Y := cy;
    end;
    
    function Clone() := new TPoint(X, Y);
    
    procedure Println() := Write(Format('({0}, {1})', X, Y));
  end;

begin
  var P := new TPoint(1, 2);
  P.Println();
end.

Структуры данных на базе статического массива

Простейший стек

const
  MaxSize = 100;

type
  TStack = class
  private
    _A: array [0..MaxSize - 1] of integer;
    _Count: integer;
  
  public 
    property Count: integer read _Count; // Фактическое количество элементов
    
    constructor();
    begin
    end;
    
    procedure Push(v: integer); // Добавляет элемент в конец.
    begin
      if _Count = MaxSize then
        raise new Exception('Переполнение стека.');
      
      Inc(_Count);
      _A[Pred(_Count)] := v;
    end;
    
    function Pop(): integer; // Удаляет последний элемент и возвращает его значение.
    begin
      if _Count = 0 then
        raise new Exception('Стек пуст.');
      
      Result := _A[Pred(_Count)];
      Dec(_Count);
    end;
  end;

begin
  var Q := new TStack();
  for var i := 1 to 10 do
    Q.Push(i);
  for var i := 1 to 10 do
    Writeln(Q.Pop());
end.

Простейшая очередь

const
  MaxSize = 100;

type
  TQueue = class
  private 
    _A: array [0..MaxSize - 1] of integer;
    _Head, _Tail: integer;
    _Count: integer;
  
  public 
    property Count: integer read _Count;
    
    constructor();
    begin
    end;
    
    procedure Enqueue(v: integer); // Вставляет элемент в конец.
    begin
      if _Count = MaxSize then
        raise new Exception('Переполнение очереди.');
      
      _A[_Tail] := v;
      _Tail := Succ(_Tail) mod MaxSize;
      Inc(_Count);
    end;
    
    function Dequeue(): integer; // Удаляет первый элемент и возвращает его значение.
    begin
      if _Count = 0 then
        raise new Exception('Очередь пуста.');
      
      Result := _A[_Head];
      _Head := Succ(_Head) mod MaxSize;
      Dec(_Count);
    end;
  end;

begin
  var Q := new TQueue();
  for var i := 1 to 100 do
    Q.Enqueue(i);
  for var i := 1 to 100 do
    Writeln(Q.Dequeue());
end.

Структуры данных на базе динамического массива

Стек

type
  TStack = class
  private 
    _A: array of integer;
    _Count, _Capacity: integer;
  
  public 
    property Count: integer read _Count; // Фактическое количество элементов
    property Capacity: integer read _Capacity; // Ёмкость
    
    constructor();
    begin
      _Capacity := 2;
      SetLength(_A, _Capacity);
    end;
    
    procedure Clear() := _Count := 0; // Выполняет очистку стека.
    
    procedure Push(v: integer); // Выполняет вставку числа в стек.
    begin
      Inc(_Count);
      if _Count > _Capacity then
      begin
        _Capacity *= 2;
        SetLength(_A, _Capacity);
      end;
      _A[Pred(_Count)] := v;
    end;
    
    function Pop(): integer; // Выполняет удаление последнего элемента стека.
    begin
      if _Count > 0 then
      begin
        Result := _A[Pred(_Count)];
        Dec(_Count);
      end
      else
        raise new System.InvalidOperationException('Стек пуст.');
    end;
    
    procedure Print(); // Выполняет вывод на экран стека.
    begin
      for var i := 0 to Pred(_Count) do
        if i < Pred(_Count) then
          WriteFormat('{0} ', _A[i].ToString())
        else
          Write(_A[i].ToString());
    end;
    
    procedure Println(); // Выполняет вывод на экран стека и переходит на новую строку.
    begin
      Print();
      Writeln();
    end;
  end;

begin
  var S := new TStack();
  for var i := 0 to 2 do
    S.Push(i);
  
  Writeln('Изначальный стек:');
  S.Print();
  S.Clear();
  Writeln('Пустой стек:');
  S.Print();
end.

Функции быстрого создания стека

function GenStack(params values: array of integer): TStack; // Выполняет генерацию стека на основе параметров.
begin
  Result := new TStack();
  foreach var v in values do
    Result.Push(v);
end;

Список

type
  TDynamicArray = class(System.ICloneable, System.IEquatable<TDynamicArray>)
  private 
    _A: array of integer;
    _Count, _Capacity: integer;
    
    procedure TryRaiseIndexOutOfRangeException(i: integer);
    begin
      if (i >= _Count) or (i < 0) then
        raise new System.IndexOutOfRangeException();
    end;
    
    procedure TryRaiseZeroCountException();
    begin
      if _Count = 0 then
        raise new Exception('Список пуст.');
    end;
    
    function GetItem(i: integer): integer;
    begin
      TryRaiseIndexOutOfRangeException(i);
      Result := _A[i];
    end;
    
    procedure SetItem(i: integer; v: integer);
    begin
      TryRaiseIndexOutOfRangeException(i);
      _A[i] := v;
    end;
    
    procedure TryResize();
    begin
      Inc(_Count);
      if _Count > _Capacity then
      begin
        _Capacity *= 2;
        SetLength(_A, _Capacity);
      end;
    end;
  
  public 
    property Items[i: integer]: integer read GetItem write SetItem;default;
    property Count: integer read _Count;
    property Capacity: integer read _Capacity;
    
    constructor();
    begin
      _Capacity := 2;
      SetLength(_A, _Capacity);
    end;
    
    procedure AddLast(v: integer); // Выполняет добавление элемента в конец списка.
    begin
      TryResize();
      _A[Pred(_Count)] := v;
    end;
    
    procedure RemoveLast(); // Выполняет удаление последнего элемента списка.
    begin
      TryRaiseZeroCountException();
      Dec(_Count);
    end;
    
    procedure AddFirst(v: integer); // Выполняет добавление элемента в начало списка.
    begin
      TryResize();
      for var i := Pred(_Count) downto 1 do
        _A[i] := _A[Pred(i)];
      _A[0] := v;
    end;
    
    procedure RemoveFirst(); // Выполняет удаление первого элемента списка.
    begin
      TryRaiseZeroCountException();
      for var i := 0 to _Count - 2 do
        _A[i] := _A[Succ(i)];
    end;
    
    function Seach(v1: integer): integer; // Выполняет поиск элемента по списку и возвращает его индекс (либо выбрасывает исключение при его отсутствии).
    begin
      Result := 0;
      while (Result < _Count) and (_A[Result] <> v1) do Inc(Result);
      TryRaiseIndexOutOfRangeException(Result);
    end;
    
    procedure Insert(v1, v2: integer); // Выполняет вставку элемента v2 после элемента со значением v1 в список.
    begin
      TryResize();
      var j := Seach(v1);
      for var i := Pred(_Count) downto Succ(j) do
        _A[i] := _A[Pred(i)];
      _A[j] := v2;
    end;
    
    procedure Remove(v1: integer); // Выполняет удаление элемента со значением v1 из списка.
    begin
      TryRaiseZeroCountException();
      var j := Seach(v1);
      for var i := j to _Count - 2 do
        _A[i] := _A[Succ(i)];
      Dec(_Count);
    end;
    
    procedure Remove(a: TDynamicArray); // Выполняет удаление всех элементов a из списка.
    begin
      for var i := 0 to Pred(a.Count) do
        Remove(a[i]);
    end;
    
    procedure AppendLast(a: TDynamicArray); // Выполняет добавление второго списка в конец.
    begin
      for var i := 0 to Pred(a.Count) do
        AddLast(a[i]);
    end;
    
    procedure AppendFirst(a: TDynamicArray); // Выполняет добавление второго списка в начало.
    begin
      for var i := 0 to Pred(a.Count) do
        AddFirst(a[i]);
    end;
    
    procedure Shuffle(); // Выполняет случайное перемешивание списка.
    begin
      for var i := 0 to _Count - 2 do
        Swap(_A[i], _A[Random(Succ(i), Pred(_Count))]);
    end;
    
    function &Repeat(c: integer): TDynamicArray; // Выполняет дублирование списка c раз.
    begin
      Result := new TDynamicArray();
      for var i := 1 to c do
        Result.AppendLast(self);
    end;
    
    function Clone(): object; // Выполняет полное копирование списка.
    begin
      var outcome := new TDynamicArray();
      for var i := 0 to Pred(_Count) do
        outcome.AddLast(_A[i]);
      Result := outcome;
    end;
    
    function CloneAs() := TDynamicArray(Clone());
    
    function Equals(b: TDynamicArray): boolean; // Выполняет сравнение списков.
    begin
      if _Count = b.Count then
      begin
        Result := true;
        var i := 0;
        while Result and (i < _Count) do
        begin
          Result := _A[i] = b[i];
          Inc(i);
        end;
      end;
    end;
    
    class function Readln(c: integer): TDynamicArray; // Выполняет чтение списка с клавиатуры и возвращает новый список.
    begin
      Result := new TDynamicArray();
      for var i := 1 to c do
        Result.AddLast(ReadlnInteger(Format('Value {0}:', i)));
    end;
    
    class procedure operator+=(a: TDynamicArray; v1: integer) := a.AddLast(v1);
    
    class function operator*(a: TDynamicArray; c: integer): TDynamicArray; // Выполняет дублирование списка c раз.
    begin
      Result := new TDynamicArray();
      for var i := 1 to c do
        Result.AppendLast(a);
    end;
    
    class function operator+(a: TDynamicArray; v1: integer): TDynamicArray;
    begin
      Result := a.CloneAs();
      Result.AddLast(v1);
    end;
    
    class function operator+(v1: integer; a: TDynamicArray): TDynamicArray;
    begin
      Result := a.CloneAs();
      Result.AddFirst(v1);
    end;
    
    class function operator+(a, b: TDynamicArray): TDynamicArray;
    begin
      Result := a.CloneAs();
      Result.AppendLast(b);
    end;
    
    class function operator-(a: TDynamicArray; v1: integer): TDynamicArray;
    begin
      Result := a.CloneAs();
      Result.Remove(v1);
    end;
    
    class function operator-(a, b: TDynamicArray): TDynamicArray;
    begin
      Result := a.CloneAs();
      for var i := 0 to Pred(b.Count) do
        Result.Remove(b[i]);
    end;
    
    class function operator=(a, b: TDynamicArray) := a.Equals(b);
    
    class function operator<>(a, b: TDynamicArray) := not (a = b);
    
    class function operator explicit(numbers: array of integer): TDynamicArray;
    begin
      Result := new TDynamicArray();
      foreach var number in numbers do
        Result.AddLast(number);
    end;
    
    class function operator explicit(s: string): TDynamicArray;
    begin
      var numbers := s.ToIntegers();
      Result := new TDynamicArray();
      foreach var number in numbers do
        Result.AddLast(number);
    end;
    
    procedure Print();
    begin
      for var i := 0 to Pred(_Count) do
        if i < Pred(_Count) then
          WriteFormat('{0} ', _A[i].ToString())
        else
          Write(_A[i].ToString());
    end;
    
    procedure Println();
    begin
      Print();
      Writeln();
    end;
  end;

begin
  var L := new TDynamicArray();
  
  for var i := 0 to 9 do
    L += i;
  
  L.Println();
  L.Repeat(2).Println();
  L.Shuffle();
  L.Println();
  TDynamicArray('0 12 3 4 512').Println();
end.

Функции быстрого создания списков

function DArr(params values: array of integer): TDynamicArray;
begin
  Result := new TDynamicArray();
  foreach var v in values do
    Result.AddLast(v);
end;

function DArr(params arrays: array of TDynamicArray): TDynamicArray; // Выполняет склеивание списков и возвращает новый список.
begin
  Result := new TDynamicArray();
  foreach var a in arrays do
    Result.AppendLast(a);
end;

Методы расширения

Простейшие методы

function First(self: TDynamicArray): integer; extensionmethod; // Возвращает первый элемент списка.
begin
  Result := self[0];
end;

function Last(self: TDynamicArray): integer; extensionmethod; // Возвращает последний элемент списка.
begin
  Result := self[Pred(self.Count)];
end;

function GetAt(self: TDynamicArray; i: integer): integer; extensionmethod; // Получает значение элемента с индексом i mod self.Count.
begin
  Result := self[i mod self.Count];
end;

procedure SetAt(self: TDynamicArray; i, v: integer); extensionmethod; // Устанавливает значение элемента с индексом i mod self.Count.
begin
  self[i mod self.Count] := v;
end;

function Min(self: TDynamicArray): integer; extensionmethod; // Возвращает минимальный элемент списка.
begin
  Result := integer.MaxValue;
  for var i := 0 to Pred(self.Count) do
    if Result > self[i] then
      Result := self[i];
end;

function Max(self: TDynamicArray): integer; extensionmethod; // Возвращает максимальный элемент списка.
begin
  Result := integer.MinValue;
  for var i := 0 to Pred(self.Count) do
    if Result < self[i] then
      Result := self[i];
end;

function Average(self: TDynamicArray): real; extensionmethod; // Возвращает среднее значение элементов списка.
begin
  for var i := 0 to Pred(self.Count) do
    Result += self[i];
  Result /= self.Count;
end;

function Cartesian(self, a: TDynamicArray): sequence of (integer, integer); extensionmethod; // Возвращает декартово произведение двух списков в виде кортежей вида (integer, integer).
begin
  for var i := 0 to Pred(self.Count) do
    for var j := 0 to Pred(a.Count) do
      yield (self[i], a[j]);
end;

function Reversed(self: TDynamicArray): TDynamicArray; extensionmethod;// Возвращает перевёрнутый список.
begin
  Result := self.CloneAs();
  for var i := 0 to Pred(Result.Count) div 2 do
  begin
    var i1 := Pred(Result.Count) - i;
    var c := Result[i];
    Result[i] := Result[i1];
    Result[i1] := c;
  end;
end;

function Contains(self: TDynamicArray; v1: integer): boolean; extensionmethod;
begin
  try
    self.Seach(v1);
    Result := true;
  except 
    on System.IndexOutOfRangeException do end;
end;

function operator in(v1: integer; a: TDynamicArray): boolean; extensionmethod;
begin
  Result := a.Contains(v1);
end;

function CountEqual(self, b: TDynamicArray): boolean; extensionmethod;
begin
  Result := self.Count = b.Count;
end;

function operator>(a, b: TDynamicArray): boolean; extensionmethod; // Возвращает true, если все элементы a больше элементов b.
begin
  if not a.CountEqual(b) then exit;
  var i := 0;
  while (i < a.Count) and (a[i] > b[i]) do Inc(i);
  if i = a.Count then Result := true;
end;

function operator<(a, b: TDynamicArray): boolean; extensionmethod; // Возвращает true, если все элементы a меньше элементов b.
begin
  if not a.CountEqual(b) then exit;
  var i := 0;
  while (i < a.Count) and (a[i] < b[i]) do Inc(i);
  if i = a.Count then Result := true;
end;

function operator>=(a, b: TDynamicArray): boolean; extensionmethod; // Возвращает true, если все элементы a больше или равны элементам b.
begin
  if not a.CountEqual(b) then exit;
  var i := 0;
  while (i < a.Count) and (a[i] >= b[i]) do Inc(i);
  if i = a.Count then Result := true;
end;

function operator<=(a, b: TDynamicArray): boolean; extensionmethod; // Возвращает true, если все элементы a меньше или равны элементам b.
begin
  if not a.CountEqual(b) then exit;
  var i := 0;
  while (i < a.Count) and (a[i] <= b[i]) do Inc(i);
  if i = a.Count then Result := true;
end;

function JoinIntoString(self: TDynamicArray; delim: string): string; extensionmethod; // Объединяет в строку все элементы массива, заполняя промежутки между элементами разделителем delim.
begin
  var i := 0;
  while i < self.Count do
  begin
    if i < Pred(self.Count) then
      Result += self[i] + delim
    else
      Result += self[i];
    Inc(i);
  end;
end;

function JoinIntoString(self: TDynamicArray; delims: array of string): string; extensionmethod; // Объединяет в строку все элементы массива, заполняя промежутки между элементами разделителями из массива delims.
begin
  var (i, j) := (0, 0);
  while i < self.Count do
  begin
    if i < Pred(self.Count) then
      Result += self[i] + delims[j mod delims.Length]
    else
      Result += self[i];
    Inc(i);
    Inc(j);
  end;
end;

Селектор и поиск минимума и максимума по ключу

type
  TSelector = function(x: integer): integer;
  TSelector2 = function(x, y: integer): integer;

function MinBy(self: TDynamicArray; f: TSelector): integer; extensionmethod; // Возвращает элемент списка с минимальным ключём, получаемым функцией f.
begin
  Result := integer.MaxValue;
  for var i := 0 to Pred(self.Count) do
  begin
    var outcome := f(self[i]);
    if Result > outcome then
      Result := outcome;
  end;
end;

function MaxBy(self: TDynamicArray; f: TSelector): integer; extensionmethod; // Возвращает элемент списка с максимальным ключём, получаемым функцией f.
begin
  Result := integer.MinValue;
  for var i := 0 to Pred(self.Count) do
  begin
    var outcome := f(self[i]);
    if Result < outcome then
      Result := outcome;
  end;
end;

function Select(self: TDynamicArray; f: TSelector): TDynamicArray; extensionmethod; // Возвращает список, который получается из изначального применением к каждому из его элементов функции f.
begin
  Result := new TDynamicArray();
  for var i := 0 to Pred(self.Count) do
    Result.AddLast(f(self[i]));
end;

function SelectMany(self, a: TDynamicArray; f: TSelector2): TDynamicArray; // Возвращает список из элементов, которые были получены применением функции.
begin
  Result := new TDynamicArray();
  foreach var x in self.Cartesian(a) do
    Result.AddLast(f(x.Item1, x.Item2));
end;

Срезы

type
  InvalidSliceParameterValueException = class(Exception)
  end;

function Slice(self: TDynamicArray; a: integer := 0; b: integer := 1; step: integer := 1): TDynamicArray; extensionmethod; // Возвращает срез списка.
begin
  if (step = 0) or (a < b) and (step < 0) or (a >= b) and (step > 0) then
    raise new InvalidSliceParameterValueException('Недопустимая нижняя(верхняя) граница/шаг. При a > b step должен быть больше 0, иначе step должен быть меньше 0.');
  
  Result := new TDynamicArray();
  if a < b then
  begin
    var i := a;
    while (i <= b) do
    begin
      Result.AddLast(self[i]);
      Inc(i, step);
    end;
  end
  else
  begin
    var i := a;
    while (i >= b) do
    begin
      Result.AddLast(self[i]);
      Inc(i, step);
    end;
  end
end;

Связные списки

Односвязный список

Реализация через record

type
  PNode = ^TNode;
  TNode = record
    Value: integer;
    Next: PNode;
  end;
  
  TLinkedList = PNode;

function NewNode(value: integer; next: PNode): PNode;
begin
  New(Result);
  Result^.Value := value;
  Result^.Next := next;
end;

function IsEmpty(var l: TLinkedList) := l = nil;

function GetCount(l: TLinkedList): integer;
begin
  while l <> nil do
  begin
    Inc(Result);
    l := l^.Next;
  end;
end;

procedure Clear(var l: TLinkedList);
begin
  while l <> nil do
  begin
    var l1 := l^.Next;
    Dispose(l);
    l := l1;
  end;
end;

procedure AddFirst(var l: TLinkedList; n: PNode);
begin
  n^.Next := l;
  l := n;
end;

procedure RemoveFirst(var l: TLinkedList);
begin
  if l <> nil then
    l := l^.Next;
end;

procedure Print(l: TLinkedList);
begin
  while l <> nil do
  begin
    if l^.Next <> nil then
      WriteFormat('{0} ', l^.Value)
    else
      Write(l^.Value);
    l := l^.Next;
  end;
end;

procedure Println(l: TLinkedList);
begin
  Print(l);
  Writeln();
end;

begin
  var L := NewNode(0, nil);
  
  for var i := 1 to 9 do
    AddFirst(L, NewNode(i, nil));
  
  Println(L);
  Writeln(GetCount(L));
end.

Реализация через классы

Примитивная реализация

type
  TNode = auto class
    Value: integer;
    Next: TNode;
  end;
  
  TLinkedList = TNode;

function IsEmpty(l: TLinkedList) := l = nil;

function GetCount(l: TLinkedList): integer;
begin
  while l <> nil do
  begin
    Inc(Result);
    l := l.Next;
  end;
end;

procedure Clear(var l: TLinkedList) := l := nil;

procedure AddFirst(var l: TLinkedList; n: TNode);
begin
  n.Next := l;
  l := n;
end;

procedure RemoveFirst(var l: TLinkedList);
begin
  if l <> nil then
    l := l.Next;
end;

procedure Print(l: TLinkedList);
begin
  while l <> nil do
  begin
    if l.Next <> nil then
      WriteFormat('{0} ', l.Value)
    else
      Write(l.Value);
    l := l.Next;
  end;
end;

procedure Println(l: TLinkedList);
begin
  Print(l);
  Writeln();
end;

begin
  var L := new TLinkedList(0, nil);
  
  for var i := 1 to 9 do
    AddFirst(L, new TNode(i, nil));
  
  Println(L);
  Writeln(GetCount(L));
end.

Многослойная абстракция

type
  TNode = class
  private 
    _Value: integer;
    _Next: TNode;
  
  public 
    property Value: integer read _Value write _Value;
    property Next: TNode read _Next write _Next;
    
    constructor(v: integer);
    begin
      Value := v;
    end;
  end;

type
  TLinkedList = class
  private 
    _Head: TNode;
    _Count: integer;
  
  public 
    property Head: TNode read _Head;
    property Count: integer read _Count;
    
    constructor();
    begin
    end;
    
    function IsEmpty() := _Count = 0;
    
    procedure Clear();
    begin
      _Head := nil;
      _Count := 0;
    end;
    
    procedure AddFirst(n: TNode);
    begin
      n.Next := _Head;
      _Head := n;
      Inc(_Count);
    end;
    
    procedure RemoveFirst();
    begin
      if _Head <> nil then
      begin
        _Head := _Head.Next;
        Dec(_Count);
      end;
    end;
    
    class procedure operator+=(l: TLinkedList; v: integer) := l.AddFirst(new TNode(v));
    
    procedure Print();
    begin
      var n := _Head;
      while n <> nil do
      begin
        if n.Next <> nil then
          WriteFormat('{0} ', n.Value)
        else
          Write(n.Value);
        n := n.Next;
      end;
    end;
    
    procedure Println();
    begin
      Print();
      Writeln();
    end;
  end;

begin
  var L := new TLinkedList();
  
  for var i := 0 to 9 do
    L += i;
  
  WritelnFormat('Количество элементов в списке равно {0}.', L.Count);
  L.Println();
end.

Функции трансформации в другие структуры данных:

function ToArray(): array of integer;
begin
  SetLength(Result, _Count);
  var n := _Head;
  var i := 0;
  while n <> nil do
  begin
    Result[i] := n.Value;
    n := n.Next;
    Inc(i);
  end;
end;

Функции быстрого создания списков

function Lst(params values: array of integer): TLinkedList;
begin
  Result := new TLinkedList();
  for var i := Pred(values.Length) downto 0 do
    Result.AddFirst(new TNode(values[i]));
end;

Двусвязный список с многослойной абстракцией

type
  TNode = class
  private 
    _Value: integer;
    _Next, _Previous: TNode;
  
  public 
    property Value: integer read _Value write _Value;
    property Next: TNode read _Next write _Next;
    property Previous: TNode read _Previous write _Previous;
    
    constructor(v: integer);
    begin
      Value := v;
    end;
  end;

type
  TLinkedList = class
  private 
    _Head, _Tail: TNode;
    _Count: integer;
    
    procedure TryRaiseZeroCountException();
    begin
      if _Count = 0 then
        raise new Exception('Список пуст.');
    end;
  
  public 
    property Head: TNode read _Head;
    property Tail: TNode read _Tail;
    property Count: integer read _Count;
    
    constructor();
    begin
    end;
    
    function IsEmpty() := _Count = 0;
    
    procedure Clear();
    begin
      _Head := nil;
      _Tail := nil;
      _Count := 0;
    end;
    
    procedure AddFirst(n: TNode);
    begin
      n.Next := _Head;
      n.Previous := nil;
      if _Head <> nil then
        _Head.Previous := n
      else
        _Tail := n;
      _Head := n;
      Inc(_Count);
    end;
    
    procedure RemoveFirst();
    begin
      TryRaiseZeroCountException();
      _Head := _Head.Next;
      if _Count = 1 then
        _Tail := nil;
      Dec(_Count);
    end;
    
    procedure AddLast(n: TNode);
    begin
      if _Count = 0 then
        AddFirst(n)
      else
      begin
        n.Next := nil;
        n.Previous := _Tail;
        _Tail.Next := n;
        _Tail := n;
        Inc(_Count);
      end;
    end;
    
    procedure RemoveLast();
    begin
      if _Count = 1 then
        RemoveFirst()
      else
      begin
        TryRaiseZeroCountException();
        _Tail := _Tail.Previous;
        _Tail.Next := nil;
        Dec(_Count);
      end;
    end;
    
    class function Readln(c: integer): TLinkedList;
    begin
      Result := new TLinkedList();
      for var i := 1 to c do
        Result.AddLast(new TNode(ReadlnInteger(Format('Value {0}:', i))));
    end;
    
    class procedure operator+=(var l: TLinkedList; v: integer) := l.AddLast(new TNode(v));
    
    procedure Print();
    begin
      var n := _Head;
      while n <> nil do
      begin
        if n.Next <> nil then
          WriteFormat('{0} ', n.Value)
        else
          Write(n.Value);
        n := n.Next;
      end;
    end;
    
    procedure Println();
    begin
      Print();
      Writeln();
    end;
  end;

begin
  var L := TLinkedList.Readln(ReadlnInteger('Count:'));
  L.Println();
end.

Функции быстрого создания списков

function Lst(params values: array of integer): TLinkedList;
begin
  Result := new TLinkedList();
  foreach var v in values do
    Result.AddLast(new TNode(v));
end;

Математические структуры данных

Точка

Первый подход

uses System;
const
  Eps = 1E-5; // Погрешность

type
  TPoint = class(ICloneable, IEquatable<TPoint>)
  private 
    _X, _Y: real;
  
  public 
    property X: real read _X write _X; // X координата точки
    property Y: real read _Y write _Y; // Y координата точки
    
    constructor(x_, y_: real);
    begin
      X := x_;Y := y_;
    end;
    
    function DistanceTo(p: TPoint) := Sqrt(Sqr(p.X - _X) + Sqr(p.Y - _Y)); // Возвращает дистанцию от данной точки до точки p.
    
    function GetRadiusVectorLength() := Sqrt(Sqr(_X) + Sqr(_Y)); // Получает длину радиус вектора, задаваемого координатами данной точки.
    
    function Clone(): object := new TPoint(_X, _Y);
    
    function CloneAs() := TPoint(Clone());
    
    function Equals(p: TPoint) := (Abs(_X - p.X) < Eps) and (Abs(_Y - p.Y) < Eps);
    
    class function Readln() := new TPoint(ReadlnReal('X:'), ReadlnReal('Y:')); // Выполняет чтение точки с клавиатуры и возвращает новую точку.
    
    class function operator=(a, b: TPoint) := a.Equals(b);
    
    class function operator<>(a, b: TPoint) := not (a = b);
    
    function ToString() := Format('Point({0}, {1})', _X, _Y); // Возвращает строковое представление объекта.
    
    procedure Print() := Write(ToString());
    
    procedure Println() := Writeln(ToString());
  end;

begin
  TPoint.Readln().Println();
end.

Второй подход

uses System;
const
  Eps = 1E-5; // Погрешность

type
  TPoint = class
  private 
    _X, _Y: real;
  
  public 
    property X: real read _X write _X;
    property Y: real read _Y write _Y;
    
    constructor(x_, y_: real);
    begin
      X := x_;Y := y_;
    end;
    
    class function DistanceBetween(p1, p2: TPoint) := Sqrt(Sqr(p2.X - p1.X) + Sqr(p2.Y - p1.Y));
    
    class function GetRadiusVectorLength(p: TPoint) := Sqrt(Sqr(p.X) + Sqr(p.Y));
    
    class function Clone(p: TPoint): object := new TPoint(p.X, p.Y);
    
    class function CloneAs(p: TPoint) := TPoint(Clone(p));
    
    class function Equals(p1, p2: TPoint) := (Abs(p2.X - p1.X) < Eps) and (Abs(p2.Y - p1.Y) < Eps);
    
    class function Readln() := new TPoint(ReadlnReal('X:'), ReadlnReal('Y:'));
    
    class function operator=(a, b: TPoint) := TPoint.Equals(a, b);
    
    class function operator<>(a, b: TPoint) := not (a = b);
    
    function ToString() := Format('Point({0}, {1})', _X, _Y);
    
    procedure Print() := Write(ToString());
    
    procedure Println() := Writeln(ToString());
  end;

begin
  var (A, B) := (TPoint.Readln(), TPoint.Readln());
  TPoint.DistanceBetween(A, B).Println();
  TPoint.Equals(A, B).Println();
end.

Диапазон

Первый подход

uses System;
const
  Eps = 1E-5; // Погрешность

type
  TRange = class(ICloneable, IEquatable<TRange>)
  private 
    _A, _B: real;
    _IncludeA, _IncludeB: boolean;
    
    procedure TrySwap(var less, most: real);
    begin
      if most - less < -Eps then
        Swap(less, most);
    end;
    
    procedure SetA(v: real);
    begin
      TrySwap(v, _B);
      _A := v;
    end;
    
    procedure SetB(v: real);
    begin
      TrySwap(_A, v);
      _B := v;
    end;
    
    function AreEqual(a_, b_: real) := Abs(a_ - b_) <= Eps;
  
  public 
    property A: real read _A write SetA; // Нижняя граница
    property B: real read _B write SetB; // Верхняя граница
    property IncludeA: boolean read _IncludeA write _IncludeA; // Включать ли нижнюю границу
    property IncludeB: boolean read _IncludeB write _IncludeB; // Включать ли верхнюю границу
    
    constructor(a_, b_: real);
    begin
      TrySwap(a_, b_);
      _A := a_;_B := b_;
    end;
    
    // Возвращает true, если точка внутри диапазона (учитывается Eps).
    function IsIn(c: real) := ((c - _A > Eps) or _IncludeA and AreEqual(_A, c)) and
                              ((_B - c > Eps) or _IncludeB and AreEqual(_B, c));
    
    function IsIn(r: TRange) := IsIn(r.A) and IsIn(r.B);
    
    function Clone(): object := new TRange(_A, _B);
    
    function CloneAs() := TRange(Clone());
    
    function Equals(r: TRange) := (Abs(_A - r.A) < Eps) and (Abs(_B - r.B) < Eps);
    
    class function Readln() := new TRange(ReadlnReal('A:'), ReadlnReal('B:'));
    
    class function operator in(c: real; r: TRange) := r.IsIn(c);
    
    class function operator in(r1, r2: TRange) := r2.IsIn(r1);
    
    function ToString() := Format('{0}{1}, {2}{3}', _IncludeA ? '[' : '(', _A, _B, _IncludeB ? ']' : ')');
    
    procedure Print() := Write(ToString());
    
    procedure Println() := Writeln(ToString());
  end;

begin
  var R := new TRange(-2, 2);
  R.Println();
  R.B := -8;
  R.IncludeA := true;
  R.Println();
  WritelnFormat('-4 внутри R: {0}.', -5 in R); // Эквивалентно: R.IsIn(-5).
  WritelnFormat('-2 внутри R: {0}.', -4 in R);
  WritelnFormat('Второй диапазон внутри R: {0}.', new TRange(-8, -2.1) in R);
end.

Второй подход

type
  TRange = class
  private 
    _A, _B: real;
    _IncludeA, _IncludeB: boolean;
    
    procedure TrySwap(var less, most: real);
    begin
      if most - less < -Eps then
        Swap(less, most);
    end;
    
    procedure SetA(v: real);
    begin
      TrySwap(v, _B);
      _A := v;
    end;
    
    procedure SetB(v: real);
    begin
      TrySwap(_A, v);
      _B := v;
    end;
    
    class function AreEqual(a_, b_: real) := Abs(a_ - b_) <= Eps;
  
  public 
    property A: real read _A write SetA; // Нижняя граница
    property B: real read _B write SetB; // Верхняя граница
    property IncludeA: boolean read _IncludeA write _IncludeA; // Включать ли нижнюю границу
    property IncludeB: boolean read _IncludeB write _IncludeB; // Включать ли верхнюю границу
    
    constructor(a_, b_: real);
    begin
      TrySwap(a_, b_);
      _A := a_;_B := b_;
    end;
    
    // Возвращает true, если точка внутри диапазона (учитывается Eps).
    class function IsIn(r: TRange; c: real) := ((c - r.A > Eps) or r.IncludeA and TRange.AreEqual(r.A, c)) and
                                               ((r.B - c > Eps) or r.IncludeB and TRange.AreEqual(r.B, c));
    
    class function IsIn(big, small: TRange) := TRange.IsIn(big, small.A) and TRange.IsIn(big, small.B);
    
    class function Clone(r: TRange): object := new TRange(r.A, r.B);
    
    class function CloneAs(r: TRange) := TRange(Clone(r));
    
    class function Equals(r1, r2: TRange) := (Abs(r2.A - r1.A) < Eps) and (Abs(r2.B - r1.B) < Eps);
    
    class function Readln() := new TRange(ReadlnReal('A:'), ReadlnReal('B:'));
    
    class function operator in(c: real; r: TRange) := TRange.IsIn(r, c);
    
    class function operator in(small, big: TRange) := TRange.IsIn(big, small);
    
    function ToString() := Format('{0}{1}, {2}{3}', _IncludeA ? '[' : '(', _A, _B, _IncludeB ? ']' : ')');
    
    procedure Print() := Write(ToString());
    
    procedure Println() := Writeln(ToString());
  end;

begin
  var R := new TRange(-2, 2);
  R.Println();
  R.B := -8;
  R.IncludeA := true;
  R.Println();
  WritelnFormat('-4 внутри R: {0}.', -2.1 in R);
  WritelnFormat('-2 внутри R: {0}.', -4 in R);
  WritelnFormat('Второй диапазон внутри R: {0}.', new TRange(-8, -2.1) in R);
end.

Вектора

Двумерный вектор

uses System;
const
  Eps = 1E-5; // Погрешность

type
  TVector2D = class(ICloneable, IEquatable<TVector2D>)
  private 
    _X, _Y: real;
    
    function GetLength() := Sqrt(Sqr(_X) + Sqr(_Y));
    
    function GetAngle() := Math.Atan2(_Y, _X) + 2 * Pi * Ord(_Y < 0);
  
  public 
    property X: real read _X write _X;
    property Y: real read _Y write _Y;
    property Length: real read GetLength; // Длина вектора
    property Angle: real read GetAngle; // Угол поворота вектора
    
    constructor(x_, y_: real);
    begin
      X := x_;Y := y_;
    end;
    
    procedure Normalize();
    begin
      var l := GetLength();
      _X /= l;_Y /= l;
    end;
    
    function DotProduct(v: TVector2D) := _X * v.X + _Y * v.Y; // Возвращает скалярное произведение векторов.
    
    function CrossProductAbs(v: TVector2D) := Abs(_X * v.Y - _Y * v.X); // Возвращает модуль векторного произведения (координаты z векторов self и v считаются равными 0).
    
    function IsCollinear(v: TVector2D) := CrossProductAbs(v) = 0; // Возвращает true, если векторы являются коллинеарными.
    
    procedure Add(v: TVector2D);
    begin
      _X += v.X;
      _Y += v.Y;
    end;
    
    procedure Subtract(v: TVector2D);
    begin
      _X -= v.X;
      _Y -= v.Y;
    end;
    
    procedure Multiply(k: real);
    begin
      _X *= k;
      _Y *= k;
    end;
    
    procedure Divide(k: real);
    begin
      _X /= k;
      _Y /= k;
    end;
    
    class function VectorX() := new TVector2D(1, 0);
    
    class function VectorY() := new TVector2D(0, 1);
    
    class function VectorSum(params vectors: array of TVector2D): TVector2D;// Возвращает вектор, получаемый суммированием всех векторов, указанных в параметрах.
    begin
      Result := new TVector2D(0, 0);
      foreach var vector in vectors do
        Result := Result + vector;
    end;
    
    function Clone(): object := new TVector2D(_X, _Y);
    
    function CloneAs() := TVector2D(Clone());
    
    function Equals(v: TVector2D) := (Abs(_X - v.X) < Eps) and (Abs(_Y - v.Y) < Eps);
    
    class function Readln() := new TVector2D(ReadlnInteger('X:'), ReadlnInteger('Y:'));
    
    class procedure operator+=(v, v1: TVector2D) := v.Add(v1);
    
    class procedure operator-=(v, v1: TVector2D) := v.Subtract(v1);
    
    class procedure operator*=(v: TVector2D; k: real) := v.Multiply(k);
    
    class procedure operator/=(v: TVector2D; k: real) := v.Divide(k);
    
    class function operator+(v, v1: TVector2D): TVector2D;
    begin
      Result := v.CloneAs();
      Result += v1;
    end;
    
    class function operator-(v, v1: TVector2D): TVector2D;
    begin
      Result := v.CloneAs();
      Result -= v1;
    end;
    
    class function operator*(v: TVector2D; k: real): TVector2D;
    begin
      Result := v.CloneAs();
      Result *= k;
    end;
    
    class function operator/(v: TVector2D; k: real): TVector2D;
    begin
      Result := v.CloneAs();
      Result /= k;
    end;
    
    class function operator-(v: TVector2D): TVector2D; // Возвращает новый вектор с координатами (-X, -Y).
    begin
      Result := v.CloneAs();
      Result *= -1;
    end;
    
    class function operator=(a, b: TVector2D) := a.Equals(b);
    
    class function operator<>(a, b: TVector2D) := not (a = b);
    
    function ToString() := Format('Vector({0}, {1})', _X, _Y);
    
    procedure Print() := Write(ToString());
    
    procedure Println() := Writeln(ToString());
  end;

begin
  var V1 := new TVector2D(4, 6);
  var V2 := new TVector2D(1, 3);
  Writeln((V1 + V2).ToString());
end.

Если площадь параллелограмма равна нулю, то векторы коллинеарны.

Трехмерный вектор

uses System;
const
  Eps = 1E-5; // Погрешность

type
  TVector3D = class(ICloneable, IEquatable<TVector3D>)
  private 
    _X, _Y, _Z: real;
    
    function GetLength() := Sqrt(Sqr(_X) + Sqr(_Y) + Sqr(_Z));
    
    function AreEqual(v1, v2: real) := Abs(v1 - v2) < Eps;
    
  public 
    property X: real read _X write _X;
    property Y: real read _Y write _Y;
    property Z: real read _Z write _Z;
    property Length: real read GetLength;
    
    constructor(x_, y_, z_: real);
    begin
      X := x_;Y := y_;Z := z_;
    end;
    
    procedure Normalize();
    begin
      var l := GetLength();
      _X /= l;_Y /= l;_Z /= l;
    end;
    
    function DotProduct(v: TVector3D) := _X * v.X + _Y * v.Y + _Z * v.Z;
    
    function CrossProduct(v: TVector3D) := new TVector3D(_Y * v.Z - v.Y * _Z, -(_X * v.Z - v.X * _Z), _X * v.Y - v.X * _Y);
    
    function IsCollinear(v: TVector3D) := CrossProduct(v).Length = 0;
    
    // Вычисляет смешанное произведение векторов в координатах.
    function MixedMult(v1, v2: TVector3D) := _X * v1.Y * v2.Z + _Y * v1.Z * v2.X + v1.X * v2.Y * _Z -
                                             v2.X * v1.Y * _Z - v1.X * _Y * v2.Z - v2.Y * v1.Z * _X;
    
    procedure Add(v: TVector3D);
    begin
      _X += v.X;
      _Y += v.Y;
      _Z += v.Z;
    end;
    
    procedure Subtract(v: TVector3D);
    begin
      _X -= v.X;
      _Y -= v.Y;
      _Z -= v.Z;
    end;
    
    procedure Multiply(k: real);
    begin
      _X *= k;
      _Y *= k;
      _Z *= k;
    end;
    
    procedure Divide(k: real);
    begin
      _X /= k;
      _Y /= k;
      _Z /= k;
    end;
    
    class function VectorX() := new TVector3D(1, 0, 0);
    
    class function VectorY() := new TVector3D(0, 1, 0);
    
    class function VectorZ() := new TVector3D(0, 0, 1);
    
    class function VectorSum(params vectors: array of TVector3D): TVector3D;
    begin
      Result := new TVector3D(0, 0, 0);
      foreach var vector in vectors do
        Result := Result + vector;
    end;
    
    function Clone(): object := new TVector3D(_X, _Y, _Z);
    
    function CloneAs() := TVector3D(Clone());
    
    function Equals(v: TVector3D) := AreEqual(_X, v.X) and AreEqual(_Y, v.Y) and AreEqual(_Z, v.Z);
    
    class function Readln() := new TVector3D(ReadlnInteger('X:'), ReadlnInteger('Y:'), ReadlnInteger('Z:'));
    
    class procedure operator+=(v, v1: TVector3D) := v.Add(v1);
    
    class procedure operator-=(v, v1: TVector3D) := v.Subtract(v1);
    
    class procedure operator*=(v: TVector3D; k: real) := v.Multiply(k);
    
    class procedure operator/=(v: TVector3D; k: real) := v.Divide(k);
    
    class function operator+(v, v1: TVector3D): TVector3D;
    begin
      Result := v.CloneAs();
      Result += v1;
    end;
    
    class function operator-(v, v1: TVector3D): TVector3D;
    begin
      Result := v.CloneAs();
      Result -= v1;
    end;
    
    class function operator*(v: TVector3D; k: real): TVector3D;
    begin
      Result := v.CloneAs();
      Result *= k;
    end;
    
    class function operator/(v: TVector3D; k: real): TVector3D;
    begin
      Result := v.CloneAs();
      Result /= k;
    end;
    
    class function operator-(v: TVector3D): TVector3D; // Возвращает новый вектор с координатами (-X, -Y).
    begin
      Result := v.CloneAs();
      Result *= -1;
    end;
    
    function ToString() := Format('Vector({0}, {1}, {2})', _X, _Y, _Z);
    
    procedure Print() := Write(ToString());
    
    procedure Println() := Writeln(ToString());
  end;

begin
  var (V1, V2, V3) := (new TVector3D(2, -1, 4), new TVector3D(7, 2, 3), new TVector3D(3, -2, 1));
  Writeln(V1.MixedMult(V2, V3).ToString());
end.

Что такое смешанное произведение?

Класс окружности

type
  NegativeOrZeroRadiusException = class(Exception)
  end;

type
  TCircle = class(ICloneable, IEquatable<TCircle>)
  private 
    _Center: TPoint;
    _R: real;
    
    procedure SetR(v: real);
    begin
      if v <= 0 then
        raise new NegativeOrZeroRadiusException('Отрицательный или равный нулю радиус не может быть у окружности.');
      _R := v;
    end;
    
    function GetD() := _R * 2;
    
    function GetLength() := 2 * Pi * _R;
    
  public 
    property Center: TPoint read _Center write _Center; // Центр окружности
    property R: real read _R write _R; // Радиус
    property D: real read GetD; // Диаметр
    property Length: real read GetLength; // Длина окружности
    
    constructor(c: TPoint; radius: real);
    begin
      Center := c;
      R := radius;
    end;
    
    function IntersectsWith(c: TCircle) := _Center.DistanceTo(c.Center) < _R + c.R; // Возвращает true, если окружности пересекаются.
    
    function ConcernWith(c: TCircle) := _Center.DistanceTo(c.Center) = _R + c.R; // Возвращает true, если окружности касаются друг друга.
    
    function Clone(): object := new TCircle(_Center.CloneAs(), _R);
    
    function CloneAs() := TCircle(Clone());
    
    function Equals(c: TCircle) := _Center.Equals(c.Center) and (Abs(_R - c.R) < Eps);
    
    class function Readln() := new TCircle(TPoint.Readln(), ReadlnReal('R:'));
    
    function ToString() := Format('Circle({0}, {1})', _Center.ToString(), _R);
    
    procedure Print() := Write(ToString());
    
    procedure Println() := Writeln(ToString());
  end;

begin
  (new TCircle(new TPoint(0, 0), 5)).IntersectsWith(new TCircle(new TPoint(0, 5), 5)).Println();
end.

Класс дроби

uses System;

type
  TFraction = class(ICloneable, IEquatable<TFraction>, IComparable<TFraction>)
  private 
    _Numerator, _Denominator: integer;
    _TryAlwaysReduce: boolean;
    _TryCutOutput: boolean;
  
  public 
    procedure Reduce();
    begin
      var a := _Numerator;
      var b := _Denominator;
      while (a <> 0) and (b <> 0) do
        if a > b then a := a mod b else b := b mod a;
      
      var gcd := a + b;
      _Numerator := _Numerator div gcd;
      _Denominator := _Denominator div gcd;
    end;
  
  private 
    procedure TryReduce();
    begin
      if _TryAlwaysReduce then Reduce();
    end;
    
    procedure SetDenominator(v: integer);
    begin
      if v = 0 then
        raise new Exception('Знаменатель не может быть нулем.');
      _Denominator := v;
    end;
    
    procedure SetTryAlwaysReduce(v: boolean);
    begin
      _TryAlwaysReduce := v;
      TryReduce();
    end;
  
  public 
    property Numerator: integer read _Numerator write _Numerator; // Числитель
    property Denominator: integer read _Denominator write SetDenominator; // Знаменатель
    property TryAlwaysReduce: boolean read _TryAlwaysReduce write SetTryAlwaysReduce; // Сокращать ли всегда дробь (если возможно)
    property TryCutOutput: boolean read _TryCutOutput write _TryCutOutput; // Выводить ли только числитель (если знаменатель равен единице)
    
    constructor(n: integer; dn: integer := 1);
    begin
      Numerator := n;
      Denominator := dn;
    end;
    
    function ToReal() := _Numerator / _Denominator; // Возвращает вещественное число, соответствующее данной дроби.
    
    class function FromReal(a: real): TFraction; // Возвращает дробь, соответствующую данному вещественному числу.
    begin
      var n := Frac(a);
      var d := 1;
      while Frac(n) <> 0 do
      begin
        n *= 10;
        d *= 10;
      end;
      Result := new TFraction(Trunc(n), Trunc(d));
    end;
    
    procedure Add(f: TFraction);
    begin
      if _Denominator = f.Denominator then
        _Numerator += f.Numerator
      else
      begin
        _Numerator := _Numerator * f.Denominator + f.Numerator * _Denominator;
        _Denominator *= f.Denominator;
      end;
      TryReduce();
    end;
    
    procedure Subtract(f: TFraction);
    begin
      if _Denominator = f.Denominator then
        _Numerator -= f.Numerator
      else
      begin
        _Numerator := _Numerator * f.Denominator - f.Numerator * _Denominator;
        _Denominator *= f.Denominator;
      end;
      TryReduce();
    end;
    
    procedure Multiply(f: TFraction);
    begin
      _Numerator *= f.Numerator;
      _Denominator *= f.Denominator;
      TryReduce();
    end;
    
    procedure Divide(f: TFraction);
    begin
      _Numerator *= f.Denominator;
      _Denominator *= f.Numerator;
      TryReduce();
    end;
    
    function Clone(): object := new TFraction(_Numerator, _Denominator);
    
    function CloneAs() := TFraction(Clone());
    
    function Equals(f: TFraction) := (_Numerator = f.Numerator) and (_Denominator = f.Denominator);
    
    function CompareTo(f: TFraction): integer;
    begin
      var outcome := CloneAs();
      outcome.Subtract(f);
      var r := outcome.ToReal();
      if r > 0 then
        Result := 1
      else if r < 0 then
        Result := -1;
    end;
    
    class function Readln() := new TFraction(ReadlnInteger('Numerator:'), ReadlnInteger('Denominator:'));
    
    class procedure operator+=(f1, f2: TFraction) := f1.Add(f2);
    
    class procedure operator-=(f1, f2: TFraction) := f1.Subtract(f2);
    
    class procedure operator*=(f1, f2: TFraction) := f1.Multiply(f2);
    
    class procedure operator/=(f1, f2: TFraction) := f1.Divide(f2);
    
    class procedure operator+=(f1: TFraction; n: integer) := f1 += new TFraction(n, 1);
    
    class procedure operator-=(f1: TFraction; n: integer) := f1 -= new TFraction(n, 1);
    
    class procedure operator*=(f1: TFraction; n: integer) := f1 *= new TFraction(n, 1);
    
    class procedure operator/=(f1: TFraction; n: integer) := f1 -= new TFraction(n, 1);
    
    class function operator+(f1, f2: TFraction): TFraction;
    begin
      Result := f1.CloneAs();
      Result += f2;
    end;
    
    class function operator-(f1, f2: TFraction): TFraction;
    begin
      Result := f1.CloneAs();
      Result -= f2;
    end;
    
    class function operator*(f1, f2: TFraction): TFraction;
    begin
      Result := f1.CloneAs();
      Result *= f2;
    end;
    
    class function operator/(f1, f2: TFraction): TFraction;
    begin
      Result := f1.CloneAs();
      Result /= f2;
    end;
    
    class function operator-(f1: TFraction) := new TFraction(-f1.Numerator, f1.Denominator); // Возвращает дробь с противоположным знаком (минус вносится в числитель).
    
    class function operator=(f1, f2: TFraction) := f1.Equals(f2);
    
    class function operator<>(f1, f2: TFraction) := not (f1 = f2);
    
    class function operator>(f1, f2: TFraction) := f1.CompareTo(f2) = 1;
    
    class function operator>=(f1, f2: TFraction) := (f1 - f2).ToReal() >= 0;
    
    class function operator<(f1, f2: TFraction) := f1.CompareTo(f2) = -1;
    
    class function operator<=(f1, f2: TFraction) := (f1 - f2).ToReal() <= 0;
    
    function ToString(): string; override;
    begin
      if not _TryCutOutput then
        Result := Format('{0}/{1}', _Numerator, _Denominator)
      else if _Denominator = 1 then
        Result := _Numerator.ToString();
    end;
    
    procedure Print() := Write(ToString());
    
    procedure Println() := Writeln(ToString());
  end;

begin
  var F1 := new TFraction(3, 10);
  var F2 := new TFraction(1, 5);
  F1.CompareTo(F2).Println();
  (F1 + F2).Println();
  F1.TryAlwaysReduce := true;
  F1.Println();
end.

Методы расширения

function Succ(self: TFraction): TFraction; extensionmethod; // Возвращает следующую дробь (если дробь равна, например, 2/5, то функция вернет 3/5).
begin
  Result := new TFraction(Succ(self.Numerator), self.Denominator);
end;

function Pred(self: TFraction): TFraction; extensionmethod; // Возвращает предыдущую дробь (если дробь равна, например, 4/5, то функция вернет 3/5).
begin
  Result := new TFraction(Pred(self.Numerator), self.Denominator);
end;

procedure Inc(self: TFraction); extensionmethod; // Увеличивает числитель дроби на 1.
begin
  self.Numerator += 1;
end;

procedure Dec(self: TFraction); extensionmethod; // Уменьшает числитель дроби на 1.
begin
  self.Numerator -= 1;
end;

function IsPositive(self: TFraction): boolean; extensionmethod; // Возвращает true, если дробь больше 0.
begin
  Result := self.Numerator * self.Denominator > 0;
end;

function IsNegative(self: TFraction): boolean; extensionmethod; // Возвращает true, если дробь меньше или равна 0.
begin
  Result := not self.IsPositive();
end;

Комплексное число

uses System;
const
  Eps = 1E-5; // Погрешность

type
  TComplex = class(ICloneable, IEquatable<TComplex>)
  private 
    _X, _Y: real;
  
  public 
    property X: real read _X write _X;
    property Y: real read _Y write _Y;
    
    constructor(x_, y_: real);
    begin
      X := x_;Y := y_;
    end;
    
    procedure Add(z: TComplex);
    begin
      _X += z.X;
      _Y += z.Y;
    end;
    
    procedure Subtract(z: TComplex);
    begin
      _X += z.X;
      _Y += z.Y;
    end;
    
    procedure Multiply(z: TComplex);
    begin
      var cx := _X;
      _X := _X * z.X - _Y * z.Y;
      _Y := cx * z.Y + z.X * _Y;
    end;
    
    procedure Divide(z: TComplex);
    begin
      var v := Sqr(z.X) + Sqr(z.Y);
      var cx := _X;
      _X := (_X * z.X - _Y * z.Y) / v;
      _Y := (z.X * _Y - cx * z.Y) / v;
    end;
    
    function Conjugate() := new TComplex(_X, -_Y);
    
    function Clone(): object := new TComplex(_X, _Y);
    
    function CloneAs() := TComplex(Clone());
    
    function Equals(p: TComplex) := (Abs(_X - p.X) < Eps) and (Abs(_Y - p.Y) < Eps);
    
    class function Readln() := new TComplex(ReadlnInteger('X:'), ReadlnInteger('Y:'));
    
    class procedure operator+=(z1, z2: TComplex) := z1.Add(z2);
    
    class procedure operator-=(z1, z2: TComplex) := z1.Subtract(z2);
    
    class procedure operator*=(z1, z2: TComplex) := z1.Multiply(z2);
    
    class procedure operator/=(z1, z2: TComplex) := z1.Divide(z2);
    
    class function operator+(z1, z2: TComplex): TComplex;
    begin
      Result := z1.CloneAs();
      Result += z2;
    end;
    
    class function operator-(z1, z2: TComplex): TComplex;
    begin
      Result := z1.CloneAs();
      Result -= z2;
    end;
    
    class function operator*(z1, z2: TComplex): TComplex;
    begin
      Result := z1.CloneAs();
      Result *= z2;
    end;
    
    class function operator/(z1, z2: TComplex): TComplex;
    begin
      Result := z1.CloneAs();
      Result /= z2;
    end;
    
    class function operator=(z1, z2: TComplex) := z1.Equals(z2);
    
    class function operator<>(z1, z2: TComplex) := not (z1 = z2);
    
    function ToString() := Format('Complex = {0} + i({1})', _X, _Y);
    
    procedure Print() := Write(ToString());
    
    procedure Println() := Writeln(ToString());
  end;

begin
  var Z1 := new TComplex(1, 3);
  var Z2 := new TComplex(5, -2);
  Z1.Println();
  Z2.Println();
  (Z1 * Z2).Println();
end.

Класс матрицы

type
  InvalidSizeException = class(Exception)
  end;

type
  TMatrix = class(System.ICloneable, System.IEquatable<TMatrix>)
  private 
    _A: array [,] of real;
    _RowsCount, _ColsCount: integer;
    
    procedure TryRaiseInvalidSizeException(v: integer);
    begin
      if v <= 0 then
        raise new InvalidSizeException('Недопустимое значение.');
    end;
    
    function GetItem(i, j: int64) := _A[i, j];
    
    procedure SetItem(i, j: int64; v: real) := _A[i, j] := v;
    
    procedure Resize() := SetLength(_A, _RowsCount, _ColsCount);
    
    procedure SetRowsCount(v: integer);
    begin
      TryRaiseInvalidSizeException(v);
      _RowsCount := v;
      Resize();
    end;
    
    procedure SetColCount(v: integer);
    begin
      TryRaiseInvalidSizeException(v);
      _ColsCount := v;
      Resize();
    end;
  
  public 
    property Items[i, j: int64]: real read GetItem write SetItem;default;
    property RowsCount: integer read _RowsCount write SetRowsCount;
    property ColsCount: integer read _ColsCount write SetColCount;
    
    constructor(rCount: integer := 3; cCount: integer := 3);
    begin
      RowsCount := rCount;
      ColsCount := cCount;
      Resize();
    end;
    
    function Add(k: integer): TMatrix;
    begin
      for var i := 0 to Pred(_RowsCount) do
        for var j := 0 to Pred(_ColsCount) do
          _A[i, j] += k;
      Result := self;
    end;
    
    function Subtract(k: integer) := Add(-k);
    
    function Multiply(k: integer): TMatrix;
    begin
      for var i := 0 to Pred(_RowsCount) do
        for var j := 0 to Pred(_ColsCount) do
          _A[i, j] *= k;
      Result := self;
    end;
    
    function Divide(k: integer): TMatrix;
    begin
      for var i := 0 to Pred(_RowsCount) do
        for var j := 0 to Pred(_ColsCount) do
          _A[i, j] /= k;
      Result := self;
    end;
    
    function ToZero(): TMatrix; // Заполняет матрицу нулями и возвращает ссылку на нее.
    begin
      for var i := 0 to Pred(_RowsCount) do
        for var j := 0 to Pred(_ColsCount) do
          _A[i, j] := 0;
      Result := self;
    end;
    
    function ToUnitMatrix(): TMatrix; // Возвращает единичную матрицу.
    begin
      ToZero();
      for var i := 0 to Pred(_RowsCount) do
        _A[i, i] := 1;
      Result := self;
    end;
    
    function Transpose(): TMatrix; // Транспонирует матрицу.
    begin
      Result := new TMatrix(_ColsCount, _RowsCount);
      for var i := 0 to Pred(_RowsCount) do
        for var j := 0 to Pred(_ColsCount) do
          Result[j, i] := _A[i, j];
    end;
    
    function Resize(k: integer): TMatrix; // Изменяет размер матрицы, сохраняя отношение RowsCount / ColsCount.
    begin
      TryRaiseInvalidSizeException(k);
      _RowsCount *= k;
      _ColsCount *= k;
      Result := self;
    end;
    
    function Shuffle(): TMatrix;
    begin
      for var i := 0 to Pred(_RowsCount) do
        for var j := 0 to _ColsCount - 2 do
          Swap(_A[i, j], _A[i, Random(Succ(j), Pred(_ColsCount))]);
      Result := self;
    end;
    
    function AlgebraicComplement(i, j: integer): (integer, TMatrix); // Вычисляет алгебраическое дополнение и возвращает его в виде кортежа вида (integer, TMatrix).
    begin
      var outcome := new TMatrix(Pred(_RowsCount), Pred(_ColsCount));
      for var i1 := 0 to Pred(_RowsCount) do
        for var j1 := 0 to Pred(_ColsCount) do
          if (i1 <> i) and (j1 <> j) then
          begin
            var i2 := i1 - 1 * Ord(i1 > i);
            var j2 := j1 - 1 * Ord(j1 > j);
            outcome[i2, j2] := _A[i1, j1];
          end;
      Result := (1 - 2 * Ord((i + j) mod 2 <> 0), outcome);
    end;
    
    function Clone(): object;
    begin
      var outcome := new TMatrix(_RowsCount, _ColsCount);
      for var i := 0 to Pred(_RowsCount) do
        for var j := 0 to Pred(_ColsCount) do
          outcome[i, j] := _A[i, j];
      Result := outcome;
    end;
    
    function CloneAs() := TMatrix(Clone());
    
    function Equals(m: TMatrix): boolean;
    begin
      if (_RowsCount <> m.RowsCount) or (_ColsCount <> m.ColsCount) then
        raise new System.InvalidOperationException('Матрицы имеют различные размеры.');
      
      Result := true;
      for var i := 0 to Pred(_RowsCount) do
      begin
        for var j := 0 to Pred(_ColsCount) do
          if _A[i, j] <> m[i, j] then
          begin
            Result := false;
            break;
          end;
        if not Result then break;
      end;
    end;
    
    class function Readln(rCount, cCount: integer): TMatrix;
    begin
      Result := new TMatrix(rCount, cCount);
      for var i := 0 to Pred(rCount) do
        for var j := 0 to Pred(cCount) do
          Result[i, j] := ReadlnInteger(Format('Value ({0}, {1}):', Succ(i), Succ(j)));;
    end;
    
    class procedure operator+=(m: TMatrix; k: integer) := m.Add(k);
    
    class procedure operator-=(m: TMatrix; k: integer) := m.Subtract(k);
    
    class procedure operator*=(m: TMatrix; k: integer) := m.Multiply(k);
    
    class procedure operator/=(m: TMatrix; k: integer) := m.Divide(k);
    
    class function operator+(m: TMatrix; k: integer): TMatrix;
    begin
      Result := m.CloneAs();
      Result += k;
    end;
    
    class function operator-(m: TMatrix; k: integer) := m + (-k);
    
    class function operator*(m: TMatrix; k: integer): TMatrix;
    begin
      Result := m.CloneAs();
      Result *= k;
    end;
    
    class function operator/(m: TMatrix; k: integer): TMatrix;
    begin
      Result := m.CloneAs();
      Result /= k;
    end;
    
    class function operator*(m1, m2: TMatrix): TMatrix; // Возвращает результат умножения матриц.
    begin
      Result := new TMatrix(m1.RowsCount, m2.ColsCount);
      for var i := 0 to Pred(Result.RowsCount) do
        for var j := 0 to Pred(Result.ColsCount) do
          for var k := 0 to Pred(Result.RowsCount) do
            Result[i, j] += m1[i, k] + m2[k, j];
    end;
    
    class function operator-(m: TMatrix) := m * (-1);
    
    class function operator=(m1, m2: TMatrix) := m1.Equals(m2);
    
    class function operator<>(m1, m2: TMatrix) := not (m1 = m2);
    
    function ToString() := Format('Matrix {0}x{1}', _RowsCount, _ColsCount);
    
    function Print(): TMatrix;
    begin
      Write(ToString());
      Result := self;
    end;
    
    function Println(): TMatrix;
    begin
      Result := Print();
      Write();
    end;
    
    function WritelnMatrix(width: integer := 4): TMatrix; // Выводит содержимое матрицы.
    begin
      for var i := 0 to Pred(_RowsCount) do
      begin
        for var j := 0 to Pred(_ColsCount) do
          Write(_A[i, j]:width);
        Writeln();
      end;
      Result := self;
    end;
  end;

begin
  TMatrix.Readln(ReadlnInteger('Rows count 1:'), ReadlnInteger('Cols count 1:')).WritelnMatrix();
end.

Методы расширения

function First(self: TMatrix): real; extensionmethod;
begin
  Result := self[0, 0];
end;

function Last(self: TMatrix): real; extensionmethod;
begin
  Result := self[Pred(self.RowsCount), Pred(self.ColsCount)];
end;

function Min(self: TMatrix): real; extensionmethod;
begin
  Result := integer.MaxValue;
  for var i := 0 to Pred(self.RowsCount) do
    for var j := 0 to Pred(self.ColsCount) do
      if self[i, j] < Result then
        Result := self[i, j];
end;

function Max(self: TMatrix): real; extensionmethod;
begin
  Result := integer.MinValue;
  for var i := 0 to Pred(self.RowsCount) do
    for var j := 0 to Pred(self.ColsCount) do
      if self[i, j] > Result then
        Result := self[i, j];
end;

function Average(self: TMatrix): real; extensionmethod; // Возвращает среднее значение элементов матрицы.
begin
  for var i := 0 to Pred(self.RowsCount) do
    for var j := 0 to Pred(self.ColsCount) do
      Result += self[i, j];
  Result /= self.RowsCount * self.ColsCount;
end;

function Cartesian(self, m: TMatrix): sequence of (real, real); extensionmethod; // Возвращает декартово произведение двух матриц в виде кортежей вида (integer, integer).
begin
  for var i := 0 to Pred(self.RowsCount) do
    for var j := 0 to Pred(self.ColsCount) do
      for var i1 := 0 to Pred(m.RowsCount) do
        for var j1 := 0 to Pred(m.ColsCount) do
          yield (self[i, j], m[i1, j1]);
end;

function SwapRows(self: TMatrix; i1, i2: integer): TMatrix; extensionmethod;
begin
  for var j := 0 to Pred(self.ColsCount) do
  begin
    var c := self[i1, j];
    self[i1, j] := self[i2, j];
    self[i2, j] := c;
  end;
  Result := self;
end;

function SwapCols(self: TMatrix; j1, j2: integer): TMatrix; extensionmethod;
begin
  for var i := 0 to Pred(self.RowsCount) do
  begin
    var c := self[i, j1];
    self[i, j1] := self[i, j2];
    self[i, j2] := c;
  end;
  Result := self;
end;

function SwapRowsSucc(self: TMatrix; i: integer): TMatrix; extensionmethod;
begin
  Result := self.SwapRows(i, Succ(i));
end;

function SwapRowsPred(self: TMatrix; i: integer): TMatrix; extensionmethod;
begin
  Result := self.SwapRows(i, Pred(i));
end;

function SwapColsSucc(self: TMatrix; j: integer): TMatrix; extensionmethod;
begin
  Result := self.SwapCols(j, Succ(j));
end;

function SwapColsPred(self: TMatrix; j: integer): TMatrix; extensionmethod;
begin
  Result := self.SwapCols(j, Pred(j));
end;

function InsertRow(self: TMatrix; row: array of real; i: integer): TMatrix; extensionmethod;
begin
  if row.Length <> self.ColsCount then
    raise new Exception('Длина массива не равна количеству столбцов.');
  
  self.RowsCount += 1;
  
  for var i1 := self.RowsCount - 2 downto i do
    self.SwapRowsSucc(i1);
  
  for var j := 0 to Pred(self.ColsCount) do
    self[i, j] := row[j];
  Result := self;
end;

function InsertCol(self: TMatrix; col: array of real; j: integer): TMatrix; extensionmethod;
begin
  if col.Length <> self.RowsCount then
    raise new Exception('Длина массива не равна количеству строк.');
  
  self.ColsCount += 1;
  
  for var j1 := self.ColsCount - 2 downto j do
    self.SwapColsSucc(j1);
  
  for var i := 0 to Pred(self.RowsCount) do
    self[i, j] := col[i];
  Result := self;
end;

Преобразования на плоскости

Класс линейного оператора

type
  TTransformFunc = function(x: real): real; // Тип функции преобразования.
  TLinearOperatorMatrix2D = class
  private 
    _A, _B, _C, _D: real;
  
  public 
    property A: real read _A write _A;
    property B: real read _B write _B;
    property C: real read _C write _C;
    property D: real read _D write _D;
    
    constructor(vi, vj: TVector2D; xF, yF: TTransformFunc);
    begin
      _A := xF(vi.X);_C := yF(vi.Y);
      _B := xF(vj.X);_D := yF(vj.Y);
    end;
    
    constructor(va, vb, vc, vd: real);
    begin
      _A := va;_B := vb;
      _C := vc;_D := vd;
    end;
    
    class function ScaleOperator(k: integer) := new TLinearOperatorMatrix2D(k, 0, 0, k); // Возвращает оператор масштабирования.
    
    class function BiasOperator() := new TLinearOperatorMatrix2D(1, 1, 0, 1); // Возвращает оператор сдвига плоскости.
    
    function ApplyToVector(v: TVector2D) := new TVector2D(v.X * _A + v.Y * _B, v.X * _C + v.Y * _D); // Применяет преобразование к вектору.
    
    function ToString() := Format('{0}, {1}; {2}, {3}', _A, _B, _C, _D);
    
    procedure Print() := Write(ToString());
    
    procedure Println() := Writeln(ToString());
  end;

begin
  var Op := TLinearOperatorMatrix2D.ScaleOperator(3);
  Op.Println();
  Op.ApplyToVector(new TVector2D(2, 2)).Println();
end.

Что такое линейный оператор?

Структуры данных для графики

Класс цвета

type
  TColor = class(System.ICloneable, System.IEquatable<TColor>)
  private 
    _R, _G, _B: byte;
  
    function RandomFromPair(v1, v2: byte): byte;
    begin
      Result := v1;
      if Random(100) mod 2 = 0 then
        Result := v2;
    end;
    
  public 
    property R: byte read _R write _R;
    property G: byte read _G write _G;
    property B: byte read _B write _B;
    
    constructor(r_, g_, b_: byte);
    begin
      R := r_;
      G := g_;
      B := b_;
    end;
    
    procedure Add(c1: TColor);
    begin
      (_R, _G, _B) := (_R + c1.R, _G + c1.G, _B + c1.B);
    end;
    
    procedure Subtract(c1: TColor);
    begin
      (_R, _G, _B) := (_R - c1.R, _G - c1.G, _B - c1.B);
    end;
    
    procedure Multiply(c1: TColor);
    begin
      (_R, _G, _B) := (_R * c1.R, _G * c1.G, _B * c1.B);
    end;
    
    procedure Divide(c1: TColor);
    begin
      (_R, _G, _B) := (_R div c1.R, _G div c1.G, _B div c1.B);
    end;
    
    procedure &Mod(c1: TColor);
    begin
      (_R, _G, _B) := (_R mod c1.R, _G mod c1.G, _B mod c1.B);
    end;
    
    procedure Darken(c1: TColor);
    begin
      (_R, _G, _B) := (Min(_R, c1.R), Min(_G, c1.G), Min(_B, c1.B));
    end;
    
    procedure Brighten(c1: TColor);
    begin
      (_R, _G, _B) := (Max(_R, c1.R), Max(_G, c1.G), Max(_B, c1.B));
    end;
    
    procedure RandomFrom(c1: TColor);
    begin
      (_R, _G, _B) := (RandomFromPair(_R, c1.R), RandomFromPair(_G, c1.G), RandomFromPair(_B, c1.B));
    end;
    
    procedure Invert();
    begin
      (_R, _G, _B) := (255 - _R, 255 - _G, 255 - _B);
    end;
    
    function Clone(): object := new TColor(_R, _G, _B);
    
    function CloneAs() := TColor(Clone());
    
    function Equals(c: TColor) := (_R = c.R) and (_G = c.G) and (_B = c.B);
    
    class function Readln() := new TColor(ReadlnInteger('R:'), ReadlnInteger('G:'), ReadlnInteger('B:'));
    
    class procedure operator+=(c1, c2: TColor) := c1.Add(c2);
    
    class procedure operator-=(c1, c2: TColor) := c1.Subtract(c2);
    
    class procedure operator*=(c1, c2: TColor) := c1.Multiply(c2);
    
    class function operator+(c1, c2: TColor): TColor;
    begin
      Result := c1.CloneAs();
      Result.Add(c2);
    end;
    
    class function operator-(c1, c2: TColor): TColor;
    begin
      Result := c1.CloneAs();
      Result.Subtract(c2);
    end;
    
    class function operator*(c1, c2: TColor): TColor;
    begin
      Result := c1.CloneAs();
      Result.Multiply(c2);
    end;
    
    class function operator div(c1, c2: TColor): TColor;
    begin
      Result := c1.CloneAs();
      Result.Divide(c2);
    end;
    
    class function operator mod(c1, c2: TColor): TColor;
    begin
      Result := c1.CloneAs();
      Result.Mod(c2);
    end;
    
    class function operator-(c1: TColor): TColor;
    begin
      Result := c1.CloneAs();
      Result.Invert();
    end;
    
    class function operator=(c1, c2: TColor) := c1.Equals(c2);
    
    class function operator<>(c1, c2: TColor) := not (c1 = c2);
    
    function ToString() := Format('Color({0}, {1}, {2})', _R, _G, _B);
    
    procedure Print() := Write(ToString());
    
    procedure Println() := Writeln(ToString());
  end;

begin
  (-(new TColor(155, 10, 10) + new TColor(55, 50, 10))).Println();
end.

Класс черепашки

uses GraphABC;
type
  TTurtle = class(System.ICloneable)
  private 
    _SavedX, _SavedY: real;
    _CoordinatesAreSaved: boolean;
    
    _SavedAngle: real;
    _AngleIsSaved: boolean;
    
    _X, _Y: real;
    _Step: real;
    _MustDraw: boolean;
    _Angle: real;
    
    procedure TurtleLine(x1, y1, x2, y2: real);
    begin
      if _MustDraw then
        Line(Round(x1), Round(y1), Round(x2), Round(y2));
    end;
  
  public 
    property X: real read _X; // X координата черепашки
    property Y: real read _Y; // Y координата черепашки
    property Step: real read _Step write _Step; // Длина одного шага
    property MustDraw: boolean read _MustDraw write _MustDraw; // Рисовать ли отрезки
    property Angle: real read _Angle; // Угол поворота
    property CoordinatesAreSaved: boolean read _CoordinatesAreSaved;
    property AngleIsSaved: boolean read _AngleIsSaved;
    
    constructor(a: real := 90; s: real := 50);
    begin
      _Angle := a;
      _X := Window.Width / 2;
      _Y := Window.Height / 2;
      Step := s;
      MustDraw := true;
    end;
    
    procedure DecAngle(rotation: real) := _Angle -= rotation;
    
    procedure IncAngle(rotation: real) := _Angle += rotation;
    
    procedure MoveForward(); // Выполняет смещение вперед.
    begin
      var ang := DegToRad(_Angle);
      var (x1, y1) := (_X + _Step * Cos(ang), _Y + _Step * Sin(ang));
      TurtleLine(_X, _Y, x1, y1);
      (_X, _Y) := (x1, y1);
    end;
    
    procedure MoveBackward(); // Выполняет смещение назад.
    begin
      var ang := DegToRad(_Angle);
      var (x1, y1) := (_X - _Step * Cos(ang), _Y - _Step * Sin(ang));
      TurtleLine(_X, _Y, x1, y1);
      (_X, _Y) := (x1, y1);
    end;
    
    procedure MoveTo(cx, cy: real);
    begin
      (_X, _Y) := (cx, cy);
    end;
    
    procedure SaveCoordinates(); // Сохраняет координаты
    begin
      _CoordinatesAreSaved := true;
      (_SavedX, _SavedY) := (_X, _Y);
    end;
    
    function LoadCoordinates(): boolean; // Загружает сохраненные координаты
    begin
      if not _CoordinatesAreSaved then exit;
      (_X, _Y) := (_SavedX, _SavedY);
      Result := _CoordinatesAreSaved;
    end;
    
    procedure ClearSavedCoordinates() := _CoordinatesAreSaved := false; // Отменяет сохранение координат
    
    procedure SaveAngle(); // Сохраняет угол поворота
    begin
      _AngleIsSaved := true;
      _SavedAngle := _Angle;
    end;
    
    function LoadAngle(): boolean; // Загружает сохраненный угол
    begin
      if _AngleIsSaved then
        _Angle := _SavedAngle;
      Result := _AngleIsSaved;
    end;
    
    procedure ClearSavedAngle() := _AngleIsSaved := false; // Отменяет сохранение угла
    
    function Clone(): object;
    begin
      var outcome := new TTurtle(_Angle, _Step);
      outcome.MoveTo(_X, _Y);
      outcome.MustDraw := _MustDraw;
      Result := outcome;
    end;
    
    function CloneAs() := TTurtle(Clone());
    
    function ToString() := Format('Motion vector: ({0}, {1})', _X, _Y);
    
    procedure Print() := Write(ToString());
    
    procedure Println() := Writeln(ToString());
  end;

begin
  var T := new TTurtle(45);
  T.MoveForward();
  T.DecAngle(45);
  T.MoveForward();
end.

Ссылки

Динамические структуры данных