7310596312

Committed 23 Dec 2023 09:33PM UTC coverage: 55.262% (-0.02%) from 55.278%

Build # 7310596312

Build Type

Pull #85

github

Committed by

web-flow

Commit Message

Merge 028c85e48 into eb5e3f39f

Pull Request Pull Request #85: Xcor cmp

Run Details

7283 of 12566 branches covered (0.0%)

Branch coverage included in aggregate %.

21 of 69 new or added lines in 2 files covered. (30.43%)

11 existing lines in 4 files now uncovered.

47969 of 87415 relevant lines covered (54.88%)

1680664.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.19

/tests/test_ncm_stats_dist_kernel.c

/***************************************************************************
 *            test_ncm_stats_dist.c
 *
 *  Wed November 07 17:57:28 2018
 *  Copyright  2018  Sandro Dias Pinto Vitenti
 *  <vitenti@uel.br>
 ****************************************************************************/
/*
 * numcosmo
 * Copyright (C) Sandro Dias Pinto Vitenti 2018 <vitenti@uel.br>
 * numcosmo 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 3 of the License, or
 * (at your option) any later version.
 *
 * numcosmo 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifdef HAVE_CONFIG_H
#  include "config.h"
#undef GSL_RANGE_CHECK_OFF
#endif /* HAVE_CONFIG_H */
#include <numcosmo/numcosmo.h>

#include <math.h>
#include <glib.h>
#include <glib-object.h>
#include <gsl/gsl_randist.h>
#include <gsl/gsl_statistics_double.h>
#include <gsl/gsl_randist.h>
#include <gsl/gsl_cdf.h>

typedef enum _NcmStatsDistKernelType
{
  NCM_STATS_DIST_KERNEL_TYPE_GAUSS,
  NCM_STATS_DIST_KERNEL_TYPE_ST3,
} NcmStatsDistKernelType;

typedef struct _TestNcmStatsDistKernel
{
  NcmStatsDistKernel *kernel;
  NcmMSet *mset;
  NcmStatsDistKernelType kernel_type;
  gdouble nu;
  guint dim;
  guint nfail;
} TestNcmStatsDistKernel;


static void test_ncm_stats_dist_kernel_new_st (TestNcmStatsDistKernel *test, gconstpointer pdata);
static void test_ncm_stats_dist_kernel_new_gauss (TestNcmStatsDistKernel *test, gconstpointer pdata);

static void test_ncm_stats_dist_kernel_dim (TestNcmStatsDistKernel *test, gconstpointer pdata);
static void test_ncm_stats_dist_kernel_bandwidth (TestNcmStatsDistKernel *test, gconstpointer pdata);
static void test_ncm_stats_dist_kernel_norm (TestNcmStatsDistKernel *test, gconstpointer pdata);
static void test_ncm_stats_dist_kernel_sum (TestNcmStatsDistKernel *test, gconstpointer pdata);
static void test_ncm_stats_dist_kernel_sample (TestNcmStatsDistKernel *test, gconstpointer pdata);

static void test_ncm_stats_dist_kernel_free (TestNcmStatsDistKernel *test, gconstpointer pdata);

static void test_ncm_stats_dist_kernel_traps (TestNcmStatsDistKernel *test, gconstpointer pdata);
static void test_ncm_stats_dist_kernel_invalid_stub (TestNcmStatsDistKernel *test, gconstpointer pdata);

typedef struct _TestNcmStatsDistKernelFunc
{
  const gchar *name;

  void (*test_func) (TestNcmStatsDistKernel *test, gconstpointer pdata);
} TestNcmStatsDistKernelFunc;

#define TEST_NCM_STATS_DIST_KERNEL_CONSTRUCTORS_LEN 2
#define TEST_NCM_STATS_DIST_KERNEL_TESTS_LEN 5

static TestNcmStatsDistKernelFunc constructors[TEST_NCM_STATS_DIST_KERNEL_CONSTRUCTORS_LEN] = {
  {"gauss", &test_ncm_stats_dist_kernel_new_gauss},
  {"st",  &test_ncm_stats_dist_kernel_new_st}
};

static TestNcmStatsDistKernelFunc tests[TEST_NCM_STATS_DIST_KERNEL_TESTS_LEN] = {
  {"dim",   &test_ncm_stats_dist_kernel_dim},
  {"band",        &test_ncm_stats_dist_kernel_bandwidth},
  {"gauss/norm",        &test_ncm_stats_dist_kernel_norm},
  {"sum",         &test_ncm_stats_dist_kernel_sum},
  {"sample",      &test_ncm_stats_dist_kernel_sample},
};

gint
main (gint argc, gchar *argv[])
{
  gint i, j;

  g_test_init (&argc, &argv, NULL);

  ncm_cfg_init_full_ptr (&argc, &argv);
  ncm_cfg_enable_gsl_err_handler ();

  g_test_set_nonfatal_assertions ();

  for (i = 0; i < TEST_NCM_STATS_DIST_KERNEL_CONSTRUCTORS_LEN; i++)
  {
    for (j = 0; j < TEST_NCM_STATS_DIST_KERNEL_TESTS_LEN; j++)
    {
      gchar *test_name = g_strdup_printf ("/ncm/stats/dist/kernel/%s/%s", constructors[i].name, tests[j].name);

      g_test_add (test_name, TestNcmStatsDistKernel, NULL, constructors[i].test_func, tests[j].test_func, &test_ncm_stats_dist_kernel_free);
      g_free (test_name);
    }
  }

  g_test_add ("/ncm/stats/dist/kernel/gauss/traps", TestNcmStatsDistKernel, NULL,
              &test_ncm_stats_dist_kernel_new_gauss,
              &test_ncm_stats_dist_kernel_traps,
              &test_ncm_stats_dist_kernel_free);

  g_test_add ("/ncm/stats/dist/kernel/gauss/invalid/stub/subprocess", TestNcmStatsDistKernel, NULL,
              &test_ncm_stats_dist_kernel_new_gauss,
              &test_ncm_stats_dist_kernel_invalid_stub,
              &test_ncm_stats_dist_kernel_free);

  g_test_run ();
}

static void
test_ncm_stats_dist_kernel_new_gauss (TestNcmStatsDistKernel *test, gconstpointer pdata)
{
  const guint dim                    = g_test_rand_int_range (2, 4);
  NcmStatsDistKernelGauss *sdk_gauss = ncm_stats_dist_kernel_gauss_new (dim);

  test->dim         = dim;
  test->kernel      = NCM_STATS_DIST_KERNEL (sdk_gauss);
  test->kernel_type = NCM_STATS_DIST_KERNEL_TYPE_GAUSS;
  test->nfail       = 0;

  ncm_stats_dist_kernel_gauss_ref (sdk_gauss);
  ncm_stats_dist_kernel_gauss_free (sdk_gauss);
  {
    NcmStatsDistKernelGauss *sdk_gauss0 = ncm_stats_dist_kernel_gauss_ref (sdk_gauss);

    ncm_stats_dist_kernel_gauss_clear (&sdk_gauss0);
    g_assert_true (sdk_gauss0 == NULL);
  }
}

static void
test_ncm_stats_dist_kernel_new_st (TestNcmStatsDistKernel *test, gconstpointer pdata)
{
  const gdouble nu             = g_test_rand_double_range (3.0, 5.0);
  const guint dim              = g_test_rand_int_range (2, 4);
  NcmStatsDistKernelST *sdk_st = ncm_stats_dist_kernel_st_new (dim, nu);

  test->dim         = dim;
  test->nu          = nu;
  test->kernel_type = NCM_STATS_DIST_KERNEL_TYPE_ST3;
  test->kernel      = NCM_STATS_DIST_KERNEL (sdk_st);
  test->nfail       = 0;

  ncm_stats_dist_kernel_st_ref (sdk_st);
  ncm_stats_dist_kernel_st_free (sdk_st);
  {
    NcmStatsDistKernelST *sdk_st0 = ncm_stats_dist_kernel_st_ref (sdk_st);

    ncm_stats_dist_kernel_st_clear (&sdk_st0);
    g_assert_true (sdk_st0 == NULL);
  }
}

static void
test_ncm_stats_dist_kernel_dim (TestNcmStatsDistKernel *test, gconstpointer pdata)
{
  g_assert_true (test->dim == ncm_stats_dist_kernel_get_dim (test->kernel));
}

static void
test_ncm_stats_dist_kernel_bandwidth (TestNcmStatsDistKernel *test, gconstpointer pdata)
{
  const gdouble n = g_test_rand_double_range (1.0, 200.0);
  const gdouble h = ncm_stats_dist_kernel_get_rot_bandwidth (test->kernel, n);
  gdouble h_test  = 0.0;

  switch (test->kernel_type)
  {
    case NCM_STATS_DIST_KERNEL_TYPE_GAUSS:
      h_test = pow (4.0 / (n * (test->dim + 2.0)), 1.0 / (test->dim + 4.0));
      break;
    case NCM_STATS_DIST_KERNEL_TYPE_ST3:
      h_test = pow (16.0 * gsl_pow_2 (test->nu - 2) * (1.0 + test->dim + test->nu) * (3.0 + test->dim + test->nu) / ((2.0 + test->dim) * (test->dim + test->nu) * (2.0 + test->dim + test->nu) * (test->dim + 2.0 * test->nu) * (2.0 + test->dim + 2.0 * test->nu) * n), 1.0 / (test->dim + 4.0));
      break;
    default:
      g_assert_not_reached ();
      break;
  }

  ncm_assert_cmpdouble_e (h_test, ==, h, 1.0e-14, 0.0);
}

#define TESTMULT 200

static void
test_ncm_stats_dist_kernel_norm (TestNcmStatsDistKernel *test, gconstpointer pdata)
{
  NcmRNG *rng                    = ncm_rng_seeded_new (NULL, g_test_rand_int ());
  NcmDataGaussCovMVND *data_mvnd = ncm_data_gauss_cov_mvnd_new_full (test->dim, 1.0e-2, 5.0e-1, 1.0, -2.0, 2.0, rng);
  NcmModelMVND *model_mvnd       = ncm_model_mvnd_new (test->dim);
  NcmMSet *mset                  = ncm_mset_new (NCM_MODEL (model_mvnd), NULL);
  const guint np                 = TESTMULT * test->dim;
  NcmVector *m2lnp_v             = ncm_vector_new (np);
  const guint ntests             = 100 * g_test_rand_int_range (1, 5);
  guint i;
  NcmMatrix *cov    = NULL;
  gdouble lndet_cov = 0.0;

  ncm_data_gauss_cov_use_norma (NCM_DATA_GAUSS_COV (data_mvnd), FALSE);
  ncm_mset_param_set_vector (mset, ncm_data_gauss_cov_mvnd_peek_mean (data_mvnd));

  for (i = 0; i < np; i++)
  {
    gdouble m2lnL;

    ncm_data_m2lnL_val (NCM_DATA (data_mvnd), mset, &m2lnL);
    ncm_vector_set (m2lnp_v, i, m2lnL);
  }

  cov       = ncm_data_gauss_cov_peek_cov (NCM_DATA_GAUSS_COV (data_mvnd));
  lndet_cov = ncm_matrix_cholesky_lndet (cov);


  switch (test->kernel_type)
  {
    case NCM_STATS_DIST_KERNEL_TYPE_GAUSS:
    {
      gdouble norm_test    = 0.5 * (test->dim * ncm_c_ln2pi () + lndet_cov);
      const gdouble lnnorm = ncm_stats_dist_kernel_get_lnnorm (test->kernel, cov);

      ncm_assert_cmpdouble_e (norm_test, ==, lnnorm, 1.0e-14, 0.0);
      break;
    }
    case NCM_STATS_DIST_KERNEL_TYPE_ST3:
    {
      const guint d             = test->dim;
      const gdouble lg_lnnorm   = lgamma (test->nu / 2.0) - lgamma ((test->nu + d) / 2.0);
      const gdouble chol_lnnorm = 0.5 * lndet_cov;
      const gdouble nc_lnnorm   = (d / 2.0) * (ncm_c_lnpi () + log (test->nu));
      const gdouble lnnorm      = ncm_stats_dist_kernel_get_lnnorm (test->kernel, cov);

      ncm_assert_cmpdouble_e (lg_lnnorm + chol_lnnorm + nc_lnnorm, ==, lnnorm, 1.0e-14, 0.0);

      break;
    }
    default:
      g_assert_not_reached ();
      break;
  }

  {
    gdouble *data         = g_new (gdouble, 2 * ntests);
    NcmVector *chi2_vec   = ncm_vector_new_full (data, ntests, 2, data, g_free);
    NcmVector *kernel_vec = ncm_vector_new (ntests);

    for (i = 0; i < ntests; i++)
    {
      const gdouble chi2_i = g_test_rand_double_range (0.0, 1.0e2);

      ncm_vector_set (chi2_vec, i, chi2_i);
    }

    ncm_stats_dist_kernel_eval_unnorm_vec (test->kernel, chi2_vec, kernel_vec);

    switch (test->kernel_type)
    {
      case NCM_STATS_DIST_KERNEL_TYPE_GAUSS:

        for (i = 0; i < ntests; i++)
        {
          gdouble eval_test = exp (-0.5 * ncm_vector_get (chi2_vec, i));

          ncm_assert_cmpdouble_e (ncm_vector_get (kernel_vec, i), ==, ncm_stats_dist_kernel_eval_unnorm (test->kernel, ncm_vector_get (chi2_vec, i)), 1.0e-15, 0.0);
          ncm_assert_cmpdouble_e (eval_test, ==, ncm_stats_dist_kernel_eval_unnorm (test->kernel, ncm_vector_get (chi2_vec, i)), 1.0e-15, 0.0);
        }

        break;
      case NCM_STATS_DIST_KERNEL_TYPE_ST3:

        for (i = 0; i < ntests; i++)
        {
          gdouble eval_test = pow (1 + ncm_vector_get (chi2_vec, i) / test->nu, -0.5 * (test->nu + test->dim));

          ncm_assert_cmpdouble_e (ncm_vector_get (kernel_vec, i), ==, ncm_stats_dist_kernel_eval_unnorm (test->kernel, ncm_vector_get (chi2_vec, i)), 1.0e-15, 0.0);
          ncm_assert_cmpdouble_e (eval_test, ==, ncm_stats_dist_kernel_eval_unnorm (test->kernel, ncm_vector_get (chi2_vec, i)), 1.0e-15, 0.0);
        }

        break;
      default:
        g_assert_not_reached ();
        break;
    }

    ncm_vector_free (chi2_vec);
    ncm_vector_free (kernel_vec);
  }
  ncm_model_mvnd_free (model_mvnd);
  ncm_rng_free (rng);
  ncm_vector_free (m2lnp_v);
  ncm_mset_free (mset);
  ncm_matrix_free (cov);
}

static void
test_ncm_stats_dist_kernel_sum (TestNcmStatsDistKernel *test, gconstpointer pdata)
{
  guint i        = 0;
  const guint n  = g_test_rand_int_range (5, 100);
  gdouble lnnorm = g_test_rand_double_range (1.0, 200.0);
  gdouble lambda0, gamma0, gamma1, lambda1;
  gdouble lambda_test0   = 0.0;
  gdouble lambda_test1   = 0.0;
  gdouble lnt_i0         = 0.0;
  gdouble lnt_i1         = 0.0;
  NcmVector *weights     = ncm_vector_new (n);
  NcmVector *chi2        = ncm_vector_new (n);
  NcmVector *lnnorms_vec = ncm_vector_new (n);
  NcmVector *lnK         = ncm_vector_new (n);
  GArray *t_array0       = g_array_new (FALSE, FALSE, sizeof (gdouble));
  GArray *t_array1       = g_array_new (FALSE, FALSE, sizeof (gdouble));
  const gdouble kappa    = -0.5 * (test->nu + test->dim);
  gdouble lnt_max0       = GSL_NEGINF;
  gdouble lnt_max1       = GSL_NEGINF;
  guint i_max0           = 0;
  guint i_max1           = 0;

  for (i = 0; i < n; i++)
  {
    const gdouble j = g_test_rand_double_range (1.0, 200.0);
    const gdouble k = g_test_rand_double_range (1.0, 200.0);
    const gdouble l = g_test_rand_double_range (1.0, 200.0);

    ncm_vector_set (weights, i, j);
    ncm_vector_set (lnnorms_vec, i, k);
    ncm_vector_set (chi2, i, l);
  }


  for (i = 0; i < n; i++)
  {
    const gdouble chi2_i = ncm_vector_fast_get (chi2, i);
    const gdouble w_i    = ncm_vector_fast_get (weights, i);
    const gdouble lnu_i  = ncm_vector_fast_get (lnnorms_vec, i);

    switch (test->kernel_type)
    {
      case NCM_STATS_DIST_KERNEL_TYPE_GAUSS:
        lnt_i0 = -0.5 * chi2_i - lnu_i + log (w_i);
        lnt_i1 = -0.5 * chi2_i + log (w_i);
        break;
      case NCM_STATS_DIST_KERNEL_TYPE_ST3:
        lnt_i0 = kappa * log1p (chi2_i / test->nu) - lnu_i + log (w_i);
        lnt_i1 = kappa * log1p (chi2_i / test->nu) + log (w_i);
        break;
      default:
        g_assert_not_reached ();
        break;
    }

    if (lnt_i0 > lnt_max0)
    {
      lnt_max0 = lnt_i0;
      i_max0   = i;
    }

    if (lnt_i1 > lnt_max1)
    {
      lnt_max1 = lnt_i1;
      i_max1   = i;
    }

    g_array_insert_val (t_array0, i, lnt_i0);
    g_array_insert_val (t_array1, i, lnt_i1);
  }

  ncm_stats_dist_kernel_eval_sum0_gamma_lambda (test->kernel, chi2, weights, lnnorms_vec, lnK, &gamma0, &lambda0);
  ncm_stats_dist_kernel_eval_sum1_gamma_lambda (test->kernel, chi2, weights, lnnorm, lnK, &gamma1, &lambda1);

  for (i = 0; i < i_max0; i++)
  {
    lambda_test0 += exp (g_array_index (t_array0, gdouble, i) - lnt_max0);
    ncm_assert_cmpdouble_e (g_array_index (t_array0, gdouble, i), <, gamma0, 1.0e-15, 0.0);
  }

  for (i = 0; i < i_max1; i++)
  {
    lambda_test1 += exp (g_array_index (t_array1, gdouble, i) - lnt_max1);
    ncm_assert_cmpdouble_e (g_array_index (t_array1, gdouble, i) - lnnorm, <, gamma1, 1.0e-15, 0.0);
  }

  for (i = i_max0 + 1; i < n; i++)
  {
    lambda_test0 += exp (g_array_index (t_array0, gdouble, i) - lnt_max0);
    ncm_assert_cmpdouble_e (g_array_index (t_array0, gdouble, i), <, gamma0, 1.0e-15, 0.0);
  }

  for (i = i_max1 + 1; i < n; i++)
  {
    lambda_test1 += exp (g_array_index (t_array1, gdouble, i) - lnt_max1);
    ncm_assert_cmpdouble_e (g_array_index (t_array1, gdouble, i) - lnnorm, <, gamma1, 1.0e-15, 0.0);
  }

  ncm_assert_cmpdouble_e (lnt_max0, ==, gamma0, 1.0e-15, 0.0);
  ncm_assert_cmpdouble_e (lnt_max1 - lnnorm, ==, gamma1, 1.0e-15, 0.0);

  ncm_assert_cmpdouble_e (lambda_test0, ==, lambda0, 1.0e-15, 0.0);
  ncm_assert_cmpdouble_e (lambda_test1, ==, lambda1, 1.0e-15, 0.0);

  ncm_assert_cmpdouble_e (lambda_test0 + exp (lnt_max0), ==, lambda0 + exp (gamma0), 1.0e-15, 0.0);
  ncm_assert_cmpdouble_e (lambda_test1 + exp (lnt_max1 - lnnorm), ==, lambda1 + exp (gamma1), 1.0e-15, 0.0);

  ncm_vector_free (weights);
  ncm_vector_free (chi2);
  ncm_vector_free (lnnorms_vec);
  g_clear_pointer (&t_array0, g_array_unref);
  g_clear_pointer (&t_array1, g_array_unref);
}

static void
test_ncm_stats_dist_kernel_sample (TestNcmStatsDistKernel *test, gconstpointer pdata)
{
  NcmRNG *rng             = ncm_rng_seeded_new (NULL, g_test_rand_int ());
  NcmMatrix *cov_decomp   = ncm_matrix_new (test->dim, test->dim);
  gdouble href            = g_test_rand_double_range (1.0, 200.0);
  gdouble dif             = 0.0;
  NcmVector *mu           = ncm_vector_new (test->dim);
  NcmStatsVec *test_stats = ncm_stats_vec_new (test->dim, NCM_STATS_VEC_VAR, FALSE);
  const guint ntests      = 300 * g_test_rand_int_range (1, 5);
  guint i, j;

  for (i = 0; i < test->dim; i++)
  {
    const gdouble val1 = g_test_rand_double_range (1.0, 200.0);

    ncm_vector_set (mu, i, val1);

    for (j = 0; j < test->dim; j++)
    {
      const gdouble val2 = g_test_rand_double_range (1.0, 200.0);

      ncm_matrix_set (cov_decomp, i, j, val2);
    }
  }

  ncm_matrix_cholesky_decomp (cov_decomp, 'U');

  while (test->nfail < 20)
  {
    for (i = 0; i < ntests; i++)
    {
      NcmVector *x_test = ncm_vector_new (test->dim);

      ncm_stats_dist_kernel_sample (test->kernel, cov_decomp, href, mu, x_test, rng);

      ncm_stats_vec_append (test_stats, x_test, FALSE);
    }

    for (i = 0; i < test->dim; i++)
    {
      gdouble dif_i;

      dif_i = fabs ((ncm_stats_vec_get_mean (test_stats, i) - ncm_vector_get (mu, i)) / ncm_vector_get (mu, i));
      dif   = dif + dif_i;
    }

    if (dif >= (test->dim * 0.2))
    {
      dif         = 0.0;
      test->nfail = test->nfail + 1;
    }
    else
    {
      test->nfail = 20;
    }
  }

  g_assert_cmpfloat (dif, <, (test->dim * 0.2));



  ncm_vector_free (mu);
  ncm_matrix_free (cov_decomp);
  ncm_rng_free (rng);
  ncm_stats_vec_free (test_stats);
}

static void
test_ncm_stats_dist_kernel_free (TestNcmStatsDistKernel *test, gconstpointer pdata)
{
  NCM_TEST_FREE (ncm_stats_dist_kernel_free, test->kernel);
}

static void
test_ncm_stats_dist_kernel_traps (TestNcmStatsDistKernel *test, gconstpointer pdata)
{
  g_test_trap_subprocess ("/ncm/stats/dist/kernel/gauss/invalid/stub/subprocess", 0, 0);
  g_test_trap_assert_failed ();
}

static void
test_ncm_stats_dist_kernel_invalid_stub (TestNcmStatsDistKernel *test, gconstpointer pdata)
{
  g_assert_not_reached ();
}


1	/***************************************************************************
2	* test_ncm_stats_dist.c
3	*
4	* Wed November 07 17:57:28 2018
5	* Copyright 2018 Sandro Dias Pinto Vitenti
6	* <vitenti@uel.br>
7	****************************************************************************/
8	/*
9	* numcosmo
10	* Copyright (C) Sandro Dias Pinto Vitenti 2018 <vitenti@uel.br>
11	* numcosmo is free software: you can redistribute it and/or modify it
12	* under the terms of the GNU General Public License as published by the
13	* Free Software Foundation, either version 3 of the License, or
14	* (at your option) any later version.
15	*
16	* numcosmo is distributed in the hope that it will be useful, but
17	* WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
19	* See the GNU General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License along
22	* with this program. If not, see <http://www.gnu.org/licenses/>.
23	*/
24
25	#ifdef HAVE_CONFIG_H
26	# include "config.h"
27	#undef GSL_RANGE_CHECK_OFF
28	#endif /* HAVE_CONFIG_H */
29	#include <numcosmo/numcosmo.h>
30
31	#include <math.h>
32	#include <glib.h>
33	#include <glib-object.h>
34	#include <gsl/gsl_randist.h>
35	#include <gsl/gsl_statistics_double.h>
36	#include <gsl/gsl_randist.h>
37	#include <gsl/gsl_cdf.h>
38
39	typedef enum _NcmStatsDistKernelType
40	{
41	NCM_STATS_DIST_KERNEL_TYPE_GAUSS,
42	NCM_STATS_DIST_KERNEL_TYPE_ST3,
43	} NcmStatsDistKernelType;
44
45	typedef struct _TestNcmStatsDistKernel
46	{
47	NcmStatsDistKernel *kernel;
48	NcmMSet *mset;
49	NcmStatsDistKernelType kernel_type;
50	gdouble nu;
51	guint dim;
52	guint nfail;
53	} TestNcmStatsDistKernel;
54
55
56	static void test_ncm_stats_dist_kernel_new_st (TestNcmStatsDistKernel *test, gconstpointer pdata);
57	static void test_ncm_stats_dist_kernel_new_gauss (TestNcmStatsDistKernel *test, gconstpointer pdata);
58
59	static void test_ncm_stats_dist_kernel_dim (TestNcmStatsDistKernel *test, gconstpointer pdata);
60	static void test_ncm_stats_dist_kernel_bandwidth (TestNcmStatsDistKernel *test, gconstpointer pdata);
61	static void test_ncm_stats_dist_kernel_norm (TestNcmStatsDistKernel *test, gconstpointer pdata);
62	static void test_ncm_stats_dist_kernel_sum (TestNcmStatsDistKernel *test, gconstpointer pdata);
63	static void test_ncm_stats_dist_kernel_sample (TestNcmStatsDistKernel *test, gconstpointer pdata);
64
65	static void test_ncm_stats_dist_kernel_free (TestNcmStatsDistKernel *test, gconstpointer pdata);
66
67	static void test_ncm_stats_dist_kernel_traps (TestNcmStatsDistKernel *test, gconstpointer pdata);
68	static void test_ncm_stats_dist_kernel_invalid_stub (TestNcmStatsDistKernel *test, gconstpointer pdata);
69
70	typedef struct _TestNcmStatsDistKernelFunc
71	{
72	const gchar *name;
73
74	void (test_func) (TestNcmStatsDistKernel test, gconstpointer pdata);
75	} TestNcmStatsDistKernelFunc;
76
77	#define TEST_NCM_STATS_DIST_KERNEL_CONSTRUCTORS_LEN 2
78	#define TEST_NCM_STATS_DIST_KERNEL_TESTS_LEN 5
79
80	static TestNcmStatsDistKernelFunc constructors[TEST_NCM_STATS_DIST_KERNEL_CONSTRUCTORS_LEN] = {
81	{"gauss", &test_ncm_stats_dist_kernel_new_gauss},
82	{"st", &test_ncm_stats_dist_kernel_new_st}
83	};
84
85	static TestNcmStatsDistKernelFunc tests[TEST_NCM_STATS_DIST_KERNEL_TESTS_LEN] = {
86	{"dim", &test_ncm_stats_dist_kernel_dim},
87	{"band", &test_ncm_stats_dist_kernel_bandwidth},
88	{"gauss/norm", &test_ncm_stats_dist_kernel_norm},
89	{"sum", &test_ncm_stats_dist_kernel_sum},
90	{"sample", &test_ncm_stats_dist_kernel_sample},
91	};
92
93	gint
94	main (gint argc, gchar *argv[])	1✔
95	{
96	gint i, j;	1✔
97
98	g_test_init (&argc, &argv, NULL);	1✔
99
100	ncm_cfg_init_full_ptr (&argc, &argv);	1✔
101	ncm_cfg_enable_gsl_err_handler ();	1✔
102
103	g_test_set_nonfatal_assertions ();	1✔
104
105	for (i = 0; i < TEST_NCM_STATS_DIST_KERNEL_CONSTRUCTORS_LEN; i++)	4✔
106	{
107	for (j = 0; j < TEST_NCM_STATS_DIST_KERNEL_TESTS_LEN; j++)	12✔
108	{
109	gchar *test_name = g_strdup_printf ("/ncm/stats/dist/kernel/%s/%s", constructors[i].name, tests[j].name);	10✔
110
111	g_test_add (test_name, TestNcmStatsDistKernel, NULL, constructors[i].test_func, tests[j].test_func, &test_ncm_stats_dist_kernel_free);	10✔
112	g_free (test_name);	10✔
113	}
114	}
115
116	g_test_add ("/ncm/stats/dist/kernel/gauss/traps", TestNcmStatsDistKernel, NULL,	1✔
117	&test_ncm_stats_dist_kernel_new_gauss,
118	&test_ncm_stats_dist_kernel_traps,
119	&test_ncm_stats_dist_kernel_free);
120
121	g_test_add ("/ncm/stats/dist/kernel/gauss/invalid/stub/subprocess", TestNcmStatsDistKernel, NULL,	1✔
122	&test_ncm_stats_dist_kernel_new_gauss,
123	&test_ncm_stats_dist_kernel_invalid_stub,
124	&test_ncm_stats_dist_kernel_free);
125
126	g_test_run ();	1✔
127	}
128
129	static void
130	test_ncm_stats_dist_kernel_new_gauss (TestNcmStatsDistKernel *test, gconstpointer pdata)	6✔
131	{
132	const guint dim = g_test_rand_int_range (2, 4);	6✔
133	NcmStatsDistKernelGauss *sdk_gauss = ncm_stats_dist_kernel_gauss_new (dim);	6✔
134
135	test->dim = dim;	6✔
136	test->kernel = NCM_STATS_DIST_KERNEL (sdk_gauss);	6✔
137	test->kernel_type = NCM_STATS_DIST_KERNEL_TYPE_GAUSS;	6✔
138	test->nfail = 0;	6✔
139
140	ncm_stats_dist_kernel_gauss_ref (sdk_gauss);	6✔
141	ncm_stats_dist_kernel_gauss_free (sdk_gauss);	6✔
142	{
143	NcmStatsDistKernelGauss *sdk_gauss0 = ncm_stats_dist_kernel_gauss_ref (sdk_gauss);	6✔
144
145	ncm_stats_dist_kernel_gauss_clear (&sdk_gauss0);	6✔
146	g_assert_true (sdk_gauss0 == NULL);	6✔
147	}
148	}	6✔
149
150	static void
151	test_ncm_stats_dist_kernel_new_st (TestNcmStatsDistKernel *test, gconstpointer pdata)	5✔
152	{
153	const gdouble nu = g_test_rand_double_range (3.0, 5.0);	5✔
154	const guint dim = g_test_rand_int_range (2, 4);	5✔
155	NcmStatsDistKernelST *sdk_st = ncm_stats_dist_kernel_st_new (dim, nu);	5✔
156
157	test->dim = dim;	5✔
158	test->nu = nu;	5✔
159	test->kernel_type = NCM_STATS_DIST_KERNEL_TYPE_ST3;	5✔
160	test->kernel = NCM_STATS_DIST_KERNEL (sdk_st);	5✔
161	test->nfail = 0;	5✔
162
163	ncm_stats_dist_kernel_st_ref (sdk_st);	5✔
164	ncm_stats_dist_kernel_st_free (sdk_st);	5✔
165	{
166	NcmStatsDistKernelST *sdk_st0 = ncm_stats_dist_kernel_st_ref (sdk_st);	5✔
167
168	ncm_stats_dist_kernel_st_clear (&sdk_st0);	5✔
169	g_assert_true (sdk_st0 == NULL);	5✔
170	}
171	}	5✔
172
173	static void
174	test_ncm_stats_dist_kernel_dim (TestNcmStatsDistKernel *test, gconstpointer pdata)	2✔
175	{
176	g_assert_true (test->dim == ncm_stats_dist_kernel_get_dim (test->kernel));	2✔
177	}	2✔
178
179	static void
180	test_ncm_stats_dist_kernel_bandwidth (TestNcmStatsDistKernel *test, gconstpointer pdata)	2✔
181	{
182	const gdouble n = g_test_rand_double_range (1.0, 200.0);	2✔
183	const gdouble h = ncm_stats_dist_kernel_get_rot_bandwidth (test->kernel, n);	2✔
184	gdouble h_test = 0.0;	2✔
185
186	switch (test->kernel_type)	2✔
187	{
188	case NCM_STATS_DIST_KERNEL_TYPE_GAUSS:	1✔
189	h_test = pow (4.0 / (n * (test->dim + 2.0)), 1.0 / (test->dim + 4.0));	1✔
190	break;	1✔
191	case NCM_STATS_DIST_KERNEL_TYPE_ST3:	1✔
192	h_test = pow (16.0 * gsl_pow_2 (test->nu - 2) * (1.0 + test->dim + test->nu) * (3.0 + test->dim + test->nu) / ((2.0 + test->dim) * (test->dim + test->nu) * (2.0 + test->dim + test->nu) * (test->dim + 2.0 * test->nu) * (2.0 + test->dim + 2.0 * test->nu) * n), 1.0 / (test->dim + 4.0));	1✔
193	break;	1✔
194	default:	×
195	g_assert_not_reached ();	×
196	break;
197	}
198
199	ncm_assert_cmpdouble_e (h_test, ==, h, 1.0e-14, 0.0);	2✔
200	}	2✔
201
202	#define TESTMULT 200
203
204	static void
205	test_ncm_stats_dist_kernel_norm (TestNcmStatsDistKernel *test, gconstpointer pdata)	2✔
206	{
207	NcmRNG *rng = ncm_rng_seeded_new (NULL, g_test_rand_int ());	2✔
208	NcmDataGaussCovMVND *data_mvnd = ncm_data_gauss_cov_mvnd_new_full (test->dim, 1.0e-2, 5.0e-1, 1.0, -2.0, 2.0, rng);	2✔
209	NcmModelMVND *model_mvnd = ncm_model_mvnd_new (test->dim);	2✔
210	NcmMSet *mset = ncm_mset_new (NCM_MODEL (model_mvnd), NULL);	2✔
211	const guint np = TESTMULT * test->dim;	2✔
212	NcmVector *m2lnp_v = ncm_vector_new (np);	2✔
213	const guint ntests = 100 * g_test_rand_int_range (1, 5);	2✔
214	guint i;	2✔
215	NcmMatrix *cov = NULL;	2✔
216	gdouble lndet_cov = 0.0;	2✔
217
218	ncm_data_gauss_cov_use_norma (NCM_DATA_GAUSS_COV (data_mvnd), FALSE);	2✔
219	ncm_mset_param_set_vector (mset, ncm_data_gauss_cov_mvnd_peek_mean (data_mvnd));	2✔
220
221	for (i = 0; i < np; i++)	1,204✔
222	{
223	gdouble m2lnL;	1,200✔
224
225	ncm_data_m2lnL_val (NCM_DATA (data_mvnd), mset, &m2lnL);	1,200✔
226	ncm_vector_set (m2lnp_v, i, m2lnL);	1,200✔
227	}
228
229	cov = ncm_data_gauss_cov_peek_cov (NCM_DATA_GAUSS_COV (data_mvnd));	2✔
230	lndet_cov = ncm_matrix_cholesky_lndet (cov);	2✔
231
232
233	switch (test->kernel_type)	2✔
234	{
235	case NCM_STATS_DIST_KERNEL_TYPE_GAUSS:	1✔
236	{
237	gdouble norm_test = 0.5 * (test->dim * ncm_c_ln2pi () + lndet_cov);	1✔
238	const gdouble lnnorm = ncm_stats_dist_kernel_get_lnnorm (test->kernel, cov);	1✔
239
240	ncm_assert_cmpdouble_e (norm_test, ==, lnnorm, 1.0e-14, 0.0);	1✔
241	break;
242	}
243	case NCM_STATS_DIST_KERNEL_TYPE_ST3:	1✔
244	{
245	const guint d = test->dim;	1✔
246	const gdouble lg_lnnorm = lgamma (test->nu / 2.0) - lgamma ((test->nu + d) / 2.0);	1✔
247	const gdouble chol_lnnorm = 0.5 * lndet_cov;	1✔
248	const gdouble nc_lnnorm = (d / 2.0) * (ncm_c_lnpi () + log (test->nu));	1✔
249	const gdouble lnnorm = ncm_stats_dist_kernel_get_lnnorm (test->kernel, cov);	1✔
250
251	ncm_assert_cmpdouble_e (lg_lnnorm + chol_lnnorm + nc_lnnorm, ==, lnnorm, 1.0e-14, 0.0);	1✔
252
253	break;
254	}
255	default:	×
256	g_assert_not_reached ();	×
257	break;
258	}
259
260	{
261	gdouble data = g_new (gdouble, 2 ntests);	2✔
262	NcmVector *chi2_vec = ncm_vector_new_full (data, ntests, 2, data, g_free);	2✔
263	NcmVector *kernel_vec = ncm_vector_new (ntests);	2✔
264
265	for (i = 0; i < ntests; i++)	404✔
266	{
267	const gdouble chi2_i = g_test_rand_double_range (0.0, 1.0e2);	400✔
268
269	ncm_vector_set (chi2_vec, i, chi2_i);	400✔
270	}
271
272	ncm_stats_dist_kernel_eval_unnorm_vec (test->kernel, chi2_vec, kernel_vec);	2✔
273
274	switch (test->kernel_type)	2✔
275	{
276	case NCM_STATS_DIST_KERNEL_TYPE_GAUSS:
277
278	for (i = 0; i < ntests; i++)	201✔
279	{
280	gdouble eval_test = exp (-0.5 * ncm_vector_get (chi2_vec, i));	200✔
281
282	ncm_assert_cmpdouble_e (ncm_vector_get (kernel_vec, i), ==, ncm_stats_dist_kernel_eval_unnorm (test->kernel, ncm_vector_get (chi2_vec, i)), 1.0e-15, 0.0);	200✔
283	ncm_assert_cmpdouble_e (eval_test, ==, ncm_stats_dist_kernel_eval_unnorm (test->kernel, ncm_vector_get (chi2_vec, i)), 1.0e-15, 0.0);	200✔
284	}
285
286	break;
287	case NCM_STATS_DIST_KERNEL_TYPE_ST3:
288
289	for (i = 0; i < ntests; i++)	201✔
290	{
291	gdouble eval_test = pow (1 + ncm_vector_get (chi2_vec, i) / test->nu, -0.5 * (test->nu + test->dim));	200✔
292
293	ncm_assert_cmpdouble_e (ncm_vector_get (kernel_vec, i), ==, ncm_stats_dist_kernel_eval_unnorm (test->kernel, ncm_vector_get (chi2_vec, i)), 1.0e-15, 0.0);	200✔
294	ncm_assert_cmpdouble_e (eval_test, ==, ncm_stats_dist_kernel_eval_unnorm (test->kernel, ncm_vector_get (chi2_vec, i)), 1.0e-15, 0.0);	200✔
295	}
296
297	break;
298	default:	×
299	g_assert_not_reached ();	×
300	break;
301	}
302
303	ncm_vector_free (chi2_vec);	2✔
304	ncm_vector_free (kernel_vec);	2✔
305	}
306	ncm_model_mvnd_free (model_mvnd);	2✔
307	ncm_rng_free (rng);	2✔
308	ncm_vector_free (m2lnp_v);	2✔
309	ncm_mset_free (mset);	2✔
310	ncm_matrix_free (cov);	2✔
311	}	2✔
312
313	static void
314	test_ncm_stats_dist_kernel_sum (TestNcmStatsDistKernel *test, gconstpointer pdata)	2✔
315	{
316	guint i = 0;	2✔
317	const guint n = g_test_rand_int_range (5, 100);	2✔
318	gdouble lnnorm = g_test_rand_double_range (1.0, 200.0);	2✔
319	gdouble lambda0, gamma0, gamma1, lambda1;	2✔
320	gdouble lambda_test0 = 0.0;	2✔
321	gdouble lambda_test1 = 0.0;	2✔
322	gdouble lnt_i0 = 0.0;	2✔
323	gdouble lnt_i1 = 0.0;	2✔
324	NcmVector *weights = ncm_vector_new (n);	2✔
325	NcmVector *chi2 = ncm_vector_new (n);	2✔
326	NcmVector *lnnorms_vec = ncm_vector_new (n);	2✔
327	NcmVector *lnK = ncm_vector_new (n);	2✔
328	GArray *t_array0 = g_array_new (FALSE, FALSE, sizeof (gdouble));	2✔
329	GArray *t_array1 = g_array_new (FALSE, FALSE, sizeof (gdouble));	2✔
330	const gdouble kappa = -0.5 * (test->nu + test->dim);	2✔
331	gdouble lnt_max0 = GSL_NEGINF;	2✔
332	gdouble lnt_max1 = GSL_NEGINF;	2✔
333	guint i_max0 = 0;	2✔
334	guint i_max1 = 0;	2✔
335
336	for (i = 0; i < n; i++)	110✔
337	{
338	const gdouble j = g_test_rand_double_range (1.0, 200.0);	108✔
339	const gdouble k = g_test_rand_double_range (1.0, 200.0);	108✔
340	const gdouble l = g_test_rand_double_range (1.0, 200.0);	108✔
341
342	ncm_vector_set (weights, i, j);	108✔
343	ncm_vector_set (lnnorms_vec, i, k);	108✔
344	ncm_vector_set (chi2, i, l);	108✔
345	}
346
347
348	for (i = 0; i < n; i++)	110✔
349	{
350	const gdouble chi2_i = ncm_vector_fast_get (chi2, i);	108✔
351	const gdouble w_i = ncm_vector_fast_get (weights, i);	108✔
352	const gdouble lnu_i = ncm_vector_fast_get (lnnorms_vec, i);	108✔
353
354	switch (test->kernel_type)	108✔
355	{
356	case NCM_STATS_DIST_KERNEL_TYPE_GAUSS:	45✔
357	lnt_i0 = -0.5 * chi2_i - lnu_i + log (w_i);	45✔
358	lnt_i1 = -0.5 * chi2_i + log (w_i);	45✔
359	break;	45✔
360	case NCM_STATS_DIST_KERNEL_TYPE_ST3:	63✔
361	lnt_i0 = kappa * log1p (chi2_i / test->nu) - lnu_i + log (w_i);	63✔
362	lnt_i1 = kappa * log1p (chi2_i / test->nu) + log (w_i);	63✔
363	break;	63✔
364	default:	×
365	g_assert_not_reached ();	×
366	break;
367	}
368
369	if (lnt_i0 > lnt_max0)	108✔
370	{
371	lnt_max0 = lnt_i0;	12✔
372	i_max0 = i;	12✔
373	}
374
375	if (lnt_i1 > lnt_max1)	108✔
376	{
377	lnt_max1 = lnt_i1;	8✔
378	i_max1 = i;	8✔
379	}
380
381	g_array_insert_val (t_array0, i, lnt_i0);	108✔
382	g_array_insert_val (t_array1, i, lnt_i1);	108✔
383	}
384
385	ncm_stats_dist_kernel_eval_sum0_gamma_lambda (test->kernel, chi2, weights, lnnorms_vec, lnK, &gamma0, &lambda0);	2✔
386	ncm_stats_dist_kernel_eval_sum1_gamma_lambda (test->kernel, chi2, weights, lnnorm, lnK, &gamma1, &lambda1);	2✔
387
388	for (i = 0; i < i_max0; i++)	99✔
389	{
390	lambda_test0 += exp (g_array_index (t_array0, gdouble, i) - lnt_max0);	95✔
391	ncm_assert_cmpdouble_e (g_array_index (t_array0, gdouble, i), <, gamma0, 1.0e-15, 0.0);	95✔
392	}
393
394	for (i = 0; i < i_max1; i++)	48✔
395	{
396	lambda_test1 += exp (g_array_index (t_array1, gdouble, i) - lnt_max1);	46✔
397	ncm_assert_cmpdouble_e (g_array_index (t_array1, gdouble, i) - lnnorm, <, gamma1, 1.0e-15, 0.0);	46✔
398	}
399
400	for (i = i_max0 + 1; i < n; i++)	13✔
401	{
402	lambda_test0 += exp (g_array_index (t_array0, gdouble, i) - lnt_max0);	11✔
403	ncm_assert_cmpdouble_e (g_array_index (t_array0, gdouble, i), <, gamma0, 1.0e-15, 0.0);	11✔
404	}
405
406	for (i = i_max1 + 1; i < n; i++)	62✔
407	{
408	lambda_test1 += exp (g_array_index (t_array1, gdouble, i) - lnt_max1);	60✔
409	ncm_assert_cmpdouble_e (g_array_index (t_array1, gdouble, i) - lnnorm, <, gamma1, 1.0e-15, 0.0);	60✔
410	}
411
412	ncm_assert_cmpdouble_e (lnt_max0, ==, gamma0, 1.0e-15, 0.0);	2✔
413	ncm_assert_cmpdouble_e (lnt_max1 - lnnorm, ==, gamma1, 1.0e-15, 0.0);	2✔
414
415	ncm_assert_cmpdouble_e (lambda_test0, ==, lambda0, 1.0e-15, 0.0);	2✔
416	ncm_assert_cmpdouble_e (lambda_test1, ==, lambda1, 1.0e-15, 0.0);	2✔
417
418	ncm_assert_cmpdouble_e (lambda_test0 + exp (lnt_max0), ==, lambda0 + exp (gamma0), 1.0e-15, 0.0);	2✔
419	ncm_assert_cmpdouble_e (lambda_test1 + exp (lnt_max1 - lnnorm), ==, lambda1 + exp (gamma1), 1.0e-15, 0.0);	2✔
420
421	ncm_vector_free (weights);	2✔
422	ncm_vector_free (chi2);	2✔
423	ncm_vector_free (lnnorms_vec);	2✔
424	g_clear_pointer (&t_array0, g_array_unref);	2✔
425	g_clear_pointer (&t_array1, g_array_unref);	2✔
426	}	2✔
427
428	static void
429	test_ncm_stats_dist_kernel_sample (TestNcmStatsDistKernel *test, gconstpointer pdata)	2✔
430	{
431	NcmRNG *rng = ncm_rng_seeded_new (NULL, g_test_rand_int ());	2✔
432	NcmMatrix *cov_decomp = ncm_matrix_new (test->dim, test->dim);	2✔
433	gdouble href = g_test_rand_double_range (1.0, 200.0);	2✔
434	gdouble dif = 0.0;	2✔
435	NcmVector *mu = ncm_vector_new (test->dim);	2✔
436	NcmStatsVec *test_stats = ncm_stats_vec_new (test->dim, NCM_STATS_VEC_VAR, FALSE);	2✔
437	const guint ntests = 300 * g_test_rand_int_range (1, 5);	2✔
438	guint i, j;	2✔
439
440	for (i = 0; i < test->dim; i++)	8✔
441	{
442	const gdouble val1 = g_test_rand_double_range (1.0, 200.0);	6✔
443
444	ncm_vector_set (mu, i, val1);	6✔
445
446	for (j = 0; j < test->dim; j++)	30✔
447	{
448	const gdouble val2 = g_test_rand_double_range (1.0, 200.0);	18✔
449
450	ncm_matrix_set (cov_decomp, i, j, val2);	18✔
451	}
452	}
453
454	ncm_matrix_cholesky_decomp (cov_decomp, 'U');	2✔
455
456	while (test->nfail < 20)	42✔
457	{
458	for (i = 0; i < ntests; i++)	18,040✔
459	{
460	NcmVector *x_test = ncm_vector_new (test->dim);	18,000✔
461
462	ncm_stats_dist_kernel_sample (test->kernel, cov_decomp, href, mu, x_test, rng);	18,000✔
463
464	ncm_stats_vec_append (test_stats, x_test, FALSE);	18,000✔
465	}
466
467	for (i = 0; i < test->dim; i++)	160✔
468	{
469	gdouble dif_i;	120✔
470
471	dif_i = fabs ((ncm_stats_vec_get_mean (test_stats, i) - ncm_vector_get (mu, i)) / ncm_vector_get (mu, i));	120✔
472	dif = dif + dif_i;	120✔
473	}
474
475	if (dif >= (test->dim * 0.2))	40✔
476	{
477	dif = 0.0;	40✔
478	test->nfail = test->nfail + 1;	40✔
479	}
480	else
481	{
UNCOV 482	test->nfail = 20;	×
483	}
484	}
485
486	g_assert_cmpfloat (dif, <, (test->dim * 0.2));	2✔
487
488
489
490	ncm_vector_free (mu);	2✔
491	ncm_matrix_free (cov_decomp);	2✔
492	ncm_rng_free (rng);	2✔
493	ncm_stats_vec_free (test_stats);	2✔
494	}	2✔
495
496	static void
497	test_ncm_stats_dist_kernel_free (TestNcmStatsDistKernel *test, gconstpointer pdata)	11✔
498	{
499	NCM_TEST_FREE (ncm_stats_dist_kernel_free, test->kernel);	11✔
500	}	11✔
501
502	static void
503	test_ncm_stats_dist_kernel_traps (TestNcmStatsDistKernel *test, gconstpointer pdata)	1✔
504	{
505	g_test_trap_subprocess ("/ncm/stats/dist/kernel/gauss/invalid/stub/subprocess", 0, 0);	1✔
506	g_test_trap_assert_failed ();	1✔
507	}	1✔
508
509	static void
510	test_ncm_stats_dist_kernel_invalid_stub (TestNcmStatsDistKernel *test, gconstpointer pdata)	×
511	{
512	g_assert_not_reached ();	×
513	}
514

NumCosmo / NumCosmo / 7310596312

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous