void dot_product(const double* x, const double* y, double *scalar){
    *scalar = *x*(*y)+*(x+1)*(*(y+1))+*(x+2)*(*(y+2));
}
void cross_product(const double* x, const double* y, double *vector){
   *vector     =   *(x+1)*(*(y+2)) - *(x+2)*(*(y+1)); 
   *(vector+1) =  - (  *x*(*(y+2)) - *(x+2)*(*y)  );
   *(vector+2) =   *x*(*(y+1))     - *(x+1)*(*y) ; 
}
void module(const double *vect, double *mod){
    *mod = sqrt(pow(*vect,2.)+pow(*(vect+1),2.)+pow(*(vect+2),2.));
}
void dist_segm_point(const double *x, const double *a, const double *b, double *res){
    double dist_ab, proj, r_ab[3], r_ax[3], r_bx[3], tmp_vect[3];
    *r_ab     = *b     - *a;
    *(r_ab+1) = *(b+1) - *(a+1);
    *(r_ab+2) = *(b+2) - *(a+2);
    *r_ax     = *x     - *a;
    *(r_ax+1) = *(x+1) - *(a+1);
    *(r_ax+2) = *(x+2) - *(a+2);
    *r_bx     = *x     - *b;
    *(r_bx+1) = *(x+1) - *(b+1);
    *(r_bx+2) = *(x+2) - *(b+2);
    module(r_ab,&dist_ab);
    dot_product(r_ax,r_ab,&proj);
    proj /= dist_ab;
    if( proj<0 ){
        module(r_ax,res);
    } else if ( proj > dist_ab ){
        module(r_bx,res);
    } else {
       cross_product(r_ab,r_ax,tmp_vect);
       module(tmp_vect,res);
       *res /= dist_ab; 
    }
}

// ...
// эти и другие функции  нужны для  процедуры заполнения матрицы
// и вызываются только в ней:

void matrix_maker( const int n_row, const double* vect_row, const int n_col, const double* vect_col, ... , double* mtx) 
{
   int i,j;
   double xi1,yi1,zi1, ... ; 
   double xj1,yj1,zj1, ...;
   const double* ptr_j;
   for(i=0; i<n_row; ++i) {
       xi1 = *(vect_row++);
       yi1 = *(vect_row++);
       ...
       ptr_j = vect_col;
       for(j=0; j<n_col-1; ++j){
           xj1 = *(ptr_j++);
           yj1 = *(ptr_j++);
           ...
           *(mtx++) = ... ;
..

R>void dot_product(const double* x, const double* y, double *scalar){
R>    *scalar = *x*(*y)+*(x+1)*(*(y+1))+*(x+2)*(*(y+2));
R>}
R>void cross_product(const double* x, const double* y, double *vector){
R>   *vector     =   *(x+1)*(*(y+2)) - *(x+2)*(*(y+1)); 
R>   *(vector+1) =  - (  *x*(*(y+2)) - *(x+2)*(*y)  );
R>   *(vector+2) =   *x*(*(y+1))     - *(x+1)*(*y) ; 
R>}
R>void module(const double *vect, double *mod){
R>    *mod = sqrt(pow(*vect,2.)+pow(*(vect+1),2.)+pow(*(vect+2),2.));
R>}
R>void dist_segm_point(const double *x, const double *a, const double *b, double *res){
R>    double dist_ab, proj, r_ab[3], r_ax[3], r_bx[3], tmp_vect[3];
R>..
R>

double dot_product(const double x[], const double y[])
{
    return x[0]*y[0] + x[1]*y[1] + x[2]*y[2];
}

R>void module(const double *vect, double *mod){
R>    *mod = sqrt(pow(*vect,2.)+pow(*(vect+1),2.)+pow(*(vect+2),2.));
R>}

E>Так что лучше писать ПОНЯТНЕЕ

E>double dot_product(const double x[], const double y[])
E>{
E>    return x[0]*y[0] + x[1]*y[1] + x[2]*y[2];
E>}
E>

/* Subroutine int dgesvd_(char *jobu, char *jobvt, integer *m, integer *n, 
        doublereal *a, integer *lda, doublereal *s, doublereal *u, integer *
        ldu, doublereal *vt, integer *ldvt, doublereal *work, integer *lwork, 
        integer *info)
*/

    dgesvd_( &JOBU, &JOBVT, &M, &N, a, &LDA, s, uu, 
          &LDU, vt, &LDVT, wk, &LWORK, &INFO);

void cross_product(const double* __restrict__ x, const double* __restrict__  y, double * __restrict__ vector)
{
   const double x0 = x[0], x1 = x[1], x2 = x[2];
   const double y0 = y[0], y1 = y[1], y2 = y[2];

   vector[0] = x1*y2 - x2*y1; 
   vector[1] = x2*y0 - x0*y2;
   vector[2] = x0*y1 - x1*y0; 
}