HklMatrix

typedef struct {
	double data[3][3];
} HklMatrix;

HklQuaternion

typedef struct {
	double data[4];
} HklQuaternion;

HklVector

typedef struct {
	double data[3];
} HklVector;

hkl_vector_init ()

void                hkl_vector_init                     (HklVector *self,
                                                         double x,
                                                         double y,
                                                         double z);

initialize an HklVector

hkl_vector_fprintf ()

void                hkl_vector_fprintf                  (FILE *file,
                                                         const HklVector *self);

print an HklVector into a stream

hkl_vector_cmp ()

int                 hkl_vector_cmp                      (const HklVector *self,
                                                         const HklVector *vector);

compare two HklVector. this comparison use HKL_EPSILON to do the comparison.

hkl_vector_is_opposite ()

int                 hkl_vector_is_opposite              (const HklVector *self,
                                                         const HklVector *vector);

hkl_vector_add_vector ()

void                hkl_vector_add_vector               (HklVector *self,
                                                         const HklVector *vector);

add an HklVector to another one.

hkl_vector_minus_vector ()

void                hkl_vector_minus_vector             (HklVector *self,
                                                         const HklVector *vector);

substract an HklVector to another one.

hkl_vector_div_double ()

void                hkl_vector_div_double               (HklVector *self,
                                                         const double d);

divide an HklVector by constant.

hkl_vector_times_double ()

void                hkl_vector_times_double             (HklVector *self,
                                                         const double d);

multiply an HklVector by a constant value.

hkl_vector_times_vector ()

void                hkl_vector_times_vector             (HklVector *self,
                                                         const HklVector *vector);

multiply an HklVector by another one. This method multiply coordinate by coordinate.

hkl_vector_times_matrix ()

void                hkl_vector_times_matrix             (HklVector *self,
                                                         const HklMatrix *m);

hkl_vector_sum ()

double              hkl_vector_sum                      (const HklVector *self);

compute the HklVector sum of all its elements.

hkl_vector_scalar_product ()

double              hkl_vector_scalar_product           (const HklVector *self,
                                                         const HklVector *vector);

compute the scalar product of two HklVector

hkl_vector_vectorial_product ()

void                hkl_vector_vectorial_product        (HklVector *self,
                                                         const HklVector *vector);

compute the vectorial product of two vectors

hkl_vector_angle ()

double              hkl_vector_angle                    (const HklVector *self,
                                                         const HklVector *vector);

compute the angles beetween two HklVector

hkl_vector_oriented_angle ()

double              hkl_vector_oriented_angle           (const HklVector *self,
                                                         const HklVector *vector,
                                                         const HklVector *ref);

compute the angles beetween two HklVector and use a reference HklVector to orientate the space. That's way the return value can be in beetween [-pi, pi]. the (self, vector, ref) is a right oriented base.

hkl_vector_norm2 ()

double              hkl_vector_norm2                    (const HklVector *self);

compute the norm2 of an HklVector

hkl_vector_normalize ()

int                 hkl_vector_normalize                (HklVector *self);

normalize a hkl_vector

hkl_vector_is_colinear ()

int                 hkl_vector_is_colinear              (const HklVector *self,
                                                         const HklVector *vector);

check if two HklVector are colinears

hkl_vector_randomize ()

void                hkl_vector_randomize                (HklVector *self);

initialize a vector with random values. coordinates range [-1, 1]

hkl_vector_randomize_vector ()

void                hkl_vector_randomize_vector         (HklVector *self,
                                                         const HklVector *vector);

randomize an HklVector an be sure that it is not equal to the HklVector vector.

hkl_vector_randomize_vector_vector ()

void                hkl_vector_randomize_vector_vector  (HklVector *self,
                                                         const HklVector *vector1,
                                                         const HklVector *vector2);

randomize an HklVector an be sure that it is not equal to the HklVector vector1 and vector2.

hkl_vector_rotated_around_vector ()

void                hkl_vector_rotated_around_vector    (HklVector *self,
                                                         const HklVector *axe,
                                                         double angle);

rotate a vector around another one with a given angle.

hkl_vector_rotated_quaternion ()

void                hkl_vector_rotated_quaternion       (HklVector *self,
                                                         const HklQuaternion *qr);

rotate an HklVector using an HklQuaternion.

hkl_vector_is_null ()

int                 hkl_vector_is_null                  (const HklVector *self);

check if all the coordinates of an HklVector are null.

hkl_vector_project_on_plan ()

void                hkl_vector_project_on_plan          (HklVector *self,
                                                         const HklVector *plan);

project an HklVector on a plan.

todo test