7255845566

Committed 19 Dec 2023 12:54AM UTC coverage: 55.152% (+0.2%) from 54.995%

Build # 7255845566

Build Type

Pull #126

github

Committed by

web-flow

Commit Message

Merge 9cdca461b into bffca6a86

Pull Request Pull Request #126: More objects encapsulation

Run Details

7272 of 12543 branches covered (0.0%)

Branch coverage included in aggregate %.

999 of 1994 new or added lines in 130 files covered. (50.1%)

74 existing lines in 20 files now uncovered.

47556 of 86869 relevant lines covered (54.74%)

1957990.82 hits per line

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

78.2

/tests/test_ncm_fftlog.c

/***************************************************************************
 *            test_ncm_fftlog.c
 *
 *  Sun September 03 11:45:13 2017
 *  Copyright  2017  Sandro Dias Pinto Vitenti
 *  <vitenti@uel.br>
 ****************************************************************************/
/*
 * test_ncm_fftlog.c
 *
 * Copyright (C) 2017 - Sandro Dias Pinto Vitenti
 *
 * This program 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 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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>

typedef struct _TestNcmFftlogK
{
  gsl_function Fk;
  gdouble lnr;
  gdouble w;
  guint ell;
  guint m;
  guint ntests;
} TestNcmFftlogK;

typedef struct _TestNcmFftlog
{
  NcmFftlog *fftlog;
  gsl_function Fk;
  gsl_function KFk;
  gdouble lnk_i, lnk_f;
  guint ntests;
  TestNcmFftlogK *argK;
} TestNcmFftlog;

void test_ncm_fftlog_tophatwin2_new (TestNcmFftlog *test, gconstpointer pdata);
void test_ncm_fftlog_gausswin2_new (TestNcmFftlog *test, gconstpointer pdata);
void test_ncm_fftlog_sbessel_j_new (TestNcmFftlog *test, gconstpointer pdata);
void test_ncm_fftlog_sbessel_jljm_new (TestNcmFftlog *test, gconstpointer pdata);
void test_ncm_fftlog_free (TestNcmFftlog *test, gconstpointer pdata);

void test_ncm_fftlog_eval (TestNcmFftlog *test, gconstpointer pdata);

void test_ncm_fftlog_tophatwin2_traps (TestNcmFftlog *test, gconstpointer pdata);
void test_ncm_fftlog_gausswin2_traps (TestNcmFftlog *test, gconstpointer pdata);
void test_ncm_fftlog_sbessel_j_traps (TestNcmFftlog *test, gconstpointer pdata);
void test_ncm_fftlog_sbessel_jljm_traps (TestNcmFftlog *test, gconstpointer pdata);
void test_ncm_fftlog_invalid_st (TestNcmFftlog *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_set_nonfatal_assertions ();

  g_test_add ("/ncm/fftlog/tophatwin2/eval", TestNcmFftlog, NULL,
              &test_ncm_fftlog_tophatwin2_new,
              &test_ncm_fftlog_eval,
              &test_ncm_fftlog_free);

  g_test_add ("/ncm/fftlog/tophatwin2/traps", TestNcmFftlog, NULL,
              &test_ncm_fftlog_tophatwin2_new,
              &test_ncm_fftlog_tophatwin2_traps,
              &test_ncm_fftlog_free);

  g_test_add ("/ncm/fftlog/gausswin2/eval", TestNcmFftlog, NULL,
              &test_ncm_fftlog_gausswin2_new,
              &test_ncm_fftlog_eval,
              &test_ncm_fftlog_free);

  g_test_add ("/ncm/fftlog/gausswin2/traps", TestNcmFftlog, NULL,
              &test_ncm_fftlog_gausswin2_new,
              &test_ncm_fftlog_gausswin2_traps,
              &test_ncm_fftlog_free);

  g_test_add ("/ncm/fftlog/sbessel_j/eval", TestNcmFftlog, NULL,
              &test_ncm_fftlog_sbessel_j_new,
              &test_ncm_fftlog_eval,
              &test_ncm_fftlog_free);

  g_test_add ("/ncm/fftlog/sbessel_j/traps", TestNcmFftlog, NULL,
              &test_ncm_fftlog_sbessel_j_new,
              &test_ncm_fftlog_sbessel_j_traps,
              &test_ncm_fftlog_free);

#if defined (HAVE_FFTW3) && defined (HAVE_ACB_H)

  g_test_add ("/ncm/fftlog/sbessel_jljm/eval", TestNcmFftlog, NULL,
              &test_ncm_fftlog_sbessel_jljm_new,
              &test_ncm_fftlog_eval,
              &test_ncm_fftlog_free);

  g_test_add ("/ncm/fftlog/sbessel_jljm/traps", TestNcmFftlog, NULL,
              &test_ncm_fftlog_sbessel_jljm_new,
              &test_ncm_fftlog_sbessel_jljm_traps,
              &test_ncm_fftlog_free);

#endif /* defined (HAVE_FFTW3) && defined (HAVE_ACB_H) */

  g_test_add ("/ncm/fftlog/tophatwin2/invalid/st/subprocess", TestNcmFftlog, NULL,
              &test_ncm_fftlog_tophatwin2_new,
              &test_ncm_fftlog_invalid_st,
              &test_ncm_fftlog_free);
  g_test_add ("/ncm/fftlog/gausswin2/invalid/st/subprocess", TestNcmFftlog, NULL,
              &test_ncm_fftlog_gausswin2_new,
              &test_ncm_fftlog_invalid_st,
              &test_ncm_fftlog_free);
  g_test_add ("/ncm/fftlog/sbessel_j/invalid/st/subprocess", TestNcmFftlog, NULL,
              &test_ncm_fftlog_sbessel_j_new,
              &test_ncm_fftlog_invalid_st,
              &test_ncm_fftlog_free);
  g_test_add ("/ncm/fftlog/sbessel_jljm/invalid/st/subprocess", TestNcmFftlog, NULL,
              &test_ncm_fftlog_sbessel_jljm_new,
              &test_ncm_fftlog_invalid_st,
              &test_ncm_fftlog_free);

#ifdef HAVE_FFTW3
  g_test_run ();
#endif
}

#define NTESTS 20

typedef struct _TestNcmFftlogPlaw
{
  gdouble lnA;
  gdouble ns;
} TestNcmFftlogPlaw;

static gdouble
_test_ncm_fftlog_plaw (gdouble k, gpointer user_data)
{
  TestNcmFftlogPlaw *args = (TestNcmFftlogPlaw *) user_data;

  return exp (args->lnA + log (k) * (args->ns - 1.0));
}

static gdouble
_test_ncm_fftlog_tophatwin2 (gdouble lnk, gpointer user_data)
{
  TestNcmFftlogK *args = (TestNcmFftlogK *) user_data;
  const gdouble kr     = exp (lnk + args->lnr);
  const gdouble k      = exp (lnk);

  return GSL_FN_EVAL (&args->Fk, k) * k * gsl_pow_2 (3.0 * ncm_sf_sbessel (1, kr) / kr);
}

static gdouble
_test_ncm_fftlog_gausswin2 (gdouble lnk, gpointer user_data)
{
  TestNcmFftlogK *args = (TestNcmFftlogK *) user_data;
  const gdouble kr     = exp (lnk + args->lnr);
  const gdouble k      = exp (lnk);

  return GSL_FN_EVAL (&args->Fk, k) * k * exp (-kr * kr);
}

static gdouble
_test_ncm_fftlog_sbessel_j (gdouble lnk, gpointer user_data)
{
  TestNcmFftlogK *args = (TestNcmFftlogK *) user_data;
  const gdouble kr     = exp (lnk + args->lnr);
  const gdouble k      = exp (lnk);

  return GSL_FN_EVAL (&args->Fk, k) * k * ncm_sf_sbessel (args->ell, kr);
}

static gdouble
_test_ncm_fftlog_sbessel_jljm (gdouble lnk, gpointer user_data)
{
  TestNcmFftlogK *args = (TestNcmFftlogK *) user_data;
  const gdouble kr     = exp (lnk + args->lnr);
  const gdouble k      = exp (lnk);

/*
 *  printf ("% 22.15g % 22.15g\n", k,
 *       GSL_FN_EVAL (&args->Fk, k) * k * ncm_sf_sbessel (args->ell, kr * args->w) * ncm_sf_sbessel (args->m, kr / args->w));
 */
  return GSL_FN_EVAL (&args->Fk, k) * k * ncm_sf_sbessel (args->ell, kr * args->w) * ncm_sf_sbessel (args->m, kr / args->w);
}

void
test_ncm_fftlog_tophatwin2_new (TestNcmFftlog *test, gconstpointer pdata)
{
  const guint N          = g_test_rand_int_range  (10000, 20000);
  NcmFftlog *fftlog      = NCM_FFTLOG (ncm_fftlog_tophatwin2_new (0.0, 0.0, 20.0, N));
  TestNcmFftlogK *argK   = g_new (TestNcmFftlogK, 1);
  TestNcmFftlogPlaw *arg = g_new (TestNcmFftlogPlaw, 1);
  gdouble Lk             = g_test_rand_double_range (log (1.0e+3), log (1.0e+6));

  test->fftlog       = fftlog;
  test->Fk.function  = &_test_ncm_fftlog_plaw;
  test->Fk.params    = arg;
  test->KFk.function = &_test_ncm_fftlog_tophatwin2;
  test->KFk.params   = argK;
  test->argK         = argK;

  test->lnk_i = g_test_rand_double_range (log (1.0e-4), log (1.0e0));
  test->lnk_f = test->lnk_i + Lk;

  test->ntests = NTESTS;

  arg->lnA = g_test_rand_double_range (log (1.0e-10), log (1.0e+10));
  arg->ns  = g_test_rand_double_range (0.5, 1.5);

  argK->lnr = 0.0;
  argK->Fk  = test->Fk;

  ncm_fftlog_set_lnk0 (fftlog, +0.5 * (test->lnk_i + test->lnk_f));
  ncm_fftlog_set_lnr0 (fftlog, -0.5 * (test->lnk_i + test->lnk_f));
  ncm_fftlog_set_length (fftlog, Lk);

  g_assert_true (fftlog != NULL);
  g_assert_true (NCM_IS_FFTLOG (fftlog));
  g_assert_true (NCM_IS_FFTLOG_TOPHATWIN2 (fftlog));
}

void
test_ncm_fftlog_gausswin2_new (TestNcmFftlog *test, gconstpointer pdata)
{
  const guint N          = g_test_rand_int_range  (1000, 2000);
  NcmFftlog *fftlog      = NCM_FFTLOG (ncm_fftlog_gausswin2_new (0.0, 0.0, 20.0, N));
  TestNcmFftlogK *argK   = g_new (TestNcmFftlogK, 1);
  TestNcmFftlogPlaw *arg = g_new (TestNcmFftlogPlaw, 1);
  gdouble Lk             = g_test_rand_double_range (log (1.0e+3), log (1.0e+6));

  test->fftlog       = fftlog;
  test->Fk.function  = &_test_ncm_fftlog_plaw;
  test->Fk.params    = arg;
  test->KFk.function = &_test_ncm_fftlog_gausswin2;
  test->KFk.params   = argK;
  test->argK         = argK;

  test->lnk_i = g_test_rand_double_range (log (1.0e-4), log (1.0e0));
  test->lnk_f = test->lnk_i + Lk;

  test->ntests = NTESTS;

  arg->lnA = g_test_rand_double_range (log (1.0e-10), log (1.0e+10));
  arg->ns  = g_test_rand_double_range (0.5, 1.5);

  argK->lnr = 0.0;
  argK->Fk  = test->Fk;

  ncm_fftlog_set_lnk0 (fftlog, +0.5 * (test->lnk_i + test->lnk_f));
  ncm_fftlog_set_lnr0 (fftlog, -0.5 * (test->lnk_i + test->lnk_f));
  ncm_fftlog_set_length (fftlog, Lk);

  g_assert_true (fftlog != NULL);
  g_assert_true (NCM_IS_FFTLOG (fftlog));
  g_assert_true (NCM_IS_FFTLOG_GAUSSWIN2 (fftlog));
}

void
test_ncm_fftlog_sbessel_j_new (TestNcmFftlog *test, gconstpointer pdata)
{
  const guint N          = g_test_rand_int_range  (1000, 2000);
  const guint ell        = g_test_rand_int_range  (0, 10);
  NcmFftlog *fftlog      = NCM_FFTLOG (ncm_fftlog_sbessel_j_new (ell, 0.0, 0.0, 20.0, N));
  TestNcmFftlogK *argK   = g_new (TestNcmFftlogK, 1);
  TestNcmFftlogPlaw *arg = g_new (TestNcmFftlogPlaw, 1);
  gdouble Lk             = g_test_rand_double_range (log (1.0e+3), log (1.0e+4));

  test->fftlog       = fftlog;
  test->Fk.function  = &_test_ncm_fftlog_plaw;
  test->Fk.params    = arg;
  test->KFk.function = &_test_ncm_fftlog_sbessel_j;
  test->KFk.params   = argK;
  test->argK         = argK;

  test->lnk_i = g_test_rand_double_range (log (1.0e-6), log (1.0e-4));
  test->lnk_f = test->lnk_i + Lk;

  test->ntests = NTESTS;

  arg->lnA = g_test_rand_double_range (log (1.0e-10), log (1.0e+10));
  arg->ns  = g_test_rand_double_range (0.5, 1.5);

  argK->lnr = 0.0;
  argK->Fk  = test->Fk;
  argK->ell = ell;

  ncm_fftlog_set_lnk0 (fftlog, +0.5 * (test->lnk_i + test->lnk_f));
  ncm_fftlog_set_length (fftlog, Lk);

  ncm_fftlog_sbessel_j_set_best_lnr0 (NCM_FFTLOG_SBESSEL_J (fftlog));

  g_assert_true (fftlog != NULL);
  g_assert_true (NCM_IS_FFTLOG (fftlog));
  g_assert_true (NCM_IS_FFTLOG_SBESSEL_J (fftlog));
}

void
test_ncm_fftlog_sbessel_jljm_new (TestNcmFftlog *test, gconstpointer pdata)
{
  const guint N          = 1 * g_test_rand_int_range  (1000, 2000);
  const guint ell        = g_test_rand_int_range  (0, 10);
  const gint dell        = ell > 1 ? g_test_rand_int_range  (-2, 2) : g_test_rand_int_range  (-ell, ell + 2);
  const gdouble lnw      = 1.0 / 4.0 * log (g_test_rand_double_range (0.4, 1.0));
  NcmFftlog *fftlog      = NCM_FFTLOG (ncm_fftlog_sbessel_jljm_new (ell, dell, lnw, 0.0, 0.0, 20.0, N));
  TestNcmFftlogK *argK   = g_new (TestNcmFftlogK, 1);
  TestNcmFftlogPlaw *arg = g_new (TestNcmFftlogPlaw, 1);
  gdouble Lk             = g_test_rand_double_range (log (1.0e+6), log (1.0e+7));

  test->fftlog       = fftlog;
  test->Fk.function  = &_test_ncm_fftlog_plaw;
  test->Fk.params    = arg;
  test->KFk.function = &_test_ncm_fftlog_sbessel_jljm;
  test->KFk.params   = argK;
  test->argK         = argK;

  test->lnk_i = g_test_rand_double_range (log (1.0e-6), log (1.0e-4));
  test->lnk_f = test->lnk_i + Lk;

  test->ntests = NTESTS;

  arg->lnA = g_test_rand_double_range (log (1.0e-10), log (1.0e-9));
  arg->ns  = g_test_rand_double_range (0.92, 0.98);

  argK->lnr = 0.0;
  argK->Fk  = test->Fk;
  argK->ell = ell;
  argK->m   = ell + dell;
  argK->w   = exp (lnw);

  /*printf ("# %u %u % 22.15g % 22.15g % 22.15g % 22.15g % 22.15g\n", ell, N, Lk, argK->w, gsl_pow_4 (argK->w), exp (test->lnk_i), exp (test->lnk_f));*/

  ncm_fftlog_set_lnk0 (fftlog, +0.5 * (test->lnk_i + test->lnk_f));
  ncm_fftlog_set_length (fftlog, Lk);
  /*ncm_fftlog_set_lnr0 (fftlog, -0.5 * (test->lnk_i + test->lnk_f) + 3.0); */
  ncm_fftlog_sbessel_jljm_set_best_lnr0 (NCM_FFTLOG_SBESSEL_JLJM (fftlog));

  g_assert (fftlog != NULL);
  g_assert (NCM_IS_FFTLOG (fftlog));
  g_assert (NCM_IS_FFTLOG_SBESSEL_JLJM (fftlog));
}

void
test_ncm_fftlog_free (TestNcmFftlog *test, gconstpointer pdata)
{
  NcmFftlog *fftlog = test->fftlog;

  NCM_TEST_FREE (ncm_fftlog_free, fftlog);

  g_free (test->Fk.params);
  g_free (test->KFk.params);
}

void
test_ncm_fftlog_eval (TestNcmFftlog *test, gconstpointer pdata)
{
  NcmFftlog *fftlog = test->fftlog;
  guint nerr        = 0;
  gdouble reltol    = 1.0e-1;
  NcmVector *lnr;
  guint i, len;

  ncm_fftlog_eval_by_gsl_function (fftlog, &test->Fk);
  ncm_fftlog_prepare_splines (fftlog);
  lnr = ncm_fftlog_get_vector_lnr (NCM_FFTLOG (fftlog));
  len = ncm_vector_len (lnr);

  for (i = 0; i < test->ntests; i++)
  {
    guint l                  = g_test_rand_int_range ((len / 3), 2 * (len / 3));
    const gdouble lnr_l      = ncm_vector_get (lnr, l);
    const gdouble fftlog_res = ncm_fftlog_eval_output (NCM_FFTLOG (fftlog), 0, lnr_l);
    gdouble res, err;

    test->argK->lnr = lnr_l;
    ncm_integral_locked_a_b (&test->KFk, test->lnk_i, test->lnk_f, 0.0, 1.0e-3, &res, &err);

    if ((fabs (fftlog_res / res - 1.0) > reltol) && (nerr < 15))
      nerr++;
    else
      ncm_assert_cmpdouble_e (res, ==, fftlog_res, reltol, 0.0);

    /* printf ("%u % 22.15g % 22.15g % 22.15g % 22.15e\n", l, test->argK->lnr, res, fftlog_res, fabs (res / fftlog_res - 1.0)); */
  }
}

void
test_ncm_fftlog_tophatwin2_traps (TestNcmFftlog *test, gconstpointer pdata)
{
  g_test_trap_subprocess ("/ncm/fftlog/tophatwin2/invalid/st/subprocess", 0, 0);
  g_test_trap_assert_failed ();
}

void
test_ncm_fftlog_gausswin2_traps (TestNcmFftlog *test, gconstpointer pdata)
{
  g_test_trap_subprocess ("/ncm/fftlog/gausswin2/invalid/st/subprocess", 0, 0);
  g_test_trap_assert_failed ();
}

void
test_ncm_fftlog_sbessel_j_traps (TestNcmFftlog *test, gconstpointer pdata)
{
  g_test_trap_subprocess ("/ncm/fftlog/sbessel_j/invalid/st/subprocess", 0, 0);
  g_test_trap_assert_failed ();
}

void
test_ncm_fftlog_sbessel_jljm_traps (TestNcmFftlog *test, gconstpointer pdata)
{
  g_test_trap_subprocess ("/ncm/fftlog/sbessel_jljm/invalid/st/subprocess", 0, 0);
  g_test_trap_assert_failed ();
}

void
test_ncm_fftlog_invalid_st (TestNcmFftlog *test, gconstpointer pdata)
{
  g_assert_not_reached ();
}


1	/***************************************************************************
2	* test_ncm_fftlog.c
3	*
4	* Sun September 03 11:45:13 2017
5	* Copyright 2017 Sandro Dias Pinto Vitenti
6	* <vitenti@uel.br>
7	****************************************************************************/
8	/*
9	* test_ncm_fftlog.c
10	*
11	* Copyright (C) 2017 - Sandro Dias Pinto Vitenti
12	*
13	* This program is free software; you can redistribute it and/or modify
14	* it under the terms of the GNU General Public License as published by
15	* the Free Software Foundation; either version 2 of the License, or
16	* (at your option) any later version.
17	*
18	* This program is distributed in the hope that it will be useful,
19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21	* GNU General Public License for more details.
22	*
23	* You should have received a copy of the GNU General Public License
24	* along with this program. If not, see <http://www.gnu.org/licenses/>.
25	*/
26
27	#ifdef HAVE_CONFIG_H
28	# include "config.h"
29	#undef GSL_RANGE_CHECK_OFF
30	#endif /* HAVE_CONFIG_H */
31	#include <numcosmo/numcosmo.h>
32
33	#include <math.h>
34	#include <glib.h>
35	#include <glib-object.h>
36
37	typedef struct _TestNcmFftlogK
38	{
39	gsl_function Fk;
40	gdouble lnr;
41	gdouble w;
42	guint ell;
43	guint m;
44	guint ntests;
45	} TestNcmFftlogK;
46
47	typedef struct _TestNcmFftlog
48	{
49	NcmFftlog *fftlog;
50	gsl_function Fk;
51	gsl_function KFk;
52	gdouble lnk_i, lnk_f;
53	guint ntests;
54	TestNcmFftlogK *argK;
55	} TestNcmFftlog;
56
57	void test_ncm_fftlog_tophatwin2_new (TestNcmFftlog *test, gconstpointer pdata);
58	void test_ncm_fftlog_gausswin2_new (TestNcmFftlog *test, gconstpointer pdata);
59	void test_ncm_fftlog_sbessel_j_new (TestNcmFftlog *test, gconstpointer pdata);
60	void test_ncm_fftlog_sbessel_jljm_new (TestNcmFftlog *test, gconstpointer pdata);
61	void test_ncm_fftlog_free (TestNcmFftlog *test, gconstpointer pdata);
62
63	void test_ncm_fftlog_eval (TestNcmFftlog *test, gconstpointer pdata);
64
65	void test_ncm_fftlog_tophatwin2_traps (TestNcmFftlog *test, gconstpointer pdata);
66	void test_ncm_fftlog_gausswin2_traps (TestNcmFftlog *test, gconstpointer pdata);
67	void test_ncm_fftlog_sbessel_j_traps (TestNcmFftlog *test, gconstpointer pdata);
68	void test_ncm_fftlog_sbessel_jljm_traps (TestNcmFftlog *test, gconstpointer pdata);
69	void test_ncm_fftlog_invalid_st (TestNcmFftlog *test, gconstpointer pdata);
70
71	gint
72	main (gint argc, gchar *argv[])	1✔
73	{
74	g_test_init (&argc, &argv, NULL);	1✔
75	ncm_cfg_init_full_ptr (&argc, &argv);	1✔
76	ncm_cfg_enable_gsl_err_handler ();	1✔
77
78	g_test_set_nonfatal_assertions ();	1✔
79
80	g_test_add ("/ncm/fftlog/tophatwin2/eval", TestNcmFftlog, NULL,	1✔
81	&test_ncm_fftlog_tophatwin2_new,
82	&test_ncm_fftlog_eval,
83	&test_ncm_fftlog_free);
84
85	g_test_add ("/ncm/fftlog/tophatwin2/traps", TestNcmFftlog, NULL,	1✔
86	&test_ncm_fftlog_tophatwin2_new,
87	&test_ncm_fftlog_tophatwin2_traps,
88	&test_ncm_fftlog_free);
89
90	g_test_add ("/ncm/fftlog/gausswin2/eval", TestNcmFftlog, NULL,	1✔
91	&test_ncm_fftlog_gausswin2_new,
92	&test_ncm_fftlog_eval,
93	&test_ncm_fftlog_free);
94
95	g_test_add ("/ncm/fftlog/gausswin2/traps", TestNcmFftlog, NULL,	1✔
96	&test_ncm_fftlog_gausswin2_new,
97	&test_ncm_fftlog_gausswin2_traps,
98	&test_ncm_fftlog_free);
99
100	g_test_add ("/ncm/fftlog/sbessel_j/eval", TestNcmFftlog, NULL,	1✔
101	&test_ncm_fftlog_sbessel_j_new,
102	&test_ncm_fftlog_eval,
103	&test_ncm_fftlog_free);
104
105	g_test_add ("/ncm/fftlog/sbessel_j/traps", TestNcmFftlog, NULL,	1✔
106	&test_ncm_fftlog_sbessel_j_new,
107	&test_ncm_fftlog_sbessel_j_traps,
108	&test_ncm_fftlog_free);
109
110	#if defined (HAVE_FFTW3) && defined (HAVE_ACB_H)
111
112	g_test_add ("/ncm/fftlog/sbessel_jljm/eval", TestNcmFftlog, NULL,
113	&test_ncm_fftlog_sbessel_jljm_new,
114	&test_ncm_fftlog_eval,
115	&test_ncm_fftlog_free);
116
117	g_test_add ("/ncm/fftlog/sbessel_jljm/traps", TestNcmFftlog, NULL,
118	&test_ncm_fftlog_sbessel_jljm_new,
119	&test_ncm_fftlog_sbessel_jljm_traps,
120	&test_ncm_fftlog_free);
121
122	#endif /* defined (HAVE_FFTW3) && defined (HAVE_ACB_H) */
123
124	g_test_add ("/ncm/fftlog/tophatwin2/invalid/st/subprocess", TestNcmFftlog, NULL,	1✔
125	&test_ncm_fftlog_tophatwin2_new,
126	&test_ncm_fftlog_invalid_st,
127	&test_ncm_fftlog_free);
128	g_test_add ("/ncm/fftlog/gausswin2/invalid/st/subprocess", TestNcmFftlog, NULL,	1✔
129	&test_ncm_fftlog_gausswin2_new,
130	&test_ncm_fftlog_invalid_st,
131	&test_ncm_fftlog_free);
132	g_test_add ("/ncm/fftlog/sbessel_j/invalid/st/subprocess", TestNcmFftlog, NULL,	1✔
133	&test_ncm_fftlog_sbessel_j_new,
134	&test_ncm_fftlog_invalid_st,
135	&test_ncm_fftlog_free);
136	g_test_add ("/ncm/fftlog/sbessel_jljm/invalid/st/subprocess", TestNcmFftlog, NULL,	1✔
137	&test_ncm_fftlog_sbessel_jljm_new,
138	&test_ncm_fftlog_invalid_st,
139	&test_ncm_fftlog_free);
140
141	#ifdef HAVE_FFTW3
142	g_test_run ();	1✔
143	#endif
144	}
145
146	#define NTESTS 20
147
148	typedef struct _TestNcmFftlogPlaw
149	{
150	gdouble lnA;
151	gdouble ns;
152	} TestNcmFftlogPlaw;
153
154	static gdouble
155	_test_ncm_fftlog_plaw (gdouble k, gpointer user_data)	36,956✔
156	{
157	TestNcmFftlogPlaw args = (TestNcmFftlogPlaw ) user_data;	36,956✔
158
159	return exp (args->lnA + log (k) * (args->ns - 1.0));	36,956✔
160	}
161
162	static gdouble
163	_test_ncm_fftlog_tophatwin2 (gdouble lnk, gpointer user_data)	7,930✔
164	{
165	TestNcmFftlogK args = (TestNcmFftlogK ) user_data;	7,930✔
166	const gdouble kr = exp (lnk + args->lnr);	7,930✔
167	const gdouble k = exp (lnk);	7,930✔
168
169	return GSL_FN_EVAL (&args->Fk, k) * k * gsl_pow_2 (3.0 * ncm_sf_sbessel (1, kr) / kr);	7,930✔
170	}
171
172	static gdouble
173	_test_ncm_fftlog_gausswin2 (gdouble lnk, gpointer user_data)	3,538✔
174	{
175	TestNcmFftlogK args = (TestNcmFftlogK ) user_data;	3,538✔
176	const gdouble kr = exp (lnk + args->lnr);	3,538✔
177	const gdouble k = exp (lnk);	3,538✔
178
179	return GSL_FN_EVAL (&args->Fk, k) * k * exp (-kr * kr);	3,538✔
180	}
181
182	static gdouble
183	_test_ncm_fftlog_sbessel_j (gdouble lnk, gpointer user_data)	8,784✔
184	{
185	TestNcmFftlogK args = (TestNcmFftlogK ) user_data;	8,784✔
186	const gdouble kr = exp (lnk + args->lnr);	8,784✔
187	const gdouble k = exp (lnk);	8,784✔
188
189	return GSL_FN_EVAL (&args->Fk, k) * k * ncm_sf_sbessel (args->ell, kr);	8,784✔
190	}
191
192	static gdouble
193	_test_ncm_fftlog_sbessel_jljm (gdouble lnk, gpointer user_data)	×
194	{
195	TestNcmFftlogK args = (TestNcmFftlogK ) user_data;	×
196	const gdouble kr = exp (lnk + args->lnr);	×
197	const gdouble k = exp (lnk);	×
198
199	/*
200	* printf ("% 22.15g % 22.15g\n", k,
201	* GSL_FN_EVAL (&args->Fk, k) * k * ncm_sf_sbessel (args->ell, kr * args->w) * ncm_sf_sbessel (args->m, kr / args->w));
202	*/
203	return GSL_FN_EVAL (&args->Fk, k) * k * ncm_sf_sbessel (args->ell, kr * args->w) * ncm_sf_sbessel (args->m, kr / args->w);	×
204	}
205
206	void
207	test_ncm_fftlog_tophatwin2_new (TestNcmFftlog *test, gconstpointer pdata)	2✔
208	{
209	const guint N = g_test_rand_int_range (10000, 20000);	2✔
210	NcmFftlog *fftlog = NCM_FFTLOG (ncm_fftlog_tophatwin2_new (0.0, 0.0, 20.0, N));	2✔
211	TestNcmFftlogK *argK = g_new (TestNcmFftlogK, 1);	2✔
212	TestNcmFftlogPlaw *arg = g_new (TestNcmFftlogPlaw, 1);	2✔
213	gdouble Lk = g_test_rand_double_range (log (1.0e+3), log (1.0e+6));	2✔
214
215	test->fftlog = fftlog;	2✔
216	test->Fk.function = &_test_ncm_fftlog_plaw;	2✔
217	test->Fk.params = arg;	2✔
218	test->KFk.function = &_test_ncm_fftlog_tophatwin2;	2✔
219	test->KFk.params = argK;	2✔
220	test->argK = argK;	2✔
221
222	test->lnk_i = g_test_rand_double_range (log (1.0e-4), log (1.0e0));	2✔
223	test->lnk_f = test->lnk_i + Lk;	2✔
224
225	test->ntests = NTESTS;	2✔
226
227	arg->lnA = g_test_rand_double_range (log (1.0e-10), log (1.0e+10));	2✔
228	arg->ns = g_test_rand_double_range (0.5, 1.5);	2✔
229
230	argK->lnr = 0.0;	2✔
231	argK->Fk = test->Fk;	2✔
232
233	ncm_fftlog_set_lnk0 (fftlog, +0.5 * (test->lnk_i + test->lnk_f));	2✔
234	ncm_fftlog_set_lnr0 (fftlog, -0.5 * (test->lnk_i + test->lnk_f));	2✔
235	ncm_fftlog_set_length (fftlog, Lk);	2✔
236
237	g_assert_true (fftlog != NULL);	2✔
238	g_assert_true (NCM_IS_FFTLOG (fftlog));	2✔
239	g_assert_true (NCM_IS_FFTLOG_TOPHATWIN2 (fftlog));	2✔
240	}	2✔
241
242	void
243	test_ncm_fftlog_gausswin2_new (TestNcmFftlog *test, gconstpointer pdata)	2✔
244	{
245	const guint N = g_test_rand_int_range (1000, 2000);	2✔
246	NcmFftlog *fftlog = NCM_FFTLOG (ncm_fftlog_gausswin2_new (0.0, 0.0, 20.0, N));	2✔
247	TestNcmFftlogK *argK = g_new (TestNcmFftlogK, 1);	2✔
248	TestNcmFftlogPlaw *arg = g_new (TestNcmFftlogPlaw, 1);	2✔
249	gdouble Lk = g_test_rand_double_range (log (1.0e+3), log (1.0e+6));	2✔
250
251	test->fftlog = fftlog;	2✔
252	test->Fk.function = &_test_ncm_fftlog_plaw;	2✔
253	test->Fk.params = arg;	2✔
254	test->KFk.function = &_test_ncm_fftlog_gausswin2;	2✔
255	test->KFk.params = argK;	2✔
256	test->argK = argK;	2✔
257
258	test->lnk_i = g_test_rand_double_range (log (1.0e-4), log (1.0e0));	2✔
259	test->lnk_f = test->lnk_i + Lk;	2✔
260
261	test->ntests = NTESTS;	2✔
262
263	arg->lnA = g_test_rand_double_range (log (1.0e-10), log (1.0e+10));	2✔
264	arg->ns = g_test_rand_double_range (0.5, 1.5);	2✔
265
266	argK->lnr = 0.0;	2✔
267	argK->Fk = test->Fk;	2✔
268
269	ncm_fftlog_set_lnk0 (fftlog, +0.5 * (test->lnk_i + test->lnk_f));	2✔
270	ncm_fftlog_set_lnr0 (fftlog, -0.5 * (test->lnk_i + test->lnk_f));	2✔
271	ncm_fftlog_set_length (fftlog, Lk);	2✔
272
273	g_assert_true (fftlog != NULL);	2✔
274	g_assert_true (NCM_IS_FFTLOG (fftlog));	2✔
275	g_assert_true (NCM_IS_FFTLOG_GAUSSWIN2 (fftlog));	2✔
276	}	2✔
277
278	void
279	test_ncm_fftlog_sbessel_j_new (TestNcmFftlog *test, gconstpointer pdata)	2✔
280	{
281	const guint N = g_test_rand_int_range (1000, 2000);	2✔
282	const guint ell = g_test_rand_int_range (0, 10);	2✔
283	NcmFftlog *fftlog = NCM_FFTLOG (ncm_fftlog_sbessel_j_new (ell, 0.0, 0.0, 20.0, N));	2✔
284	TestNcmFftlogK *argK = g_new (TestNcmFftlogK, 1);	2✔
285	TestNcmFftlogPlaw *arg = g_new (TestNcmFftlogPlaw, 1);	2✔
286	gdouble Lk = g_test_rand_double_range (log (1.0e+3), log (1.0e+4));	2✔
287
288	test->fftlog = fftlog;	2✔
289	test->Fk.function = &_test_ncm_fftlog_plaw;	2✔
290	test->Fk.params = arg;	2✔
291	test->KFk.function = &_test_ncm_fftlog_sbessel_j;	2✔
292	test->KFk.params = argK;	2✔
293	test->argK = argK;	2✔
294
295	test->lnk_i = g_test_rand_double_range (log (1.0e-6), log (1.0e-4));	2✔
296	test->lnk_f = test->lnk_i + Lk;	2✔
297
298	test->ntests = NTESTS;	2✔
299
300	arg->lnA = g_test_rand_double_range (log (1.0e-10), log (1.0e+10));	2✔
301	arg->ns = g_test_rand_double_range (0.5, 1.5);	2✔
302
303	argK->lnr = 0.0;	2✔
304	argK->Fk = test->Fk;	2✔
305	argK->ell = ell;	2✔
306
307	ncm_fftlog_set_lnk0 (fftlog, +0.5 * (test->lnk_i + test->lnk_f));	2✔
308	ncm_fftlog_set_length (fftlog, Lk);	2✔
309
310	ncm_fftlog_sbessel_j_set_best_lnr0 (NCM_FFTLOG_SBESSEL_J (fftlog));	2✔
311
312	g_assert_true (fftlog != NULL);	2✔
313	g_assert_true (NCM_IS_FFTLOG (fftlog));	2✔
314	g_assert_true (NCM_IS_FFTLOG_SBESSEL_J (fftlog));	2✔
315	}	2✔
316
317	void
318	test_ncm_fftlog_sbessel_jljm_new (TestNcmFftlog *test, gconstpointer pdata)	×
319	{
320	const guint N = 1 * g_test_rand_int_range (1000, 2000);	×
321	const guint ell = g_test_rand_int_range (0, 10);	×
322	const gint dell = ell > 1 ? g_test_rand_int_range (-2, 2) : g_test_rand_int_range (-ell, ell + 2);	×
323	const gdouble lnw = 1.0 / 4.0 * log (g_test_rand_double_range (0.4, 1.0));	×
324	NcmFftlog *fftlog = NCM_FFTLOG (ncm_fftlog_sbessel_jljm_new (ell, dell, lnw, 0.0, 0.0, 20.0, N));	×
325	TestNcmFftlogK *argK = g_new (TestNcmFftlogK, 1);	×
326	TestNcmFftlogPlaw *arg = g_new (TestNcmFftlogPlaw, 1);	×
327	gdouble Lk = g_test_rand_double_range (log (1.0e+6), log (1.0e+7));	×
328
329	test->fftlog = fftlog;	×
330	test->Fk.function = &_test_ncm_fftlog_plaw;	×
331	test->Fk.params = arg;	×
332	test->KFk.function = &_test_ncm_fftlog_sbessel_jljm;	×
333	test->KFk.params = argK;	×
334	test->argK = argK;	×
335
336	test->lnk_i = g_test_rand_double_range (log (1.0e-6), log (1.0e-4));	×
337	test->lnk_f = test->lnk_i + Lk;	×
338
339	test->ntests = NTESTS;	×
340
341	arg->lnA = g_test_rand_double_range (log (1.0e-10), log (1.0e-9));	×
342	arg->ns = g_test_rand_double_range (0.92, 0.98);	×
343
344	argK->lnr = 0.0;	×
345	argK->Fk = test->Fk;	×
346	argK->ell = ell;	×
347	argK->m = ell + dell;	×
348	argK->w = exp (lnw);	×
349
350	/printf ("# %u %u % 22.15g % 22.15g % 22.15g % 22.15g % 22.15g\n", ell, N, Lk, argK->w, gsl_pow_4 (argK->w), exp (test->lnk_i), exp (test->lnk_f));/
351
352	ncm_fftlog_set_lnk0 (fftlog, +0.5 * (test->lnk_i + test->lnk_f));	×
353	ncm_fftlog_set_length (fftlog, Lk);	×
354	/ncm_fftlog_set_lnr0 (fftlog, -0.5 (test->lnk_i + test->lnk_f) + 3.0); */
355	ncm_fftlog_sbessel_jljm_set_best_lnr0 (NCM_FFTLOG_SBESSEL_JLJM (fftlog));	×
356
357	g_assert (fftlog != NULL);	×
358	g_assert (NCM_IS_FFTLOG (fftlog));	×
359	g_assert (NCM_IS_FFTLOG_SBESSEL_JLJM (fftlog));	×
360	}
361
362	void
363	test_ncm_fftlog_free (TestNcmFftlog *test, gconstpointer pdata)	6✔
364	{
365	NcmFftlog *fftlog = test->fftlog;	6✔
366
367	NCM_TEST_FREE (ncm_fftlog_free, fftlog);	6✔
368
369	g_free (test->Fk.params);	6✔
370	g_free (test->KFk.params);	6✔
371	}	6✔
372
373	void
374	test_ncm_fftlog_eval (TestNcmFftlog *test, gconstpointer pdata)	3✔
375	{
376	NcmFftlog *fftlog = test->fftlog;	3✔
377	guint nerr = 0;	3✔
378	gdouble reltol = 1.0e-1;	3✔
379	NcmVector *lnr;	3✔
380	guint i, len;	3✔
381
382	ncm_fftlog_eval_by_gsl_function (fftlog, &test->Fk);	3✔
383	ncm_fftlog_prepare_splines (fftlog);	3✔
384	lnr = ncm_fftlog_get_vector_lnr (NCM_FFTLOG (fftlog));	3✔
385	len = ncm_vector_len (lnr);	3✔
386
387	for (i = 0; i < test->ntests; i++)	63✔
388	{
389	guint l = g_test_rand_int_range ((len / 3), 2 * (len / 3));	60✔
390	const gdouble lnr_l = ncm_vector_get (lnr, l);	60✔
391	const gdouble fftlog_res = ncm_fftlog_eval_output (NCM_FFTLOG (fftlog), 0, lnr_l);	60✔
392	gdouble res, err;	60✔
393
394	test->argK->lnr = lnr_l;	60✔
395	ncm_integral_locked_a_b (&test->KFk, test->lnk_i, test->lnk_f, 0.0, 1.0e-3, &res, &err);	60✔
396
397	if ((fabs (fftlog_res / res - 1.0) > reltol) && (nerr < 15))	60✔
UNCOV 398	nerr++;	×
399	else
400	ncm_assert_cmpdouble_e (res, ==, fftlog_res, reltol, 0.0);	60✔
401
402	/* printf ("%u % 22.15g % 22.15g % 22.15g % 22.15e\n", l, test->argK->lnr, res, fftlog_res, fabs (res / fftlog_res - 1.0)); */
403	}
404	}	3✔
405
406	void
407	test_ncm_fftlog_tophatwin2_traps (TestNcmFftlog *test, gconstpointer pdata)	1✔
408	{
409	g_test_trap_subprocess ("/ncm/fftlog/tophatwin2/invalid/st/subprocess", 0, 0);	1✔
410	g_test_trap_assert_failed ();	1✔
411	}	1✔
412
413	void
414	test_ncm_fftlog_gausswin2_traps (TestNcmFftlog *test, gconstpointer pdata)	1✔
415	{
416	g_test_trap_subprocess ("/ncm/fftlog/gausswin2/invalid/st/subprocess", 0, 0);	1✔
417	g_test_trap_assert_failed ();	1✔
418	}	1✔
419
420	void
421	test_ncm_fftlog_sbessel_j_traps (TestNcmFftlog *test, gconstpointer pdata)	1✔
422	{
423	g_test_trap_subprocess ("/ncm/fftlog/sbessel_j/invalid/st/subprocess", 0, 0);	1✔
424	g_test_trap_assert_failed ();	1✔
425	}	1✔
426
427	void
428	test_ncm_fftlog_sbessel_jljm_traps (TestNcmFftlog *test, gconstpointer pdata)	×
429	{
430	g_test_trap_subprocess ("/ncm/fftlog/sbessel_jljm/invalid/st/subprocess", 0, 0);	×
431	g_test_trap_assert_failed ();	×
432	}
433
434	void
435	test_ncm_fftlog_invalid_st (TestNcmFftlog *test, gconstpointer pdata)	×
436	{
437	g_assert_not_reached ();	×
438	}
439

NumCosmo / NumCosmo / 7255845566

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