7281313894

Committed 20 Dec 2023 10:09PM UTC coverage: 55.265% (+0.005%) from 55.26%

Build # 7281313894

Build Type

Pull #85

github

Committed by

web-flow

Commit Message

Merge 17c5c3b2a into 7ee347a7e

Pull Request Pull Request #85: Xcor cmp

Run Details

7282 of 12565 branches covered (0.0%)

Branch coverage included in aggregate %.

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

17 existing lines in 5 files now uncovered.

47969 of 87409 relevant lines covered (54.88%)

1508482.71 hits per line

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

99.08

/tests/test_ncm_data_gauss_cov.c

/***************************************************************************
 *            test_ncm_data_gauss_cov.c
 *
 *  Tue April 03 16:02:26 2012
 *  Copyright  2012  Sandro Dias Pinto Vitenti
 *  <vitenti@uel.br>
 ****************************************************************************/
/*
 * numcosmo
 * Copyright (C) Sandro Dias Pinto Vitenti 2012 <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 <gsl/gsl_statistics_double.h>

#include "ncm_data_gauss_cov_test.h"

typedef struct _TestNcmDataGaussCovTest
{
  NcmData *data;
  NcmDataGaussCovTest *gcov_test;
  NcmDataGaussCovMVND *gcov_mvnd;
  NcmModelMVND *model;
} TestNcmDataGaussCovTest;

void test_ncm_data_gauss_cov_test_new (TestNcmDataGaussCovTest *test, gconstpointer pdata);
void test_ncm_data_gauss_cov_test_free (TestNcmDataGaussCovTest *test, gconstpointer pdata);
void test_ncm_data_gauss_cov_test_sanity (TestNcmDataGaussCovTest *test, gconstpointer pdata);
void test_ncm_data_gauss_cov_test_resample (TestNcmDataGaussCovTest *test, gconstpointer pdata);
void test_ncm_data_gauss_cov_test_bulk_resample (TestNcmDataGaussCovTest *test, gconstpointer pdata);

void test_ncm_data_gauss_cov_mvnd_new (TestNcmDataGaussCovTest *test, gconstpointer pdata);
void test_ncm_data_gauss_cov_mvnd_free (TestNcmDataGaussCovTest *test, gconstpointer pdata);
void test_ncm_data_gauss_cov_mvnd_sanity (TestNcmDataGaussCovTest *test, gconstpointer pdata);
void test_ncm_data_gauss_cov_mvnd_log (TestNcmDataGaussCovTest *test, gconstpointer pdata);

gint
main (gint argc, gchar *argv[])
{
  g_test_init (&argc, &argv, NULL);
  ncm_cfg_init_full_ptr (&argc, &argv);
  ncm_cfg_enable_gsl_err_handler ();

  g_test_add ("/ncm/data_gauss_cov/test/sanity", TestNcmDataGaussCovTest, NULL,
              &test_ncm_data_gauss_cov_test_new,
              &test_ncm_data_gauss_cov_test_sanity,
              &test_ncm_data_gauss_cov_test_free);

  g_test_add ("/ncm/data_gauss_cov/test/resample", TestNcmDataGaussCovTest, NULL,
              &test_ncm_data_gauss_cov_test_new,
              &test_ncm_data_gauss_cov_test_resample,
              &test_ncm_data_gauss_cov_test_free);

  g_test_add ("/ncm/data_gauss_cov/test/bulk/resample", TestNcmDataGaussCovTest, NULL,
              &test_ncm_data_gauss_cov_test_new,
              &test_ncm_data_gauss_cov_test_bulk_resample,
              &test_ncm_data_gauss_cov_test_free);

  g_test_add ("/ncm/data_gauss_cov/mvnd/sanity", TestNcmDataGaussCovTest, NULL,
              &test_ncm_data_gauss_cov_mvnd_new,
              &test_ncm_data_gauss_cov_mvnd_sanity,
              &test_ncm_data_gauss_cov_mvnd_free);

  g_test_add ("/ncm/data_gauss_cov/mvnd/log", TestNcmDataGaussCovTest, NULL,
              &test_ncm_data_gauss_cov_mvnd_new,
              &test_ncm_data_gauss_cov_mvnd_log,
              &test_ncm_data_gauss_cov_mvnd_free);

  g_test_run ();
}

void
test_ncm_data_gauss_cov_test_new (TestNcmDataGaussCovTest *test, gconstpointer pdata)
{
  test->data      = ncm_data_gauss_cov_test_new ();
  test->gcov_test = NCM_DATA_GAUSS_COV_TEST (test->data);
  ncm_data_gauss_cov_test_gen_cov (test->gcov_test);
}

void
test_ncm_data_gauss_cov_test_free (TestNcmDataGaussCovTest *test, gconstpointer pdata)
{
  NCM_TEST_FREE (ncm_data_free, test->data);
}

void
test_ncm_data_gauss_cov_mvnd_new (TestNcmDataGaussCovTest *test, gconstpointer pdata)
{
  NcmRNG *rng                    = ncm_rng_seeded_new (NULL, g_test_rand_int ());
  const guint dim                = 5;
  NcmDataGaussCovMVND *data_mvnd = ncm_data_gauss_cov_mvnd_new_full (dim, 1.0e-2, 5.0e-2, 20.0, 1.0, 2.0, rng);
  NcmModelMVND *model_mvnd       = ncm_model_mvnd_new (dim);

  test->data      = NCM_DATA (data_mvnd);
  test->gcov_mvnd = data_mvnd;
  test->model     = model_mvnd;

  ncm_rng_free (rng);
}

void
test_ncm_data_gauss_cov_mvnd_free (TestNcmDataGaussCovTest *test, gconstpointer pdata)
{
  NCM_TEST_FREE (ncm_data_free, test->data);
  NCM_TEST_FREE (ncm_model_mvnd_free, test->model);
}

void
test_ncm_data_gauss_cov_mvnd_sanity (TestNcmDataGaussCovTest *test, gconstpointer pdata)
{
  NcmRNG *rng           = ncm_rng_seeded_new (NULL, g_test_rand_int ());
  NcmMSet *mset         = ncm_mset_new (NCM_MODEL (test->model), NULL);
  gdouble lower_data[5] = {-2.0, -2.0, -2.0, -2.0, 0.0};
  NcmVector *lower      = ncm_vector_new_data_static (lower_data, 5, 1);
  gdouble upper_data[5] = {2.0, 2.0, 2.0, 2.0, 2.0};
  NcmVector *upper      = ncm_vector_new_data_static (upper_data, 5, 1);
  NcmStatsVec *sv       = ncm_data_gauss_cov_mvnd_stats_vec (test->gcov_mvnd, mset, 10000, 100000, lower, upper, FALSE, rng);
  gint i;

  for (i = 0; i < 5; i++)
  {
    g_assert_cmpfloat_with_epsilon (ncm_stats_vec_get_mean (sv, i), 0.0, 1.0e-1);
  }

  g_assert_true (NCM_IS_STATS_VEC (sv));

  NCM_TEST_FREE (ncm_stats_vec_free, sv);

  sv = ncm_data_gauss_cov_mvnd_stats_vec (test->gcov_mvnd, mset, 5000, 100000, lower, upper, TRUE, rng);

  for (i = 0; i < 5; i++)
  {
    g_assert_cmpfloat_with_epsilon (ncm_stats_vec_get_mean (sv, i), 0.0, 1.0e-1);
  }

  g_assert (ncm_stats_vec_peek_row (sv, 0) != NULL);

  ncm_vector_free (lower);
  ncm_vector_free (upper);
  ncm_rng_free (rng);
  ncm_mset_clear (&mset);
}

void
test_ncm_data_gauss_cov_mvnd_log (TestNcmDataGaussCovTest *test, gconstpointer pdata)
{
  if (g_test_subprocess ())
  {
    ncm_data_gauss_cov_mvnd_log_info (test->gcov_mvnd);

    return;
  }

  g_test_trap_subprocess (NULL, 0, 0);
  g_test_trap_assert_stdout ("*data mean*data cov*");
}

void
test_ncm_data_gauss_cov_test_sanity (TestNcmDataGaussCovTest *test, gconstpointer pdata)
{
  NcmDataGaussCov *gauss = NCM_DATA_GAUSS_COV (test->data);
  NcmMatrix *cov         = ncm_data_gauss_cov_peek_cov (gauss);
  guint np               = ncm_data_gauss_cov_get_size (gauss);
  guint i;
  guint j;

  g_assert_true (NCM_IS_DATA_GAUSS_COV (test->data));
  g_assert_true (NCM_IS_MATRIX (cov));
  g_assert_true (np == ncm_matrix_nrows (cov));
  g_assert_true (np == ncm_matrix_ncols (cov));

  {
    NcmVector *y     = ncm_vector_ref (ncm_data_gauss_cov_peek_mean (gauss));
    NcmVector *y_dup = ncm_vector_dup (y);

    ncm_data_gauss_cov_replace_mean (gauss, y_dup);

    g_assert (y_dup == ncm_data_gauss_cov_peek_mean (gauss));

    NCM_TEST_FREE (ncm_vector_free, y);
  }

  {
    g_assert (gsl_finite (ncm_data_gauss_cov_get_log_norma (gauss, NULL)));
  }

  for (i = 0; i < np; i++)
  {
    for (j = 0; j < np; j++)
    {
      if (i == j)
      {
        continue;
      }
      else
      {
        gdouble cov_ij = ncm_matrix_get (cov, i, j);
        gdouble cov_ji = ncm_matrix_get (cov, j, i);
        gdouble var_i  = ncm_matrix_get (cov, i, i);
        gdouble var_j  = ncm_matrix_get (cov, j, j);
        gdouble cor_ij = cov_ij / sqrt (var_i * var_j);

        ncm_assert_cmpdouble (var_i, >, 0.0);
        ncm_assert_cmpdouble (var_j, >, 0.0);

        ncm_assert_cmpdouble (cov_ij, ==, cov_ji);
        ncm_assert_cmpdouble (cor_ij, >=, -1.0);
        ncm_assert_cmpdouble (cor_ij, <=,  1.0);
      }
    }
  }
}

void
test_ncm_data_gauss_cov_test_resample (TestNcmDataGaussCovTest *test, gconstpointer pdata)
{
  NcmDataGaussCov *gauss = NCM_DATA_GAUSS_COV (test->data);
  guint np               = ncm_data_gauss_cov_get_size (gauss);
  NcmStatsVec *stat      = ncm_stats_vec_new (np, NCM_STATS_VEC_COV, FALSE);
  NcmRNG *rng            = ncm_rng_seeded_new (NULL, g_test_rand_int ());
  NcmMatrix *cov         = ncm_data_gauss_cov_peek_cov (gauss);
  NcmVector *y           = ncm_data_gauss_cov_peek_mean (gauss);
  NcmVector *mean        = ncm_vector_new (np);
  guint resample_size    = 10000 * np;
  guint nerr             = 0;
  guint i;

  ncm_data_gauss_cov_test_mean_func (gauss, NULL, mean);

  for (i = 0; i < resample_size; i++)
  {
    ncm_data_resample (test->data, NULL, rng);
    ncm_stats_vec_append (stat, y, FALSE);
  }

  g_assert_true (NCM_IS_MATRIX (cov));
  g_assert_true (np == ncm_matrix_nrows (cov));
  g_assert_true (np == ncm_matrix_ncols (cov));

  for (i = 0; i < np; i++)
  {
    guint j;
    gdouble mean_i     = ncm_vector_get (mean, i);
    gdouble est_mean_i = ncm_stats_vec_get_mean (stat, i);
    gdouble est_var_i  = ncm_stats_vec_get_var (stat, i);
    gdouble var_i      = ncm_matrix_get (cov, i, i);

    gdouble mean_diff_frac = fabs ((mean_i - est_mean_i) / mean_i);
    gdouble var_diff_frac  = fabs ((var_i - est_var_i) / var_i);

    ncm_assert_cmpdouble (mean_diff_frac, <, 1.0e-2);
    ncm_assert_cmpdouble (var_diff_frac, <, 1.0e-1);

    for (j = i + 1; j < np; j++)
    {
      gdouble est_cov_ij    = ncm_stats_vec_get_cov (stat, i, j);
      gdouble cov_ij        = ncm_matrix_get (cov, i, j);
      gdouble cov_diff_frac = fabs ((cov_ij - est_cov_ij) / cov_ij);

      if (cov_diff_frac > 1.0)
        nerr++;
    }
  }

  g_assert_cmpuint (nerr, <, (np * (np - 1)) / 20);

  ncm_stats_vec_clear (&stat);
  ncm_vector_clear (&mean);
}

void
test_ncm_data_gauss_cov_test_bulk_resample (TestNcmDataGaussCovTest *test, gconstpointer pdata)
{
  NcmDataGaussCov *gauss = NCM_DATA_GAUSS_COV (test->data);
  guint np               = ncm_data_gauss_cov_get_size (gauss);
  NcmStatsVec *stat      = ncm_stats_vec_new (np, NCM_STATS_VEC_COV, FALSE);
  NcmRNG *rng            = ncm_rng_seeded_new (NULL, g_test_rand_int ());
  NcmMatrix *cov         = ncm_data_gauss_cov_peek_cov (gauss);
  NcmVector *mean        = ncm_vector_new (np);
  NcmMatrix *bulk        = ncm_matrix_new (100, np);
  guint resample_size    = 10000 * np;
  guint nerr             = 0;
  guint i;

  ncm_data_gauss_cov_test_mean_func (gauss, NULL, mean);

  for (i = 0; i < resample_size / 100; i++)
  {
    gint j;

    ncm_data_gauss_cov_bulk_resample (gauss, NULL, bulk, rng);

    for (j = 0; j < 100; j++)
    {
      NcmVector *row = ncm_matrix_get_row (bulk, j);

      ncm_stats_vec_append (stat, row, FALSE);

      ncm_vector_clear (&row);
    }
  }

  g_assert_true (NCM_IS_MATRIX (cov));
  g_assert_true (np == ncm_matrix_nrows (cov));
  g_assert_true (np == ncm_matrix_ncols (cov));

  for (i = 0; i < np; i++)
  {
    guint j;
    gdouble mean_i     = ncm_vector_get (mean, i);
    gdouble est_mean_i = ncm_stats_vec_get_mean (stat, i);
    gdouble est_var_i  = ncm_stats_vec_get_var (stat, i);
    gdouble var_i      = ncm_matrix_get (cov, i, i);

    gdouble mean_diff_frac = fabs ((mean_i - est_mean_i) / mean_i);
    gdouble var_diff_frac  = fabs ((var_i - est_var_i) / var_i);

    ncm_assert_cmpdouble (mean_diff_frac, <, 1.0e-2);
    ncm_assert_cmpdouble (var_diff_frac, <, 1.0e-1);

    for (j = i + 1; j < np; j++)
    {
      gdouble est_cov_ij    = ncm_stats_vec_get_cov (stat, i, j);
      gdouble cov_ij        = ncm_matrix_get (cov, i, j);
      gdouble cov_diff_frac = fabs ((cov_ij - est_cov_ij) / cov_ij);

      if (cov_diff_frac > 1.0)
        nerr++;
    }
  }

  g_assert_cmpuint (nerr, <, (np * (np - 1)) / 20);

  ncm_stats_vec_clear (&stat);
  ncm_vector_clear (&mean);
}


1	/***************************************************************************
2	* test_ncm_data_gauss_cov.c
3	*
4	* Tue April 03 16:02:26 2012
5	* Copyright 2012 Sandro Dias Pinto Vitenti
6	* <vitenti@uel.br>
7	****************************************************************************/
8	/*
9	* numcosmo
10	* Copyright (C) Sandro Dias Pinto Vitenti 2012 <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 <gsl/gsl_statistics_double.h>
32
33	#include "ncm_data_gauss_cov_test.h"
34
35	typedef struct _TestNcmDataGaussCovTest
36	{
37	NcmData *data;
38	NcmDataGaussCovTest *gcov_test;
39	NcmDataGaussCovMVND *gcov_mvnd;
40	NcmModelMVND *model;
41	} TestNcmDataGaussCovTest;
42
43	void test_ncm_data_gauss_cov_test_new (TestNcmDataGaussCovTest *test, gconstpointer pdata);
44	void test_ncm_data_gauss_cov_test_free (TestNcmDataGaussCovTest *test, gconstpointer pdata);
45	void test_ncm_data_gauss_cov_test_sanity (TestNcmDataGaussCovTest *test, gconstpointer pdata);
46	void test_ncm_data_gauss_cov_test_resample (TestNcmDataGaussCovTest *test, gconstpointer pdata);
47	void test_ncm_data_gauss_cov_test_bulk_resample (TestNcmDataGaussCovTest *test, gconstpointer pdata);
48
49	void test_ncm_data_gauss_cov_mvnd_new (TestNcmDataGaussCovTest *test, gconstpointer pdata);
50	void test_ncm_data_gauss_cov_mvnd_free (TestNcmDataGaussCovTest *test, gconstpointer pdata);
51	void test_ncm_data_gauss_cov_mvnd_sanity (TestNcmDataGaussCovTest *test, gconstpointer pdata);
52	void test_ncm_data_gauss_cov_mvnd_log (TestNcmDataGaussCovTest *test, gconstpointer pdata);
53
54	gint
55	main (gint argc, gchar *argv[])	2✔
56	{
57	g_test_init (&argc, &argv, NULL);	2✔
58	ncm_cfg_init_full_ptr (&argc, &argv);	2✔
59	ncm_cfg_enable_gsl_err_handler ();	2✔
60
61	g_test_add ("/ncm/data_gauss_cov/test/sanity", TestNcmDataGaussCovTest, NULL,	2✔
62	&test_ncm_data_gauss_cov_test_new,
63	&test_ncm_data_gauss_cov_test_sanity,
64	&test_ncm_data_gauss_cov_test_free);
65
66	g_test_add ("/ncm/data_gauss_cov/test/resample", TestNcmDataGaussCovTest, NULL,	2✔
67	&test_ncm_data_gauss_cov_test_new,
68	&test_ncm_data_gauss_cov_test_resample,
69	&test_ncm_data_gauss_cov_test_free);
70
71	g_test_add ("/ncm/data_gauss_cov/test/bulk/resample", TestNcmDataGaussCovTest, NULL,	2✔
72	&test_ncm_data_gauss_cov_test_new,
73	&test_ncm_data_gauss_cov_test_bulk_resample,
74	&test_ncm_data_gauss_cov_test_free);
75
76	g_test_add ("/ncm/data_gauss_cov/mvnd/sanity", TestNcmDataGaussCovTest, NULL,	2✔
77	&test_ncm_data_gauss_cov_mvnd_new,
78	&test_ncm_data_gauss_cov_mvnd_sanity,
79	&test_ncm_data_gauss_cov_mvnd_free);
80
81	g_test_add ("/ncm/data_gauss_cov/mvnd/log", TestNcmDataGaussCovTest, NULL,	2✔
82	&test_ncm_data_gauss_cov_mvnd_new,
83	&test_ncm_data_gauss_cov_mvnd_log,
84	&test_ncm_data_gauss_cov_mvnd_free);
85
86	g_test_run ();	2✔
87	}
88
89	void
90	test_ncm_data_gauss_cov_test_new (TestNcmDataGaussCovTest *test, gconstpointer pdata)	3✔
91	{
92	test->data = ncm_data_gauss_cov_test_new ();	3✔
93	test->gcov_test = NCM_DATA_GAUSS_COV_TEST (test->data);	3✔
94	ncm_data_gauss_cov_test_gen_cov (test->gcov_test);	3✔
95	}	3✔
96
97	void
98	test_ncm_data_gauss_cov_test_free (TestNcmDataGaussCovTest *test, gconstpointer pdata)	3✔
99	{
100	NCM_TEST_FREE (ncm_data_free, test->data);	3✔
101	}	3✔
102
103	void
104	test_ncm_data_gauss_cov_mvnd_new (TestNcmDataGaussCovTest *test, gconstpointer pdata)	3✔
105	{
106	NcmRNG *rng = ncm_rng_seeded_new (NULL, g_test_rand_int ());	3✔
107	const guint dim = 5;	3✔
108	NcmDataGaussCovMVND *data_mvnd = ncm_data_gauss_cov_mvnd_new_full (dim, 1.0e-2, 5.0e-2, 20.0, 1.0, 2.0, rng);	3✔
109	NcmModelMVND *model_mvnd = ncm_model_mvnd_new (dim);	3✔
110
111	test->data = NCM_DATA (data_mvnd);	3✔
112	test->gcov_mvnd = data_mvnd;	3✔
113	test->model = model_mvnd;	3✔
114
115	ncm_rng_free (rng);	3✔
116	}	3✔
117
118	void
119	test_ncm_data_gauss_cov_mvnd_free (TestNcmDataGaussCovTest *test, gconstpointer pdata)	3✔
120	{
121	NCM_TEST_FREE (ncm_data_free, test->data);	3✔
122	NCM_TEST_FREE (ncm_model_mvnd_free, test->model);	3✔
123	}	3✔
124
125	void
126	test_ncm_data_gauss_cov_mvnd_sanity (TestNcmDataGaussCovTest *test, gconstpointer pdata)	1✔
127	{
128	NcmRNG *rng = ncm_rng_seeded_new (NULL, g_test_rand_int ());	1✔
129	NcmMSet *mset = ncm_mset_new (NCM_MODEL (test->model), NULL);	1✔
130	gdouble lower_data[5] = {-2.0, -2.0, -2.0, -2.0, 0.0};	1✔
131	NcmVector *lower = ncm_vector_new_data_static (lower_data, 5, 1);	1✔
132	gdouble upper_data[5] = {2.0, 2.0, 2.0, 2.0, 2.0};	1✔
133	NcmVector *upper = ncm_vector_new_data_static (upper_data, 5, 1);	1✔
134	NcmStatsVec *sv = ncm_data_gauss_cov_mvnd_stats_vec (test->gcov_mvnd, mset, 10000, 100000, lower, upper, FALSE, rng);	1✔
135	gint i;	1✔
136
137	for (i = 0; i < 5; i++)	7✔
138	{
139	g_assert_cmpfloat_with_epsilon (ncm_stats_vec_get_mean (sv, i), 0.0, 1.0e-1);	5✔
140	}
141
142	g_assert_true (NCM_IS_STATS_VEC (sv));	1✔
143
144	NCM_TEST_FREE (ncm_stats_vec_free, sv);	1✔
145
146	sv = ncm_data_gauss_cov_mvnd_stats_vec (test->gcov_mvnd, mset, 5000, 100000, lower, upper, TRUE, rng);	1✔
147
148	for (i = 0; i < 5; i++)	7✔
149	{
150	g_assert_cmpfloat_with_epsilon (ncm_stats_vec_get_mean (sv, i), 0.0, 1.0e-1);	5✔
151	}
152
153	g_assert (ncm_stats_vec_peek_row (sv, 0) != NULL);	1✔
154
155	ncm_vector_free (lower);	1✔
156	ncm_vector_free (upper);	1✔
157	ncm_rng_free (rng);	1✔
158	ncm_mset_clear (&mset);	1✔
159	}	1✔
160
161	void
162	test_ncm_data_gauss_cov_mvnd_log (TestNcmDataGaussCovTest *test, gconstpointer pdata)	2✔
163	{
164	if (g_test_subprocess ())	2✔
165	{
166	ncm_data_gauss_cov_mvnd_log_info (test->gcov_mvnd);	1✔
167
168	return;	1✔
169	}
170
171	g_test_trap_subprocess (NULL, 0, 0);	1✔
172	g_test_trap_assert_stdout ("data meandata cov*");	1✔
173	}
174
175	void
176	test_ncm_data_gauss_cov_test_sanity (TestNcmDataGaussCovTest *test, gconstpointer pdata)	1✔
177	{
178	NcmDataGaussCov *gauss = NCM_DATA_GAUSS_COV (test->data);	1✔
179	NcmMatrix *cov = ncm_data_gauss_cov_peek_cov (gauss);	1✔
180	guint np = ncm_data_gauss_cov_get_size (gauss);	1✔
181	guint i;	1✔
182	guint j;	1✔
183
184	g_assert_true (NCM_IS_DATA_GAUSS_COV (test->data));	1✔
185	g_assert_true (NCM_IS_MATRIX (cov));	1✔
186	g_assert_true (np == ncm_matrix_nrows (cov));	1✔
187	g_assert_true (np == ncm_matrix_ncols (cov));	1✔
188
189	{
190	NcmVector *y = ncm_vector_ref (ncm_data_gauss_cov_peek_mean (gauss));	1✔
191	NcmVector *y_dup = ncm_vector_dup (y);	1✔
192
193	ncm_data_gauss_cov_replace_mean (gauss, y_dup);	1✔
194
195	g_assert (y_dup == ncm_data_gauss_cov_peek_mean (gauss));	1✔
196
197	NCM_TEST_FREE (ncm_vector_free, y);	1✔
198	}
199
200	{
201	g_assert (gsl_finite (ncm_data_gauss_cov_get_log_norma (gauss, NULL)));	1✔
202	}
203
204	for (i = 0; i < np; i++)	13✔
205	{
206	for (j = 0; j < np; j++)	156✔
207	{
208	if (i == j)	144✔
209	{
210	continue;	12✔
211	}
212	else
213	{
214	gdouble cov_ij = ncm_matrix_get (cov, i, j);	132✔
215	gdouble cov_ji = ncm_matrix_get (cov, j, i);	132✔
216	gdouble var_i = ncm_matrix_get (cov, i, i);	132✔
217	gdouble var_j = ncm_matrix_get (cov, j, j);	132✔
218	gdouble cor_ij = cov_ij / sqrt (var_i * var_j);	132✔
219
220	ncm_assert_cmpdouble (var_i, >, 0.0);	132✔
221	ncm_assert_cmpdouble (var_j, >, 0.0);	132✔
222
223	ncm_assert_cmpdouble (cov_ij, ==, cov_ji);	132✔
224	ncm_assert_cmpdouble (cor_ij, >=, -1.0);	132✔
225	ncm_assert_cmpdouble (cor_ij, <=, 1.0);	144✔
226	}
227	}
228	}
229	}	1✔
230
231	void
232	test_ncm_data_gauss_cov_test_resample (TestNcmDataGaussCovTest *test, gconstpointer pdata)	1✔
233	{
234	NcmDataGaussCov *gauss = NCM_DATA_GAUSS_COV (test->data);	1✔
235	guint np = ncm_data_gauss_cov_get_size (gauss);	1✔
236	NcmStatsVec *stat = ncm_stats_vec_new (np, NCM_STATS_VEC_COV, FALSE);	1✔
237	NcmRNG *rng = ncm_rng_seeded_new (NULL, g_test_rand_int ());	1✔
238	NcmMatrix *cov = ncm_data_gauss_cov_peek_cov (gauss);	1✔
239	NcmVector *y = ncm_data_gauss_cov_peek_mean (gauss);	1✔
240	NcmVector *mean = ncm_vector_new (np);	1✔
241	guint resample_size = 10000 * np;	1✔
242	guint nerr = 0;	1✔
243	guint i;	1✔
244
245	ncm_data_gauss_cov_test_mean_func (gauss, NULL, mean);	1✔
246
247	for (i = 0; i < resample_size; i++)	120,002✔
248	{
249	ncm_data_resample (test->data, NULL, rng);	120,000✔
250	ncm_stats_vec_append (stat, y, FALSE);	120,000✔
251	}
252
253	g_assert_true (NCM_IS_MATRIX (cov));	1✔
254	g_assert_true (np == ncm_matrix_nrows (cov));	1✔
255	g_assert_true (np == ncm_matrix_ncols (cov));	1✔
256
257	for (i = 0; i < np; i++)	13✔
258	{
259	guint j;	12✔
260	gdouble mean_i = ncm_vector_get (mean, i);	12✔
261	gdouble est_mean_i = ncm_stats_vec_get_mean (stat, i);	12✔
262	gdouble est_var_i = ncm_stats_vec_get_var (stat, i);	12✔
263	gdouble var_i = ncm_matrix_get (cov, i, i);	12✔
264
265	gdouble mean_diff_frac = fabs ((mean_i - est_mean_i) / mean_i);	12✔
266	gdouble var_diff_frac = fabs ((var_i - est_var_i) / var_i);	12✔
267
268	ncm_assert_cmpdouble (mean_diff_frac, <, 1.0e-2);	12✔
269	ncm_assert_cmpdouble (var_diff_frac, <, 1.0e-1);	12✔
270
271	for (j = i + 1; j < np; j++)	78✔
272	{
273	gdouble est_cov_ij = ncm_stats_vec_get_cov (stat, i, j);	66✔
274	gdouble cov_ij = ncm_matrix_get (cov, i, j);	66✔
275	gdouble cov_diff_frac = fabs ((cov_ij - est_cov_ij) / cov_ij);	66✔
276
277	if (cov_diff_frac > 1.0)	66✔
UNCOV 278	nerr++;	×
279	}
280	}
281
282	g_assert_cmpuint (nerr, <, (np * (np - 1)) / 20);	1✔
283
284	ncm_stats_vec_clear (&stat);	1✔
285	ncm_vector_clear (&mean);	1✔
286	}	1✔
287
288	void
289	test_ncm_data_gauss_cov_test_bulk_resample (TestNcmDataGaussCovTest *test, gconstpointer pdata)	1✔
290	{
291	NcmDataGaussCov *gauss = NCM_DATA_GAUSS_COV (test->data);	1✔
292	guint np = ncm_data_gauss_cov_get_size (gauss);	1✔
293	NcmStatsVec *stat = ncm_stats_vec_new (np, NCM_STATS_VEC_COV, FALSE);	1✔
294	NcmRNG *rng = ncm_rng_seeded_new (NULL, g_test_rand_int ());	1✔
295	NcmMatrix *cov = ncm_data_gauss_cov_peek_cov (gauss);	1✔
296	NcmVector *mean = ncm_vector_new (np);	1✔
297	NcmMatrix *bulk = ncm_matrix_new (100, np);	1✔
298	guint resample_size = 10000 * np;	1✔
299	guint nerr = 0;	1✔
300	guint i;	1✔
301
302	ncm_data_gauss_cov_test_mean_func (gauss, NULL, mean);	1✔
303
304	for (i = 0; i < resample_size / 100; i++)	1,202✔
305	{
306	gint j;	1,200✔
307
308	ncm_data_gauss_cov_bulk_resample (gauss, NULL, bulk, rng);	1,200✔
309
310	for (j = 0; j < 100; j++)	122,400✔
311	{
312	NcmVector *row = ncm_matrix_get_row (bulk, j);	120,000✔
313
314	ncm_stats_vec_append (stat, row, FALSE);	120,000✔
315
316	ncm_vector_clear (&row);	120,000✔
317	}
318	}
319
320	g_assert_true (NCM_IS_MATRIX (cov));	1✔
321	g_assert_true (np == ncm_matrix_nrows (cov));	1✔
322	g_assert_true (np == ncm_matrix_ncols (cov));	1✔
323
324	for (i = 0; i < np; i++)	13✔
325	{
326	guint j;	12✔
327	gdouble mean_i = ncm_vector_get (mean, i);	12✔
328	gdouble est_mean_i = ncm_stats_vec_get_mean (stat, i);	12✔
329	gdouble est_var_i = ncm_stats_vec_get_var (stat, i);	12✔
330	gdouble var_i = ncm_matrix_get (cov, i, i);	12✔
331
332	gdouble mean_diff_frac = fabs ((mean_i - est_mean_i) / mean_i);	12✔
333	gdouble var_diff_frac = fabs ((var_i - est_var_i) / var_i);	12✔
334
335	ncm_assert_cmpdouble (mean_diff_frac, <, 1.0e-2);	12✔
336	ncm_assert_cmpdouble (var_diff_frac, <, 1.0e-1);	12✔
337
338	for (j = i + 1; j < np; j++)	78✔
339	{
340	gdouble est_cov_ij = ncm_stats_vec_get_cov (stat, i, j);	66✔
341	gdouble cov_ij = ncm_matrix_get (cov, i, j);	66✔
342	gdouble cov_diff_frac = fabs ((cov_ij - est_cov_ij) / cov_ij);	66✔
343
344	if (cov_diff_frac > 1.0)	66✔
UNCOV 345	nerr++;	×
346	}
347	}
348
349	g_assert_cmpuint (nerr, <, (np * (np - 1)) / 20);	1✔
350
351	ncm_stats_vec_clear (&stat);	1✔
352	ncm_vector_clear (&mean);	1✔
353	}	1✔
354

NumCosmo / NumCosmo / 7281313894

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