AdVector.h

/*
   Project: Adun

   Copyright (C) 2005 Michael Johnston & Jordi Villˆ--Freixa

   Author: Michael Johnston

   This application is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This application is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA.
*/

#ifndef VECTORS
#define VECTORS

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <gsl/gsl_rng.h>
#include <gsl/gsl_randist.h>
#include <stdio.h>


typedef struct 
{
        double length;          
        double vector[3];       
}
Vector3D;

typedef struct 
{
        double length[2];               
        double vector[6];               
}
DoubleVector3D;

typedef struct 
{
        int length;             
        int* array;     
}
IntArrayStruct;

#ifdef __GNUC__

extern inline void Ad3DVectorInit(Vector3D* vector)
{
        double* array;
        
        array = vector->vector;
        array[0] = array[1] = array[2] = 0;
        vector->length = 0;
}


extern inline int AdCartesianDistanceCheck(double* position1, double* position2, double separation)
{
        if(fabs(position1[0] - position2[0]) > separation)
                return 0;
        
        if(fabs(position1[1] - position2[1]) > separation)
                return 0;
        
        if(fabs(position1[2] - position2[2]) > separation)
                return 0;
        
        return 1;
}

extern inline int AdCartesianDistanceVectorCheck(Vector3D* separation, double distance)
{
        double* components;
        
        components = separation->vector;
        
        if(fabs(components[0]) > distance)
                return 0;
        
        if(fabs(components[1]) > distance)
                return 0;
        
        if(fabs(components[2]) > distance)
                return 0;
        
        return 1;       
}

extern inline void Ad3DVectorScalarMultiply(Vector3D* vector, double value)
{
        double* array;
        
        array = vector->vector;
        array[0] *= value;
        array[1] *= value;
        array[2] *= value;
}

extern inline double Ad3DDotProduct(Vector3D* vector_one, Vector3D* vector_two)
{
        register int i;
        double product;
        
        for(product = 0, i=3; --i>=0;)
                product += vector_one->vector[i] * vector_two->vector[i];
        
        return product;
}

extern inline void Ad3DCrossProduct(Vector3D* v_one, Vector3D* v_two, Vector3D* result)
{
        //calculate the cross product of the two vectors v_one X v_two
        result->vector[0] = v_one->vector[1]*v_two->vector[2] - v_one->vector[2]*v_two->vector[1];
        result->vector[1] = v_one->vector[2]*v_two->vector[0] - v_one->vector[0]*v_two->vector[2]; 
        result->vector[2] = v_one->vector[0]*v_two->vector[1] - v_one->vector[1]*v_two->vector[0];
}

extern inline void Ad3DVectorSubstract(Vector3D* vector_one, Vector3D* vector_two, Vector3D* result)
{
        result->vector[0] = vector_one->vector[0] - vector_two->vector[0];
        result->vector[1] = vector_one->vector[1] - vector_two->vector[1];
        result->vector[2] = vector_one->vector[2] - vector_two->vector[2];
}

extern inline void Ad3DVectorAdd(Vector3D* vector_one, Vector3D* vector_two, Vector3D* result)
{
        result->vector[0] = vector_one->vector[0] + vector_two->vector[0];
        result->vector[1] = vector_one->vector[1] + vector_two->vector[1];
        result->vector[2] = vector_one->vector[2] + vector_two->vector[2];
}

extern inline void Ad3DVectorLength(Vector3D* vec)
{
        (vec->length) =  *(vec->vector) * *(vec->vector) + *(vec->vector + 1) * *(vec->vector + 1); 
        (vec->length) += *(vec->vector + 2) * *(vec->vector + 2);
        
        (vec->length) = sqrt(vec->length);
}

extern inline void Ad3DVectorLengthSquared(Vector3D* vec)
{
        (vec->length) =  *(vec->vector) * *(vec->vector) + *(vec->vector + 1) * *(vec->vector + 1); 
        (vec->length) += *(vec->vector + 2) * *(vec->vector + 2);
}

#else

//Non-inline declarations of the above functions

void Ad3DVectorInit(Vector3D* vector);
double Ad3DDotProduct(Vector3D*, Vector3D*);
void Ad3DCrossProduct(Vector3D*, Vector3D*, Vector3D*);
void Ad3DVectorLength(Vector3D* vec);
int AdCartesianDistanceCheck(double* position1, double* position2, double separation);
int AdCartesianDistanceVectorCheck(Vector3D* separation, double distance);
void Ad3DVectorScalarMultiply(Vector3D* vector, double value);
void Ad3DVectorLengthSquared(Vector3D* vec);
void Ad3DVectorSubstract(Vector3D* vector_one, Vector3D* vector_two, Vector3D* result);
void Ad3DVectorAdd(Vector3D* vector_one, Vector3D* vector_two, Vector3D* result);

#endif


Vector3D** AdAllocate3DVectorMatrix(unsigned int numberOfRows, unsigned int numberOfColumns);

void AdFree3DVectorMatrix(Vector3D** matrix);

void AdGet3DUnitVector(Vector3D*, Vector3D*);

void AdGetRandom3DUnitVector(Vector3D* vector, gsl_rng* generator);

int AdDoubleArrayMin(double*, int);
int AdDoubleArrayMax(double*, int);

void AdIntArrayIntersectionAndDifference(IntArrayStruct *prime, IntArrayStruct *query, IntArrayStruct *intersection, IntArrayStruct *complement);
void AdIntArrayIntersection(IntArrayStruct *prime, IntArrayStruct *query, IntArrayStruct *intersection);
void AdIntArrayDifference(IntArrayStruct *prime, IntArrayStruct *query, IntArrayStruct *difference);

#endif