Пересечение прямых

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;
 
type
  TLine = class(ICloneable, IEquatable<TLine>)
  private 
    _A, _B: TPoint;
    
    function GetCoefficientA() := _B.Y - _A.Y;
    
    function GetCoefficientB() := _B.X - _A.X;
    
    function GetCoefficientC() := -GetCoefficientA()*_A.X + GetCoefficientB()*_A.Y;
    
    function GetIsHorizontal() := GetCoefficientA() = 0;
    
    function GetIsVertical() := GetCoefficientB() = 0;
    
    function GetCoefficientK() := -GetCoefficientA() / GetCoefficientB();
    
  public 
    property A: TPoint read _A write _A;
    property B: TPoint read _B write _B;
    property IsHorizontal: boolean read GetIsHorizontal;
    property IsVertical: boolean read GetIsVertical;
    property CoefficientA: real read GetCoefficientA; // Коэффициент A в общем уравнении прямой
    property CoefficientB: real read GetCoefficientB; // Коэффициент B в общем уравнении прямой
    property CoefficientC: real read GetCoefficientC; // Коэффициент C в общем уравнении прямой
    property CoefficientK: real read GetCoefficientK; // K в уравнении прямой с угловым коэффициентом
    
    constructor(pA, pB: TPoint);
    begin
      A := pA;B := pB;
    end;
    
    function GetB() := -GetCoefficientC() / GetCoefficientB(); // Возвращает b в уравнении прямой с угловым коэффициентом
    
    function ToCanonicalEquation() := Format('Line[(x - {0}) / {1} = (y - {2}) / {3}]', _A.X, GetCoefficientB(), _A.Y, GetCoefficientA());
    
    function ToParametricEquation() := Format('Line[x = {0} + {1}a, y = {2} + {3}a]', _A.X, GetCoefficientB(), _A.Y, GetCoefficientA());
    
    function ToGeneralEquation() := Format('Line[{0}x + {1}y - {2} = 0]', GetCoefficientA(), GetCoefficientB(), GetCoefficientC());
    
    function ToEquationWithAngularCoefficient(): string;
    begin
      var quotient := GetCoefficientA() / GetCoefficientB();
      Result := Format('Line[{0}x + {1}]', quotient, -_A.X * quotient + A.Y);
    end;
    
    // Возвращает true, если прямые совпадают.
    function MatchesTo(l: TLine) := (GetCoefficientK() = l.CoefficientK) and (GetB() = l.GetB());
    
    // Возвращает true, если прямые параллельны.
    function ParallelTo(l: TLine) := (GetCoefficientK() = l.CoefficientK) and (GetB() <> l.GetB());
    
    // Возвращает true, если прямые пересекаются.
    function IntersectWith(l: TLine) := GetCoefficientK() <> l.CoefficientK;
    
    function GetIntersectionPoint(l: TLine): TPoint;
    begin
      if not IntersectWith(l) then
        raise new InvalidOperationException('Нет точки пересечения прямых.');
      var y := (GetCoefficientA() * l.CoefficientC - l.CoefficientA * GetCoefficientC()) / (l.CoefficientA * GetCoefficientB() - GetCoefficientA() * l.CoefficientB);
      Result := new TPoint(y, (-GetCoefficientB() * y - GetCoefficientC()) / GetCoefficientA());
    end;
    
    function Clone(): object := new TLine(_A.CloneAs(), _B.CloneAs());
    
    function CloneAs() := TLine(Clone());
    
    function Equals(l: TLine) := _A.Equals(l.A) and _B.Equals(l.B);
    
    class function Readln() := new TLine(TPoint.Readln(), TPoint.Readln());
    
    class function operator=(l1, l2: TLine) := l1.Equals(l2);
    
    class function operator<>(l1, l2: TLine) := not (l1 = l2);
    
    function ToString() := Format('Line({0}, {1})', _A.ToString(), _B.ToString());
    
    procedure Print() := Write(ToString());
    
    procedure Println() := Writeln(ToString());
  end;
 
function ToCoordsTuple(self: TLine): (real, real, real, real); extensionmethod;
begin
  Result := (self.A.X, self.A.Y, self.B.X, self.B.Y);
end;
 
begin
  var (L1, L2) := (new TLine(new TPoint(0, 0), new TPoint(1, 1)),
                   new TLine(new TPoint(0, 0), new TPoint(-1, 1)));
  L1.GetIntersectionPoint(L2).Println();
end.

uses System;
const
  eps = 1e-5;
 
type
  tPoint = class
    x, y : Real;
 
    constructor(x, y : Real);
    begin
      Self.x := x; Self.y := y;
    end;
    
  end;
 
type
  tSegment = class
    a, b : tPoint;
    
    constructor(x1, y1, x2, y2 : Real);
    begin
      a := New tPoint(x1, y1); b := New tPoint(x2, y2);
    end;
    
    function Intersections(s : tSegment) : Boolean;
    begin
      Result := False;
 
      if ( (max(max(a.x,b.x),max(s.a.x,s.b.x))-min(min(a.x,b.x),min(s.a.x,s.a.x))) -
      (max(a.x,b.x)-min(a.x,b.x)+max(s.a.x,s.b.x)-min(s.a.x,s.b.x)) ) > eps then Exit;
      
      if ( (max(max(a.y,b.y),max(s.a.y,s.b.y))-min(min(a.y,b.y),min(s.a.y,s.a.y))) -
      (max(a.y,b.y)-min(a.y,b.y)+max(s.a.y,s.b.y)-min(s.a.y,s.b.y)) ) > eps then Exit;
      
      Result := True;
      
      var d := (a.x-b.x)*(s.a.y-s.b.y) - (a.y-b.y)*(s.a.x-s.b.x);
      if d = 0 then Exit;
      
      var px := ((a.x*b.y - a.y*b.x)*(s.a.x - s.b.x) - (a.x - b.x)*(s.a.x*s.b.y - s.a.y*s.b.x)) / d;
      var py := ((a.x*b.y - a.y*b.x)*(s.a.y - s.b.y) - (a.y - b.y)*(s.a.x*s.b.y - s.a.y*s.b.x)) / d;
      
      Result := abs((max(a.x,b.x)-px) + (px-min(a.x,b.x)) - (max(a.x,b.x)-min(a.x,b.x))) < eps;
    end;
  end;
 
begin
  var(s1,s2,s3,s4) := (New tSegment(0,4,4,4), New tSegment(5,4,6,4),
                       New tSegment(1,4,-3,4), New tSegment(3,3,5,5));
  WriteLn(s1.Intersections(s2));
  WriteLn(s1.Intersections(s3));
  WriteLn(s1.Intersections(s4));
end.