7062101501

Committed 01 Dec 2023 03:42PM UTC coverage: 31.833% (-21.6%) from 53.447%

Build # 7062101501

Build Type

Pull #120

github

Committed by

web-flow

Commit Message

Merge 7b0d91c6e into 24e5f6a9b

Pull Request Pull Request #120: Moving to meson

Run Details

14322 of 71092 branches covered (0.0%)

Branch coverage included in aggregate %.

1956 of 3488 new or added lines in 312 files covered. (56.08%)

3938 existing lines in 209 files now uncovered.

57509 of 154555 relevant lines covered (37.21%)

2368545.44 hits per line

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

45.92

/numcosmo/math/ncm_spline.h

/***************************************************************************
 *            ncm_spline.h
 *
 *  Wed Aug 13 21:13:59 2008
 *  Copyright  2008  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/>.
 */

#ifndef _NCM_SPLINE_H_
#define _NCM_SPLINE_H_

#include <glib.h>
#include <glib-object.h>
#include <numcosmo/build_cfg.h>
#include <numcosmo/math/ncm_vector.h>

#ifndef NUMCOSMO_GIR_SCAN
#include <gsl/gsl_spline.h>
#endif /* NUMCOSMO_GIR_SCAN */

G_BEGIN_DECLS

#define NCM_TYPE_SPLINE             (ncm_spline_get_type ())
#define NCM_SPLINE(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), NCM_TYPE_SPLINE, NcmSpline))
#define NCM_SPLINE_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), NCM_TYPE_SPLINE, NcmSplineClass))
#define NCM_IS_SPLINE(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NCM_TYPE_SPLINE))
#define NCM_IS_SPLINE_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), NCM_TYPE_SPLINE))
#define NCM_SPLINE_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ((obj), NCM_TYPE_SPLINE, NcmSplineClass))

typedef struct _NcmSplineClass NcmSplineClass;
typedef struct _NcmSpline NcmSpline;

struct _NcmSplineClass
{
  /*< private >*/
  GObjectClass parent_class;
  const gchar *(*name) (NcmSpline *s);
  
  void (*reset) (NcmSpline *s);
  void (*prepare) (NcmSpline *s);
  void (*prepare_base) (NcmSpline *s);
  gsize (*min_size) (const NcmSpline *s);
  gdouble (*eval) (const NcmSpline *s, const gdouble x);
  gdouble (*deriv) (const NcmSpline *s, const gdouble x);
  gdouble (*deriv2) (const NcmSpline *s, const gdouble x);
  gdouble (*deriv_nmax) (const NcmSpline *s, const gdouble x);
  gdouble (*integ) (const NcmSpline *s, const gdouble xi, const gdouble xf);
  NcmSpline *(*copy_empty) (const NcmSpline *s);
};

struct _NcmSpline
{
  /*< private >*/
  GObject parent_instance;
  gsize len;
  NcmVector *xv;
  NcmVector *yv;
  gsl_interp_accel *acc;
  gboolean init;
  gboolean empty;
};

GType ncm_spline_get_type (void) G_GNUC_CONST;

NcmSpline *ncm_spline_copy_empty (const NcmSpline *s);
NcmSpline *ncm_spline_copy (const NcmSpline *s);

NcmSpline *ncm_spline_new (const NcmSpline *s, NcmVector *xv, NcmVector *yv, const gboolean init);
NcmSpline *ncm_spline_new_array (const NcmSpline *s, GArray *x, GArray *y, const gboolean init);
NcmSpline *ncm_spline_new_data (const NcmSpline *s, gdouble *x, gdouble *y, const gsize len, const gboolean init);
NcmSpline *ncm_spline_set (NcmSpline *s, NcmVector *xv, NcmVector *yv, gboolean init);
NcmSpline *ncm_spline_ref (NcmSpline *s);

void ncm_spline_acc (NcmSpline *s, gboolean enable);

void ncm_spline_set_len (NcmSpline *s, guint len);
void ncm_spline_set_xv (NcmSpline *s, NcmVector *xv, gboolean init);
void ncm_spline_set_yv (NcmSpline *s, NcmVector *yv, gboolean init);
void ncm_spline_set_array (NcmSpline *s, GArray *x, GArray *y, gboolean init);
void ncm_spline_set_data_static (NcmSpline *s, gdouble *x, gdouble *y, gsize len, gboolean init);

guint ncm_spline_get_len (NcmSpline *s);
NcmVector *ncm_spline_get_xv (NcmSpline *s);
NcmVector *ncm_spline_get_yv (NcmSpline *s);

void ncm_spline_get_bounds (NcmSpline *s, gdouble *lb, gdouble *ub);

void ncm_spline_free (NcmSpline *s);
void ncm_spline_clear (NcmSpline **s);

NCM_INLINE void ncm_spline_prepare (NcmSpline *s);
NCM_INLINE void ncm_spline_prepare_base (NcmSpline *s);
NCM_INLINE gdouble ncm_spline_eval (const NcmSpline *s, const gdouble x);
NCM_INLINE gdouble ncm_spline_eval_deriv (const NcmSpline *s, const gdouble x);
NCM_INLINE gdouble ncm_spline_eval_deriv2 (const NcmSpline *s, const gdouble x);
NCM_INLINE gdouble ncm_spline_eval_deriv_nmax (const NcmSpline *s, const gdouble x);
NCM_INLINE gdouble ncm_spline_eval_integ (const NcmSpline *s, const gdouble x0, const gdouble x1);
NCM_INLINE gboolean ncm_spline_is_empty (const NcmSpline *s);
NCM_INLINE gsize ncm_spline_min_size (const NcmSpline *s);
NCM_INLINE guint ncm_spline_get_index (const NcmSpline *s, const gdouble x);

/* Utilities -- internal use */

NCM_INLINE gdouble _ncm_spline_util_integ_eval (const gdouble ai, const gdouble bi, const gdouble ci, const gdouble di, const gdouble xi, const gdouble a, const gdouble b);

G_END_DECLS

#endif /* _NCM_SPLINE_H_ */

#ifndef _NCM_SPLINE_INLINE_H_
#define _NCM_SPLINE_INLINE_H_
#ifdef NUMCOSMO_HAVE_INLINE
#ifndef __GTK_DOC_IGNORE__

G_BEGIN_DECLS

NCM_INLINE void
ncm_spline_prepare (NcmSpline *s)
{
  s->init = TRUE;
  NCM_SPLINE_GET_CLASS (s)->prepare (s);
}

NCM_INLINE void
ncm_spline_prepare_base (NcmSpline *s)
{
  if (NCM_SPLINE_GET_CLASS (s)->prepare_base)
    NCM_SPLINE_GET_CLASS (s)->prepare_base (s);
}

NCM_INLINE gdouble
ncm_spline_eval (const NcmSpline *s, const gdouble x)
{
  return NCM_SPLINE_GET_CLASS (s)->eval (s, x);
}

NCM_INLINE gdouble
ncm_spline_eval_deriv (const NcmSpline *s, const gdouble x)
{
  return NCM_SPLINE_GET_CLASS (s)->deriv (s, x);
}

NCM_INLINE gdouble
ncm_spline_eval_deriv2 (const NcmSpline *s, const gdouble x)
{
  return NCM_SPLINE_GET_CLASS (s)->deriv2 (s, x);
}

NCM_INLINE gdouble
ncm_spline_eval_deriv_nmax (const NcmSpline *s, const gdouble x)
{
  return NCM_SPLINE_GET_CLASS (s)->deriv_nmax (s, x);
}

NCM_INLINE gdouble
ncm_spline_eval_integ (const NcmSpline *s, const gdouble x0, const gdouble x1)
{
  return NCM_SPLINE_GET_CLASS (s)->integ (s, x0, x1);
}

NCM_INLINE gboolean
ncm_spline_is_empty (const NcmSpline *s)
{
  return s->empty;
}

NCM_INLINE gsize
ncm_spline_min_size (const NcmSpline *s)
{
  return NCM_SPLINE_GET_CLASS (s)->min_size (s);
}

NCM_INLINE gsize
_ncm_spline_bsearch_stride (const gdouble x_array[], const guint stride, const gdouble x, gsize index_lo, gsize index_hi)
{
  gsize ilo = index_lo;
  gsize ihi = index_hi;
  
  while (ihi > ilo + 1)
  {
    gsize i = (ihi + ilo) / 2;
    
    if (x_array[i * stride] > x)
      ihi = i;
    else
      ilo = i;
  }
  
  return ilo;
}

NCM_INLINE gsize
_ncm_spline_accel_find (gsl_interp_accel *a, const gdouble xa[], const guint stride, gsize len, gdouble x)
{
  gsize x_index = a->cache;
  
  if (x < xa[x_index * stride])
  {
    a->miss_count++;
    a->cache = _ncm_spline_bsearch_stride (xa, stride, x, 0, x_index);
  }
  else if (x >= xa[stride * (x_index + 1)])
  {
    a->miss_count++;
    a->cache = _ncm_spline_bsearch_stride (xa, stride, x, x_index, len - 1);
  }
  else
  {
    a->hit_count++;
  }
  
  return a->cache;
}

NCM_INLINE guint
ncm_spline_get_index (const NcmSpline *s, const gdouble x)
{
  if (ncm_vector_stride (s->xv) == 1)
  {
    if (s->acc)
      return gsl_interp_accel_find (s->acc, ncm_vector_ptr (s->xv, 0), s->len, x);
    else
      return gsl_interp_bsearch (ncm_vector_ptr (s->xv, 0), x, 0, ncm_vector_len (s->xv) - 1);
  }
  else
  {
    if (s->acc)
      return _ncm_spline_accel_find (s->acc, ncm_vector_ptr (s->xv, 0), ncm_vector_stride (s->xv), s->len, x);
    else
      return _ncm_spline_bsearch_stride (ncm_vector_ptr (s->xv, 0), ncm_vector_stride (s->xv), x, 0, ncm_vector_len (s->xv) - 1);
  }
}

/* Utilities -- internal use */

NCM_INLINE gdouble
_ncm_spline_util_integ_eval (const gdouble ai, const gdouble bi, const gdouble ci, const gdouble di, const gdouble xi, const gdouble a, const gdouble b)
{
  const gdouble r1    = (a - xi);
  const gdouble r2    = (b - xi);
  const gdouble r12   = (r1 + r2);
  const gdouble bterm = 0.5 * bi * r12;
  const gdouble cterm = (1.0 / 3.0) * ci * (r1 * r1 + r2 * r2 + r1 * r2);
  const gdouble dterm = 0.25 * di * r12 * (r1 * r1 + r2 * r2);
  
  return (b - a) * (ai + bterm + cterm + dterm);
}

G_END_DECLS

#endif /* __GTK_DOC_IGNORE__ */
#endif /* NUMCOSMO_HAVE_INLINE */
#endif /* _NCM_SPLINE_INLINE_H_ */


1	/***************************************************************************
2	* ncm_spline.h
3	*
4	* Wed Aug 13 21:13:59 2008
5	* Copyright 2008 Sandro Dias Pinto Vitenti
6	* <vitenti@uel.br>
7	****************************************************************************/
8
9	/*
10	* numcosmo
11	* Copyright (C) Sandro Dias Pinto Vitenti 2012 <vitenti@uel.br>
12	* numcosmo is free software: you can redistribute it and/or modify it
13	* under the terms of the GNU General Public License as published by the
14	* Free Software Foundation, either version 3 of the License, or
15	* (at your option) any later version.
16	*
17	* numcosmo is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
20	* See the GNU General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License along
23	* with this program. If not, see <http://www.gnu.org/licenses/>.
24	*/
25
26	#ifndef _NCM_SPLINE_H_
27	#define _NCM_SPLINE_H_
28
29	#include <glib.h>
30	#include <glib-object.h>
31	#include <numcosmo/build_cfg.h>
32	#include <numcosmo/math/ncm_vector.h>
33
34	#ifndef NUMCOSMO_GIR_SCAN
35	#include <gsl/gsl_spline.h>
36	#endif /* NUMCOSMO_GIR_SCAN */
37
38	G_BEGIN_DECLS
39
40	#define NCM_TYPE_SPLINE (ncm_spline_get_type ())
41	#define NCM_SPLINE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NCM_TYPE_SPLINE, NcmSpline))
42	#define NCM_SPLINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NCM_TYPE_SPLINE, NcmSplineClass))
43	#define NCM_IS_SPLINE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NCM_TYPE_SPLINE))
44	#define NCM_IS_SPLINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NCM_TYPE_SPLINE))
45	#define NCM_SPLINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NCM_TYPE_SPLINE, NcmSplineClass))
46
47	typedef struct _NcmSplineClass NcmSplineClass;
48	typedef struct _NcmSpline NcmSpline;
49
50	struct _NcmSplineClass
51	{
52	/< private >/
53	GObjectClass parent_class;
54	const gchar (name) (NcmSpline *s);
55
56	void (reset) (NcmSpline s);
57	void (prepare) (NcmSpline s);
58	void (prepare_base) (NcmSpline s);
59	gsize (min_size) (const NcmSpline s);
60	gdouble (eval) (const NcmSpline s, const gdouble x);
61	gdouble (deriv) (const NcmSpline s, const gdouble x);
62	gdouble (deriv2) (const NcmSpline s, const gdouble x);
63	gdouble (deriv_nmax) (const NcmSpline s, const gdouble x);
64	gdouble (integ) (const NcmSpline s, const gdouble xi, const gdouble xf);
65	NcmSpline (copy_empty) (const NcmSpline *s);
66	};
67
68	struct _NcmSpline
69	{
70	/< private >/
71	GObject parent_instance;
72	gsize len;
73	NcmVector *xv;
74	NcmVector *yv;
75	gsl_interp_accel *acc;
76	gboolean init;
77	gboolean empty;
78	};
79
80	GType ncm_spline_get_type (void) G_GNUC_CONST;
81
82	NcmSpline ncm_spline_copy_empty (const NcmSpline s);
83	NcmSpline ncm_spline_copy (const NcmSpline s);
84
85	NcmSpline ncm_spline_new (const NcmSpline s, NcmVector xv, NcmVector yv, const gboolean init);
86	NcmSpline ncm_spline_new_array (const NcmSpline s, GArray x, GArray y, const gboolean init);
87	NcmSpline ncm_spline_new_data (const NcmSpline s, gdouble x, gdouble y, const gsize len, const gboolean init);
88	NcmSpline ncm_spline_set (NcmSpline s, NcmVector xv, NcmVector yv, gboolean init);
89	NcmSpline ncm_spline_ref (NcmSpline s);
90
91	void ncm_spline_acc (NcmSpline *s, gboolean enable);
92
93	void ncm_spline_set_len (NcmSpline *s, guint len);
94	void ncm_spline_set_xv (NcmSpline s, NcmVector xv, gboolean init);
95	void ncm_spline_set_yv (NcmSpline s, NcmVector yv, gboolean init);
96	void ncm_spline_set_array (NcmSpline s, GArray x, GArray *y, gboolean init);
97	void ncm_spline_set_data_static (NcmSpline s, gdouble x, gdouble *y, gsize len, gboolean init);
98
99	guint ncm_spline_get_len (NcmSpline *s);
100	NcmVector ncm_spline_get_xv (NcmSpline s);
101	NcmVector ncm_spline_get_yv (NcmSpline s);
102
103	void ncm_spline_get_bounds (NcmSpline s, gdouble lb, gdouble *ub);
104
105	void ncm_spline_free (NcmSpline *s);
106	void ncm_spline_clear (NcmSpline **s);
107
108	NCM_INLINE void ncm_spline_prepare (NcmSpline *s);
109	NCM_INLINE void ncm_spline_prepare_base (NcmSpline *s);
110	NCM_INLINE gdouble ncm_spline_eval (const NcmSpline *s, const gdouble x);
111	NCM_INLINE gdouble ncm_spline_eval_deriv (const NcmSpline *s, const gdouble x);
112	NCM_INLINE gdouble ncm_spline_eval_deriv2 (const NcmSpline *s, const gdouble x);
113	NCM_INLINE gdouble ncm_spline_eval_deriv_nmax (const NcmSpline *s, const gdouble x);
114	NCM_INLINE gdouble ncm_spline_eval_integ (const NcmSpline *s, const gdouble x0, const gdouble x1);
115	NCM_INLINE gboolean ncm_spline_is_empty (const NcmSpline *s);
116	NCM_INLINE gsize ncm_spline_min_size (const NcmSpline *s);
117	NCM_INLINE guint ncm_spline_get_index (const NcmSpline *s, const gdouble x);
118
119	/* Utilities -- internal use */
120
121	NCM_INLINE gdouble _ncm_spline_util_integ_eval (const gdouble ai, const gdouble bi, const gdouble ci, const gdouble di, const gdouble xi, const gdouble a, const gdouble b);
122
123	G_END_DECLS
124
125	#endif /* _NCM_SPLINE_H_ */
126
127	#ifndef _NCM_SPLINE_INLINE_H_
128	#define _NCM_SPLINE_INLINE_H_
129	#ifdef NUMCOSMO_HAVE_INLINE
130	#ifndef __GTK_DOC_IGNORE__
131
132	G_BEGIN_DECLS
133
134	NCM_INLINE void
135	ncm_spline_prepare (NcmSpline *s)	283,476✔
136	{
137	s->init = TRUE;	283,476✔
138	NCM_SPLINE_GET_CLASS (s)->prepare (s);	283,476✔
139	}	3,786✔
140
141	NCM_INLINE void
142	ncm_spline_prepare_base (NcmSpline *s)	197,972✔
143	{
144	if (NCM_SPLINE_GET_CLASS (s)->prepare_base)	197,972!
145	NCM_SPLINE_GET_CLASS (s)->prepare_base (s);	197,972✔
UNCOV 146	}	×
147
148	NCM_INLINE gdouble
149	ncm_spline_eval (const NcmSpline *s, const gdouble x)	167,916,437✔
150	{
151	return NCM_SPLINE_GET_CLASS (s)->eval (s, x);	136,999,142✔
152	}
153
154	NCM_INLINE gdouble
155	ncm_spline_eval_deriv (const NcmSpline *s, const gdouble x)	32,635,018✔
156	{
157	return NCM_SPLINE_GET_CLASS (s)->deriv (s, x);	4,226,071✔
158	}
159
160	NCM_INLINE gdouble
161	ncm_spline_eval_deriv2 (const NcmSpline *s, const gdouble x)	6,492✔
162	{
163	return NCM_SPLINE_GET_CLASS (s)->deriv2 (s, x);	6,492✔
164	}
165
166	NCM_INLINE gdouble
UNCOV 167	ncm_spline_eval_deriv_nmax (const NcmSpline *s, const gdouble x)	×
168	{
UNCOV 169	return NCM_SPLINE_GET_CLASS (s)->deriv_nmax (s, x);	×
170	}
171
172	NCM_INLINE gdouble
173	ncm_spline_eval_integ (const NcmSpline *s, const gdouble x0, const gdouble x1)	709,028✔
174	{
175	return NCM_SPLINE_GET_CLASS (s)->integ (s, x0, x1);	709,028✔
176	}
177
178	NCM_INLINE gboolean
179	ncm_spline_is_empty (const NcmSpline *s)	38✔
180	{
181	return s->empty;	38✔
182	}
183
184	NCM_INLINE gsize
185	ncm_spline_min_size (const NcmSpline *s)	1,100✔
186	{
187	return NCM_SPLINE_GET_CLASS (s)->min_size (s);	1,100✔
188	}
189
190	NCM_INLINE gsize
UNCOV 191	_ncm_spline_bsearch_stride (const gdouble x_array[], const guint stride, const gdouble x, gsize index_lo, gsize index_hi)	×
192	{
UNCOV 193	gsize ilo = index_lo;	×
UNCOV 194	gsize ihi = index_hi;	×
195
UNCOV 196	while (ihi > ilo + 1)	×
197	{
UNCOV 198	gsize i = (ihi + ilo) / 2;	×
199
UNCOV 200	if (x_array[i * stride] > x)	×
201	ihi = i;
202	else
UNCOV 203	ilo = i;	×
204	}
205
UNCOV 206	return ilo;	×
207	}
208
209	NCM_INLINE gsize
UNCOV 210	_ncm_spline_accel_find (gsl_interp_accel *a, const gdouble xa[], const guint stride, gsize len, gdouble x)	×
211	{
UNCOV 212	gsize x_index = a->cache;	×
213
UNCOV 214	if (x < xa[x_index * stride])	×
215	{
UNCOV 216	a->miss_count++;	×
UNCOV 217	a->cache = _ncm_spline_bsearch_stride (xa, stride, x, 0, x_index);	×
218	}
UNCOV 219	else if (x >= xa[stride * (x_index + 1)])	×
220	{
UNCOV 221	a->miss_count++;	×
UNCOV 222	a->cache = _ncm_spline_bsearch_stride (xa, stride, x, x_index, len - 1);	×
223	}
224	else
225	{
UNCOV 226	a->hit_count++;	×
227	}
228
UNCOV 229	return a->cache;	×
230	}
231
232	NCM_INLINE guint
233	ncm_spline_get_index (const NcmSpline *s, const gdouble x)	136,853,493✔
234	{
235	if (ncm_vector_stride (s->xv) == 1)	136,853,493!
236	{
237	if (s->acc)	136,853,493!
UNCOV 238	return gsl_interp_accel_find (s->acc, ncm_vector_ptr (s->xv, 0), s->len, x);	×
239	else
240	return gsl_interp_bsearch (ncm_vector_ptr (s->xv, 0), x, 0, ncm_vector_len (s->xv) - 1);	136,853,493✔
241	}
242	else
243	{
UNCOV 244	if (s->acc)	×
UNCOV 245	return _ncm_spline_accel_find (s->acc, ncm_vector_ptr (s->xv, 0), ncm_vector_stride (s->xv), s->len, x);	×
246	else
UNCOV 247	return _ncm_spline_bsearch_stride (ncm_vector_ptr (s->xv, 0), ncm_vector_stride (s->xv), x, 0, ncm_vector_len (s->xv) - 1);	×
248	}
249	}
250
251	/* Utilities -- internal use */
252
253	NCM_INLINE gdouble
254	_ncm_spline_util_integ_eval (const gdouble ai, const gdouble bi, const gdouble ci, const gdouble di, const gdouble xi, const gdouble a, const gdouble b)	10,777,217✔
255	{
256	const gdouble r1 = (a - xi);	10,777,217✔
257	const gdouble r2 = (b - xi);	10,777,217✔
258	const gdouble r12 = (r1 + r2);	10,777,217✔
259	const gdouble bterm = 0.5 * bi * r12;	10,777,217✔
260	const gdouble cterm = (1.0 / 3.0) * ci * (r1 * r1 + r2 * r2 + r1 * r2);	10,777,217✔
261	const gdouble dterm = 0.25 * di * r12 * (r1 * r1 + r2 * r2);	10,777,217✔
262
263	return (b - a) * (ai + bterm + cterm + dterm);	4,934,183✔
264	}
265
266	G_END_DECLS
267
268	#endif /* __GTK_DOC_IGNORE__ */
269	#endif /* NUMCOSMO_HAVE_INLINE */
270	#endif /* _NCM_SPLINE_INLINE_H_ */
271

NumCosmo / NumCosmo / 7062101501

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