Биссектриса угла по 3 точкам

#include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>
 
#define PI acos(-1.0)
 
#define fast_cin() std::ios_base::sync_with_stdio(false); std::cin.tie(NULL); std::cout.tie(NULL)
#define precise_cout std::cout << std::setprecision(12)
 
class Point {
public:
    explicit Point(double _x = 0, double _y = 0) : x(_x), y(_y) {};
 
    void read_point() { std::cin >> x >> y; }
 
    void print_point() const {
        std::cout << "(" << x << "," << y << ")" << " ";
    }
 
    Point operator+(const Point &other) const {
        return Point(x + other.x, y + other.y);
    }
 
    Point operator-(const Point &other) const {
        return Point(x - other.x, y - other.y);
    }
 
    Point operator/(double num) const { // На 0 поделим, получим NaN - ибо нефиг так делить
        return Point(x / num, y / num);
    }
 
    Point operator*(double num) const {
        return Point(x * num, y * num);
    }
 
 
public:
    double x, y;
};
 
class Line {
public:
    explicit Line(double _a = 0, double _b = 0, double _c = 0) : A(_a), B(_b), C(_c) {}; // По коэффициентам
    Line(Point a, Point b) : A(b.y - a.y), B(a.x - b.x), C(-(A * a.x + B * a.y)) {}; // Две точки
    Line(Point a, Vector v) : A(v.b.x), B(v.b.y), C(-(A * a.x + B * a.y)) {}; // Точка и вектор нормали к этой прямой
 
    [[nodiscard]] bool is_point_on_the_line(Point p) const {
        return A * p.x + B * p.y + C == 0;
    }
 
    [[nodiscard]] bool are_two_points_on_the_same_side_of_line(Point p1, Point p2) const {
        return (A * p1.x + B * p1.y + C) * (A * p2.x + B * p2.y + C) > 0;
    }
 
    [[nodiscard]] Line get_perpendicular_line(Point p) const {
        double a = B, b = -A, c = -a * p.x - b * p.y;
        return Line(a, b, c);
    }
 
    [[nodiscard]] Line get_line_on_dist(double dist) const {
        return Line(A, B, dist * sqrt(pow(A, 2) + pow(B, 2)) + C);
    }
 
    [[nodiscard]] double get_dist_to_point(Point p) const {
        return std::abs(A * p.x + B * p.y + C) / sqrt(pow(A, 2) + pow(B, 2));
    }
 
    void print_line_equation_coefficients() const {
        precise_cout << A << " " << B << " " << C << "\n";
    }
 
    void read_line_equation_coefficients() {
        std::cin >> A >> B >> C;
    }
 
public:
    double A, B, C;
};
 
double sq(Line l) {
    return sqrt(pow(l.A, 2) + pow(l.B, 2));
}
 
int main() {
    fast_cin();
 
    Point x, y, z;
    x.read_point();
    y.read_point();
    z.read_point();
 
    Line XY(x, y), XZ(x, z);
 
    double t1 = sq(XY), t2 = sq(XZ);
 
    auto b1 = Line(XY.A * t2 + XZ.A * t1, XY.B * t2 + XZ.B * t1, XY.C * t2 + XZ.C * t1),
            b2 = Line(XY.A * t2 - XZ.A * t1, XY.B * t2 - XZ.B * t1, XY.C * t2 - XZ.C * t1);
 
    if (!b1.are_two_points_on_the_same_side_of_line(y, z)) {
        b1.print_line_equation_coefficients();
    } else { b2.print_line_equation_coefficients(); }
    return 0;
}

#include <iostream>
#include <iomanip>
#define _USE_MATH_DEFINES // for C++
#include <cmath>
 
constexpr const double GRAD_K = 180./M_PI;
 
struct Point{
    double x{}, y{};
}; 
 
// функции проверки медианы
double scalar_product(Point a, Point b){
    return a.x * b.x + a.y * b.y;
}
double length(Point a){
    return sqrt((a.x*a.x) + (a.y*a.y));
}
double cos_a(Point a, Point b){
    return scalar_product(a, b) / (length(a) * length(b));
}
double degree_from_cos(double x){
    return acos(x)*GRAD_K;
}
// конец блока проверки
 
 
// радиус вектор
Point R(Point a, Point b){
    return {b.x - a.x, b.y - a.y};
}
// сумма векторов (бисектриса дл¤ нормализованых векторов)
Point S(Point a, Point b){
    return {a.x + b.x, a.y + b.y};
}
std::ostream& operator<<(std::ostream &out, const Point& p){
    return out << '(' << p.x << ", " << p.y << ')';
}
 
// a - тточка на пр¤мой, n - направл¤ющий вектор, x - точка принадлежит пр¤мой ?
// eps - точность сравнени¤
void Test(Point a, Point n, Point x, double eps){
    bool t = fabs(((x.x - a.x) / n.x) - ((x.y - a.y) / n.y)) <= eps;
    std ::cout << std::boolalpha << "Test  : " << t << std::endl;
   
}
// нормализаци¤ радиус вектора
Point normalize(Point a){
    double al = length(a);
    return {a.x / al, a.y / al} ;
}
 
// a - тточка на пр¤мой, n - направл¤ющий вектор
void PrintCommonLineCoef(Point a, Point n){
    std::cout << std::fixed << std::setprecision(12) <<  n.y << " " << -n.x << " " << (n.y*(-a.x) - (n.x*(-a.y))) << std::endl;
}
int main(){
 
    double x1, x2, x3, y1, y2, y3;
    std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
 
    Point A = normalize( R({x1, y1}, {x2, y2}) );
    Point B = normalize( R({x1, y1}, {x3, y3}) );
 
    Point M = S(A, B);
    Point O{x1, y1};
 
    #ifndef NDEBUG
        /*
        auto copy_flags = std::cout.setf(std::fixed | );
        std::cout.precision(12);
        */
        std::cout << "Angle BAC : " 
            << degree_from_cos( cos_a( R(O, {x2, y2}), R(O, {x3, y3}) ) )<< std::endl;
        std::cout << "Angle AB AC by normalized vectors : " 
            << degree_from_cos( cos_a( A, B ) ) << std::endl;
        std::cout << "Angles between bisectrix and original normalized vectors : " << std::endl;
        std::cout << degree_from_cos( cos_a(M, A) ) << " | " << degree_from_cos( cos_a(M, B) )  << std::endl;
        
        Test(O, M, O, 1e-12);
        // левый тест
        // Test({1, 2}, {2, 1}, {3, 3}, 1e-12);
        std ::cout << "Bisectrix : "  << O << " | " << M << std::endl;
        std ::cout << "Bisectrix common line factors  : ";
 
    #endif
    PrintCommonLineCoef(O, M);
}

#include <iostream>
#include <cmath>
 
struct Point
{
    double x;
    double y;
};
 
void printCoefficients(const Point& X, const Point& Y, const Point& Z)
{
    double t1, t2, t3, t4, t1_2, t2_2, t3_2, t4_2, t5, t6, t7, t8;
    t1 = Y.x - X.x;
    t2 = Z.x - X.x;
    t3 = Y.y - X.y;
    t4 = Z.y - X.y;
    t1_2 = t1 * t1;
    t2_2 = t2 * t2;
    t3_2 = t3 * t3;
    t4_2 = t4 * t4;
    t5 = t1_2 + t3_2;
    t6 = t2_2 + t4_2;
    t7 = std::sqrt(t5);
    t8 = std::sqrt(t6);
    Point V;
    V.x = t1 / t7 + t2 / t8;
    V.y = t3 / t7 + t4 / t8;
    std::cout << "A = " << -V.y;
    std::cout << "\nB = " << V.x;
    std::cout << "\nC = " << -X.x * V.y + X.y * V.x;
}
 
 
int main()
{
    printCoefficients({3, 2}, {2, 4}, {-4, 2});
}