Module: xenomai-3
Branch: next
Commit: 9d04cc5ee852c064cad2f28002db883d11131299
URL:    
http://git.xenomai.org/?p=xenomai-3.git;a=commit;h=9d04cc5ee852c064cad2f28002db883d11131299

Author: Jorge Ramirez-Ortiz <j...@xenomai.org>
Date:   Tue Oct 14 21:03:05 2014 -0400

utils/analogy: calibration - use the analogy's math utils

---

 include/rtdm/analogy.h            |   12 ++
 include/rtdm/uapi/analogy.h       |    2 +-
 lib/analogy/Makefile.am           |    5 +-
 lib/analogy/calibration.c         |   22 ++
 lib/analogy/calibration.h         |   21 ++
 lib/analogy/math.c                |  418 +++++++++++++++++++++++++++++++++++++
 utils/analogy/Makefile.am         |    2 +-
 utils/analogy/analogy_calibrate.c |    6 +-
 utils/analogy/calibration_ni_m.c  |  106 +++-------
 utils/analogy/calibration_ni_m.h  |    6 +-
 10 files changed, 515 insertions(+), 85 deletions(-)

diff --git a/include/rtdm/analogy.h b/include/rtdm/analogy.h
index fd26f58..c03d2b1 100644
--- a/include/rtdm/analogy.h
+++ b/include/rtdm/analogy.h
@@ -236,6 +236,18 @@ void a4l_write_calibration_file(FILE *dst, struct list *l,
 
 int a4l_read_calibration_file(char *name, struct a4l_calibration_data *data);
 
+int a4l_math_polyfit(unsigned order, double *r,double orig,
+                    const unsigned dim, double *x, double *y);
+
+void a4l_math_mean(double *pmean, double *val, unsigned nr);
+
+void a4l_math_stddev(double *pstddev,
+                    double mean, double *val, unsigned nr);
+
+void a4l_math_stddev_of_mean(double *pstddevm,
+                            double mean, double *val, unsigned nr);
+
+
 
 
 #endif /* !DOXYGEN_CPP */
diff --git a/include/rtdm/uapi/analogy.h b/include/rtdm/uapi/analogy.h
index 669ded7..a0a1e59 100644
--- a/include/rtdm/uapi/analogy.h
+++ b/include/rtdm/uapi/analogy.h
@@ -708,9 +708,9 @@ typedef struct a4l_instruction_list a4l_insnlst_t;
 
 struct a4l_calibration_subdev {
        a4l_sbinfo_t *info;
+       char *name;
        int slen;
        int idx;
-       char *name;
 };
 
 struct a4l_calibration_subdev_data {
diff --git a/lib/analogy/Makefile.am b/lib/analogy/Makefile.am
index 500453d..b79d4cb 100644
--- a/lib/analogy/Makefile.am
+++ b/lib/analogy/Makefile.am
@@ -7,6 +7,7 @@ libanalogy_la_SOURCES = \
        descriptor.c    \
        info.c          \
        internal.h      \
+       math.c          \
        calibration.c   \
        range.c         \
        root_leaf.h     \
@@ -19,4 +20,6 @@ libanalogy_la_CPPFLAGS =              \
        -I$(top_srcdir)/lib/boilerplate 
 
 libanalogy_la_LIBADD = \
-       ../boilerplate/libboilerplate.la
+       ../boilerplate/libboilerplate.la        \
+       -lm
+
diff --git a/lib/analogy/calibration.c b/lib/analogy/calibration.c
index 74b2789..85860d1 100644
--- a/lib/analogy/calibration.c
+++ b/lib/analogy/calibration.c
@@ -1,3 +1,25 @@
+/**
+ * @file
+ * Analogy for Linux, device, subdevice, etc. related features
+ *
+ * @note Copyright (C) 1997-2000 David A. Schleef <d...@schleef.org>
+ * @note Copyright (C) 2014 Jorge A. Ramirez-Ortiz <j...@xenomai.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+
 #include <rtdm/analogy.h>
 #include <stdio.h>
 #include <errno.h>
diff --git a/lib/analogy/calibration.h b/lib/analogy/calibration.h
index 04a7e72..4080c60 100644
--- a/lib/analogy/calibration.h
+++ b/lib/analogy/calibration.h
@@ -1,3 +1,24 @@
+/**
+ * @file
+ * Analogy for Linux, internal calibration declarations
+ *
+ * @note Copyright (C) 2014 Jorge A Ramirez-Ortiz <j...@xenomai.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+
 #ifndef __ANALOGY_CALIBRATION_H__
 #define __ANALOGY_CALIBRATION_H__
 
diff --git a/lib/analogy/math.c b/lib/analogy/math.c
new file mode 100644
index 0000000..e85464d
--- /dev/null
+++ b/lib/analogy/math.c
@@ -0,0 +1,418 @@
+#include <math.h>
+
+/*
+ * Copyright (C) 2014 Gilles Chanteperdrix <gilles.chanteperd...@xenomai.org>.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+ */
+
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <math.h>
+#include <assert.h>
+
+#include <rtdm/analogy.h>
+
+struct vec {
+       unsigned dim;
+       unsigned stride;
+       double *val;
+};
+
+struct mat {
+       unsigned rows;
+       unsigned cols;
+       double *val;
+};
+
+static void vec_init(struct vec *v, unsigned dim, double *val)
+{
+       v->dim = dim;
+       v->stride = 1;
+       v->val = val;
+}
+
+static int vec_alloc(struct vec *v, unsigned dim)
+{
+       double *val = malloc(sizeof(*val) * dim);
+
+       if (val == NULL)
+               return -ENOMEM;
+
+       v->dim = dim;
+       v->stride = 1;
+       v->val = val;
+
+       return 0;
+}
+
+static void vec_free(struct vec *v)
+{
+       free(v->val);
+       v->val = NULL;
+       v->dim = 0;
+       v->stride = 0;
+}
+
+static void row_vec_init(struct vec *v, struct mat *m, unsigned row)
+{
+       v->dim = m->cols;
+       v->stride = 1;
+       v->val = m->val + row * m->cols;
+}
+
+static void col_vec_init(struct vec *v, struct mat *m, unsigned col)
+{
+       v->dim = m->rows;
+       v->stride = m->cols;
+       v->val = m->val + col;
+}
+
+static void vec_copy(struct vec *dst, struct vec *src)
+{
+       const unsigned d_stride = dst->stride, s_stride = src->stride;
+       double *d_val = dst->val, *s_val = src->val;
+       unsigned dim = dst->dim;
+       unsigned i;
+
+       assert(dst->dim == src->dim);
+
+       for (i = 0; i < dim; i++, d_val += d_stride, s_val += s_stride)
+               *d_val = *s_val;
+}
+
+static inline double *vec_of(struct vec *v, unsigned k)
+{
+       return v->val + v->stride * k;
+}
+
+static void vec_mult_scalar(struct vec *v, double x)
+{
+       const unsigned v_stride = v->stride;
+       const unsigned dim = v->dim;
+       double *v_val = v->val;
+       unsigned i;
+
+       for (i = 0; i < dim; i++, v_val += v_stride)
+               *v_val *= x;
+}
+
+static double vec_dot(struct vec *l, struct vec *r)
+{
+       const unsigned l_stride = l->stride;
+       const unsigned r_stride = r->stride;
+       const double *l_val = l->val;
+       const double *r_val = r->val;
+       const unsigned dim = l->dim;
+       double res = 0;
+       unsigned i;
+
+       assert(dim == r->dim);
+
+       for (i = 0; i < dim; i++, l_val += l_stride, r_val += r_stride)
+               res += (*l_val) * (*r_val);
+
+       return res;
+}
+
+static inline double vec_norm2(struct vec *v)
+{
+       return sqrt(vec_dot(v, v));
+}
+
+static void vec_vandermonde(struct vec *v, const double x)
+{
+       const unsigned v_stride = v->stride;
+       const unsigned dim = v->dim;
+       double *v_val = v->val;
+       double tmp = 1;
+       unsigned i;
+
+       for (i = 0; i < dim; i++, v_val += v_stride, tmp *= x)
+               *v_val = tmp;
+}
+
+static void vec_householder(struct vec *res, struct vec *v, unsigned k)
+{
+       const unsigned res_stride = res->stride;
+       const unsigned v_stride = v->stride;
+       const unsigned dim = res->dim;
+       const double *v_val = v->val;
+       double *x_k, *res_val = res->val;
+       double alpha;
+       unsigned j;
+
+       assert(dim == v->dim);
+       assert(k < dim);
+
+       for (j = 0; j < k; j++, res_val += res_stride, v_val += v_stride)
+               *res_val = 0;
+       x_k = res_val;
+       for (j = k; j < dim; j++, res_val += res_stride, v_val += v_stride)
+               *res_val = *v_val;
+
+       alpha = (signbit(*x_k) ? 1 : -1) * vec_norm2(res);
+       *x_k -= alpha;
+
+       vec_mult_scalar(res, 1 / vec_norm2(res));
+}
+
+static int mat_alloc(struct mat *m, unsigned rows, unsigned cols)
+{
+       double *val = malloc(sizeof(*val) * rows * cols);
+
+       if (val == NULL)
+               return -ENOMEM;
+
+       m->rows = rows;
+       m->cols = cols;
+       m->val = val;
+
+       return 0;
+}
+
+static void mat_free(struct mat *m)
+{
+       free(m->val);
+       m->val = NULL;
+       m->cols = 0;
+       m->rows = 0;
+}
+
+static inline double *mat_of(struct mat *m, unsigned row, unsigned col)
+{
+       return m->val + row * m->cols + col;
+}
+
+static void vec_mult_mat(struct vec *res, struct vec *v, struct mat *m)
+{
+       const unsigned res_stride = res->stride;
+       const unsigned cols = m->cols;
+       double *res_val = res->val;
+       struct vec cur_col;
+       unsigned i;
+
+       assert(v->dim == m->rows);
+
+       col_vec_init(&cur_col, m, 0);
+       for (i = 0; i < cols; i++, cur_col.val++, res_val += res_stride)
+               *res_val = vec_dot(v, &cur_col);
+}
+
+static void mat_vandermonde(struct mat *m, struct vec *v, const double origin)
+{
+       const unsigned v_stride = v->stride;
+       const unsigned m_rows = m->rows;
+       const unsigned m_cols = m->cols;
+       const double *v_val = v->val;
+       struct vec m_row;
+       unsigned i;
+
+       assert(m->rows == v->dim);
+
+       row_vec_init(&m_row, m, 0);
+       for (i = 0; i < m_rows; i++, m_row.val += m_cols, v_val += v_stride)
+               vec_vandermonde(&m_row, *v_val - origin);
+}
+
+static void
+house_mult_mat(struct mat *res, struct vec *tmp, struct vec *vh, struct mat *m)
+{
+       const double *vh_val = vh->val, *tmp_val = tmp->val, *m_val = m->val;
+       const unsigned tmp_stride = tmp->stride;
+       const unsigned vh_stride = vh->stride;
+       const unsigned res_cols = res->cols;
+       const unsigned res_rows = res->rows;
+       double *res_val = res->val;
+       unsigned i, j;
+
+       assert(res_cols == m->cols &&
+               res_rows == m->rows && res->rows == vh->dim);
+
+       vec_mult_mat(tmp, vh, m);
+
+       for (j = 0; j < res_rows; j++, vh_val += vh_stride, tmp_val = tmp->val)
+               for (i = 0; i < res_cols; i++, tmp_val += tmp_stride)
+                       *res_val++ = (*m_val++) - 2 * (*vh_val) * (*tmp_val);
+}
+
+static void
+house_mult_vec(struct vec *res, struct vec *vh, struct vec *v)
+{
+       const double *vh_val = vh->val, *v_val = v->val;
+       const unsigned res_stride = res->stride;
+       const unsigned vh_stride = vh->stride;
+       const unsigned v_stride = v->stride;
+       const unsigned res_dim = res->dim;
+       double *res_val = res->val;
+       double dot;
+       unsigned i;
+
+       assert(res_dim == v->dim);
+
+       dot = 2 * vec_dot(vh, v);
+
+       for (i = 0; i < res_dim; i++, res_val += res_stride,
+                    v_val += v_stride, vh_val += vh_stride)
+               *res_val = (*v_val) - dot * (*vh_val);
+}
+
+static void
+mat_upper_triangular_backsub(struct vec *res, struct mat *m, struct vec *v)
+{
+       unsigned dim = res->dim;
+       unsigned j;
+       int i;
+
+       assert(dim == m->cols);
+
+       for (i = dim - 1; i >= 0; i--) {
+               double sum = *vec_of(v, i);
+
+               for (j = i + 1; j < dim; j++)
+                       sum -= (*mat_of(m, i, j)) * (*vec_of(res, j));
+
+               *vec_of(res, i) = sum / (*mat_of(m, i, i));
+       }
+}
+
+/*
+ * A = Q.R decomposition using Householder reflections
+ * Input: R <- A
+ *       Y
+ * Output: R
+ *        Y <- Q^tY
+ */
+static int mat_qr(struct mat *r, struct vec *y)
+{
+       struct vec r_col, vh, tr;
+       unsigned i;
+       int rc;
+
+       rc = vec_alloc(&vh, r->rows);
+       if (rc < 0)
+               return rc;
+
+       rc = vec_alloc(&tr, y->dim);
+       if (rc < 0)
+               goto err_free_vh;
+
+       col_vec_init(&r_col, r, 0);
+       for (i = 0; i < r->cols; i++, r_col.val++) {
+               vec_householder(&vh, &r_col, i);
+
+               house_mult_vec(y, &vh, y);
+               house_mult_mat(r, &tr, &vh, r);
+       }
+
+       rc = 0;
+       vec_free(&tr);
+  err_free_vh:
+       vec_free(&vh);
+       return rc;
+}
+
+/*
+ * We are looking for Res such that A.Res = Y, with A the Vandermonde
+ * matrix made from the X vector.
+ *
+ * Using the least square method, this means finding Res such that:
+ * A^t.A.Res = A^tY
+ *
+ * If we write A = Q.R with Q^t.Q = 1, and R non singular, this can be
+ * reduced to:
+ * R.Res = Q^t.Y
+ *
+ * mat_qr() gives us R and Q^t.Y from A and Y
+ *
+ * We can then obtain Res by back substitution using
+ * mat_upper_triangular_backsub() with R upper triangular.
+ */
+int a4l_math_polyfit(unsigned order, double *r, double orig, const unsigned 
dim,
+               double *x, double *y)
+{
+       struct vec v_x, v_y, v_r, qty;
+       struct mat vdm;
+       int rc;
+
+       vec_init(&v_x, dim, x);
+       vec_init(&v_y, dim, y);
+       vec_init(&v_r, order, r);
+
+       rc = vec_alloc(&qty, dim);
+       if (rc < 0)
+               return rc;
+       vec_copy(&qty, &v_y);
+
+       rc = mat_alloc(&vdm, dim, order);
+       if (rc < 0)
+               goto err_free_qty;
+
+       mat_vandermonde(&vdm, &v_x, orig);
+
+       rc = mat_qr(&vdm, &qty);
+       if (rc == 0)
+               mat_upper_triangular_backsub(&v_r, &vdm, &qty);
+
+       mat_free(&vdm);
+
+  err_free_qty:
+       vec_free(&qty);
+
+        return rc;
+}
+
+void a4l_math_mean(double *pmean, double *val, unsigned nr)
+{
+       double sum;
+       int i;
+
+       for (sum = 0, i = 0; i < nr; i++)
+               sum += val[i];
+
+       *pmean = sum / nr;
+}
+
+void a4l_math_stddev(double *pstddev, double mean, double *val, unsigned nr)
+{
+       double sum, sum_sq;
+       int i;
+
+       for (sum = 0, sum_sq = 0, i = 0; i < nr; i++) {
+               double x = val[i] - mean;
+               sum_sq += x * x;
+               sum += x;
+       }
+
+       *pstddev = sqrt((sum_sq - (sum * sum) / nr) / (nr - 1));
+}
+
+void a4l_math_stddev_of_mean(double *pstddevm, double mean, double *val, 
unsigned nr)
+{
+       double sum, sum_sq;
+       int i;
+
+       for (sum = 0, sum_sq = 0, i = 0; i < nr; i++) {
+               double x = val[i] - mean;
+               sum_sq += x * x;
+               sum += x;
+       }
+
+       *pstddevm = sqrt(((sum_sq - (sum * sum) / nr) / (nr - 1)) / nr);
+}
+
+
+
diff --git a/utils/analogy/Makefile.am b/utils/analogy/Makefile.am
index a555260..6ffd0f2 100644
--- a/utils/analogy/Makefile.am
+++ b/utils/analogy/Makefile.am
@@ -46,7 +46,7 @@ analogy_calibrate_LDADD = \
        ../../lib/analogy/libanalogy.la \
        ../../lib/cobalt/libcobalt.la   \
        @XENO_USER_LDADD@               \
-       -lpthread -lrt -lgsl -lgslcblas -lm
+       -lpthread -lrt 
 
 cmd_read_SOURCES = cmd_read.c
 cmd_read_LDADD = \
diff --git a/utils/analogy/analogy_calibrate.c 
b/utils/analogy/analogy_calibrate.c
index 5963cc4..f9add4d 100644
--- a/utils/analogy/analogy_calibrate.c
+++ b/utils/analogy/analogy_calibrate.c
@@ -32,7 +32,7 @@
 #include "calibration_ni_m.h"
 
 struct timespec calibration_start_time;
-static const char *revision = "0.0.1";
+static const char *revision = "1.0.0";
 a4l_desc_t descriptor;
 
 static const struct option options[] = {
@@ -105,8 +105,8 @@ int main(int argc, char *argv[])
                }
        }
 
-       if (!p)
-               error(EXIT, errno, "calibration file not present");
+       if (!p || !device)
+               error(EXIT, errno, "missing input parameters");
 
        fd = a4l_open(&descriptor, device);
        if (fd < 0)
diff --git a/utils/analogy/calibration_ni_m.c b/utils/analogy/calibration_ni_m.c
index 2115b6d..dc2f667 100644
--- a/utils/analogy/calibration_ni_m.c
+++ b/utils/analogy/calibration_ni_m.c
@@ -234,88 +234,51 @@ static int data_read_async(void *dst, struct 
a4l_calibration_subdev *s,
 
 /*
  *
- * math: uses the gnu statistic library and the math library
+ * math: uses the a4l statistic helpers and the math library
  *
  */
-static int statistics_standard_deviation_of_mean(double *dst, double src[],
-                                                int len, double mean)
+static void
+statistics_standard_deviation_of_mean(double *dst, double src[], int len,
+                                     double mean)
 {
-       double a;
-
-       a = gsl_stats_variance_m(src, 1, len, mean);
-       a = sqrt(a/len);
-       *dst = a;
-
-       return 0;
+       a4l_math_stddev_of_mean(dst, mean, src, len);
 }
 
-static int statistics_standard_deviation(double *dst, double src[], int len,
-                                        double mean)
+static void
+statistics_standard_deviation(double *dst, double src[], int len, double mean)
 {
-       double a;
-
-       a = gsl_stats_variance_m(src, 1, len, mean);
-       a = sqrt(a);
-       *dst = a;
-
-       return 0;
+       a4l_math_stddev(dst, mean, src, len);
 }
 
-static int statistics_mean(double *dst, double src[], int len)
+static void statistics_mean(double *dst, double src[], int len)
 {
-       *dst = gsl_stats_mean(src, 1, len);
-
-       return 0;
+       a4l_math_mean(dst, src, len);
 }
 
 static int polynomial_fit(struct polynomial *dst, struct codes_info *src)
 {
-       gsl_multifit_linear_workspace *work;
-       const int nb_coeff = dst->order + 1;
-       gsl_matrix *covariance, *m;
-       gsl_vector_view b, result;
-       double a, *tmp, chisq;
-       int i, j, len;
+       double *measured;
+       double *nominal;
+       int i, ret;
+
+       dst->nb_coefficients = dst->order + 1;
+       dst->coefficients = malloc(sizeof(double) * dst->nb_coefficients);
+       measured = malloc(sizeof(double) * src->nb_codes);
+       nominal = malloc(sizeof(double) * src->nb_codes);
 
-       work = gsl_multifit_linear_alloc(src->nb_codes, nb_coeff);
-       covariance = gsl_matrix_alloc(nb_coeff, nb_coeff);
-       m = gsl_matrix_alloc(src->nb_codes, nb_coeff);
+       if (!dst->coefficients || !measured || !nominal)
+               return -ENOMEM;
 
        for (i = 0; i < src->nb_codes; i++) {
-               gsl_matrix_set(m, i, 0, 1.0);
-               for (j = 1; j < nb_coeff; j++) {
-                       a = gsl_matrix_get(m, i, j - 1);
-                       a = a * (src->codes[i].nominal - dst->expansion_origin);
-                       gsl_matrix_set(m, i, j, a);
-               }
+               measured[i] = src->codes[i].measured;
+               nominal[i] = src->codes[i].nominal;
        }
 
-       len = src->nb_codes * sizeof(double);
-       tmp = malloc(len);
-       if (!tmp)
-               error(EXIT, 0, "malloc (%d)", len);
-
-       for (i = 0; i < src->nb_codes; i++)
-               tmp[i] = src->codes[i].measured;
+       ret = a4l_math_polyfit(dst->nb_coefficients, dst->coefficients,
+                              dst->expansion_origin,
+                              src->nb_codes, nominal, measured);
 
-       b = gsl_vector_view_array(tmp, src->nb_codes);
-
-       dst->nb_coefficients = nb_coeff;
-       len = dst->nb_coefficients * sizeof(double);
-       dst->coefficients = malloc(len);
-       if (!dst->coefficients)
-               error(EXIT, 0, "malloc (%d)", len);
-
-       result = gsl_vector_view_array(dst->coefficients, nb_coeff);
-       gsl_multifit_linear(m, &b.vector, &result.vector, covariance, &chisq,
-                           work);
-       gsl_matrix_free(m);
-       gsl_matrix_free(covariance);
-       gsl_multifit_linear_free(work);
-
-       free(tmp);
-
-       return 0;
+       return ret;
 }
 
 static int polynomial_linearize(double *dst, struct polynomial *p, double val)
@@ -568,19 +531,10 @@ static int characterize_pwm(struct pwm_info *dst, int 
pref, unsigned range)
                if (err)
                        error(EXIT, 0, "read_doubles");
 
-               err = math.stats.mean(&mean, p, len/sizeof(*p));
-               if (err)
-                       error(EXIT, 0, "estimate_mean");
-
-               err = math.stats.stddev(&stddev, p, len/sizeof(*p), mean);
-               if (err)
-                       error(EXIT, 0, "estimate_stddev");
-
-               err = math.stats.stddev_of_mean(&stddev_of_mean, p,
-                                               len/sizeof(*p), mean);
-               if (err)
-                       error(EXIT, 0, "estimate_stddev_of_mean");
-
+               math.stats.mean(&mean, p, len/sizeof(*p));
+               math.stats.stddev(&stddev, p, len/sizeof(*p), mean);
+               math.stats.stddev_of_mean(&stddev_of_mean, p,
+                                         len/sizeof(*p), mean);
                dst->node[i].up_tick = up_ticks;
                dst->node[i].mean = mean;
        }
diff --git a/utils/analogy/calibration_ni_m.h b/utils/analogy/calibration_ni_m.h
index 7cbdce3..102d271 100644
--- a/utils/analogy/calibration_ni_m.h
+++ b/utils/analogy/calibration_ni_m.h
@@ -157,9 +157,9 @@ struct codes_info {
        int nb_codes;
 };
 
-typedef int (*statistics_standard_deviation_of_mean_function)(double *, double 
[], int, double );
-typedef int (*statistics_standard_deviation_function)(double *, double [], 
int, double);
-typedef int (*statistics_mean_function)(double *, double [], int);
+typedef void (*statistics_standard_deviation_of_mean_function)(double *, 
double [], int, double );
+typedef void (*statistics_standard_deviation_function)(double *, double [], 
int, double);
+typedef void (*statistics_mean_function)(double *, double [], int);
 
 struct statistics_ops {
        statistics_standard_deviation_of_mean_function stddev_of_mean;


_______________________________________________
Xenomai-git mailing list
Xenomai-git@xenomai.org
http://www.xenomai.org/mailman/listinfo/xenomai-git

Reply via email to