test_interp.c File Reference

#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
#include <math.h>
#include <stdio.h>
#include <stdint.h>
#include "stub.h"
#include "../utils/interp.h"

Include dependency graph for test_interp.c:

Go to the source code of this file.

Macros
#define	DMAX(x, y)   ((x) > (y) ? (x) : (y))
#define	DMIN(x, y)   ((x) < (y) ? (x) : (y))
#define	DSIZE   3

Functions
double	modulus (double x, double mod)
static void	test_interp (void **state)
int	main (void)

Macro Definition Documentation

DMAX

#define DMAX	(		x,
			y
	)		((x) > (y) ? (x) : (y))

Definition at line 11 of file test_interp.c.

DMIN

#define DMIN	(		x,
			y
	)		((x) < (y) ? (x) : (y))

Definition at line 12 of file test_interp.c.

DSIZE

#define DSIZE   3

Definition at line 22 of file test_interp.c.

Function Documentation

main()

int main

(

void

)

Definition at line 79 of file test_interp.c.

               {
    const struct CMUnitTest tests[] = {
        cmocka_unit_test(test_interp),
    };
    return cmocka_run_group_tests_mpi(tests, NULL, NULL);
}

References test_interp().

Here is the call graph for this function:

modulus()

double modulus	(	double	x,
		double	mod
	)

Definition at line 15 of file test_interp.c.

                                     {
    if (x >= 0)
        return fmod(x,mod);
    else
        return fmod(x+mod,mod);
}

Referenced by test_interp().

Here is the caller graph for this function:

test_interp()

static void test_interp ( void **  state )

static

Definition at line 24 of file test_interp.c.

                                       {
    Interp ip;
    int64_t dims[] = {DSIZE, DSIZE};
    double ydata[DSIZE][DSIZE], ydata_sum[DSIZE][DSIZE];
    interp_init(&ip, 2, dims);
    interp_init_dim(&ip, 0, 0, DSIZE-1);
    interp_init_dim(&ip, 1, 0, DSIZE-1);
    /*Initialise the data*/
    {
        int i, j;
        for(i = 0; i < DSIZE; i++) {
            for(j = 0; j < DSIZE; j++) {
                ydata[i][j] = fabs((1. - j) * (1. - i));
                ydata_sum[i][j] = i+j;
            }
        }
    }
 
    double i, j;
    int status[2];
    for(i = -0.4; i <= DSIZE; i += 0.4) {
        for(j = -0.4; j <= DSIZE; j += 0.4) {
            double x[] = {i, j};
            double y = interp_eval(&ip, x, (double*) ydata, status);
            assert_true(status[0] == -1*(i < 0)  + (i > DSIZE-1));
            assert_true(status[1] == -1*(j < 0)  + (j > DSIZE-1));
            double yp = interp_eval_periodic (&ip, x, (double*) ydata);
            /*Note boundaries: without periodic use the maximum, with no remainers.*/
            double y_truth = fabs((1.-DMAX(DMIN(i,DSIZE-1),0))*(1.-DMAX(DMIN(j,DSIZE-1),0)));
            /* With a periodic boundary we normally use the modulus. However for this specific case
             * the boundaries happen to be identical so variation in the bin between them 
             * is ignored by the interpolator and y == yp. This is not true if you increase the range on i.*/
/*             printf("(%g %g ) %3.2f/%3.2f/%3.2f \n", i,j, y, yp, yp_truth); */
            assert_true(fabs(y - y_truth) <= 1e-5*y);
            assert_true(fabs(yp - y_truth) <= 1e-5*yp);
        }
    }
    i=0;
    for(i = -0.4; i <= 3.0; i += 0.4) {
        for(j = -0.4; j <= 3.0; j += 0.4) {
            double x[] = {i, j};
            double y = interp_eval(&ip, x, (double*) ydata_sum, status);
            double yp = interp_eval_periodic (&ip, x, (double*) ydata_sum);
            double y_truth = DMAX(DMIN(i,DSIZE-1),0)+DMAX(DMIN(j,DSIZE-1),0);
            double yp_truth = modulus(i,DSIZE)+ modulus(j, DSIZE);
/*             printf("(%g %g ) %3.2f/%3.2f/%3.2f \n", i,j, y, yp, yp_truth); */
            /*Linear interpolation is very inaccurate outside the boundaries in the periodic case!*/
            if(i >= 0 && j >= 0 && i <= DSIZE-1 && j <= DSIZE-1)
                assert_true(fabs(yp - yp_truth) <= 1e-5*yp);
            assert_true(fabs(y - y_truth) <= 1e-5*y);
        }
    }
    interp_destroy(&ip);
}

References DMAX, DMIN, DSIZE, interp_destroy(), interp_eval(), interp_eval_periodic(), interp_init(), interp_init_dim(), and modulus().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function: