6840481691

Committed 12 Nov 2023 11:51AM UTC coverage: 53.278% (-0.2%) from 53.454%

Build # 6840481691

Build Type

Pull #117

github

Committed by

web-flow

Commit Message

Merge ed9e62c7c into 7269172d1

Pull Request Pull Request #117: Adding interface to nc_cluster_mass_ascaso to compute mean and variances

Run Details

8760 of 20827 branches covered (0.0%)

Branch coverage included in aggregate %.

69 of 359 new or added lines in 6 files covered. (19.22%)

19 existing lines in 7 files now uncovered.

44663 of 79446 relevant lines covered (56.22%)

2719692.75 hits per line

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

79.69

/numcosmo/math/ncm_reparam.c

/***************************************************************************
 *            ncm_reparam.c
 *
 *  Thu March 08 00:36:24 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/>.
 */

/**
 * SECTION:ncm_reparam
 * @title: NcmReparam
 * @short_description: Abstract class for model reparametrization.
 *
 * FIXME
 */

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

#include "math/ncm_reparam.h"
#include "math/ncm_model.h"
#include "math/ncm_cfg.h"

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

G_DEFINE_ABSTRACT_TYPE (NcmReparam, ncm_reparam, G_TYPE_OBJECT);

enum
{
  PROP_0,
  PROP_LEN,
  PROP_PARAMS_DESC,
  PROP_COMPAT_TYPE,
};

static void
ncm_reparam_init (NcmReparam *reparam)
{
  reparam->length          = 0;
  reparam->sparams         = NULL;
  reparam->new_params      = NULL;
  reparam->sparams_name_id = g_hash_table_new_full (&g_str_hash, &g_str_equal, &g_free, NULL);
  reparam->compat_type     = G_TYPE_INVALID;
}

static void
_ncm_reparam_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
  NcmReparam *reparam = NCM_REPARAM (object);

  g_return_if_fail (NCM_IS_REPARAM (object));

  switch (prop_id)
  {
    case PROP_LEN:
      g_value_set_uint (value, reparam->length);
      break;
    case PROP_PARAMS_DESC:
    {
      g_value_take_variant (value, ncm_reparam_get_params_desc_dict (reparam));
      break;
    }
    case PROP_COMPAT_TYPE:
      g_value_set_string (value, g_type_name (reparam->compat_type));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
_ncm_reparam_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
  NcmReparam *reparam = NCM_REPARAM (object);

  g_return_if_fail (NCM_IS_REPARAM (object));

  switch (prop_id)
  {
    case PROP_LEN:
      reparam->length = g_value_get_uint (value);
      break;
    case PROP_PARAMS_DESC:
      ncm_reparam_set_params_desc_dict (reparam, g_value_get_variant (value));
      break;
    case PROP_COMPAT_TYPE:
      reparam->compat_type = g_type_from_name (g_value_get_string (value));
      if (reparam->compat_type == G_TYPE_INVALID)
        g_error ("_ncm_reparam_set_property: GType `%s' unregistered or invalid.", g_value_get_string (value));
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
_ncm_reparam_constructed (GObject *object)
{
  /* Chain up : start */
  G_OBJECT_CLASS (ncm_reparam_parent_class)->constructed (object);
  {
    NcmReparam *reparam = NCM_REPARAM (object);
    g_assert_cmpuint (reparam->length, >, 0);

    reparam->new_params = ncm_vector_new (reparam->length);

    reparam->sparams = g_ptr_array_sized_new (reparam->length);
    
    g_ptr_array_set_size (reparam->sparams, reparam->length);
  }
}

static void
_ncm_reparam_finalize (GObject *object)
{
  NcmReparam *reparam = NCM_REPARAM (object);
  guint i;

  for (i = 0; i < reparam->sparams->len; i++)
  {
    NcmSParam *sp_i = g_ptr_array_index (reparam->sparams, i);
    if (sp_i != NULL)
      ncm_sparam_free (sp_i);
  }

  g_clear_pointer (&reparam->sparams_name_id, g_hash_table_unref);
  g_clear_pointer (&reparam->sparams, g_ptr_array_unref);
  ncm_vector_clear (&reparam->new_params);

  /* Chain up : end */
  G_OBJECT_CLASS (ncm_reparam_parent_class)->finalize (object);
}

static void
ncm_reparam_class_init (NcmReparamClass *klass)
{
  GObjectClass* object_class = G_OBJECT_CLASS (klass);
  klass->old2new = NULL;
  klass->new2old = NULL;
  klass->jac     = NULL;

  object_class->set_property = &_ncm_reparam_set_property;
  object_class->get_property = &_ncm_reparam_get_property;
  object_class->constructed  = &_ncm_reparam_constructed;
  object_class->finalize     = &_ncm_reparam_finalize;

  g_object_class_install_property (object_class,
                                   PROP_LEN,
                                   g_param_spec_uint ("length",
                                                      NULL,
                                                      "System's length",
                                                      0, G_MAXUINT, 0,
                                                      G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  g_object_class_install_property (object_class,
                                   PROP_PARAMS_DESC,
                                   g_param_spec_variant ("params-desc",
                                                         NULL,
                                                         "News parameter descriptions",
                                                         G_VARIANT_TYPE (NCM_REPARAM_PARAMS_DESC_DICT_TYPE), NULL,
                                                         G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));
  g_object_class_install_property (object_class,
                                   PROP_COMPAT_TYPE,
                                   g_param_spec_string ("compat-type",
                                                        NULL,
                                                        "Compatible type",
                                                        g_type_name (NCM_TYPE_MODEL),
                                                        G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));
}

/**
 * ncm_reparam_ref:
 * @reparam: a #NcmReparam
 *
 * FIXME
 *
 * Returns: (transfer full): FIXME
 */
NcmReparam *
ncm_reparam_ref (NcmReparam *reparam)
{
  return NCM_REPARAM (g_object_ref (reparam));
}

/**
 * ncm_reparam_free:
 * @reparam: a #NcmReparam
 *
 * FIXME
 */
void
ncm_reparam_free (NcmReparam *reparam)
{
  g_object_unref (reparam);
}

/**
 * ncm_reparam_clear:
 * @reparam: a #NcmReparam
 *
 * FIXME
 */
void
ncm_reparam_clear (NcmReparam **reparam)
{
  g_clear_object (reparam);
}

/**
 * ncm_reparam_get_compat_type:
 * @reparam: a #NcmReparam
 *
 * FIXME
 *
 * Returns: the compatible #GType for this reparametrization.
 */
GType
ncm_reparam_get_compat_type (NcmReparam *reparam)
{
  return reparam->compat_type;
}

/**
 * ncm_reparam_old2new: (virtual old2new)
 * @reparam: a #NcmReparam
 * @model: a #NcmModel
 *
 * Using the values set in the original parametrization update the
 * values of the new parametrization.
 *
 */
void
ncm_reparam_old2new (NcmReparam *reparam, NcmModel *model)
{
  NCM_REPARAM_GET_CLASS (reparam)->old2new (reparam, model);
}

/**
 * ncm_reparam_new2old: (virtual new2old)
 * @reparam: a #NcmReparam
 * @model: a #NcmModel
 *
 * Using the values set in the new parametrization update the
 * values of the original parametrization.
 *
 */
void
ncm_reparam_new2old (NcmReparam *reparam, NcmModel *model)
{
  NCM_REPARAM_GET_CLASS (reparam)->new2old (reparam, model);
}

/**
 * ncm_reparam_jac: (virtual jac)
 * @reparam: a #NcmReparam
 * @model: a #NcmModel
 * @jac: a #NcmMatrix
 *
 * FIXME
 */
void
ncm_reparam_jac (NcmReparam *reparam, NcmModel *model, NcmMatrix *jac)
{
  NCM_REPARAM_GET_CLASS (reparam)->jac (reparam, model, jac);
}

/**
 * ncm_reparam_grad_old2new:
 * @reparam: a #NcmReparam
 * @model: FIXME
 * @jac: a #NcmMatrix
 * @old_grad: a #NcmVector
 * @new_grad: a #NcmVector
 *
 * FIXME
 */
void
ncm_reparam_grad_old2new (NcmReparam *reparam, struct _NcmModel *model, NcmMatrix *jac, NcmVector *old_grad, NcmVector *new_grad)
{
  gint ret;
  NCM_REPARAM_GET_CLASS (reparam)->jac (reparam, model, jac);
  ret = gsl_blas_dgemv (CblasTrans, 1.0, ncm_matrix_gsl (jac), ncm_vector_gsl (old_grad), 0.0, ncm_vector_gsl (new_grad));
  NCM_TEST_GSL_RESULT("ncm_reparam_grad_old2new", ret);
}

/**
 * ncm_reparam_M_old2new:
 * @reparam: a #NcmReparam
 * @model: FIXME
 * @jac: a #NcmMatrix
 * @old_M: a #NcmMatrix
 * @new_M: a #NcmMatrix
 *
 * FIXME
 */
void
ncm_reparam_M_old2new (NcmReparam *reparam, struct _NcmModel *model, NcmMatrix *jac, NcmMatrix *old_M, NcmMatrix *new_M)
{
  gint ret;
  NCM_REPARAM_GET_CLASS (reparam)->jac (reparam, model, jac);
  ret = gsl_blas_dgemm (CblasNoTrans, CblasNoTrans, 1.0, ncm_matrix_gsl (old_M), ncm_matrix_gsl (jac), 0.0, ncm_matrix_gsl (new_M));
  NCM_TEST_GSL_RESULT("ncm_reparam_jac_old2new", ret);
}

/**
 * ncm_reparam_get_params_desc_dict:
 * @reparam: a #NcmReparam.
 *
 * Returns a #GVariant containing a dictionary describing the new parameters.
 *
 * Returns: a #GVariant dictionary.
 */
GVariant *
ncm_reparam_get_params_desc_dict (NcmReparam *reparam)
{
  GVariantBuilder builder;
  guint i;

  g_variant_builder_init (&builder, G_VARIANT_TYPE (NCM_REPARAM_PARAMS_DESC_DICT_TYPE));

  for (i = 0; i < reparam->length; i++)
  {
    NcmSParam *sp_i = g_ptr_array_index (reparam->sparams, i);
    if (sp_i != NULL)
    {
      GVariant *i_var = g_variant_new_uint32 (i);
      GVariant *sp_var_i = ncm_serialize_global_to_variant (G_OBJECT (sp_i));
      GVariant *entry_i = g_variant_new_dict_entry (i_var, sp_var_i);
      g_variant_builder_add_value (&builder, entry_i);
      g_variant_unref (sp_var_i);
    }
  }

  return g_variant_ref_sink (g_variant_builder_end (&builder));
}

/**
 * ncm_reparam_set_params_desc_dict:
 * @reparam: a #NcmReparam.
 * @pdesc_dict: a #GVariant containing the new parameters descriptions.
 *
 * Sets the new parameters descriptions using the information from @pdesc_dict.
 *
 */
void
ncm_reparam_set_params_desc_dict (NcmReparam *reparam, GVariant *pdesc_dict)
{
  if (pdesc_dict != NULL)
  {
    g_assert (g_variant_is_of_type (pdesc_dict, G_VARIANT_TYPE (NCM_REPARAM_PARAMS_DESC_DICT_TYPE)));
    {
      gsize n = g_variant_n_children (pdesc_dict);
      guint i;
      for (i = 0; i < n; i++)
      {
        GVariant *sp_var = NULL;
        guint j;
        NcmSParam *sp = NULL;
        g_variant_get_child (pdesc_dict, i, "{u@"NCM_SERIALIZE_OBJECT_TYPE"}", &j, &sp_var);
        sp = NCM_SPARAM (ncm_serialize_global_from_variant (sp_var));
        ncm_reparam_set_param_desc (reparam, j, sp);
        ncm_sparam_free (sp);
        g_variant_unref (sp_var);
      }
    }
  }
}

/**
 * ncm_reparam_set_param_desc:
 * @reparam: a #NcmReparam
 * @i: index of the changed parameter.
 * @sp: #NcmSParam describing the new parameter.
 *
 * Change the @i-th parameter description using @sp.
 *
 */
void
ncm_reparam_set_param_desc (NcmReparam *reparam, guint i, NcmSParam *sp)
{
  NcmSParam **old_sp = (NcmSParam **) &g_ptr_array_index (reparam->sparams, i);
  g_assert (i < reparam->sparams->len);

  if (*old_sp != NULL)
  {
    g_assert (g_hash_table_remove (reparam->sparams_name_id, ncm_sparam_name (*old_sp)));
    ncm_sparam_clear (old_sp);
  }

  g_hash_table_insert (reparam->sparams_name_id,
                       g_strdup (ncm_sparam_name (sp)),
                       GUINT_TO_POINTER (i));

  g_ptr_array_index (reparam->sparams, i) = ncm_sparam_ref (sp);
}

/**
 * ncm_reparam_peek_param_desc:
 * @reparam: a #NcmReparam
 * @i: index of the changed parameter.
 *
 * Peeks the @i-th parameter description.
 *
 * Returns: (transfer none): The @i-th parameter description.
 */
NcmSParam *
ncm_reparam_peek_param_desc (NcmReparam *reparam, guint i)
{
  g_assert_cmpuint (i, <, reparam->sparams->len);
  return g_ptr_array_index (reparam->sparams, i);
}

/**
 * ncm_reparam_get_param_desc:
 * @reparam: a #NcmReparam
 * @i: index of the changed parameter.
 *
 * Gets the @i-th parameter description.
 *
 * Returns: (transfer full): The @i-th parameter description.
 */
NcmSParam *
ncm_reparam_get_param_desc (NcmReparam *reparam, guint i)
{
  g_assert (i < reparam->sparams->len);
  if (g_ptr_array_index (reparam->sparams, i) != NULL)
    return ncm_sparam_ref (g_ptr_array_index (reparam->sparams, i));
  else
    return NULL;
}

/**
 * ncm_reparam_set_param_desc_full:
 * @reparam: a #NcmReparam
 * @i: index of the changed parameter.
 * @name: #NcmSParam:name.
 * @symbol: #NcmSParam:symbol.
 * @lower_bound: value of #NcmSParam:lower-bound.
 * @upper_bound: value of #NcmSParam:upper-bound.
 * @scale: value of #NcmSParam:scale.
 * @abstol: value of #NcmSParam:absolute-tolerance.
 * @default_val: value of #NcmSParam:default-value.
 * @ftype: a #NcmParamType.
 *
 * FIXME
 *
 */
void
ncm_reparam_set_param_desc_full (NcmReparam *reparam, guint i, const gchar *name, const gchar *symbol, gdouble lower_bound, gdouble upper_bound, gdouble scale, gdouble abstol, gdouble default_val, NcmParamType ftype)
{
  NcmSParam *sp = ncm_sparam_new (name, symbol, lower_bound, upper_bound,
                                  scale, abstol, default_val, ftype);

  ncm_reparam_set_param_desc (reparam, i, sp);

  
  ncm_sparam_free (sp);
}

/**
 * ncm_reparam_index_from_name:
 * @reparam: a #NcmReparam.
 * @param_name: parameter name.
 * @i: (out): parameter index.
 *
 * Looks for a parameter named @param_name and returns TRUE if found. If found
 * puts at @i its index.
 *
 * Returns: whenever the parameter is found.
 */
gboolean
ncm_reparam_index_from_name (NcmReparam *reparam, const gchar *param_name, guint *i)
{
  gpointer param_id;
  gboolean found = g_hash_table_lookup_extended (reparam->sparams_name_id, param_name, NULL, &param_id);
  if (found)
    *i = GPOINTER_TO_UINT (param_id);
  else
    *i = -1; /* Yes, I known. */
  return found;
}

1	/***************************************************************************
2	* ncm_reparam.c
3	*
4	* Thu March 08 00:36:24 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	/**
26	* SECTION:ncm_reparam
27	* @title: NcmReparam
28	* @short_description: Abstract class for model reparametrization.
29	*
30	* FIXME
31	*/
32
33	#ifdef HAVE_CONFIG_H
34	# include "config.h"
35	#endif /* HAVE_CONFIG_H */
36	#include "build_cfg.h"
37
38	#include "math/ncm_reparam.h"
39	#include "math/ncm_model.h"
40	#include "math/ncm_cfg.h"
41
42	#ifndef NUMCOSMO_GIR_SCAN
43	#include <gsl/gsl_blas.h>
44	#endif /* NUMCOSMO_GIR_SCAN */
45
46	G_DEFINE_ABSTRACT_TYPE (NcmReparam, ncm_reparam, G_TYPE_OBJECT);	111!
47
48	enum
49	{
50	PROP_0,
51	PROP_LEN,
52	PROP_PARAMS_DESC,
53	PROP_COMPAT_TYPE,
54	};
55
56	static void
57	ncm_reparam_init (NcmReparam *reparam)	71✔
58	{
59	reparam->length = 0;	71✔
60	reparam->sparams = NULL;	71✔
61	reparam->new_params = NULL;	71✔
62	reparam->sparams_name_id = g_hash_table_new_full (&g_str_hash, &g_str_equal, &g_free, NULL);	71✔
63	reparam->compat_type = G_TYPE_INVALID;	71✔
64	}	71✔
65
66	static void
67	_ncm_reparam_get_property (GObject object, guint prop_id, GValue value, GParamSpec *pspec)	6✔
68	{
69	NcmReparam *reparam = NCM_REPARAM (object);	6✔
70
71	g_return_if_fail (NCM_IS_REPARAM (object));	6✔
72
73	switch (prop_id)	6!
74	{
75	case PROP_LEN:	2✔
76	g_value_set_uint (value, reparam->length);	2✔
77	break;	2✔
78	case PROP_PARAMS_DESC:	2✔
79	{
80	g_value_take_variant (value, ncm_reparam_get_params_desc_dict (reparam));	2✔
81	break;	2✔
82	}
83	case PROP_COMPAT_TYPE:	2✔
84	g_value_set_string (value, g_type_name (reparam->compat_type));	2✔
85	break;	2✔
86	default:	×
87	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
88	break;	×
89	}
90	}
91
92	static void
93	_ncm_reparam_set_property (GObject object, guint prop_id, const GValue value, GParamSpec *pspec)	144✔
94	{
95	NcmReparam *reparam = NCM_REPARAM (object);	144✔
96
97	g_return_if_fail (NCM_IS_REPARAM (object));	144✔
98
99	switch (prop_id)	144!
100	{
101	case PROP_LEN:	71✔
102	reparam->length = g_value_get_uint (value);	71✔
103	break;	71✔
104	case PROP_PARAMS_DESC:	2✔
105	ncm_reparam_set_params_desc_dict (reparam, g_value_get_variant (value));	2✔
106	break;	2✔
107	case PROP_COMPAT_TYPE:	71✔
108	reparam->compat_type = g_type_from_name (g_value_get_string (value));	71✔
109	if (reparam->compat_type == G_TYPE_INVALID)	71!
110	g_error ("_ncm_reparam_set_property: GType `%s' unregistered or invalid.", g_value_get_string (value));
111	break;	71✔
112	default:	×
113	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
114	break;	×
115	}
116	}
117
118	static void
119	_ncm_reparam_constructed (GObject *object)	71✔
120	{
121	/* Chain up : start */
122	G_OBJECT_CLASS (ncm_reparam_parent_class)->constructed (object);	71✔
123	{
124	NcmReparam *reparam = NCM_REPARAM (object);	71✔
125	g_assert_cmpuint (reparam->length, >, 0);	71✔
126
127	reparam->new_params = ncm_vector_new (reparam->length);	71✔
128
129	reparam->sparams = g_ptr_array_sized_new (reparam->length);	71✔
130
131	g_ptr_array_set_size (reparam->sparams, reparam->length);	71✔
132	}
133	}	71✔
134
135	static void
136	_ncm_reparam_finalize (GObject *object)	70✔
137	{
138	NcmReparam *reparam = NCM_REPARAM (object);	70✔
139	guint i;
140
141	for (i = 0; i < reparam->sparams->len; i++)	1,394✔
142	{
143	NcmSParam *sp_i = g_ptr_array_index (reparam->sparams, i);	1,324✔
144	if (sp_i != NULL)	1,324✔
145	ncm_sparam_free (sp_i);	138✔
146	}
147
148	g_clear_pointer (&reparam->sparams_name_id, g_hash_table_unref);	70✔
149	g_clear_pointer (&reparam->sparams, g_ptr_array_unref);	70✔
150	ncm_vector_clear (&reparam->new_params);	70✔
151
152	/* Chain up : end */
153	G_OBJECT_CLASS (ncm_reparam_parent_class)->finalize (object);	70✔
154	}	70✔
155
156	static void
157	ncm_reparam_class_init (NcmReparamClass *klass)	111✔
158	{
159	GObjectClass* object_class = G_OBJECT_CLASS (klass);	111✔
160	klass->old2new = NULL;	111✔
161	klass->new2old = NULL;	111✔
162	klass->jac = NULL;	111✔
163
164	object_class->set_property = &_ncm_reparam_set_property;	111✔
165	object_class->get_property = &_ncm_reparam_get_property;	111✔
166	object_class->constructed = &_ncm_reparam_constructed;	111✔
167	object_class->finalize = &_ncm_reparam_finalize;	111✔
168
169	g_object_class_install_property (object_class,	111✔
170	PROP_LEN,
171	g_param_spec_uint ("length",
172	NULL,
173	"System's length",
174	0, G_MAXUINT, 0,
175	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
176
177	g_object_class_install_property (object_class,	111✔
178	PROP_PARAMS_DESC,
179	g_param_spec_variant ("params-desc",
180	NULL,
181	"News parameter descriptions",
182	G_VARIANT_TYPE (NCM_REPARAM_PARAMS_DESC_DICT_TYPE), NULL,
183	G_PARAM_READWRITE \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
184	g_object_class_install_property (object_class,	111✔
185	PROP_COMPAT_TYPE,
186	g_param_spec_string ("compat-type",
187	NULL,
188	"Compatible type",
189	g_type_name (NCM_TYPE_MODEL),
190	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT_ONLY \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
191	}	111✔
192
193	/**
194	* ncm_reparam_ref:
195	* @reparam: a #NcmReparam
196	*
197	* FIXME
198	*
199	* Returns: (transfer full): FIXME
200	*/
201	NcmReparam *
202	ncm_reparam_ref (NcmReparam *reparam)	71✔
203	{
204	return NCM_REPARAM (g_object_ref (reparam));	71✔
205	}
206
207	/**
208	* ncm_reparam_free:
209	* @reparam: a #NcmReparam
210	*
211	* FIXME
212	*/
213	void
214	ncm_reparam_free (NcmReparam *reparam)	68✔
215	{
216	g_object_unref (reparam);	68✔
217	}	68✔
218
219	/**
220	* ncm_reparam_clear:
221	* @reparam: a #NcmReparam
222	*
223	* FIXME
224	*/
225	void
226	ncm_reparam_clear (NcmReparam **reparam)	1,382✔
227	{
228	g_clear_object (reparam);	1,382✔
229	}	1,382✔
230
231	/**
232	* ncm_reparam_get_compat_type:
233	* @reparam: a #NcmReparam
234	*
235	* FIXME
236	*
237	* Returns: the compatible #GType for this reparametrization.
238	*/
239	GType
240	ncm_reparam_get_compat_type (NcmReparam *reparam)	71✔
241	{
242	return reparam->compat_type;	71✔
243	}
244
245	/**
246	* ncm_reparam_old2new: (virtual old2new)
247	* @reparam: a #NcmReparam
248	* @model: a #NcmModel
249	*
250	* Using the values set in the original parametrization update the
251	* values of the new parametrization.
252	*
253	*/
254	void
255	ncm_reparam_old2new (NcmReparam reparam, NcmModel model)	128✔
256	{
257	NCM_REPARAM_GET_CLASS (reparam)->old2new (reparam, model);	128✔
258	}	128✔
259
260	/**
261	* ncm_reparam_new2old: (virtual new2old)
262	* @reparam: a #NcmReparam
263	* @model: a #NcmModel
264	*
265	* Using the values set in the new parametrization update the
266	* values of the original parametrization.
267	*
268	*/
269	void
270	ncm_reparam_new2old (NcmReparam reparam, NcmModel model)	494✔
271	{
272	NCM_REPARAM_GET_CLASS (reparam)->new2old (reparam, model);	494✔
273	}	494✔
274
275	/**
276	* ncm_reparam_jac: (virtual jac)
277	* @reparam: a #NcmReparam
278	* @model: a #NcmModel
279	* @jac: a #NcmMatrix
280	*
281	* FIXME
282	*/
283	void
284	ncm_reparam_jac (NcmReparam reparam, NcmModel model, NcmMatrix *jac)	×
285	{
286	NCM_REPARAM_GET_CLASS (reparam)->jac (reparam, model, jac);	×
287	}	×
288
289	/**
290	* ncm_reparam_grad_old2new:
291	* @reparam: a #NcmReparam
292	* @model: FIXME
293	* @jac: a #NcmMatrix
294	* @old_grad: a #NcmVector
295	* @new_grad: a #NcmVector
296	*
297	* FIXME
298	*/
299	void
300	ncm_reparam_grad_old2new (NcmReparam reparam, struct _NcmModel model, NcmMatrix jac, NcmVector old_grad, NcmVector *new_grad)	×
301	{
302	gint ret;
303	NCM_REPARAM_GET_CLASS (reparam)->jac (reparam, model, jac);	×
304	ret = gsl_blas_dgemv (CblasTrans, 1.0, ncm_matrix_gsl (jac), ncm_vector_gsl (old_grad), 0.0, ncm_vector_gsl (new_grad));	×
305	NCM_TEST_GSL_RESULT("ncm_reparam_grad_old2new", ret);	×
306	}	×
307
308	/**
309	* ncm_reparam_M_old2new:
310	* @reparam: a #NcmReparam
311	* @model: FIXME
312	* @jac: a #NcmMatrix
313	* @old_M: a #NcmMatrix
314	* @new_M: a #NcmMatrix
315	*
316	* FIXME
317	*/
318	void
319	ncm_reparam_M_old2new (NcmReparam reparam, struct _NcmModel model, NcmMatrix jac, NcmMatrix old_M, NcmMatrix *new_M)	×
320	{
321	gint ret;
322	NCM_REPARAM_GET_CLASS (reparam)->jac (reparam, model, jac);	×
323	ret = gsl_blas_dgemm (CblasNoTrans, CblasNoTrans, 1.0, ncm_matrix_gsl (old_M), ncm_matrix_gsl (jac), 0.0, ncm_matrix_gsl (new_M));	×
324	NCM_TEST_GSL_RESULT("ncm_reparam_jac_old2new", ret);	×
325	}	×
326
327	/**
328	* ncm_reparam_get_params_desc_dict:
329	* @reparam: a #NcmReparam.
330	*
331	* Returns a #GVariant containing a dictionary describing the new parameters.
332	*
333	* Returns: a #GVariant dictionary.
334	*/
335	GVariant *
336	ncm_reparam_get_params_desc_dict (NcmReparam *reparam)	2✔
337	{
338	GVariantBuilder builder;
339	guint i;
340
341	g_variant_builder_init (&builder, G_VARIANT_TYPE (NCM_REPARAM_PARAMS_DESC_DICT_TYPE));	2✔
342
343	for (i = 0; i < reparam->length; i++)	146✔
344	{
345	NcmSParam *sp_i = g_ptr_array_index (reparam->sparams, i);	144✔
346	if (sp_i != NULL)	144✔
347	{
348	GVariant *i_var = g_variant_new_uint32 (i);	14✔
349	GVariant *sp_var_i = ncm_serialize_global_to_variant (G_OBJECT (sp_i));	14✔
350	GVariant *entry_i = g_variant_new_dict_entry (i_var, sp_var_i);	14✔
351	g_variant_builder_add_value (&builder, entry_i);	14✔
352	g_variant_unref (sp_var_i);	14✔
353	}
354	}
355
356	return g_variant_ref_sink (g_variant_builder_end (&builder));	2✔
357	}
358
359	/**
360	* ncm_reparam_set_params_desc_dict:
361	* @reparam: a #NcmReparam.
362	* @pdesc_dict: a #GVariant containing the new parameters descriptions.
363	*
364	* Sets the new parameters descriptions using the information from @pdesc_dict.
365	*
366	*/
367	void
368	ncm_reparam_set_params_desc_dict (NcmReparam reparam, GVariant pdesc_dict)	2✔
369	{
370	if (pdesc_dict != NULL)	2!
371	{
372	g_assert (g_variant_is_of_type (pdesc_dict, G_VARIANT_TYPE (NCM_REPARAM_PARAMS_DESC_DICT_TYPE)));	2✔
373	{
374	gsize n = g_variant_n_children (pdesc_dict);	2✔
375	guint i;
376	for (i = 0; i < n; i++)	16✔
377	{
378	GVariant *sp_var = NULL;	14✔
379	guint j;
380	NcmSParam *sp = NULL;	14✔
381	g_variant_get_child (pdesc_dict, i, "{u@"NCM_SERIALIZE_OBJECT_TYPE"}", &j, &sp_var);	14✔
382	sp = NCM_SPARAM (ncm_serialize_global_from_variant (sp_var));	14✔
383	ncm_reparam_set_param_desc (reparam, j, sp);	14✔
384	ncm_sparam_free (sp);	14✔
385	g_variant_unref (sp_var);	14✔
386	}
387	}
388	}
389	}	2✔
390
391	/**
392	* ncm_reparam_set_param_desc:
393	* @reparam: a #NcmReparam
394	* @i: index of the changed parameter.
395	* @sp: #NcmSParam describing the new parameter.
396	*
397	* Change the @i-th parameter description using @sp.
398	*
399	*/
400	void
401	ncm_reparam_set_param_desc (NcmReparam reparam, guint i, NcmSParam sp)	145✔
402	{
403	NcmSParam old_sp = (NcmSParam ) &g_ptr_array_index (reparam->sparams, i);	145✔
404	g_assert (i < reparam->sparams->len);	145✔
405
406	if (*old_sp != NULL)	145!
407	{
UNCOV 408	g_assert (g_hash_table_remove (reparam->sparams_name_id, ncm_sparam_name (*old_sp)));	×
UNCOV 409	ncm_sparam_clear (old_sp);	×
410	}
411
412	g_hash_table_insert (reparam->sparams_name_id,	145✔
413	g_strdup (ncm_sparam_name (sp)),	145✔
414	GUINT_TO_POINTER (i));	145✔
415
416	g_ptr_array_index (reparam->sparams, i) = ncm_sparam_ref (sp);	145✔
417	}	145✔
418
419	/**
420	* ncm_reparam_peek_param_desc:
421	* @reparam: a #NcmReparam
422	* @i: index of the changed parameter.
423	*
424	* Peeks the @i-th parameter description.
425	*
426	* Returns: (transfer none): The @i-th parameter description.
427	*/
428	NcmSParam *
429	ncm_reparam_peek_param_desc (NcmReparam *reparam, guint i)	1,152✔
430	{
431	g_assert_cmpuint (i, <, reparam->sparams->len);	1,152✔
432	return g_ptr_array_index (reparam->sparams, i);	1,152✔
433	}
434
435	/**
436	* ncm_reparam_get_param_desc:
437	* @reparam: a #NcmReparam
438	* @i: index of the changed parameter.
439	*
440	* Gets the @i-th parameter description.
441	*
442	* Returns: (transfer full): The @i-th parameter description.
443	*/
444	NcmSParam *
445	ncm_reparam_get_param_desc (NcmReparam *reparam, guint i)	×
446	{
447	g_assert (i < reparam->sparams->len);	×
448	if (g_ptr_array_index (reparam->sparams, i) != NULL)	×
449	return ncm_sparam_ref (g_ptr_array_index (reparam->sparams, i));	×
450	else
451	return NULL;	×
452	}
453
454	/**
455	* ncm_reparam_set_param_desc_full:
456	* @reparam: a #NcmReparam
457	* @i: index of the changed parameter.
458	* @name: #NcmSParam:name.
459	* @symbol: #NcmSParam:symbol.
460	* @lower_bound: value of #NcmSParam:lower-bound.
461	* @upper_bound: value of #NcmSParam:upper-bound.
462	* @scale: value of #NcmSParam:scale.
463	* @abstol: value of #NcmSParam:absolute-tolerance.
464	* @default_val: value of #NcmSParam:default-value.
465	* @ftype: a #NcmParamType.
466	*
467	* FIXME
468	*
469	*/
470	void
471	ncm_reparam_set_param_desc_full (NcmReparam reparam, guint i, const gchar name, const gchar *symbol, gdouble lower_bound, gdouble upper_bound, gdouble scale, gdouble abstol, gdouble default_val, NcmParamType ftype)	131✔
472	{
473	NcmSParam *sp = ncm_sparam_new (name, symbol, lower_bound, upper_bound,	131✔
474	scale, abstol, default_val, ftype);
475
476	ncm_reparam_set_param_desc (reparam, i, sp);	131✔
477
478
479	ncm_sparam_free (sp);	131✔
480	}	131✔
481
482	/**
483	* ncm_reparam_index_from_name:
484	* @reparam: a #NcmReparam.
485	* @param_name: parameter name.
486	* @i: (out): parameter index.
487	*
488	* Looks for a parameter named @param_name and returns TRUE if found. If found
489	* puts at @i its index.
490	*
491	* Returns: whenever the parameter is found.
492	*/
493	gboolean
494	ncm_reparam_index_from_name (NcmReparam reparam, const gchar param_name, guint *i)	29✔
495	{
496	gpointer param_id;
497	gboolean found = g_hash_table_lookup_extended (reparam->sparams_name_id, param_name, NULL, &param_id);	29✔
498	if (found)	29!
499	*i = GPOINTER_TO_UINT (param_id);	29✔
500	else
501	i = -1; / Yes, I known. */	×
502	return found;	29✔
503	}

NumCosmo / NumCosmo / 6840481691

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