7101048423

Committed 05 Dec 2023 12:56PM UTC coverage: 54.691% (-0.001%) from 54.692%

Build # 7101048423

Build Type

Pull #121

github

Committed by

web-flow

Commit Message

Merge 5c3242ead into 03fd86611

Pull Request Pull Request #121: Fixing warnings in conda build.

Run Details

7091 of 12377 branches covered (0.0%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

9 existing lines in 4 files now uncovered.

46799 of 86159 relevant lines covered (54.32%)

2184326.43 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_GAUSS,
  NCM_STATS_DIST_KERNEL_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);

#if GLIB_CHECK_VERSION (2, 38, 0)
  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);
#endif


  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_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_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_GAUSS:
      h_test = pow (4.0 / (n * (test->dim + 2.0)), 1.0 / (test->dim + 4.0));
      break;
    case NCM_STATS_DIST_KERNEL_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_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_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_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_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_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_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)
{
  #if GLIB_CHECK_VERSION (2, 38, 0)
  g_test_trap_subprocess ("/ncm/stats/dist/kernel/gauss/invalid/stub/subprocess", 0, 0);
  g_test_trap_assert_failed ();
  #endif
}

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_GAUSS,
42	NCM_STATS_DIST_KERNEL_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	#if GLIB_CHECK_VERSION (2, 38, 0)
122	g_test_add ("/ncm/stats/dist/kernel/gauss/invalid/stub/subprocess", TestNcmStatsDistKernel, NULL,	1✔
123	&test_ncm_stats_dist_kernel_new_gauss,
124	&test_ncm_stats_dist_kernel_invalid_stub,
125	&test_ncm_stats_dist_kernel_free);
126	#endif
127
128
129	g_test_run ();	1✔
130	}
131
132	static void
133	test_ncm_stats_dist_kernel_new_gauss (TestNcmStatsDistKernel *test, gconstpointer pdata)	6✔
134	{
135	const guint dim = g_test_rand_int_range (2, 4);	6✔
136	NcmStatsDistKernelGauss *sdk_gauss = ncm_stats_dist_kernel_gauss_new (dim);	6✔
137
138	test->dim = dim;	6✔
139	test->kernel = NCM_STATS_DIST_KERNEL (sdk_gauss);	6✔
140	test->kernel_type = NCM_STATS_DIST_KERNEL_GAUSS;	6✔
141	test->nfail = 0;	6✔
142
143	ncm_stats_dist_kernel_gauss_ref (sdk_gauss);	6✔
144	ncm_stats_dist_kernel_gauss_free (sdk_gauss);	6✔
145	{
146	NcmStatsDistKernelGauss *sdk_gauss0 = ncm_stats_dist_kernel_gauss_ref (sdk_gauss);	6✔
147
148	ncm_stats_dist_kernel_gauss_clear (&sdk_gauss0);	6✔
149	g_assert_true (sdk_gauss0 == NULL);	6✔
150	}
151	}	6✔
152
153	static void
154	test_ncm_stats_dist_kernel_new_st (TestNcmStatsDistKernel *test, gconstpointer pdata)	5✔
155	{
156	const gdouble nu = g_test_rand_double_range (3.0, 5.0);	5✔
157	const guint dim = g_test_rand_int_range (2, 4);	5✔
158	NcmStatsDistKernelST *sdk_st = ncm_stats_dist_kernel_st_new (dim, nu);	5✔
159
160	test->dim = dim;	5✔
161	test->nu = nu;	5✔
162	test->kernel_type = NCM_STATS_DIST_KERNEL_ST3;	5✔
163	test->kernel = NCM_STATS_DIST_KERNEL (sdk_st);	5✔
164	test->nfail = 0;	5✔
165
166	ncm_stats_dist_kernel_st_ref (sdk_st);	5✔
167	ncm_stats_dist_kernel_st_free (sdk_st);	5✔
168	{
169	NcmStatsDistKernelST *sdk_st0 = ncm_stats_dist_kernel_st_ref (sdk_st);	5✔
170
171	ncm_stats_dist_kernel_st_clear (&sdk_st0);	5✔
172	g_assert_true (sdk_st0 == NULL);	5✔
173	}
174	}	5✔
175
176	static void
177	test_ncm_stats_dist_kernel_dim (TestNcmStatsDistKernel *test, gconstpointer pdata)	2✔
178	{
179	g_assert_true (test->dim == ncm_stats_dist_kernel_get_dim (test->kernel));	2✔
180	}	2✔
181
182	static void
183	test_ncm_stats_dist_kernel_bandwidth (TestNcmStatsDistKernel *test, gconstpointer pdata)	2✔
184	{
185	const gdouble n = g_test_rand_double_range (1.0, 200.0);	2✔
186	const gdouble h = ncm_stats_dist_kernel_get_rot_bandwidth (test->kernel, n);	2✔
187	gdouble h_test = 0.0;	2✔
188
189	switch (test->kernel_type)	2✔
190	{
191	case NCM_STATS_DIST_KERNEL_GAUSS:	1✔
192	h_test = pow (4.0 / (n * (test->dim + 2.0)), 1.0 / (test->dim + 4.0));	1✔
193	break;	1✔
194	case NCM_STATS_DIST_KERNEL_ST3:	1✔
195	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✔
196	break;	1✔
197	default:	×
198	g_assert_not_reached ();	×
199	break;
200	}
201
202	ncm_assert_cmpdouble_e (h_test, ==, h, 1.0e-14, 0.0);	2✔
203	}	2✔
204
205	#define TESTMULT 200
206
207	static void
208	test_ncm_stats_dist_kernel_norm (TestNcmStatsDistKernel *test, gconstpointer pdata)	2✔
209	{
210	NcmRNG *rng = ncm_rng_seeded_new (NULL, g_test_rand_int ());	2✔
211	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✔
212	NcmModelMVND *model_mvnd = ncm_model_mvnd_new (test->dim);	2✔
213	NcmMSet *mset = ncm_mset_new (NCM_MODEL (model_mvnd), NULL);	2✔
214	const guint np = TESTMULT * test->dim;	2✔
215	NcmVector *m2lnp_v = ncm_vector_new (np);	2✔
216	const guint ntests = 100 * g_test_rand_int_range (1, 5);	2✔
217	guint i;	2✔
218	NcmMatrix *cov = NULL;	2✔
219	gdouble lndet_cov = 0.0;	2✔
220
221	ncm_data_gauss_cov_use_norma (NCM_DATA_GAUSS_COV (data_mvnd), FALSE);	2✔
222	ncm_mset_param_set_vector (mset, ncm_data_gauss_cov_mvnd_peek_mean (data_mvnd));	2✔
223
224	for (i = 0; i < np; i++)	1,204✔
225	{
226	gdouble m2lnL;	1,200✔
227
228	ncm_data_m2lnL_val (NCM_DATA (data_mvnd), mset, &m2lnL);	1,200✔
229	ncm_vector_set (m2lnp_v, i, m2lnL);	1,200✔
230	}
231
232	cov = ncm_data_gauss_cov_peek_cov (NCM_DATA_GAUSS_COV (data_mvnd));	2✔
233	lndet_cov = ncm_matrix_cholesky_lndet (cov);	2✔
234
235
236	switch (test->kernel_type)	2✔
237	{
238	case NCM_STATS_DIST_KERNEL_GAUSS:	1✔
239	{
240	gdouble norm_test = 0.5 * (test->dim * ncm_c_ln2pi () + lndet_cov);	1✔
241	const gdouble lnnorm = ncm_stats_dist_kernel_get_lnnorm (test->kernel, cov);	1✔
242
243	ncm_assert_cmpdouble_e (norm_test, ==, lnnorm, 1.0e-14, 0.0);	1✔
244	break;
245	}
246	case NCM_STATS_DIST_KERNEL_ST3:	1✔
247	{
248	const guint d = test->dim;	1✔
249	const gdouble lg_lnnorm = lgamma (test->nu / 2.0) - lgamma ((test->nu + d) / 2.0);	1✔
250	const gdouble chol_lnnorm = 0.5 * lndet_cov;	1✔
251	const gdouble nc_lnnorm = (d / 2.0) * (ncm_c_lnpi () + log (test->nu));	1✔
252	const gdouble lnnorm = ncm_stats_dist_kernel_get_lnnorm (test->kernel, cov);	1✔
253
254	ncm_assert_cmpdouble_e (lg_lnnorm + chol_lnnorm + nc_lnnorm, ==, lnnorm, 1.0e-14, 0.0);	1✔
255
256	break;
257	}
258	default:	×
259	g_assert_not_reached ();	×
260	break;
261	}
262
263	{
264	gdouble data = g_new (gdouble, 2 ntests);	2✔
265	NcmVector *chi2_vec = ncm_vector_new_full (data, ntests, 2, data, g_free);	2✔
266	NcmVector *kernel_vec = ncm_vector_new (ntests);	2✔
267
268	for (i = 0; i < ntests; i++)	604✔
269	{
270	const gdouble chi2_i = g_test_rand_double_range (0.0, 1.0e2);	600✔
271
272	ncm_vector_set (chi2_vec, i, chi2_i);	600✔
273	}
274
275	ncm_stats_dist_kernel_eval_unnorm_vec (test->kernel, chi2_vec, kernel_vec);	2✔
276
277	switch (test->kernel_type)	2✔
278	{
279	case NCM_STATS_DIST_KERNEL_GAUSS:
280
281	for (i = 0; i < ntests; i++)	401✔
282	{
283	gdouble eval_test = exp (-0.5 * ncm_vector_get (chi2_vec, i));	400✔
284
285	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);	400✔
286	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);	400✔
287	}
288
289	break;
290	case NCM_STATS_DIST_KERNEL_ST3:
291
292	for (i = 0; i < ntests; i++)	201✔
293	{
294	gdouble eval_test = pow (1 + ncm_vector_get (chi2_vec, i) / test->nu, -0.5 * (test->nu + test->dim));	200✔
295
296	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✔
297	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✔
298	}
299
300	break;
301	default:	×
302	g_assert_not_reached ();	×
303	break;
304	}
305
306	ncm_vector_free (chi2_vec);	2✔
307	ncm_vector_free (kernel_vec);	2✔
308	}
309	ncm_model_mvnd_free (model_mvnd);	2✔
310	ncm_rng_free (rng);	2✔
311	ncm_vector_free (m2lnp_v);	2✔
312	ncm_mset_free (mset);	2✔
313	ncm_matrix_free (cov);	2✔
314	}	2✔
315
316	static void
317	test_ncm_stats_dist_kernel_sum (TestNcmStatsDistKernel *test, gconstpointer pdata)	2✔
318	{
319	guint i = 0;	2✔
320	const guint n = g_test_rand_int_range (5, 100);	2✔
321	gdouble lnnorm = g_test_rand_double_range (1.0, 200.0);	2✔
322	gdouble lambda0, gamma0, gamma1, lambda1;	2✔
323	gdouble lambda_test0 = 0.0;	2✔
324	gdouble lambda_test1 = 0.0;	2✔
325	gdouble lnt_i0 = 0.0;	2✔
326	gdouble lnt_i1 = 0.0;	2✔
327	NcmVector *weights = ncm_vector_new (n);	2✔
328	NcmVector *chi2 = ncm_vector_new (n);	2✔
329	NcmVector *lnnorms_vec = ncm_vector_new (n);	2✔
330	NcmVector *lnK = ncm_vector_new (n);	2✔
331	GArray *t_array0 = g_array_new (FALSE, FALSE, sizeof (gdouble));	2✔
332	GArray *t_array1 = g_array_new (FALSE, FALSE, sizeof (gdouble));	2✔
333	const gdouble kappa = -0.5 * (test->nu + test->dim);	2✔
334	gdouble lnt_max0 = GSL_NEGINF;	2✔
335	gdouble lnt_max1 = GSL_NEGINF;	2✔
336	guint i_max0 = 0;	2✔
337	guint i_max1 = 0;	2✔
338
339	for (i = 0; i < n; i++)	151✔
340	{
341	const gdouble j = g_test_rand_double_range (1.0, 200.0);	149✔
342	const gdouble k = g_test_rand_double_range (1.0, 200.0);	149✔
343	const gdouble l = g_test_rand_double_range (1.0, 200.0);	149✔
344
345	ncm_vector_set (weights, i, j);	149✔
346	ncm_vector_set (lnnorms_vec, i, k);	149✔
347	ncm_vector_set (chi2, i, l);	149✔
348	}
349
350
351	for (i = 0; i < n; i++)	151✔
352	{
353	const gdouble chi2_i = ncm_vector_fast_get (chi2, i);	149✔
354	const gdouble w_i = ncm_vector_fast_get (weights, i);	149✔
355	const gdouble lnu_i = ncm_vector_fast_get (lnnorms_vec, i);	149✔
356
357	switch (test->kernel_type)	149✔
358	{
359	case NCM_STATS_DIST_KERNEL_GAUSS:	92✔
360	lnt_i0 = -0.5 * chi2_i - lnu_i + log (w_i);	92✔
361	lnt_i1 = -0.5 * chi2_i + log (w_i);	92✔
362	break;	92✔
363	case NCM_STATS_DIST_KERNEL_ST3:	57✔
364	lnt_i0 = kappa * log1p (chi2_i / test->nu) - lnu_i + log (w_i);	57✔
365	lnt_i1 = kappa * log1p (chi2_i / test->nu) + log (w_i);	57✔
366	break;	57✔
367	default:	×
368	g_assert_not_reached ();	×
369	break;
370	}
371
372	if (lnt_i0 > lnt_max0)	149✔
373	{
374	lnt_max0 = lnt_i0;	12✔
375	i_max0 = i;	12✔
376	}
377
378	if (lnt_i1 > lnt_max1)	149✔
379	{
380	lnt_max1 = lnt_i1;	9✔
381	i_max1 = i;	9✔
382	}
383
384	g_array_insert_val (t_array0, i, lnt_i0);	149✔
385	g_array_insert_val (t_array1, i, lnt_i1);	149✔
386	}
387
388	ncm_stats_dist_kernel_eval_sum0_gamma_lambda (test->kernel, chi2, weights, lnnorms_vec, lnK, &gamma0, &lambda0);	2✔
389	ncm_stats_dist_kernel_eval_sum1_gamma_lambda (test->kernel, chi2, weights, lnnorm, lnK, &gamma1, &lambda1);	2✔
390
391	for (i = 0; i < i_max0; i++)	76✔
392	{
393	lambda_test0 += exp (g_array_index (t_array0, gdouble, i) - lnt_max0);	72✔
394	ncm_assert_cmpdouble_e (g_array_index (t_array0, gdouble, i), <, gamma0, 1.0e-15, 0.0);	72✔
395	}
396
397	for (i = 0; i < i_max1; i++)	73✔
398	{
399	lambda_test1 += exp (g_array_index (t_array1, gdouble, i) - lnt_max1);	71✔
400	ncm_assert_cmpdouble_e (g_array_index (t_array1, gdouble, i) - lnnorm, <, gamma1, 1.0e-15, 0.0);	71✔
401	}
402
403	for (i = i_max0 + 1; i < n; i++)	77✔
404	{
405	lambda_test0 += exp (g_array_index (t_array0, gdouble, i) - lnt_max0);	75✔
406	ncm_assert_cmpdouble_e (g_array_index (t_array0, gdouble, i), <, gamma0, 1.0e-15, 0.0);	75✔
407	}
408
409	for (i = i_max1 + 1; i < n; i++)	78✔
410	{
411	lambda_test1 += exp (g_array_index (t_array1, gdouble, i) - lnt_max1);	76✔
412	ncm_assert_cmpdouble_e (g_array_index (t_array1, gdouble, i) - lnnorm, <, gamma1, 1.0e-15, 0.0);	76✔
413	}
414
415	ncm_assert_cmpdouble_e (lnt_max0, ==, gamma0, 1.0e-15, 0.0);	2✔
416	ncm_assert_cmpdouble_e (lnt_max1 - lnnorm, ==, gamma1, 1.0e-15, 0.0);	2✔
417
418	ncm_assert_cmpdouble_e (lambda_test0, ==, lambda0, 1.0e-15, 0.0);	2✔
419	ncm_assert_cmpdouble_e (lambda_test1, ==, lambda1, 1.0e-15, 0.0);	2✔
420
421	ncm_assert_cmpdouble_e (lambda_test0 + exp (lnt_max0), ==, lambda0 + exp (gamma0), 1.0e-15, 0.0);	2✔
422	ncm_assert_cmpdouble_e (lambda_test1 + exp (lnt_max1 - lnnorm), ==, lambda1 + exp (gamma1), 1.0e-15, 0.0);	2✔
423
424	ncm_vector_free (weights);	2✔
425	ncm_vector_free (chi2);	2✔
426	ncm_vector_free (lnnorms_vec);	2✔
427	g_clear_pointer (&t_array0, g_array_unref);	2✔
428	g_clear_pointer (&t_array1, g_array_unref);	2✔
429	}	2✔
430
431	static void
432	test_ncm_stats_dist_kernel_sample (TestNcmStatsDistKernel *test, gconstpointer pdata)	2✔
433	{
434	NcmRNG *rng = ncm_rng_seeded_new (NULL, g_test_rand_int ());	2✔
435	NcmMatrix *cov_decomp = ncm_matrix_new (test->dim, test->dim);	2✔
436	gdouble href = g_test_rand_double_range (1.0, 200.0);	2✔
437	gdouble dif = 0.0;	2✔
438	NcmVector *mu = ncm_vector_new (test->dim);	2✔
439	NcmStatsVec *test_stats = ncm_stats_vec_new (test->dim, NCM_STATS_VEC_VAR, FALSE);	2✔
440	const guint ntests = 300 * g_test_rand_int_range (1, 5);	2✔
441	guint i, j;	2✔
442
443	for (i = 0; i < test->dim; i++)	8✔
444	{
445	const gdouble val1 = g_test_rand_double_range (1.0, 200.0);	6✔
446
447	ncm_vector_set (mu, i, val1);	6✔
448
449	for (j = 0; j < test->dim; j++)	30✔
450	{
451	const gdouble val2 = g_test_rand_double_range (1.0, 200.0);	18✔
452
453	ncm_matrix_set (cov_decomp, i, j, val2);	18✔
454	}
455	}
456
457	ncm_matrix_cholesky_decomp (cov_decomp, 'U');	2✔
458
459	while (test->nfail < 20)	42✔
460	{
461	for (i = 0; i < ntests; i++)	30,040✔
462	{
463	NcmVector *x_test = ncm_vector_new (test->dim);	30,000✔
464
465	ncm_stats_dist_kernel_sample (test->kernel, cov_decomp, href, mu, x_test, rng);	30,000✔
466
467	ncm_stats_vec_append (test_stats, x_test, FALSE);	30,000✔
468	}
469
470	for (i = 0; i < test->dim; i++)	160✔
471	{
472	gdouble dif_i;	120✔
473
474	dif_i = fabs ((ncm_stats_vec_get_mean (test_stats, i) - ncm_vector_get (mu, i)) / ncm_vector_get (mu, i));	120✔
475	dif = dif + dif_i;	120✔
476	}
477
478	if (dif >= (test->dim * 0.2))	40✔
479	{
480	dif = 0.0;	40✔
481	test->nfail = test->nfail + 1;	40✔
482	}
483	else
484	{
UNCOV 485	test->nfail = 20;	×
486	}
487	}
488
489	g_assert_cmpfloat (dif, <, (test->dim * 0.2));	2✔
490
491
492
493	ncm_vector_free (mu);	2✔
494	ncm_matrix_free (cov_decomp);	2✔
495	ncm_rng_free (rng);	2✔
496	ncm_stats_vec_free (test_stats);	2✔
497	}	2✔
498
499	static void
500	test_ncm_stats_dist_kernel_free (TestNcmStatsDistKernel *test, gconstpointer pdata)	11✔
501	{
502	NCM_TEST_FREE (ncm_stats_dist_kernel_free, test->kernel);	11✔
503	}	11✔
504
505	static void
506	test_ncm_stats_dist_kernel_traps (TestNcmStatsDistKernel *test, gconstpointer pdata)	1✔
507	{
508	#if GLIB_CHECK_VERSION (2, 38, 0)
509	g_test_trap_subprocess ("/ncm/stats/dist/kernel/gauss/invalid/stub/subprocess", 0, 0);	1✔
510	g_test_trap_assert_failed ();	1✔
511	#endif
512	}	1✔
513
514	static void
515	test_ncm_stats_dist_kernel_invalid_stub (TestNcmStatsDistKernel *test, gconstpointer pdata)	×
516	{
517	g_assert_not_reached ();	×
518	}
519

NumCosmo / NumCosmo / 7101048423

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