7269966887

Committed 20 Dec 2023 01:51AM UTC coverage: 55.261% (+0.3%) from 54.995%

Build # 7269966887

Build Type

Pull #126

github

Committed by

web-flow

Commit Message

Merge 5c0d59b26 into bffca6a86

Pull Request Pull Request #126: More objects encapsulation

Run Details

7271 of 12543 branches covered (0.0%)

Branch coverage included in aggregate %.

2435 of 3811 new or added lines in 163 files covered. (63.89%)

148 existing lines in 31 files now uncovered.

47888 of 87273 relevant lines covered (54.87%)

2016762.11 hits per line

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

63.64

/numcosmo/math/ncm_spline_gsl.c

/***************************************************************************
 *            ncm_spline_gsl.c
 *
 *  Wed Nov 21 19:09:20 2007
 *  Copyright  2007  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/>.
 */

/**
 * SECTION:ncm_spline_gsl
 * @title: NcmSplineGsl
 * @short_description: GSL spline object wrapper.
 * @stability: Stable
 * @include: numcosmo/math/ncm_spline_gsl.h
 *
 * This object comprises the proper functions to use the [GNU Scientific
 * Library (GSL)](https://www.gnu.org/software/gsl/) spline functions and interpolation methods.
 *
 */

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif /* HAVE_CONFIG_H */
#include "build_cfg.h"

#include "math/ncm_spline_gsl.h"
#include "math/ncm_cfg.h"
#include "ncm_enum_types.h"

struct _NcmSplineGsl
{
  /*< private >*/
  NcmSpline parent_instance;
  gsl_interp *interp;
  NcmSplineGslType type_id;
  gchar *inst_name;
  const gsl_interp_type *type;
};

G_DEFINE_TYPE (NcmSplineGsl, ncm_spline_gsl, NCM_TYPE_SPLINE)

enum
{
  PROP_0,
  PROP_TYPE_ID,
  PROP_TYPE_NAME,
  PROP_SIZE,
};

static void
ncm_spline_gsl_init (NcmSplineGsl *sg)
{
  sg->interp    = NULL;
  sg->type      = NULL;
  sg->type_id   = NCM_SPLINE_GSL_TYPES_LEN;
  sg->inst_name = NULL;
}

static void
_ncm_spline_gsl_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
  NcmSplineGsl *fit = NCM_SPLINE_GSL (object);

  g_return_if_fail (NCM_IS_SPLINE_GSL (object));

  switch (prop_id)
  {
    case PROP_TYPE_NAME:
      ncm_spline_gsl_set_type_by_name (fit, g_value_get_string (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
_ncm_spline_gsl_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
  NcmSplineGsl *sgsl = NCM_SPLINE_GSL (object);

  g_return_if_fail (NCM_IS_SPLINE_GSL (object));

  switch (prop_id)
  {
    case PROP_TYPE_NAME:
    {
      const GEnumValue *e = ncm_cfg_enum_get_value (NCM_TYPE_SPLINE_GSL_TYPE, sgsl->type_id);

      g_value_set_string (value, e->value_name);
      break;
    }
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
ncm_spline_gsl_finalize (GObject *object)
{
  NcmSplineGsl *sg = NCM_SPLINE_GSL (object);

  gsl_interp_free (sg->interp);
  sg->type = gsl_interp_linear;
  g_free (sg->inst_name);

  G_OBJECT_CLASS (ncm_spline_gsl_parent_class)->finalize (object);
}

static void _ncm_spline_gsl_reset (NcmSpline *s);
static const gchar *_ncm_spline_gsl_name (NcmSpline *s);
static void _ncm_spline_gsl_prepare (NcmSpline *s);
static gsize _ncm_spline_gsl_min_size (const NcmSpline *s);
static gdouble _ncm_spline_gsl_eval (const NcmSpline *s, const gdouble x);
static gdouble _ncm_spline_gsl_deriv (const NcmSpline *s, const gdouble x);
static gdouble _ncm_spline_gsl_deriv2 (const NcmSpline *s, const gdouble x);
static gdouble _ncm_spline_gsl_deriv_nmax (const NcmSpline *s, const gdouble x);
static gdouble _ncm_spline_gsl_integ (const NcmSpline *s, const gdouble x0, const gdouble x1);
static NcmSpline *_ncm_spline_gsl_copy_empty (const NcmSpline *s);

static void
ncm_spline_gsl_class_init (NcmSplineGslClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
  NcmSplineClass *s_class    = NCM_SPLINE_CLASS (klass);

  object_class->set_property = &_ncm_spline_gsl_set_property;
  object_class->get_property = &_ncm_spline_gsl_get_property;
  object_class->finalize     = &ncm_spline_gsl_finalize;

  /**
   * NcmSplineGsl:type-name:
   *
   * The name of the interpolation method from [GNU Scientific Library (GSL)](https://www.gnu.org/software/gsl/).
   *
   */
  g_object_class_install_property (object_class,
                                   PROP_TYPE_NAME,
                                   g_param_spec_string ("type-name",
                                                        NULL,
                                                        "GSL Interpolation method name",
                                                        "NCM_SPLINE_GSL_CSPLINE",
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  s_class->name         = &_ncm_spline_gsl_name;
  s_class->reset        = &_ncm_spline_gsl_reset;
  s_class->prepare      = &_ncm_spline_gsl_prepare;
  s_class->prepare_base = NULL;
  s_class->min_size     = &_ncm_spline_gsl_min_size;
  s_class->eval         = &_ncm_spline_gsl_eval;
  s_class->deriv        = &_ncm_spline_gsl_deriv;
  s_class->deriv2       = &_ncm_spline_gsl_deriv2;
  s_class->deriv_nmax   = &_ncm_spline_gsl_deriv_nmax;
  s_class->integ        = &_ncm_spline_gsl_integ;
  s_class->copy_empty   = &_ncm_spline_gsl_copy_empty;
}

static void
_ncm_spline_gsl_reset (NcmSpline *s)
{
  NcmSplineGsl *sg  = NCM_SPLINE_GSL (s);
  const guint s_len = ncm_spline_get_len (s);

  if (sg->interp != NULL)
  {
    if (sg->interp->size != s_len)
    {
      gsl_interp_free (sg->interp);
      sg->interp = gsl_interp_alloc (sg->type, s_len);
    }
  }
  else
  {
    sg->interp = gsl_interp_alloc (sg->type, s_len);
    g_free (sg->inst_name);
    sg->inst_name = g_strdup_printf ("NcmSplineGsl[%s]", gsl_interp_name (sg->interp));
  }
}

static const gchar *
_ncm_spline_gsl_name (NcmSpline *s)
{
  NcmSplineGsl *sg = NCM_SPLINE_GSL (s);

  return sg->inst_name;
}

static void
_ncm_spline_gsl_prepare (NcmSpline *s)
{
  NcmSplineGsl *sg  = NCM_SPLINE_GSL (s);
  const guint s_len = ncm_spline_get_len (s);
  NcmVector *s_xv   = ncm_spline_peek_xv (s);
  NcmVector *s_yv   = ncm_spline_peek_yv (s);

  g_assert_cmpint (ncm_vector_stride (s_xv), ==, 1);
  g_assert_cmpint (ncm_vector_stride (s_yv), ==, 1);

  gsl_interp_init (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), s_len);
}

static gsize
_ncm_spline_gsl_min_size (const NcmSpline *s)
{
  NcmSplineGsl *sg = NCM_SPLINE_GSL ((NcmSpline *) s);

  return sg->type->min_size;
}

static gdouble
_ncm_spline_gsl_eval (const NcmSpline *s, const gdouble x)
{
  NcmSplineGsl *sg        = NCM_SPLINE_GSL ((NcmSpline *) s);
  NcmVector *s_xv         = ncm_spline_peek_xv ((NcmSpline *) s);
  NcmVector *s_yv         = ncm_spline_peek_yv ((NcmSpline *) s);
  gsl_interp_accel *s_acc = ncm_spline_peek_acc ((NcmSpline *) s);

  return gsl_interp_eval (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x, s_acc);
}

static gdouble
_ncm_spline_gsl_deriv (const NcmSpline *s, const gdouble x)
{
  NcmSplineGsl *sg        = NCM_SPLINE_GSL ((NcmSpline *) s);
  NcmVector *s_xv         = ncm_spline_peek_xv ((NcmSpline *) s);
  NcmVector *s_yv         = ncm_spline_peek_yv ((NcmSpline *) s);
  gsl_interp_accel *s_acc = ncm_spline_peek_acc ((NcmSpline *) s);

  return gsl_interp_eval_deriv (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x, s_acc);
}

static gdouble
_ncm_spline_gsl_deriv2 (const NcmSpline *s, const gdouble x)
{
  NcmSplineGsl *sg        = NCM_SPLINE_GSL ((NcmSpline *) s);
  NcmVector *s_xv         = ncm_spline_peek_xv ((NcmSpline *) s);
  NcmVector *s_yv         = ncm_spline_peek_yv ((NcmSpline *) s);
  gsl_interp_accel *s_acc = ncm_spline_peek_acc ((NcmSpline *) s);

  return gsl_interp_eval_deriv2 (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x, s_acc);
}

static gdouble
_ncm_spline_gsl_deriv_nmax (const NcmSpline *s, const gdouble x)
{
  NcmSplineGsl *sg        = NCM_SPLINE_GSL ((NcmSpline *) s);
  NcmVector *s_xv         = ncm_spline_peek_xv ((NcmSpline *) s);
  NcmVector *s_yv         = ncm_spline_peek_yv ((NcmSpline *) s);
  gsl_interp_accel *s_acc = ncm_spline_peek_acc ((NcmSpline *) s);

  if (sg->type == gsl_interp_linear)
  {
    return gsl_interp_eval_deriv (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x, s_acc);
  }
  else if ((sg->type == gsl_interp_cspline) || (sg->type == gsl_interp_cspline_periodic) ||
           (sg->type == gsl_interp_akima) || (sg->type == gsl_interp_akima_periodic))
  {
    const guint knot_i        = ncm_spline_get_index (s, x);
    const gdouble x_i         = ncm_vector_get (s_xv, knot_i);
    const gdouble x_ip1       = ncm_vector_get (s_xv, knot_i + 1);
    const gdouble dx          = x_ip1 - x_i;
    gdouble two_c_i           = gsl_interp_eval_deriv2 (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x_i, s_acc);
    gdouble two_c_i_p_6d_i_dx = gsl_interp_eval_deriv2 (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x_ip1, s_acc);

    return (two_c_i_p_6d_i_dx - two_c_i) / dx;
  }
  else
  {
    g_error ("ncm_spline_gsl_deriv_nmax: Calculation of the nmax derivative not supported.");

    return 0.0;
  }
}

static gdouble
_ncm_spline_gsl_integ (const NcmSpline *s, const gdouble x0, const gdouble x1)
{
  NcmSplineGsl *sg        = NCM_SPLINE_GSL ((NcmSpline *) s);
  NcmVector *s_xv         = ncm_spline_peek_xv ((NcmSpline *) s);
  NcmVector *s_yv         = ncm_spline_peek_yv ((NcmSpline *) s);
  gsl_interp_accel *s_acc = ncm_spline_peek_acc ((NcmSpline *) s);

  return gsl_interp_eval_integ (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x0, x1, s_acc);
}

static NcmSpline *
_ncm_spline_gsl_copy_empty (const NcmSpline *s)
{
  NcmSplineGsl *sg = NCM_SPLINE_GSL ((NcmSpline *) s);

  return ncm_spline_gsl_new (sg->type);
}

/**
 * ncm_spline_gsl_new:
 * @type: gsl interpolation method
 *
 * This function returns a new gsl #NcmSpline which will use @type
 * interpolation method.
 *
 * Returns: a new #NcmSpline.
 */
NcmSpline *
ncm_spline_gsl_new (const gsl_interp_type *type)
{
  NcmSplineGsl *sg = g_object_new (NCM_TYPE_SPLINE_GSL, NULL);

  ncm_spline_gsl_set_type (sg, type);

  return NCM_SPLINE (sg);
}

/**
 * ncm_spline_gsl_new_by_id:
 * @type_id: gsl interpolation method id
 *
 * This function returns a new gsl #NcmSpline which will use @type
 * interpolation method.
 *
 * Returns: a new #NcmSpline.
 */
NcmSpline *
ncm_spline_gsl_new_by_id (NcmSplineGslType type_id)
{
  NcmSplineGsl *sg = g_object_new (NCM_TYPE_SPLINE_GSL, NULL);

  ncm_spline_gsl_set_type_by_id (sg, type_id);

  return NCM_SPLINE (sg);
}

/**
 * ncm_spline_gsl_new_full:
 * @type: gsl interpolation method
 * @xv: #NcmVector of knots
 * @yv: #NcmVector of the values of the function, to be interpolated, computed at @xv
 * @init: TRUE to prepare the new #NcmSpline or FALSE to not prepare it
 *
 * This function returns a new gsl #NcmSpline setting all its members.
 *
 * Returns: a new #NcmSpline.
 */
NcmSpline *
ncm_spline_gsl_new_full (const gsl_interp_type *type, NcmVector *xv, NcmVector *yv, gboolean init)
{
  NcmSpline *s = ncm_spline_gsl_new (type);

  ncm_spline_set (s, xv, yv, init);

  return s;
}

/**
 * ncm_spline_gsl_new_full_by_id:
 * @type_id: gsl interpolation method id
 * @xv: #NcmVector of knots
 * @yv: #NcmVector of the values of the function, to be interpolated, computed at @xv
 * @init: TRUE to prepare the new #NcmSpline or FALSE to not prepare it
 *
 * This function returns a new gsl #NcmSpline setting all its members.
 *
 * Returns: a new #NcmSpline.
 */
NcmSpline *
ncm_spline_gsl_new_full_by_id (NcmSplineGslType type_id, NcmVector *xv, NcmVector *yv, gboolean init)
{
  NcmSpline *s = ncm_spline_gsl_new_by_id (type_id);

  ncm_spline_set (s, xv, yv, init);

  return s;
}

/**
 * ncm_spline_gsl_set_type:
 * @sg: a #NcmSplineGsl
 * @type: gsl interpolation method
 *
 * This function sets the interpolation method @type to @sg.
 *
 */
void
ncm_spline_gsl_set_type (NcmSplineGsl *sg, const gsl_interp_type *type)
{
  if (sg->interp != NULL)
  {
    if (sg->type != type)
    {
      sg->type = type;
      gsl_interp_free (sg->interp);
      sg->interp = NULL;
      _ncm_spline_gsl_reset (NCM_SPLINE (sg));
    }
  }
  else
  {
    sg->type = type;
    g_free (sg->inst_name);
    /* printf("NcmSplineGsl[%s]", type->name); */
    sg->inst_name = g_strdup_printf ("NcmSplineGsl[%s]", type->name);
  }
}

/**
 * ncm_spline_gsl_set_type_by_id:
 * @sg: a #NcmSplineGsl
 * @type_id: gsl interpolation method id
 *
 * This function sets the interpolation method @type_id to @sg.
 *
 */
void
ncm_spline_gsl_set_type_by_id (NcmSplineGsl *sg, NcmSplineGslType type_id)
{
  sg->type_id = type_id;

  switch (type_id)
  {
    case NCM_SPLINE_GSL_LINEAR:
      ncm_spline_gsl_set_type (sg, gsl_interp_linear);
      break;
    case NCM_SPLINE_GSL_POLYNOMIAL:
      ncm_spline_gsl_set_type (sg, gsl_interp_polynomial);
      break;
    case NCM_SPLINE_GSL_CSPLINE:
      ncm_spline_gsl_set_type (sg, gsl_interp_cspline);
      break;
    case NCM_SPLINE_GSL_CSPLINE_PERIODIC:
      ncm_spline_gsl_set_type (sg, gsl_interp_cspline_periodic);
      break;
    case NCM_SPLINE_GSL_AKIMA:
      ncm_spline_gsl_set_type (sg, gsl_interp_akima);
      break;
    case NCM_SPLINE_GSL_AKIMA_PERIODIC:
      ncm_spline_gsl_set_type (sg, gsl_interp_akima_periodic);
      break;
    default:
      g_assert_not_reached ();
      break;
  }
}

/**
 * ncm_spline_gsl_set_type_by_name:
 * @sg: a #NcmSplineGsl
 * @type_name: gsl interpolation method name
 *
 * This function sets the interpolation method @type_name to @sg.
 *
 */
void
ncm_spline_gsl_set_type_by_name (NcmSplineGsl *sg, const gchar *type_name)
{
  const GEnumValue *type_id = ncm_cfg_get_enum_by_id_name_nick (NCM_TYPE_SPLINE_GSL_TYPE, type_name);

  if (type_id == NULL)
  {
    ncm_cfg_enum_print_all (NCM_TYPE_SPLINE_GSL_TYPE, "Error");
    g_error ("NcmSplineGsl type '%s' not found. Availables types above.", type_name);
  }

  ncm_spline_gsl_set_type_by_id (sg, type_id->value);
}


1	/***************************************************************************
2	* ncm_spline_gsl.c
3	*
4	* Wed Nov 21 19:09:20 2007
5	* Copyright 2007 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	/**
26	* SECTION:ncm_spline_gsl
27	* @title: NcmSplineGsl
28	* @short_description: GSL spline object wrapper.
29	* @stability: Stable
30	* @include: numcosmo/math/ncm_spline_gsl.h
31	*
32	* This object comprises the proper functions to use the [GNU Scientific
33	* Library (GSL)](https://www.gnu.org/software/gsl/) spline functions and interpolation methods.
34	*
35	*/
36
37	#ifdef HAVE_CONFIG_H
38	# include "config.h"
39	#endif /* HAVE_CONFIG_H */
40	#include "build_cfg.h"
41
42	#include "math/ncm_spline_gsl.h"
43	#include "math/ncm_cfg.h"
44	#include "ncm_enum_types.h"
45
46	struct _NcmSplineGsl
47	{
48	/< private >/
49	NcmSpline parent_instance;
50	gsl_interp *interp;
51	NcmSplineGslType type_id;
52	gchar *inst_name;
53	const gsl_interp_type *type;
54	};
55
56	G_DEFINE_TYPE (NcmSplineGsl, ncm_spline_gsl, NCM_TYPE_SPLINE)	8,164✔
57
58	enum
59	{
60	PROP_0,
61	PROP_TYPE_ID,
62	PROP_TYPE_NAME,
63	PROP_SIZE,
64	};
65
66	static void
67	ncm_spline_gsl_init (NcmSplineGsl *sg)	1,852✔
68	{
69	sg->interp = NULL;	1,852✔
70	sg->type = NULL;	1,852✔
71	sg->type_id = NCM_SPLINE_GSL_TYPES_LEN;	1,852✔
72	sg->inst_name = NULL;	1,852✔
73	}	1,852✔
74
75	static void
76	_ncm_spline_gsl_set_property (GObject object, guint prop_id, const GValue value, GParamSpec *pspec)	1,852✔
77	{
78	NcmSplineGsl *fit = NCM_SPLINE_GSL (object);	1,852✔
79
80	g_return_if_fail (NCM_IS_SPLINE_GSL (object));	1,852✔
81
82	switch (prop_id)	1,852✔
83	{
84	case PROP_TYPE_NAME:	1,852✔
85	ncm_spline_gsl_set_type_by_name (fit, g_value_get_string (value));	1,852✔
86	break;	1,852✔
87	default:	×
88	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);	×
89	break;	×
90	}
91	}
92
93	static void
94	_ncm_spline_gsl_get_property (GObject object, guint prop_id, GValue value, GParamSpec *pspec)	3✔
95	{
96	NcmSplineGsl *sgsl = NCM_SPLINE_GSL (object);	3✔
97
98	g_return_if_fail (NCM_IS_SPLINE_GSL (object));	3✔
99
100	switch (prop_id)	3✔
101	{
102	case PROP_TYPE_NAME:	3✔
103	{
104	const GEnumValue *e = ncm_cfg_enum_get_value (NCM_TYPE_SPLINE_GSL_TYPE, sgsl->type_id);	3✔
105
106	g_value_set_string (value, e->value_name);	3✔
107	break;	3✔
108	}
109	default:	×
110	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);	×
111	break;	×
112	}
113	}
114
115	static void
116	ncm_spline_gsl_finalize (GObject *object)	1,852✔
117	{
118	NcmSplineGsl *sg = NCM_SPLINE_GSL (object);	1,852✔
119
120	gsl_interp_free (sg->interp);	1,852✔
121	sg->type = gsl_interp_linear;	1,852✔
122	g_free (sg->inst_name);	1,852✔
123
124	G_OBJECT_CLASS (ncm_spline_gsl_parent_class)->finalize (object);	1,852✔
125	}	1,852✔
126
127	static void _ncm_spline_gsl_reset (NcmSpline *s);
128	static const gchar _ncm_spline_gsl_name (NcmSpline s);
129	static void _ncm_spline_gsl_prepare (NcmSpline *s);
130	static gsize _ncm_spline_gsl_min_size (const NcmSpline *s);
131	static gdouble _ncm_spline_gsl_eval (const NcmSpline *s, const gdouble x);
132	static gdouble _ncm_spline_gsl_deriv (const NcmSpline *s, const gdouble x);
133	static gdouble _ncm_spline_gsl_deriv2 (const NcmSpline *s, const gdouble x);
134	static gdouble _ncm_spline_gsl_deriv_nmax (const NcmSpline *s, const gdouble x);
135	static gdouble _ncm_spline_gsl_integ (const NcmSpline *s, const gdouble x0, const gdouble x1);
136	static NcmSpline _ncm_spline_gsl_copy_empty (const NcmSpline s);
137
138	static void
139	ncm_spline_gsl_class_init (NcmSplineGslClass *klass)	112✔
140	{
141	GObjectClass *object_class = G_OBJECT_CLASS (klass);	112✔
142	NcmSplineClass *s_class = NCM_SPLINE_CLASS (klass);	112✔
143
144	object_class->set_property = &_ncm_spline_gsl_set_property;	112✔
145	object_class->get_property = &_ncm_spline_gsl_get_property;	112✔
146	object_class->finalize = &ncm_spline_gsl_finalize;	112✔
147
148	/**
149	* NcmSplineGsl:type-name:
150	*
151	* The name of the interpolation method from [GNU Scientific Library (GSL)](https://www.gnu.org/software/gsl/).
152	*
153	*/
154	g_object_class_install_property (object_class,	112✔
155	PROP_TYPE_NAME,
156	g_param_spec_string ("type-name",
157	NULL,
158	"GSL Interpolation method name",
159	"NCM_SPLINE_GSL_CSPLINE",
160	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
161
162	s_class->name = &_ncm_spline_gsl_name;	112✔
163	s_class->reset = &_ncm_spline_gsl_reset;	112✔
164	s_class->prepare = &_ncm_spline_gsl_prepare;	112✔
165	s_class->prepare_base = NULL;	112✔
166	s_class->min_size = &_ncm_spline_gsl_min_size;	112✔
167	s_class->eval = &_ncm_spline_gsl_eval;	112✔
168	s_class->deriv = &_ncm_spline_gsl_deriv;	112✔
169	s_class->deriv2 = &_ncm_spline_gsl_deriv2;	112✔
170	s_class->deriv_nmax = &_ncm_spline_gsl_deriv_nmax;	112✔
171	s_class->integ = &_ncm_spline_gsl_integ;	112✔
172	s_class->copy_empty = &_ncm_spline_gsl_copy_empty;	112✔
173	}	112✔
174
175	static void
176	_ncm_spline_gsl_reset (NcmSpline *s)	1,931✔
177	{
178	NcmSplineGsl *sg = NCM_SPLINE_GSL (s);	1,931✔
179	const guint s_len = ncm_spline_get_len (s);	1,931✔
180
181	if (sg->interp != NULL)	1,931✔
182	{
183	if (sg->interp->size != s_len)	93✔
184	{
185	gsl_interp_free (sg->interp);	91✔
186	sg->interp = gsl_interp_alloc (sg->type, s_len);	91✔
187	}
188	}
189	else
190	{
191	sg->interp = gsl_interp_alloc (sg->type, s_len);	1,838✔
192	g_free (sg->inst_name);	1,838✔
193	sg->inst_name = g_strdup_printf ("NcmSplineGsl[%s]", gsl_interp_name (sg->interp));	1,838✔
194	}
195	}	1,931✔
196
197	static const gchar *
198	_ncm_spline_gsl_name (NcmSpline *s)	×
199	{
200	NcmSplineGsl *sg = NCM_SPLINE_GSL (s);	×
201
UNCOV 202	return sg->inst_name;	×
203	}
204
205	static void
206	_ncm_spline_gsl_prepare (NcmSpline *s)	3,098✔
207	{
208	NcmSplineGsl *sg = NCM_SPLINE_GSL (s);	3,098✔
209	const guint s_len = ncm_spline_get_len (s);	3,098✔
210	NcmVector *s_xv = ncm_spline_peek_xv (s);	3,098✔
211	NcmVector *s_yv = ncm_spline_peek_yv (s);	3,098✔
212
213	g_assert_cmpint (ncm_vector_stride (s_xv), ==, 1);	3,098✔
214	g_assert_cmpint (ncm_vector_stride (s_yv), ==, 1);	3,098✔
215
216	gsl_interp_init (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), s_len);	3,098✔
217	}	3,098✔
218
219	static gsize
220	_ncm_spline_gsl_min_size (const NcmSpline *s)	1,987✔
221	{
222	NcmSplineGsl sg = NCM_SPLINE_GSL ((NcmSpline ) s);	1,987✔
223
224	return sg->type->min_size;	1,987✔
225	}
226
227	static gdouble
228	_ncm_spline_gsl_eval (const NcmSpline *s, const gdouble x)	32,479,108✔
229	{
230	NcmSplineGsl sg = NCM_SPLINE_GSL ((NcmSpline ) s);	32,479,108✔
231	NcmVector s_xv = ncm_spline_peek_xv ((NcmSpline ) s);	32,479,108✔
232	NcmVector s_yv = ncm_spline_peek_yv ((NcmSpline ) s);	32,479,108✔
233	gsl_interp_accel s_acc = ncm_spline_peek_acc ((NcmSpline ) s);	32,479,108✔
234
235	return gsl_interp_eval (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x, s_acc);	32,479,108✔
236	}
237
238	static gdouble
239	_ncm_spline_gsl_deriv (const NcmSpline *s, const gdouble x)	32,623,432✔
240	{
241	NcmSplineGsl sg = NCM_SPLINE_GSL ((NcmSpline ) s);	32,623,432✔
242	NcmVector s_xv = ncm_spline_peek_xv ((NcmSpline ) s);	32,623,432✔
243	NcmVector s_yv = ncm_spline_peek_yv ((NcmSpline ) s);	32,623,432✔
244	gsl_interp_accel s_acc = ncm_spline_peek_acc ((NcmSpline ) s);	32,623,432✔
245
246	return gsl_interp_eval_deriv (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x, s_acc);	32,623,432✔
247	}
248
249	static gdouble
250	_ncm_spline_gsl_deriv2 (const NcmSpline *s, const gdouble x)	×
251	{
NEW 252	NcmSplineGsl sg = NCM_SPLINE_GSL ((NcmSpline ) s);	×
NEW 253	NcmVector s_xv = ncm_spline_peek_xv ((NcmSpline ) s);	×
NEW 254	NcmVector s_yv = ncm_spline_peek_yv ((NcmSpline ) s);	×
NEW 255	gsl_interp_accel s_acc = ncm_spline_peek_acc ((NcmSpline ) s);	×
256
NEW 257	return gsl_interp_eval_deriv2 (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x, s_acc);	×
258	}
259
260	static gdouble
261	_ncm_spline_gsl_deriv_nmax (const NcmSpline *s, const gdouble x)	×
262	{
NEW 263	NcmSplineGsl sg = NCM_SPLINE_GSL ((NcmSpline ) s);	×
NEW 264	NcmVector s_xv = ncm_spline_peek_xv ((NcmSpline ) s);	×
NEW 265	NcmVector s_yv = ncm_spline_peek_yv ((NcmSpline ) s);	×
NEW 266	gsl_interp_accel s_acc = ncm_spline_peek_acc ((NcmSpline ) s);	×
267
UNCOV 268	if (sg->type == gsl_interp_linear)	×
269	{
NEW 270	return gsl_interp_eval_deriv (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x, s_acc);	×
271	}
NEW 272	else if ((sg->type == gsl_interp_cspline) \|\| (sg->type == gsl_interp_cspline_periodic) \|\|	×
NEW 273	(sg->type == gsl_interp_akima) \|\| (sg->type == gsl_interp_akima_periodic))	×
274	{
NEW 275	const guint knot_i = ncm_spline_get_index (s, x);	×
NEW 276	const gdouble x_i = ncm_vector_get (s_xv, knot_i);	×
NEW 277	const gdouble x_ip1 = ncm_vector_get (s_xv, knot_i + 1);	×
NEW 278	const gdouble dx = x_ip1 - x_i;	×
NEW 279	gdouble two_c_i = gsl_interp_eval_deriv2 (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x_i, s_acc);	×
NEW 280	gdouble two_c_i_p_6d_i_dx = gsl_interp_eval_deriv2 (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x_ip1, s_acc);	×
281
UNCOV 282	return (two_c_i_p_6d_i_dx - two_c_i) / dx;	×
283	}
284	else
285	{
286	g_error ("ncm_spline_gsl_deriv_nmax: Calculation of the nmax derivative not supported.");	×
287
288	return 0.0;
289	}
290	}
291
292	static gdouble
293	_ncm_spline_gsl_integ (const NcmSpline *s, const gdouble x0, const gdouble x1)	6,480✔
294	{
295	NcmSplineGsl sg = NCM_SPLINE_GSL ((NcmSpline ) s);	6,480✔
296	NcmVector s_xv = ncm_spline_peek_xv ((NcmSpline ) s);	6,480✔
297	NcmVector s_yv = ncm_spline_peek_yv ((NcmSpline ) s);	6,480✔
298	gsl_interp_accel s_acc = ncm_spline_peek_acc ((NcmSpline ) s);	6,480✔
299
300	return gsl_interp_eval_integ (sg->interp, ncm_vector_ptr (s_xv, 0), ncm_vector_ptr (s_yv, 0), x0, x1, s_acc);	6,480✔
301	}
302
303	static NcmSpline *
304	_ncm_spline_gsl_copy_empty (const NcmSpline *s)	1,827✔
305	{
306	NcmSplineGsl sg = NCM_SPLINE_GSL ((NcmSpline ) s);	1,827✔
307
308	return ncm_spline_gsl_new (sg->type);	1,827✔
309	}
310
311	/**
312	* ncm_spline_gsl_new:
313	* @type: gsl interpolation method
314	*
315	* This function returns a new gsl #NcmSpline which will use @type
316	* interpolation method.
317	*
318	* Returns: a new #NcmSpline.
319	*/
320	NcmSpline *
321	ncm_spline_gsl_new (const gsl_interp_type *type)	1,849✔
322	{
323	NcmSplineGsl *sg = g_object_new (NCM_TYPE_SPLINE_GSL, NULL);	1,849✔
324
325	ncm_spline_gsl_set_type (sg, type);	1,849✔
326
327	return NCM_SPLINE (sg);	1,849✔
328	}
329
330	/**
331	* ncm_spline_gsl_new_by_id:
332	* @type_id: gsl interpolation method id
333	*
334	* This function returns a new gsl #NcmSpline which will use @type
335	* interpolation method.
336	*
337	* Returns: a new #NcmSpline.
338	*/
339	NcmSpline *
340	ncm_spline_gsl_new_by_id (NcmSplineGslType type_id)	×
341	{
342	NcmSplineGsl *sg = g_object_new (NCM_TYPE_SPLINE_GSL, NULL);	×
343
344	ncm_spline_gsl_set_type_by_id (sg, type_id);	×
345
UNCOV 346	return NCM_SPLINE (sg);	×
347	}
348
349	/**
350	* ncm_spline_gsl_new_full:
351	* @type: gsl interpolation method
352	* @xv: #NcmVector of knots
353	* @yv: #NcmVector of the values of the function, to be interpolated, computed at @xv
354	* @init: TRUE to prepare the new #NcmSpline or FALSE to not prepare it
355	*
356	* This function returns a new gsl #NcmSpline setting all its members.
357	*
358	* Returns: a new #NcmSpline.
359	*/
360	NcmSpline *
361	ncm_spline_gsl_new_full (const gsl_interp_type type, NcmVector xv, NcmVector *yv, gboolean init)	×
362	{
363	NcmSpline *s = ncm_spline_gsl_new (type);	×
364
365	ncm_spline_set (s, xv, yv, init);	×
366
UNCOV 367	return s;	×
368	}
369
370	/**
371	* ncm_spline_gsl_new_full_by_id:
372	* @type_id: gsl interpolation method id
373	* @xv: #NcmVector of knots
374	* @yv: #NcmVector of the values of the function, to be interpolated, computed at @xv
375	* @init: TRUE to prepare the new #NcmSpline or FALSE to not prepare it
376	*
377	* This function returns a new gsl #NcmSpline setting all its members.
378	*
379	* Returns: a new #NcmSpline.
380	*/
381	NcmSpline *
382	ncm_spline_gsl_new_full_by_id (NcmSplineGslType type_id, NcmVector xv, NcmVector yv, gboolean init)	×
383	{
384	NcmSpline *s = ncm_spline_gsl_new_by_id (type_id);	×
385
386	ncm_spline_set (s, xv, yv, init);	×
387
UNCOV 388	return s;	×
389	}
390
391	/**
392	* ncm_spline_gsl_set_type:
393	* @sg: a #NcmSplineGsl
394	* @type: gsl interpolation method
395	*
396	* This function sets the interpolation method @type to @sg.
397	*
398	*/
399	void
400	ncm_spline_gsl_set_type (NcmSplineGsl sg, const gsl_interp_type type)	3,701✔
401	{
402	if (sg->interp != NULL)	3,701✔
403	{
404	if (sg->type != type)	×
405	{
406	sg->type = type;	×
407	gsl_interp_free (sg->interp);	×
408	sg->interp = NULL;	×
409	_ncm_spline_gsl_reset (NCM_SPLINE (sg));	×
410	}
411	}
412	else
413	{
414	sg->type = type;	3,701✔
415	g_free (sg->inst_name);	3,701✔
416	/* printf("NcmSplineGsl[%s]", type->name); */
417	sg->inst_name = g_strdup_printf ("NcmSplineGsl[%s]", type->name);	3,701✔
418	}
419	}	3,701✔
420
421	/**
422	* ncm_spline_gsl_set_type_by_id:
423	* @sg: a #NcmSplineGsl
424	* @type_id: gsl interpolation method id
425	*
426	* This function sets the interpolation method @type_id to @sg.
427	*
428	*/
429	void
430	ncm_spline_gsl_set_type_by_id (NcmSplineGsl *sg, NcmSplineGslType type_id)	1,852✔
431	{
432	sg->type_id = type_id;	1,852✔
433
434	switch (type_id)	1,852✔
435	{
436	case NCM_SPLINE_GSL_LINEAR:	×
437	ncm_spline_gsl_set_type (sg, gsl_interp_linear);	×
438	break;	×
439	case NCM_SPLINE_GSL_POLYNOMIAL:	×
440	ncm_spline_gsl_set_type (sg, gsl_interp_polynomial);	×
441	break;	×
442	case NCM_SPLINE_GSL_CSPLINE:	1,852✔
443	ncm_spline_gsl_set_type (sg, gsl_interp_cspline);	1,852✔
444	break;	1,852✔
445	case NCM_SPLINE_GSL_CSPLINE_PERIODIC:	×
446	ncm_spline_gsl_set_type (sg, gsl_interp_cspline_periodic);	×
447	break;	×
448	case NCM_SPLINE_GSL_AKIMA:	×
449	ncm_spline_gsl_set_type (sg, gsl_interp_akima);	×
450	break;	×
451	case NCM_SPLINE_GSL_AKIMA_PERIODIC:	×
452	ncm_spline_gsl_set_type (sg, gsl_interp_akima_periodic);	×
453	break;	×
454	default:	×
455	g_assert_not_reached ();	×
456	break;
457	}
458	}	1,852✔
459
460	/**
461	* ncm_spline_gsl_set_type_by_name:
462	* @sg: a #NcmSplineGsl
463	* @type_name: gsl interpolation method name
464	*
465	* This function sets the interpolation method @type_name to @sg.
466	*
467	*/
468	void
469	ncm_spline_gsl_set_type_by_name (NcmSplineGsl sg, const gchar type_name)	1,852✔
470	{
471	const GEnumValue *type_id = ncm_cfg_get_enum_by_id_name_nick (NCM_TYPE_SPLINE_GSL_TYPE, type_name);	1,852✔
472
473	if (type_id == NULL)	1,852✔
474	{
475	ncm_cfg_enum_print_all (NCM_TYPE_SPLINE_GSL_TYPE, "Error");	×
476	g_error ("NcmSplineGsl type '%s' not found. Availables types above.", type_name);	×
477	}
478
479	ncm_spline_gsl_set_type_by_id (sg, type_id->value);	1,852✔
480	}	1,852✔
481

NumCosmo / NumCosmo / 7269966887

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