6829146633

Committed 10 Nov 2023 08:05PM UTC coverage: 53.304% (-0.2%) from 53.454%

Build # 6829146633

Build Type

Pull #117

github

Committed by

web-flow

Commit Message

Merge 270eed4d8 into 7269172d1

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

Run Details

8770 of 20823 branches covered (0.0%)

Branch coverage included in aggregate %.

67 of 349 new or added lines in 6 files covered. (19.2%)

29 existing lines in 5 files now uncovered.

44672 of 79436 relevant lines covered (56.24%)

2675935.45 hits per line

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

38.59

/numcosmo/math/ncm_data_gauss_diag.c

/***************************************************************************
 *            ncm_data_gauss_diag.c
 *
 *  Fri Mar 19 14:57:35 2010
 *  Copyright  2010  Sandro Dias Pinto Vitenti
 *  <vitenti@uel.br>
 ****************************************************************************/
/*
 * numcosmo
 * Copyright (C) 2012 Sandro Dias Pinto Vitenti <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_data_gauss_diag
 * @title: NcmDataGaussDiag
 * @short_description: Gaussian data -- diagonal covariance provided.
 *
 * Gaussian distribution which uses a diagonal covariance matrix as input.
 *
 */

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

#include "math/ncm_data_gauss_diag.h"
#include "math/ncm_cfg.h"
#include "math/ncm_c.h"

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

enum
{
  PROP_0,
  PROP_NPOINTS,
  PROP_WMEAN,
  PROP_MEAN,
  PROP_SIGMA,
  PROP_SIZE,
};

typedef struct _NcmDataGaussDiagPrivate
{
  guint np;
  NcmVector *y;
  NcmVector *v;
  NcmVector *sigma;
  NcmVector *weight;
  gdouble wt;
  gboolean prepared_w;
  gboolean wmean;
} NcmDataGaussDiagPrivate;

G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (NcmDataGaussDiag, ncm_data_gauss_diag, NCM_TYPE_DATA);

static void
ncm_data_gauss_diag_init (NcmDataGaussDiag *diag)
{
  NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);

  self->np         = 0;
  self->y          = NULL;
  self->v          = NULL;
  self->sigma      = NULL;
  self->weight     = NULL;
  self->wt         = 0.0;
  self->prepared_w = FALSE;
  self->wmean      = FALSE;
}

static void
_ncm_data_gauss_diag_constructed (GObject *object)
{
  /* Chain up : start */
  G_OBJECT_CLASS (ncm_data_gauss_diag_parent_class)->constructed (object);
}

static void
ncm_data_gauss_diag_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
  NcmDataGaussDiag *diag               = NCM_DATA_GAUSS_DIAG (object);
  NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);

  g_return_if_fail (NCM_IS_DATA_GAUSS_DIAG (object));

  switch (prop_id)
  {
    case PROP_NPOINTS:
      ncm_data_gauss_diag_set_size (diag, g_value_get_uint (value));
      break;
    case PROP_WMEAN:
      self->wmean = g_value_get_boolean (value);
      break;
    case PROP_MEAN:
      ncm_vector_substitute (&self->y, g_value_get_object (value), TRUE);
      break;
    case PROP_SIGMA:
      ncm_vector_substitute (&self->sigma, g_value_get_object (value), TRUE);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
ncm_data_gauss_diag_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
  NcmDataGaussDiag *diag               = NCM_DATA_GAUSS_DIAG (object);
  NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);

  g_return_if_fail (NCM_IS_DATA_GAUSS_DIAG (object));

  switch (prop_id)
  {
    case PROP_NPOINTS:
      g_value_set_uint (value, ncm_data_gauss_diag_get_size (diag));
      break;
    case PROP_WMEAN:
      g_value_set_boolean (value, self->wmean);
      break;
    case PROP_MEAN:
      g_value_set_object (value, self->y);
      break;
    case PROP_SIGMA:
      g_value_set_object (value, self->sigma);
      break;
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
      break;
  }
}

static void
ncm_data_gauss_diag_dispose (GObject *object)
{
  NcmDataGaussDiag *diag               = NCM_DATA_GAUSS_DIAG (object);
  NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);

  ncm_vector_clear (&self->y);
  ncm_vector_clear (&self->v);
  ncm_vector_clear (&self->sigma);
  ncm_vector_clear (&self->weight);

  /* Chain up : end */
  G_OBJECT_CLASS (ncm_data_gauss_diag_parent_class)->dispose (object);
}

static void
ncm_data_gauss_diag_finalize (GObject *object)
{
  /* Chain up : end */
  G_OBJECT_CLASS (ncm_data_gauss_diag_parent_class)->finalize (object);
}

static guint _ncm_data_gauss_diag_get_length (NcmData *data);
static guint _ncm_data_gauss_diag_get_dof (NcmData *data);

/* static void _ncm_data_gauss_diag_begin (NcmData *data); */
static void _ncm_data_gauss_diag_resample (NcmData *data, NcmMSet *mset, NcmRNG *rng);
static void _ncm_data_gauss_diag_m2lnL_val (NcmData *data, NcmMSet *mset, gdouble *m2lnL);
static void _ncm_data_gauss_diag_leastsquares_f (NcmData *data, NcmMSet *mset, NcmVector *v);
static void _ncm_data_gauss_diag_mean_vector (NcmData *data, NcmMSet *mset, NcmVector *mu);
static void _ncm_data_gauss_diag_inv_cov_UH (NcmData *data, NcmMSet *mset, NcmMatrix *H);

static void _ncm_data_gauss_diag_set_size (NcmDataGaussDiag *diag, guint np);
static guint _ncm_data_gauss_diag_get_size (NcmDataGaussDiag *diag);

static void
ncm_data_gauss_diag_class_init (NcmDataGaussDiagClass *klass)
{
  GObjectClass *object_class              = G_OBJECT_CLASS (klass);
  NcmDataClass *data_class                = NCM_DATA_CLASS (klass);
  NcmDataGaussDiagClass *gauss_diag_class = NCM_DATA_GAUSS_DIAG_CLASS (klass);

  object_class->constructed  = &_ncm_data_gauss_diag_constructed;
  object_class->set_property = &ncm_data_gauss_diag_set_property;
  object_class->get_property = &ncm_data_gauss_diag_get_property;
  object_class->dispose      = &ncm_data_gauss_diag_dispose;
  object_class->finalize     = &ncm_data_gauss_diag_finalize;

  g_object_class_install_property (object_class,
                                   PROP_NPOINTS,
                                   g_param_spec_uint ("n-points",
                                                      NULL,
                                                      "Data sample size",
                                                      0, G_MAXUINT, 0,
                                                      G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  g_object_class_install_property (object_class,
                                   PROP_WMEAN,
                                   g_param_spec_boolean ("w-mean",
                                                         NULL,
                                                         "Whether to minimize analytically over the weighted mean",
                                                         FALSE,
                                                         G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  g_object_class_install_property (object_class,
                                   PROP_MEAN,
                                   g_param_spec_object ("mean",
                                                        NULL,
                                                        "Data mean",
                                                        NCM_TYPE_VECTOR,
                                                        G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  g_object_class_install_property (object_class,
                                   PROP_SIGMA,
                                   g_param_spec_object ("sigma",
                                                        NULL,
                                                        "Data standard deviation",
                                                        NCM_TYPE_VECTOR,
                                                        G_PARAM_READWRITE | G_PARAM_STATIC_NAME | G_PARAM_STATIC_BLURB));

  data_class->bootstrap      = TRUE;
  data_class->get_length     = &_ncm_data_gauss_diag_get_length;
  data_class->get_dof        = &_ncm_data_gauss_diag_get_dof;
  data_class->resample       = &_ncm_data_gauss_diag_resample;
  data_class->m2lnL_val      = &_ncm_data_gauss_diag_m2lnL_val;
  data_class->leastsquares_f = &_ncm_data_gauss_diag_leastsquares_f;
  data_class->mean_vector    = &_ncm_data_gauss_diag_mean_vector;
  data_class->inv_cov_UH     = &_ncm_data_gauss_diag_inv_cov_UH;

  gauss_diag_class->mean_func  = NULL;
  gauss_diag_class->sigma_func = NULL;
  gauss_diag_class->set_size   = &_ncm_data_gauss_diag_set_size;
  gauss_diag_class->get_size   = &_ncm_data_gauss_diag_get_size;
}

static guint
_ncm_data_gauss_diag_get_length (NcmData *data)
{
  NcmDataGaussDiag *diag               = NCM_DATA_GAUSS_DIAG (data);
  NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);

  return self->np;
}

static guint
_ncm_data_gauss_diag_get_dof (NcmData *data)
{
  NcmDataGaussDiag *diag               = NCM_DATA_GAUSS_DIAG (data);
  NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);
  guint dof                            = self->np;

  if (self->wmean && (dof > 0))
    dof--;

  return dof;
}

static void
_ncm_data_gauss_prepare_weight (NcmData *data)
{
  NcmDataGaussDiag *diag               = NCM_DATA_GAUSS_DIAG (data);
  NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);
  guint i;

  if (self->weight == NULL)
    self->weight = ncm_vector_new (self->np);

  self->wt = 0.0;

  for (i = 0; i < self->np; i++)
  {
    const gdouble sigma_i = ncm_vector_get (self->sigma, i);
    const gdouble w_i     = 1.0 / (sigma_i * sigma_i);

    ncm_vector_set (self->weight, i, w_i);
    self->wt += w_i;
  }

  self->prepared_w = TRUE;
}

static void
_ncm_data_gauss_diag_resample (NcmData *data, NcmMSet *mset, NcmRNG *rng)
{
  NcmDataGaussDiag *diag                  = NCM_DATA_GAUSS_DIAG (data);
  NcmDataGaussDiagPrivate * const self    = ncm_data_gauss_diag_get_instance_private (diag);
  NcmDataGaussDiagClass *gauss_diag_class = NCM_DATA_GAUSS_DIAG_GET_CLASS (diag);
  gdouble has_sigma_func                  = (gauss_diag_class->sigma_func != NULL);
  guint i;

  if (has_sigma_func)
    gauss_diag_class->sigma_func (diag, mset, self->sigma);

  gauss_diag_class->mean_func (diag, mset, self->y);

  ncm_rng_lock (rng);

  for (i = 0; i < self->np; i++)
  {
    const gdouble sigma_i = ncm_vector_get (self->sigma, i);
    const gdouble u_i     = gsl_ran_gaussian_ziggurat (rng->r, sigma_i);

    ncm_vector_subfrom (self->y, i, u_i);
  }

  ncm_rng_unlock (rng);
}

static void
_ncm_data_gauss_diag_m2lnL_val (NcmData *data, NcmMSet *mset, gdouble *m2lnL)
{
  NcmDataGaussDiag *diag                  = NCM_DATA_GAUSS_DIAG (data);
  NcmDataGaussDiagPrivate * const self    = ncm_data_gauss_diag_get_instance_private (diag);
  NcmDataGaussDiagClass *gauss_diag_class = NCM_DATA_GAUSS_DIAG_GET_CLASS (diag);
  gdouble has_sigma_func                  = (gauss_diag_class->sigma_func != NULL);
  gboolean sigma_update                   = FALSE;
  guint i;

  *m2lnL = 0.0;

  if (has_sigma_func)
    sigma_update = gauss_diag_class->sigma_func (diag, mset, self->sigma);

  gauss_diag_class->mean_func (diag, mset, self->v);

  if (self->wmean)
  {
    if (sigma_update || !self->prepared_w)
      _ncm_data_gauss_prepare_weight (data);

    if (!ncm_data_bootstrap_enabled (data))
    {
      gdouble tmp = 0.0;

      for (i = 0; i < self->np; i++)
      {
        const gdouble y_i  = ncm_vector_get (self->y, i);
        const gdouble yt_i = ncm_vector_get (self->v, i);
        const gdouble r_i  = (yt_i - y_i);
        const gdouble w_i  = ncm_vector_get (self->weight, i);
        const gdouble r_i2 = r_i * r_i;

        *m2lnL += r_i2 * w_i - log (w_i);
        tmp    += r_i * w_i;
      }

      *m2lnL -= tmp * tmp / self->wt;
      *m2lnL += self->np * ncm_c_ln2pi ();
    }
    else
    {
      NcmBootstrap *bstrap = ncm_data_peek_bootstrap (data);
      const guint bsize    = ncm_bootstrap_get_bsize (bstrap);
      gdouble tmp          = 0.0;
      gdouble wt           = 0.0;

      for (i = 0; i < bsize; i++)
      {
        guint k            = ncm_bootstrap_get (bstrap, i);
        const gdouble y_k  = ncm_vector_get (self->y, k);
        const gdouble yt_k = ncm_vector_get (self->v, k);
        const gdouble r_k  = (yt_k - y_k);
        const gdouble w_k  = ncm_vector_get (self->weight, k);
        const gdouble r_k2 = r_k * r_k;

        *m2lnL += r_k2 * w_k + log (w_k);
        tmp    += r_k * w_k;
        wt     += w_k;
      }

      *m2lnL -= tmp * tmp / wt;
      *m2lnL += self->np * ncm_c_ln2pi ();
    }
  }
  else
  {
    if (!ncm_data_bootstrap_enabled (data))
    {
      for (i = 0; i < self->np; i++)
      {
        const gdouble y_i     = ncm_vector_get (self->y, i);
        const gdouble yt_i    = ncm_vector_get (self->v, i);
        const gdouble sigma_i = ncm_vector_get (self->sigma, i);
        const gdouble r_i     = (yt_i - y_i) / sigma_i;

        *m2lnL += r_i * r_i + 2.0 * log (sigma_i);
      }

      *m2lnL += self->np * ncm_c_ln2pi ();
    }
    else
    {
      NcmBootstrap *bstrap = ncm_data_peek_bootstrap (data);
      const guint bsize    = ncm_bootstrap_get_bsize (bstrap);

      for (i = 0; i < bsize; i++)
      {
        guint k               = ncm_bootstrap_get (bstrap, i);
        const gdouble y_k     = ncm_vector_get (self->y, k);
        const gdouble yt_k    = ncm_vector_get (self->v, k);
        const gdouble sigma_k = ncm_vector_get (self->sigma, k);
        const gdouble r_k     = (yt_k - y_k) / sigma_k;

        *m2lnL += r_k * r_k + 2.0 * log (sigma_k);
      }

      *m2lnL += self->np * ncm_c_ln2pi ();
    }
  }
}

static void
_ncm_data_gauss_diag_leastsquares_f (NcmData *data, NcmMSet *mset, NcmVector *v)
{
  NcmDataGaussDiag *diag                  = NCM_DATA_GAUSS_DIAG (data);
  NcmDataGaussDiagPrivate * const self    = ncm_data_gauss_diag_get_instance_private (diag);
  NcmDataGaussDiagClass *gauss_diag_class = NCM_DATA_GAUSS_DIAG_GET_CLASS (diag);
  gdouble has_sigma_func                  = (gauss_diag_class->sigma_func != NULL);
  gboolean sigma_update                   = FALSE;
  guint i;

  if (ncm_data_bootstrap_enabled (data))
    g_error ("NcmDataGaussDiag: does not support bootstrap with least squares");

  if (has_sigma_func)
    sigma_update = gauss_diag_class->sigma_func (diag, mset, self->sigma);

  gauss_diag_class->mean_func (diag, mset, v);

  if (self->wmean)
  {
    gdouble wmean;

    if (sigma_update || !self->prepared_w)
      _ncm_data_gauss_prepare_weight (data);

    ncm_vector_sub (v, self->y);

    wmean = gsl_stats_wmean (ncm_vector_gsl (self->weight)->data,
                             ncm_vector_gsl (self->weight)->stride,
                             ncm_vector_gsl (v)->data,
                             ncm_vector_gsl (v)->stride,
                             ncm_vector_gsl (v)->size);

    for (i = 0; i < self->np; i++)
    {
      const gdouble sigma_i = ncm_vector_get (self->sigma, i);
      const gdouble v_i     = ncm_vector_get (v, i);

      ncm_vector_set (v, i, (v_i - wmean) / sigma_i);
    }
  }
  else
  {
    for (i = 0; i < self->np; i++)
    {
      const gdouble y_i     = ncm_vector_get (self->y, i);
      const gdouble yt_i    = ncm_vector_get (v, i);
      const gdouble sigma_i = ncm_vector_get (self->sigma, i);
      const gdouble r_i     = (yt_i - y_i) / sigma_i;

      ncm_vector_set (v, i, r_i);
    }
  }
}

static void
_ncm_data_gauss_diag_mean_vector (NcmData *data, NcmMSet *mset, NcmVector *mu)
{
  NcmDataGaussDiag *diag                  = NCM_DATA_GAUSS_DIAG (data);
  NcmDataGaussDiagClass *gauss_diag_class = NCM_DATA_GAUSS_DIAG_GET_CLASS (diag);

  gauss_diag_class->mean_func (diag, mset, mu);
}

static void
_ncm_data_gauss_diag_inv_cov_UH (NcmData *data, NcmMSet *mset, NcmMatrix *H)
{
  NcmDataGaussDiag *diag                  = NCM_DATA_GAUSS_DIAG (data);
  NcmDataGaussDiagPrivate * const self    = ncm_data_gauss_diag_get_instance_private (diag);
  NcmDataGaussDiagClass *gauss_diag_class = NCM_DATA_GAUSS_DIAG_GET_CLASS (diag);
  guint i;

  if (ncm_data_bootstrap_enabled (data))
    g_error ("NcmDataGaussDiag: does not support bootstrap with least squares");

  if (gauss_diag_class->sigma_func != NULL)
    gauss_diag_class->sigma_func (diag, mset, self->sigma);

  for (i = 0; i < self->np; i++)
  {
    const gdouble sigma_i = ncm_vector_get (self->sigma, i);

    ncm_matrix_mul_col (H, i, 1.0 / sigma_i);
  }
}

static void
_ncm_data_gauss_diag_set_size (NcmDataGaussDiag *diag, guint np)
{
  NcmData *data                        = NCM_DATA (diag);
  NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);

  if ((np == 0) || (np != self->np))
  {
    self->np = 0;
    ncm_vector_clear (&self->y);
    ncm_vector_clear (&self->v);
    ncm_vector_clear (&self->sigma);
    ncm_vector_clear (&self->weight);

    ncm_data_set_init (data, FALSE);
  }

  if ((np != 0) && (np != self->np))
  {
    NcmBootstrap *bstrap = ncm_data_peek_bootstrap (data);

    self->np    = np;
    self->y     = ncm_vector_new (self->np);
    self->v     = ncm_vector_new (self->np);
    self->sigma = ncm_vector_new (self->np);

    if (ncm_data_bootstrap_enabled (data))
    {
      ncm_bootstrap_set_fsize (bstrap, np);
      ncm_bootstrap_set_bsize (bstrap, np);
    }

    ncm_data_set_init (data, FALSE);
  }
}

static guint
_ncm_data_gauss_diag_get_size (NcmDataGaussDiag *diag)
{
  NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);

  return self->np;
}

/**
 * ncm_data_gauss_diag_set_size: (virtual set_size)
 * @diag: a #NcmDataGaussDiag
 * @np: data size.
 *
 * Sets the data size to @np.
 *
 */
void
ncm_data_gauss_diag_set_size (NcmDataGaussDiag *diag, guint np)
{
  NCM_DATA_GAUSS_DIAG_GET_CLASS (diag)->set_size (diag, np);
}

/**
 * ncm_data_gauss_diag_get_size: (virtual get_size)
 * @diag: a #NcmDataGaussDiag
 *
 * Gets the data size.
 *
 * Returns: Data size.
 *
 */
guint
ncm_data_gauss_diag_get_size (NcmDataGaussDiag *diag)
{
  return NCM_DATA_GAUSS_DIAG_GET_CLASS (diag)->get_size (diag);
}

/**
 * ncm_data_gauss_diag_peek_mean:
 * @diag: a #NcmDataGaussDiag
 *
 * Returns: (transfer none): the current data mean #NcmVector.
 */
NcmVector *
ncm_data_gauss_diag_peek_mean (NcmDataGaussDiag *diag)
{
  NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);

  return self->y;
}

/**
 * ncm_data_gauss_diag_peek_std:
 * @diag: a #NcmDataGaussDiag
 *
 * Returns: (transfer none): the current data standard deviation #NcmVector.
 */
NcmVector *
ncm_data_gauss_diag_peek_std (NcmDataGaussDiag *diag)
{
  NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);

  return self->sigma;
}


1	/***************************************************************************
2	* ncm_data_gauss_diag.c
3	*
4	* Fri Mar 19 14:57:35 2010
5	* Copyright 2010 Sandro Dias Pinto Vitenti
6	* <vitenti@uel.br>
7	****************************************************************************/
8	/*
9	* numcosmo
10	* Copyright (C) 2012 Sandro Dias Pinto Vitenti <vitenti@uel.br>
11	*
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	/**
27	* SECTION:ncm_data_gauss_diag
28	* @title: NcmDataGaussDiag
29	* @short_description: Gaussian data -- diagonal covariance provided.
30	*
31	* Gaussian distribution which uses a diagonal covariance matrix as input.
32	*
33	*/
34
35	#ifdef HAVE_CONFIG_H
36	# include "config.h"
37	#endif /* HAVE_CONFIG_H */
38	#include "build_cfg.h"
39
40	#include "math/ncm_data_gauss_diag.h"
41	#include "math/ncm_cfg.h"
42	#include "math/ncm_c.h"
43
44	#ifndef NUMCOSMO_GIR_SCAN
45	#include <gsl/gsl_linalg.h>
46	#include <gsl/gsl_blas.h>
47	#include <gsl/gsl_randist.h>
48	#include <gsl/gsl_statistics_double.h>
49	#endif /* NUMCOSMO_GIR_SCAN */
50
51	enum
52	{
53	PROP_0,
54	PROP_NPOINTS,
55	PROP_WMEAN,
56	PROP_MEAN,
57	PROP_SIGMA,
58	PROP_SIZE,
59	};
60
61	typedef struct _NcmDataGaussDiagPrivate
62	{
63	guint np;
64	NcmVector *y;
65	NcmVector *v;
66	NcmVector *sigma;
67	NcmVector *weight;
68	gdouble wt;
69	gboolean prepared_w;
70	gboolean wmean;
71	} NcmDataGaussDiagPrivate;
72
73	G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (NcmDataGaussDiag, ncm_data_gauss_diag, NCM_TYPE_DATA);	111!
74
75	static void
76	ncm_data_gauss_diag_init (NcmDataGaussDiag *diag)	5✔
77	{
78	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	5✔
79
80	self->np = 0;	5✔
81	self->y = NULL;	5✔
82	self->v = NULL;	5✔
83	self->sigma = NULL;	5✔
84	self->weight = NULL;	5✔
85	self->wt = 0.0;	5✔
86	self->prepared_w = FALSE;	5✔
87	self->wmean = FALSE;	5✔
88	}	5✔
89
90	static void
91	_ncm_data_gauss_diag_constructed (GObject *object)	5✔
92	{
93	/* Chain up : start */
94	G_OBJECT_CLASS (ncm_data_gauss_diag_parent_class)->constructed (object);	5✔
95	}	5✔
96
97	static void
98	ncm_data_gauss_diag_set_property (GObject object, guint prop_id, const GValue value, GParamSpec *pspec)	20✔
99	{
100	NcmDataGaussDiag *diag = NCM_DATA_GAUSS_DIAG (object);	20✔
101	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	20✔
102
103	g_return_if_fail (NCM_IS_DATA_GAUSS_DIAG (object));	20✔
104
105	switch (prop_id)	20!
106	{
107	case PROP_NPOINTS:	5✔
108	ncm_data_gauss_diag_set_size (diag, g_value_get_uint (value));	5✔
109	break;	5✔
110	case PROP_WMEAN:	5✔
111	self->wmean = g_value_get_boolean (value);	5✔
112	break;	5✔
113	case PROP_MEAN:	5✔
114	ncm_vector_substitute (&self->y, g_value_get_object (value), TRUE);	5✔
115	break;	5✔
116	case PROP_SIGMA:	5✔
117	ncm_vector_substitute (&self->sigma, g_value_get_object (value), TRUE);	5✔
118	break;	5✔
119	default:	×
120	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
121	break;	×
122	}
123	}
124
125	static void
126	ncm_data_gauss_diag_get_property (GObject object, guint prop_id, GValue value, GParamSpec *pspec)	4✔
127	{
128	NcmDataGaussDiag *diag = NCM_DATA_GAUSS_DIAG (object);	4✔
129	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	4✔
130
131	g_return_if_fail (NCM_IS_DATA_GAUSS_DIAG (object));	4✔
132
133	switch (prop_id)	4!
134	{
135	case PROP_NPOINTS:	1✔
136	g_value_set_uint (value, ncm_data_gauss_diag_get_size (diag));	1✔
137	break;	1✔
138	case PROP_WMEAN:	1✔
139	g_value_set_boolean (value, self->wmean);	1✔
140	break;	1✔
141	case PROP_MEAN:	1✔
142	g_value_set_object (value, self->y);	1✔
143	break;	1✔
144	case PROP_SIGMA:	1✔
145	g_value_set_object (value, self->sigma);	1✔
146	break;	1✔
147	default:	×
148	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
149	break;	×
150	}
151	}
152
153	static void
154	ncm_data_gauss_diag_dispose (GObject *object)	3✔
155	{
156	NcmDataGaussDiag *diag = NCM_DATA_GAUSS_DIAG (object);	3✔
157	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	3✔
158
159	ncm_vector_clear (&self->y);	3✔
160	ncm_vector_clear (&self->v);	3✔
161	ncm_vector_clear (&self->sigma);	3✔
162	ncm_vector_clear (&self->weight);	3✔
163
164	/* Chain up : end */
165	G_OBJECT_CLASS (ncm_data_gauss_diag_parent_class)->dispose (object);	3✔
166	}	3✔
167
168	static void
169	ncm_data_gauss_diag_finalize (GObject *object)	3✔
170	{
171	/* Chain up : end */
172	G_OBJECT_CLASS (ncm_data_gauss_diag_parent_class)->finalize (object);	3✔
173	}	3✔
174
175	static guint _ncm_data_gauss_diag_get_length (NcmData *data);
176	static guint _ncm_data_gauss_diag_get_dof (NcmData *data);
177
178	/* static void _ncm_data_gauss_diag_begin (NcmData data); /
179	static void _ncm_data_gauss_diag_resample (NcmData data, NcmMSet mset, NcmRNG *rng);
180	static void _ncm_data_gauss_diag_m2lnL_val (NcmData data, NcmMSet mset, gdouble *m2lnL);
181	static void _ncm_data_gauss_diag_leastsquares_f (NcmData data, NcmMSet mset, NcmVector *v);
182	static void _ncm_data_gauss_diag_mean_vector (NcmData data, NcmMSet mset, NcmVector *mu);
183	static void _ncm_data_gauss_diag_inv_cov_UH (NcmData data, NcmMSet mset, NcmMatrix *H);
184
185	static void _ncm_data_gauss_diag_set_size (NcmDataGaussDiag *diag, guint np);
186	static guint _ncm_data_gauss_diag_get_size (NcmDataGaussDiag *diag);
187
188	static void
189	ncm_data_gauss_diag_class_init (NcmDataGaussDiagClass *klass)	111✔
190	{
191	GObjectClass *object_class = G_OBJECT_CLASS (klass);	111✔
192	NcmDataClass *data_class = NCM_DATA_CLASS (klass);	111✔
193	NcmDataGaussDiagClass *gauss_diag_class = NCM_DATA_GAUSS_DIAG_CLASS (klass);	111✔
194
195	object_class->constructed = &_ncm_data_gauss_diag_constructed;	111✔
196	object_class->set_property = &ncm_data_gauss_diag_set_property;	111✔
197	object_class->get_property = &ncm_data_gauss_diag_get_property;	111✔
198	object_class->dispose = &ncm_data_gauss_diag_dispose;	111✔
199	object_class->finalize = &ncm_data_gauss_diag_finalize;	111✔
200
201	g_object_class_install_property (object_class,	111✔
202	PROP_NPOINTS,
203	g_param_spec_uint ("n-points",
204	NULL,
205	"Data sample size",
206	0, G_MAXUINT, 0,
207	G_PARAM_READWRITE \| G_PARAM_CONSTRUCT \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
208
209	g_object_class_install_property (object_class,	111✔
210	PROP_WMEAN,
211	g_param_spec_boolean ("w-mean",
212	NULL,
213	"Whether to minimize analytically over the weighted mean",
214	FALSE,
215	G_PARAM_READWRITE \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
216
217	g_object_class_install_property (object_class,	111✔
218	PROP_MEAN,
219	g_param_spec_object ("mean",
220	NULL,
221	"Data mean",
222	NCM_TYPE_VECTOR,
223	G_PARAM_READWRITE \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
224
225	g_object_class_install_property (object_class,	111✔
226	PROP_SIGMA,
227	g_param_spec_object ("sigma",
228	NULL,
229	"Data standard deviation",
230	NCM_TYPE_VECTOR,
231	G_PARAM_READWRITE \| G_PARAM_STATIC_NAME \| G_PARAM_STATIC_BLURB));
232
233	data_class->bootstrap = TRUE;	111✔
234	data_class->get_length = &_ncm_data_gauss_diag_get_length;	111✔
235	data_class->get_dof = &_ncm_data_gauss_diag_get_dof;	111✔
236	data_class->resample = &_ncm_data_gauss_diag_resample;	111✔
237	data_class->m2lnL_val = &_ncm_data_gauss_diag_m2lnL_val;	111✔
238	data_class->leastsquares_f = &_ncm_data_gauss_diag_leastsquares_f;	111✔
239	data_class->mean_vector = &_ncm_data_gauss_diag_mean_vector;	111✔
240	data_class->inv_cov_UH = &_ncm_data_gauss_diag_inv_cov_UH;	111✔
241
242	gauss_diag_class->mean_func = NULL;	111✔
243	gauss_diag_class->sigma_func = NULL;	111✔
244	gauss_diag_class->set_size = &_ncm_data_gauss_diag_set_size;	111✔
245	gauss_diag_class->get_size = &_ncm_data_gauss_diag_get_size;	111✔
246	}	111✔
247
248	static guint
249	_ncm_data_gauss_diag_get_length (NcmData *data)	×
250	{
NEW 251	NcmDataGaussDiag *diag = NCM_DATA_GAUSS_DIAG (data);	×
252	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	×
253
254	return self->np;	×
255	}
256
257	static guint
258	_ncm_data_gauss_diag_get_dof (NcmData *data)	×
259	{
NEW 260	NcmDataGaussDiag *diag = NCM_DATA_GAUSS_DIAG (data);	×
261	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	×
NEW 262	guint dof = self->np;	×
263
264	if (self->wmean && (dof > 0))	×
265	dof--;	×
266
267	return dof;	×
268	}
269
270	static void
271	_ncm_data_gauss_prepare_weight (NcmData *data)	×
272	{
NEW 273	NcmDataGaussDiag *diag = NCM_DATA_GAUSS_DIAG (data);	×
274	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	×
275	guint i;
276
277	if (self->weight == NULL)	×
278	self->weight = ncm_vector_new (self->np);	×
279
280	self->wt = 0.0;	×
281
282	for (i = 0; i < self->np; i++)	×
283	{
284	const gdouble sigma_i = ncm_vector_get (self->sigma, i);	×
285	const gdouble w_i = 1.0 / (sigma_i * sigma_i);	×
286
287	ncm_vector_set (self->weight, i, w_i);	×
288	self->wt += w_i;	×
289	}
290
291	self->prepared_w = TRUE;	×
292	}	×
293
294	static void
295	_ncm_data_gauss_diag_resample (NcmData data, NcmMSet mset, NcmRNG *rng)	×
296	{
297	NcmDataGaussDiag *diag = NCM_DATA_GAUSS_DIAG (data);	×
298	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	×
299	NcmDataGaussDiagClass *gauss_diag_class = NCM_DATA_GAUSS_DIAG_GET_CLASS (diag);	×
NEW UNCOV 300	gdouble has_sigma_func = (gauss_diag_class->sigma_func != NULL);	×
301	guint i;
302
NEW 303	if (has_sigma_func)	×
304	gauss_diag_class->sigma_func (diag, mset, self->sigma);	×
305
306	gauss_diag_class->mean_func (diag, mset, self->y);	×
307
308	ncm_rng_lock (rng);	×
309
310	for (i = 0; i < self->np; i++)	×
311	{
312	const gdouble sigma_i = ncm_vector_get (self->sigma, i);	×
313	const gdouble u_i = gsl_ran_gaussian_ziggurat (rng->r, sigma_i);	×
314
315	ncm_vector_subfrom (self->y, i, u_i);	×
316	}
317
318	ncm_rng_unlock (rng);	×
319	}	×
320
321	static void
322	_ncm_data_gauss_diag_m2lnL_val (NcmData data, NcmMSet mset, gdouble *m2lnL)	×
323	{
324	NcmDataGaussDiag *diag = NCM_DATA_GAUSS_DIAG (data);	×
325	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	×
326	NcmDataGaussDiagClass *gauss_diag_class = NCM_DATA_GAUSS_DIAG_GET_CLASS (diag);	×
NEW 327	gdouble has_sigma_func = (gauss_diag_class->sigma_func != NULL);	×
UNCOV 328	gboolean sigma_update = FALSE;	×
329	guint i;
330
331	*m2lnL = 0.0;	×
332
NEW 333	if (has_sigma_func)	×
334	sigma_update = gauss_diag_class->sigma_func (diag, mset, self->sigma);	×
335
336	gauss_diag_class->mean_func (diag, mset, self->v);	×
337
338	if (self->wmean)	×
339	{
340	if (sigma_update \|\| !self->prepared_w)	×
341	_ncm_data_gauss_prepare_weight (data);	×
342
343	if (!ncm_data_bootstrap_enabled (data))	×
344	{
345	gdouble tmp = 0.0;	×
346
347	for (i = 0; i < self->np; i++)	×
348	{
349	const gdouble y_i = ncm_vector_get (self->y, i);	×
350	const gdouble yt_i = ncm_vector_get (self->v, i);	×
351	const gdouble r_i = (yt_i - y_i);	×
352	const gdouble w_i = ncm_vector_get (self->weight, i);	×
353	const gdouble r_i2 = r_i * r_i;	×
354
NEW 355	m2lnL += r_i2 w_i - log (w_i);	×
356	tmp += r_i * w_i;	×
357	}
358
359	m2lnL -= tmp tmp / self->wt;	×
NEW UNCOV 360	m2lnL += self->np ncm_c_ln2pi ();	×
361	}
362	else
363	{
364	NcmBootstrap *bstrap = ncm_data_peek_bootstrap (data);	×
NEW 365	const guint bsize = ncm_bootstrap_get_bsize (bstrap);	×
NEW 366	gdouble tmp = 0.0;	×
NEW 367	gdouble wt = 0.0;	×
368
369	for (i = 0; i < bsize; i++)	×
370	{
371	guint k = ncm_bootstrap_get (bstrap, i);	×
372	const gdouble y_k = ncm_vector_get (self->y, k);	×
373	const gdouble yt_k = ncm_vector_get (self->v, k);	×
374	const gdouble r_k = (yt_k - y_k);	×
375	const gdouble w_k = ncm_vector_get (self->weight, k);	×
376	const gdouble r_k2 = r_k * r_k;	×
377
NEW 378	m2lnL += r_k2 w_k + log (w_k);	×
379	tmp += r_k * w_k;	×
380	wt += w_k;	×
381	}
382
383	m2lnL -= tmp tmp / wt;	×
NEW UNCOV 384	m2lnL += self->np ncm_c_ln2pi ();	×
385	}
386	}
387	else
388	{
389	if (!ncm_data_bootstrap_enabled (data))	×
390	{
391	for (i = 0; i < self->np; i++)	×
392	{
393	const gdouble y_i = ncm_vector_get (self->y, i);	×
394	const gdouble yt_i = ncm_vector_get (self->v, i);	×
395	const gdouble sigma_i = ncm_vector_get (self->sigma, i);	×
396	const gdouble r_i = (yt_i - y_i) / sigma_i;	×
397
NEW 398	m2lnL += r_i r_i + 2.0 * log (sigma_i);	×
399	}
400
NEW UNCOV 401	m2lnL += self->np ncm_c_ln2pi ();	×
402	}
403	else
404	{
405	NcmBootstrap *bstrap = ncm_data_peek_bootstrap (data);	×
NEW 406	const guint bsize = ncm_bootstrap_get_bsize (bstrap);	×
407
408	for (i = 0; i < bsize; i++)	×
409	{
410	guint k = ncm_bootstrap_get (bstrap, i);	×
411	const gdouble y_k = ncm_vector_get (self->y, k);	×
412	const gdouble yt_k = ncm_vector_get (self->v, k);	×
413	const gdouble sigma_k = ncm_vector_get (self->sigma, k);	×
414	const gdouble r_k = (yt_k - y_k) / sigma_k;	×
415
NEW 416	m2lnL += r_k r_k + 2.0 * log (sigma_k);	×
417	}
418
NEW UNCOV 419	m2lnL += self->np ncm_c_ln2pi ();	×
420	}
421	}
UNCOV 422	}	×
423
424	static void
425	_ncm_data_gauss_diag_leastsquares_f (NcmData data, NcmMSet mset, NcmVector *v)	×
426	{
427	NcmDataGaussDiag *diag = NCM_DATA_GAUSS_DIAG (data);	×
428	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	×
429	NcmDataGaussDiagClass *gauss_diag_class = NCM_DATA_GAUSS_DIAG_GET_CLASS (diag);	×
NEW 430	gdouble has_sigma_func = (gauss_diag_class->sigma_func != NULL);	×
UNCOV 431	gboolean sigma_update = FALSE;	×
432	guint i;
433
434	if (ncm_data_bootstrap_enabled (data))	×
435	g_error ("NcmDataGaussDiag: does not support bootstrap with least squares");
436
NEW 437	if (has_sigma_func)	×
438	sigma_update = gauss_diag_class->sigma_func (diag, mset, self->sigma);	×
439
440	gauss_diag_class->mean_func (diag, mset, v);	×
441
442	if (self->wmean)	×
443	{
444	gdouble wmean;
445
446	if (sigma_update \|\| !self->prepared_w)	×
447	_ncm_data_gauss_prepare_weight (data);	×
448
449	ncm_vector_sub (v, self->y);	×
450
451	wmean = gsl_stats_wmean (ncm_vector_gsl (self->weight)->data,	×
452	ncm_vector_gsl (self->weight)->stride,	×
453	ncm_vector_gsl (v)->data,	×
454	ncm_vector_gsl (v)->stride,	×
455	ncm_vector_gsl (v)->size);	×
456
457	for (i = 0; i < self->np; i++)	×
458	{
459	const gdouble sigma_i = ncm_vector_get (self->sigma, i);	×
460	const gdouble v_i = ncm_vector_get (v, i);	×
461
462	ncm_vector_set (v, i, (v_i - wmean) / sigma_i);	×
463	}
464	}
465	else
466	{
467	for (i = 0; i < self->np; i++)	×
468	{
469	const gdouble y_i = ncm_vector_get (self->y, i);	×
470	const gdouble yt_i = ncm_vector_get (v, i);	×
471	const gdouble sigma_i = ncm_vector_get (self->sigma, i);	×
472	const gdouble r_i = (yt_i - y_i) / sigma_i;	×
473
474	ncm_vector_set (v, i, r_i);	×
475	}
476	}
477	}	×
478
479	static void
480	_ncm_data_gauss_diag_mean_vector (NcmData data, NcmMSet mset, NcmVector *mu)	×
481	{
482	NcmDataGaussDiag *diag = NCM_DATA_GAUSS_DIAG (data);	×
483	NcmDataGaussDiagClass *gauss_diag_class = NCM_DATA_GAUSS_DIAG_GET_CLASS (diag);	×
484
485	gauss_diag_class->mean_func (diag, mset, mu);	×
486	}	×
487
488	static void
489	_ncm_data_gauss_diag_inv_cov_UH (NcmData data, NcmMSet mset, NcmMatrix *H)	×
490	{
491	NcmDataGaussDiag *diag = NCM_DATA_GAUSS_DIAG (data);	×
492	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	×
493	NcmDataGaussDiagClass *gauss_diag_class = NCM_DATA_GAUSS_DIAG_GET_CLASS (diag);	×
494	guint i;
495
496	if (ncm_data_bootstrap_enabled (data))	×
497	g_error ("NcmDataGaussDiag: does not support bootstrap with least squares");
498
499	if (gauss_diag_class->sigma_func != NULL)	×
500	gauss_diag_class->sigma_func (diag, mset, self->sigma);	×
501
502	for (i = 0; i < self->np; i++)	×
503	{
504	const gdouble sigma_i = ncm_vector_get (self->sigma, i);	×
505
506	ncm_matrix_mul_col (H, i, 1.0 / sigma_i);	×
507	}
508	}	×
509
510	static void
511	_ncm_data_gauss_diag_set_size (NcmDataGaussDiag *diag, guint np)	5✔
512	{
513	NcmData *data = NCM_DATA (diag);	5✔
514	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	5✔
515
516	if ((np == 0) \|\| (np != self->np))	5!
517	{
518	self->np = 0;	5✔
519	ncm_vector_clear (&self->y);	5✔
520	ncm_vector_clear (&self->v);	5✔
521	ncm_vector_clear (&self->sigma);	5✔
522	ncm_vector_clear (&self->weight);	5✔
523
524	ncm_data_set_init (data, FALSE);	5✔
525	}
526
527	if ((np != 0) && (np != self->np))	5!
528	{
529	NcmBootstrap *bstrap = ncm_data_peek_bootstrap (data);	5✔
530
531	self->np = np;	5✔
532	self->y = ncm_vector_new (self->np);	5✔
533	self->v = ncm_vector_new (self->np);	5✔
534	self->sigma = ncm_vector_new (self->np);	5✔
535
536	if (ncm_data_bootstrap_enabled (data))	5!
537	{
538	ncm_bootstrap_set_fsize (bstrap, np);	×
539	ncm_bootstrap_set_bsize (bstrap, np);	×
540	}
541
542	ncm_data_set_init (data, FALSE);	5✔
543	}
544	}	5✔
545
546	static guint
547	_ncm_data_gauss_diag_get_size (NcmDataGaussDiag *diag)	4✔
548	{
549	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	4✔
550
551	return self->np;	4✔
552	}
553
554	/**
555	* ncm_data_gauss_diag_set_size: (virtual set_size)
556	* @diag: a #NcmDataGaussDiag
557	* @np: data size.
558	*
559	* Sets the data size to @np.
560	*
561	*/
562	void
563	ncm_data_gauss_diag_set_size (NcmDataGaussDiag *diag, guint np)	5✔
564	{
565	NCM_DATA_GAUSS_DIAG_GET_CLASS (diag)->set_size (diag, np);	5✔
566	}	5✔
567
568	/**
569	* ncm_data_gauss_diag_get_size: (virtual get_size)
570	* @diag: a #NcmDataGaussDiag
571	*
572	* Gets the data size.
573	*
574	* Returns: Data size.
575	*
576	*/
577	guint
578	ncm_data_gauss_diag_get_size (NcmDataGaussDiag *diag)	4✔
579	{
580	return NCM_DATA_GAUSS_DIAG_GET_CLASS (diag)->get_size (diag);	4✔
581	}
582
583	/**
584	* ncm_data_gauss_diag_peek_mean:
585	* @diag: a #NcmDataGaussDiag
586	*
587	* Returns: (transfer none): the current data mean #NcmVector.
588	*/
589	NcmVector *
590	ncm_data_gauss_diag_peek_mean (NcmDataGaussDiag *diag)	2✔
591	{
592	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	2✔
593
594	return self->y;	2✔
595	}
596
597	/**
598	* ncm_data_gauss_diag_peek_std:
599	* @diag: a #NcmDataGaussDiag
600	*
601	* Returns: (transfer none): the current data standard deviation #NcmVector.
602	*/
603	NcmVector *
604	ncm_data_gauss_diag_peek_std (NcmDataGaussDiag *diag)	2✔
605	{
606	NcmDataGaussDiagPrivate * const self = ncm_data_gauss_diag_get_instance_private (diag);	2✔
607
608	return self->sigma;	2✔
609	}
610

NumCosmo / NumCosmo / 6829146633

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