Задано множество прямых на плоскости коэффициентами своих уравнений. Определить номера прямых по условию задания - C (СИ)

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <locale.h>
 
/*  данные о точке пересечения двух прямых  */
struct POINT
{   double X,Y, distance2;      /*координаты, квадрат расстояния*/
    int exist, line1, line2;    /*существует ли(для данных прямых), индексы прямых*/
};
 
/*  данные о прямой */
struct LINE
{   double A,B,C;       /*коэффициенты уравнения*/
};
 
/*  входные данные  */
double data[][3] = {{1,2,3},
                    {1.5,16,6},
                    {-8,-16,0},  /*параллельна прямой [0]*/
                    {1,0,2},
                    {16,-3,1.2}};
 
/*  создаем массив из N прямых  */
LINE **createLinesArray(int N)
{   int i;
    LINE **Lines = (LINE**) malloc(N*sizeof(LINE*));
    for(i = 0; i<N; i++)
    {   Lines[i] = (LINE*) malloc(sizeof(LINE));
        Lines[i]->A = Lines[i]->B = Lines[i]->C = 0.;   /*defaults*/
    }
 
    for(i = 0; i<N; i++)
    {   Lines[i]->A = data[i][0];
        Lines[i]->B = data[i][1];
        Lines[i]->C = data[i][2];
    }   
 
    return Lines;
}
 
/*  если две прямые не пересекаются возвращает ~ 0  */
double twoLinesIntersect(LINE *p, LINE *q)
{   return fabs(p->A * q->B - p->B * q->A);
}
 
/*  квадрат расстояния от точки до начала координат */
double distance2(POINT *p)
{   return p->X * p->X + p->Y * p->Y;
}
 
/*  создаем массив из M = N(N-1)/2 точек    */
POINT **createPointsArray(int M, int N, LINE** Lines)
{   int i, j, k;
    double epsilon = 1.E-12;    /*  точность */
    POINT **Points = (POINT**) malloc(M*sizeof(POINT*));
    for(i = 0; i<M; i++)
    {   Points[i] = (POINT*) malloc(sizeof(POINT));
        Points[i]->exist = 0;                           /*defaults*/                            
        Points[i]->line1 = Points[i]->line2 = -1;
        Points[i]->X = Points[i]->Y = Points[i]->distance2 = 0.;
    }
 
    for(j = 0, i = 0; j<N-1; j++)
        for(k = j+1; k<N; k++)
        {   Points[i]->line1 = j;
            Points[i]->line2 = k;
            if(twoLinesIntersect(Lines[j], Lines[k]) > epsilon) 
            {   Points[i]->exist = 1;
                Points[i]->X = -(Lines[j]->C * Lines[k]->B - Lines[k]->C * Lines[j]->B) / \
                                (Lines[j]->A * Lines[k]->B - Lines[k]->A * Lines[j]->B);
                Points[i]->Y = -(Lines[j]->A * Lines[k]->C - Lines[k]->A * Lines[j]->C) / \
                                (Lines[j]->A * Lines[k]->B - Lines[k]->A * Lines[j]->B);
                Points[i]->distance2 = distance2(Points[i]);
                i++;
            }
        }
 
    return Points;
}
 
/*  определение индекса точки с минимальным расстоянием*/
int findMin(POINT **Points, int M)
{   int i, res = 0;
    double min = Points[0]->distance2;
    for(i = 0; i<M; i++)
        if(Points[i]->exist)  
        {   printf("\nПрямые %d и %d - т.(%.3lf; %.3lf), расстояние до начала координат: %.3lf",
                Points[i]->line1, Points[i]->line2, Points[i]->X, Points[i]->Y, sqrt(Points[i]->distance2));
            if(Points[i]->distance2 < min)
            {   min = Points[i]->distance2;
                res = i;
            }
        }
        else
            break;
 
    return res;
}
 
int main()
{   setlocale(LC_ALL, "");
    
    int N = 4;          /*qty of lines*/
    int M = N*(N-1)/2;  /*qty of intersection points*/
 
    LINE **L = createLinesArray(N);
    POINT **P = createPointsArray(M, N, L);
 
    if(P[0]->exist)         /*  есть хотя бы одна точка пересечения */
    {   int cur = findMin(P, M);
        printf("\n\nМинимальное расстояние %.3lf - т.(%.3lf, %.3lf), пересечение прямых %d и %d",
            sqrt(P[cur]->distance2), P[cur]->X, P[cur]->Y, P[cur]->line1, P[cur]->line2);
    }
    else                    /*  все прямые параллельны или совпадают    */
        printf("\n\nПрямые не пересекаются");   
 
    getchar();
    return 0;
}