<META

Details

GtsVector[3]

typedef gdouble                  GtsVector[3];

A GtsVector is just an array of three coordinates.

gts_vector_init()

#define     gts_vector_init(v, p1, p2)

Given two points p1 and p2, fills v with the coordinates of vector p1->p2.

`v` :	a GtsVector.
`p1` :	a GtsPoint.
`p2` :	another GtsPoint.

gts_vector_scalar()

#define     gts_vector_scalar(v1, v2)

Given two vectors v1 and v2 evaluates to the scalar product v1.v2.

`v1` :	a GtsVector.
`v2` :	another GtsVector.

gts_vector_cross()

#define     gts_vector_cross(C,A,B)

Given two vectors A and B fills C with the coordinates of the cross-product A^B.

`C` :	a GtsVector.
`A` :	another GtsVector.
`B` :	and another.

gts_vector_norm()

#define     gts_vector_norm(v)

v :

gts_vector_normalize()

#define     gts_vector_normalize(v)

v :

gts_vector_print ()

void        gts_vector_print                (GtsVector v,
                                             FILE *fptr);

Print s to file fptr.

`v` :	a GtsVector.
`fptr` :	a file descriptor.

GtsMatrix

typedef GtsVector                GtsMatrix;

A GtsMatrix is a 3x3 matrix.

gts_matrix_new ()

GtsMatrix*  gts_matrix_new                  (gdouble a00,
                                             gdouble a01,
                                             gdouble a02,
                                             gdouble a10,
                                             gdouble a11,
                                             gdouble a12,
                                             gdouble a20,
                                             gdouble a21,
                                             gdouble a22);

Allocates memory and initializes a new GtsMatrix.

`a00` :	element [0][0].
`a01` :	element [0][1].
`a02` :	element [0][2].
`a10` :	element [1][0].
`a11` :	element [1][1].
`a12` :	element [1][2].
`a20` :	element [2][0].
`a21` :	element [2][1].
`a22` :	element [2][2].
Returns :	a pointer to the newly created GtsMatrix.

gts_matrix_assign ()

void        gts_matrix_assign               (GtsMatrix *m,
                                             gdouble a00,
                                             gdouble a01,
                                             gdouble a02,
                                             gdouble a10,
                                             gdouble a11,
                                             gdouble a12,
                                             gdouble a20,
                                             gdouble a21,
                                             gdouble a22);

Set values of matrix elements.

`m` :	a GtsMatrix.
`a00` :	element [0][0].
`a01` :	element [0][1].
`a02` :	element [0][2].
`a10` :	element [1][0].
`a11` :	element [1][1].
`a12` :	element [1][2].
`a20` :	element [2][0].
`a21` :	element [2][1].
`a22` :	element [2][2].

gts_matrix_transpose ()

GtsMatrix*  gts_matrix_transpose            (GtsMatrix *m);

`m` :	a GtsMatrix.
Returns :	a pointer to a newly created GtsMatrix transposed of `m`.

gts_matrix_determinant ()

gdouble     gts_matrix_determinant          (GtsMatrix *m);

`m` :	a GtsMatrix.
Returns :	the value of the det(`m`).

gts_matrix_inverse ()

GtsMatrix*  gts_matrix_inverse              (GtsMatrix *m);

`m` :	a GtsMatrix.
Returns :	a pointer to a newly created GtsMatrix inverse of `m` or `NULL` if `m` is not invertible.

gts_matrix_projection ()

GtsMatrix*  gts_matrix_projection           (GtsTriangle *t);

Creates a new GtsMatrix representing the projection onto a plane of normal given by t.

`t` :	a GtsTriangle.
Returns :	a pointer to the newly created GtsMatrix.

gts_matrix_product ()

GtsMatrix*  gts_matrix_product              (GtsMatrix *m1,
                                             GtsMatrix *m2);

`m1` :	a GtsMatrix.
`m2` :	another GtsMatrix.
Returns :	a new GtsMatrix, product of `m1` and `m2`.

gts_matrix_compatible_row ()

guint       gts_matrix_compatible_row       (GtsMatrix *A,
                                             GtsVector b,
                                             guint n,
                                             GtsVector A1,
                                             gdouble b1);

Given a system of n constraints A.x=b adds to it the compatible constraints defined by A1.x=b1. The compatibility is determined by insuring that the resulting system is well-conditioned (see Lindstrom and Turk (1998, 1999)).

`A` :	a GtsMatrix.
`b` :	a GtsVector.
`n` :	the number of previous constraints of `A`.x=`b`.
`A1` :	a GtsMatrix.
`b1` :	a GtsVector.
Returns :	the number of constraints of the resulting system.

gts_matrix_quadratic_optimization ()

guint       gts_matrix_quadratic_optimization
                                            (GtsMatrix *A,
                                             GtsVector b,
                                             guint n,
                                             GtsMatrix *H,
                                             GtsVector c);

Solve a quadratic optimization problem: Given a quadratic objective function f which can be written as: f(x) = x^t.H.x + c^t.x + k, where H is the symmetric positive definite Hessian of f and k is a constant, find the minimum of f subject to the set of n prior linear constraints, defined by the first n rows of A and b (A.x = b). The new constraints given by the minimization are added to A and b only if they are linearly independent as determined by gts_matrix_compatible_row().

`A` :	a GtsMatrix.
`b` :	a GtsVector.
`n` :	the number of constraints (must be smaller than 3).
`H` :	a symmetric positive definite Hessian.
`c` :	a GtsVector.
Returns :	the new number of constraints defined by `A` and `b`.

gts_matrix_print ()

void        gts_matrix_print                (GtsMatrix *m,
                                             FILE *fptr);

Print m to file fptr.

`m` :	a GtsMatrix.
`fptr` :	a file descriptor.

gts_matrix_destroy ()

void        gts_matrix_destroy              (GtsMatrix *m);

Free all the memory allocated for m.

m : a GtsMatrix.

Vectors and matrices

Name

Synopsis

Description