ROUND()

#define ROUND(x) ((gint)floor((x) + 0.5))

Rounds a number to nearest integer. Use GWY_ROUND instead.

GWY_ROUND()

#define GWY_ROUND(x) ((gint)floor((x) + 0.5))

Rounds a number to nearest integer.

Since: 2.5

gwy_xy_new ()

GwyXY *
gwy_xy_new (gdouble x,
            gdouble y);

Creates Cartesian coordinates in plane.

This is mostly useful for language bindings.

Since: 2.47

gwy_xy_copy ()

GwyXY *
gwy_xy_copy (const GwyXY *xy);

Copies Cartesian coordinates in plane.

Since: 2.45

gwy_xy_free ()

void
gwy_xy_free (GwyXY *xy);

Frees Cartesian coordinates in plane created with gwy_xy_copy().

Since: 2.45

gwy_xyz_new ()

GwyXYZ *
gwy_xyz_new (gdouble x,
             gdouble y,
             gdouble z);

Creates Cartesian coordinates in space.

This is mostly useful for language bindings.

Since: 2.47

gwy_xyz_copy ()

GwyXYZ *
gwy_xyz_copy (const GwyXYZ *xyz);

Copies Cartesian coordinates in space.

Since: 2.45

gwy_xyz_free ()

void
gwy_xyz_free (GwyXYZ *xyz);

Frees Cartesian coordinates in space created with gwy_xyz_copy().

Since: 2.45

GwyRealFunc ()

gdouble
(*GwyRealFunc) (gdouble x,
                gpointer user_data);

gwy_math_humanize_numbers ()

gdouble
gwy_math_humanize_numbers (gdouble unit,
                           gdouble maximum,
                           gint *precision);

Finds a human-friendly representation for a range of numbers.

gwy_math_is_in_polygon ()

gboolean
gwy_math_is_in_polygon (gdouble x,
                        gdouble y,
                        const gdouble *poly,
                        guint n);

Establishes wether the test point x , y is inside the polygon poly . The polygon can be defined either clockwise or anti-clockwise and can be a concave, convex or self-intersecting polygon.

Since: 2.7

gwy_math_find_nearest_line ()

gint
gwy_math_find_nearest_line (gdouble x,
                            gdouble y,
                            gdouble *d2min,
                            gint n,
                            const gdouble *coords,
                            const gdouble *metric);

Finds the line from coords nearest to the point (x , y ).

gwy_math_find_nearest_point ()

gint
gwy_math_find_nearest_point (gdouble x,
                             gdouble y,
                             gdouble *d2min,
                             gint n,
                             const gdouble *coords,
                             const gdouble *metric);

Finds the point from coords nearest to the point (x , y ).

gwy_math_lin_solve ()

gdouble *
gwy_math_lin_solve (gint n,
                    const gdouble *matrix,
                    const gdouble *rhs,
                    gdouble *result);

Solve a regular system of linear equations.

gwy_math_lin_solve_rewrite ()

gdouble *
gwy_math_lin_solve_rewrite (gint n,
                            gdouble *matrix,
                            gdouble *rhs,
                            gdouble *result);

Solves a regular system of linear equations.

This is a memory-conservative version of gwy_math_lin_solve() overwriting matrix and rhs with intermediate results.

gwy_math_tridiag_solve_rewrite ()

gboolean
gwy_math_tridiag_solve_rewrite (gint n,
                                gdouble *d,
                                const gdouble *a,
                                const gdouble *b,
                                gdouble *rhs);

Solves a tridiagonal system of linear equations.

gwy_math_fit_polynom ()

gdouble *
gwy_math_fit_polynom (gint ndata,
                      const gdouble *xdata,
                      const gdouble *ydata,
                      gint n,
                      gdouble *coeffs);

Fits a polynom through a general (x, y) data set.

gwy_math_choleski_decompose ()

gboolean
gwy_math_choleski_decompose (gint n,
                             gdouble *matrix);

Decomposes a symmetric positive definite matrix in place.

gwy_math_choleski_solve ()

void
gwy_math_choleski_solve (gint n,
                         const gdouble *decomp,
                         gdouble *rhs);

Solves a system of linear equations with predecomposed symmetric positive definite matrix a and right hand side b .

gwy_math_choleski_invert ()

gboolean
gwy_math_choleski_invert (gint n,
                          gdouble *matrix);

Inverts a symmetric positive definite matrix in place.

Since: 2.46

gwy_math_curvature ()

guint
gwy_math_curvature (const gdouble *coeffs,
                    gdouble *kappa1,
                    gdouble *kappa2,
                    gdouble *phi1,
                    gdouble *phi2,
                    gdouble *xc,
                    gdouble *yc,
                    gdouble *zc);

Calculates curvature parameters from two-dimensional quadratic polynomial coefficients.

If the quadratic surface was obtained by fitting the dimensions of the fitted area should not differ, in the lateral coordinates used, by many orders from 1. Otherwise the recognition of flat surfaces might not work.

Curvatures have signs, positive mean a concave (cup-like) surface, negative mean a convex (cap-like) surface. They are ordered including the sign.

Directions are angles from the interval (-π/2, π/2].

If the quadratic surface is degenerate, i.e. flat in at least one direction, the centre is undefined. The centre is then chosen as the closest point the origin of coordinates. For flat surfaces this means the origin is simply returned as the centre position. Consequently, you should use Cartesian coordinates with origin in a natural centre, for instance centre of image or grain.

Since: 2.22

gwy_math_refine_maximum_1d ()

gboolean
gwy_math_refine_maximum_1d (const gdouble *y,
                            gdouble *x);

Performs subpixel refinement of parabolic a one-dimensional maximum.

The central value corresponds to x-coordinate 0, distances between values are unity. The refinement is based by fitting a parabola through the maximum. If it fails or the calculated maximum lies farther than the surrounding values the function sets the refined maximum to the origin and returns FALSE.

Since: 2.49

gwy_math_refine_maximum_2d ()

gboolean
gwy_math_refine_maximum_2d (const gdouble *z,
                            gdouble *x,
                            gdouble *y);

Performs subpixel refinement of parabolic a two-dimensional maximum.

The central value corresponds to coordinates (0,0), distances between values are unity. The refinement is based by fitting a two-dimensional parabola through the maximum. If it fails or the calculated maximum lies farther than the surrounding values the function sets the refined maximum to the origin and returns FALSE.

Since: 2.49

gwy_math_refine_maximum ()

gboolean
gwy_math_refine_maximum (const gdouble *z,
                         gdouble *x,
                         gdouble *y);

Performs subpixel refinement of parabolic a two-dimensional maximum.

An alias for gwy_math_refine_maximum_2d().

Since: 2.42

gwy_math_find_minimum_1d ()

gdouble
gwy_math_find_minimum_1d (GwyRealFunc function,
                          gdouble a,
                          gdouble b,
                          gpointer user_data);

Finds a minimum of a real function in a finite interval.

The function simply does what it says on the tin. If there are multiple minima in [a,b] any of them can be returned, even though some effort to scan the interval is made. There is no requiement for the minimum to lie inside [a,b]; if it occurrs at one of the endpoints, the endpoint is returned.

Since: 2.51

gwy_check_regular_2d_grid ()

guint *
gwy_check_regular_2d_grid (const gdouble *coords,
                           guint stride,
                           guint n,
                           gdouble tolerance,
                           guint *xres,
                           guint *yres,
                           GwyXY *xymin,
                           GwyXY *xystep);

Detects if points in plane form a regular rectangular grid oriented along the Cartesian axes.

Points lying in one straight line are not considered to form a rectangle.

When the function fails, i.e. the points do not form a regular grid, the values of output arguments are undefined.

Since: 2.48

gwy_math_median ()

gdouble
gwy_math_median (gsize n,
                 gdouble *array);

Finds median of an array of values using Quick select algorithm.

See gwy_math_kth_rank() for details of how the values are shuffled.

gwy_math_kth_rank ()

gdouble
gwy_math_kth_rank (gsize n,
                   gdouble *array,
                   gsize k);

Finds k-th item of an array of values using Quick select algorithm.

The value positions change as follows. The returned value is guaranteed to be at k -th position in the array (i.e. correctly ranked). All other values are correctly ordered with respect to this value: preceeding values are smaller (or equal) and following values are larger (or equal).

Since: 2.50

gwy_math_kth_ranks ()

void
gwy_math_kth_ranks (gsize n,
                    gdouble *array,
                    guint nk,
                    const guint *k,
                    gdouble *values);

Finds simultaneously several k-th items of an array of values.

The values are shuffled similarly to gwy_math_kth_rank(), except that the guarantee holds for all given ranks simultaneously. All values with explicitly requested ranks are at their correct positions and all values lying between them in the array are also between them numerically.

Since: 2.50

gwy_math_percentiles ()

void
gwy_math_percentiles (gsize n,
                      gdouble *array,
                      GwyPercentileInterpolationType interp,
                      guint np,
                      const gdouble *p,
                      gdouble *values);

Finds simultaneously several percentiles of an array of values.

The values in array are shuffled similarly to gwy_math_kth_ranks(). However, it is difficult to state how exactly p translates to the values that become correctly ranked (and it depends on interp ). Hence you can only assume the set of values is preserved.

Since: 2.50

gwy_math_sort ()

void
gwy_math_sort (gsize n,
               gdouble *array);

Sorts an array of doubles using a quicksort algorithm.

This is usually about twice as fast as the generic quicksort function thanks to specialization for doubles.

gwy_guint_sort ()

void
gwy_guint_sort (gsize n,
                guint *array);

Sorts an array of unsigned integers using a quicksort algorithm.

This is usually about twice as fast as the generic quicksort function thanks to specialization for integers.

Since: 2.50

gwy_math_sort_with_index ()

void
gwy_math_sort_with_index (gsize n,
                          gdouble *array,
                          guint *index_array);

Sorts an array of doubles using a quicksort algorithm, remembering the permutation.

The simplest and probably most common use of index_array is to fill it with numbers 0 to n -1 before calling gwy_math_sort(). After sorting, index_array [i ] then contains the original position of the i -th item of the sorted array.

Since: 2.50

gwy_math_trimmed_mean ()

gdouble
gwy_math_trimmed_mean (gsize n,
                       gdouble *array,
                       guint nlowest,
                       guint nhighest);

Finds trimmed mean of an array of values.

At least one value must remain after the trimming, i.e. nlowest + nhighest must be smaller than n . Usually one passes the same number as both nlowest and nhighest , but it is not a requirement.

The function can be also used to calculate normal mean values as it implements efficiently the cases when no trimming is done at either end.

Since: 2.50

gwy_math_median_uncertainty ()

gdouble
gwy_math_median_uncertainty (gsize n,
                             gdouble *array,
                             gdouble *uarray);

Find the uncertainty value corresponding to data median.

Note that this is not the uncertainty arising from the calculation of the median. It is just the uncertainty of the single value that happens to be the data median. As such, the function is not very useful.

Since: 2.23

gwy_xlnx_int ()

gdouble
gwy_xlnx_int (guint x);

Calculates natural logarithm multiplied by the argument for integers.

The value for zero x is taken as the limit, i.e. zero.

This function is useful for entropy calculations where values of n *log(n ) can be evaulated a lot for small n . Therefore, values for small arguments are tabulated. For large arguments the function is evaluated using the standard log() function which is of course slower.

Since: 2.44

gwy_sinc ()

gdouble
gwy_sinc (gdouble x);

Calculates the sinc function.

The sinc function is equal to sin(x )/x for non-zero x , and defined to the limit 1 for zero x .

Since: 2.51

gwy_canonicalize_angle ()

gdouble
gwy_canonicalize_angle (gdouble phi,
                        gboolean positive,
                        gboolean oriented);

Canonicalizes an angle to requested interval.

For positive =FALSE, oriented =FALSE the output interval is [-π/2,π/2].

For positive =FALSE, oriented =TRUE the output interval is [-π,π].

For positive =TRUE, oriented =FALSE the output interval is [0,π).

For positive =TRUE, oriented =TRUE the output interval is [0,2π).

Since: 2.50

gwy_math_histogram ()

guint
gwy_math_histogram (const gdouble *values,
                    guint n,
                    gdouble min,
                    gdouble max,
                    guint nbins,
                    guint *counts);

Counts the numbers of values falling into equal-sized bins.

The value of min must not be larger than max . The values may lie outside [min ,max ]. They are not counted in the histogram, nor the returned total.

Rounding rules for values exactly at the edge of two bins are arbitrary and must not be relied upon.

Since: 2.49

GWY_SQRT3

#define GWY_SQRT3 1.73205080756887729352744634150587236694280525381038

The square root of 3.

GWY_SQRT_PI

#define GWY_SQRT_PI 1.77245385090551602729816748334114518279754945612237

The square root of pi.

GwyXY

typedef struct {
    gdouble x;
    gdouble y;
} GwyXY;

Representation of Cartesian coordinates in plane.

Since: 2.45

GwyXYZ

typedef struct {
    gdouble x;
    gdouble y;
    gdouble z;
} GwyXYZ;

Representation of Cartesian coordinates in space.

Since: 2.45