Пересечение отрезка и окружности

static class Doubles
{
    public static double Square(this double x)
    {
        return x * x;
    }

    public static double Sqrt(this double x)
    {
        return Math.Sqrt(x);
    }

    public static bool SafeEquals(this double left, double rigth)
    {
        const double epsilon = 1e-7;
        return Math.Abs(left - rigth) <= epsilon;
    }
}

struct Vector
{
    public Vector(double x, double y)
        : this()
    {
        X = x;
        Y = y;
    }

    public double Length
    {
        get { return (X.Square() + Y.Square()).Sqrt(); }
    }

    public double X { get; private set; }
    public double Y { get; private set; }

    public static Vector operator+(Vector left, Vector right)
    {
        return new Vector(left.X + right.X, left.Y + right.Y);
    }

    public static Vector operator-(Vector minuend, Vector substrahend)
    {
        return new Vector(minuend.X - substrahend.X, minuend.Y - substrahend.Y);
    }

    public static double operator*(Vector left, Vector right)
    {
        return left.X*right.X + left.Y*right.Y;
    }

    public static Vector operator *(double ratio, Vector v)
    {
        return new Vector(v.X*ratio, v.Y*ratio);
    }

    public static Vector operator * (Vector v, double ratio)
    {
        return ratio * v;
    }

    public Vector Normalize()
    {
        double length = Length;
        if (length.SafeEquals(0.0))
            throw new InvalidOperationException("Attempt to normalize zero-length vector");

        return new Vector(X / length, Y / length);
    }
}

struct Pair<T>
{
    public Pair(T first, T second)
        : this()
    {
        First = first;
        Second = second;
    }

    public T First { get; private set; }
    public T Second { get; private set; }
}

class Circle
{
    public Circle(Vector center, double radius)
    {
        Center = center;
        Radius = radius;
    }

    public Vector Center { get; private set; }
    public double Radius { get; private set; }
}

struct Line
{
    public Line(Vector pivot, Vector direction)
        : this()
    {
        U = pivot;
        V = direction;
    }

    public static Line FromPoints(Vector p1, Vector p2)
    {
        return new Line(p1, p2 - p1);
    }

    public Vector U { get; private set; }
    public Vector V { get; private set; }

    public Pair<Vector>? Intersect(Circle circle)
    {
        Vector g = U - circle.Center;
       
        double a = V * V;
        double b = 2 * (V * g);
        double c = g*g - circle.Radius.Square();
        double d = b.Square() - 4*a*c;

        if (d < 0)
            return null;

        double sqrt_from_d = d.Sqrt();
        double double_a = 2*a;

        double first = (-b - sqrt_from_d)/double_a;
        double second = (-b + sqrt_from_d)/double_a;

        return new Pair<Vector>(PointFromRatio(first), PointFromRatio(second));
    }

    public Line Normalize()
    {
        return new Line(U, V.Normalize());
    }

    public Vector PointFromRatio(double ratio)
    {
        return U + V*ratio;
    }

    public bool Contains(Vector p)
    {
        if (V.X.SafeEquals(0d))
            return p.X.SafeEquals(U.X);

        if (V.Y.SafeEquals(0d))
            return p.Y.SafeEquals(U.Y);
       
        return ((p.X - U.X) / V.X).SafeEquals((p.Y - U.Y) / V.Y);
    }
}

...

struct Line
{
    ...
   
    public Pair<double>? Intersect(Circle circle)
    {
        Vector g = U - circle.Center;
       
        double a = V * V;
        double b = 2 * (V * g);
        double c = g*g - circle.Radius.Square();
        double d = b.Square() - 4*a*c;
   
        if (d < 0)
            return null;
   
        double sqrt_from_d = d.Sqrt();
        double double_a = 2*a;
   
        double first = (-b - sqrt_from_d)/double_a;
        double second = (-b + sqrt_from_d)/double_a;
   
        return new Pair<double>(first, second);
    }
}

struct Segment
{
    public readonly Vector Start;
    public readonly Vector End;
   
    public Segment(Vector start, Vector end)
    {
        Start = start;
        End = end;
    }
   
    public bool IntersectsWith(Circle circle)
    {
        Line line = Line.FromPoints(Start, End);
        Pair<double>? intersection = line.Intersect(circle);
       
        if (!intersection.HasValue)
            return false;
           
        Pair<double> value = intersection.Value;
        double first = value.First;
        double second = value.Second;
       
        // Не пересекает в двух случаях:
        // 1. first < 0 && second < 0;
        // 2. first > 1 && second > 1.
       
        // !((first < 0 && second < 0) || (first > 1 && secons > 1))
        return (first >= 0d || second >= 0d) && (first <= 1d || second <= 1d);
    }    
}