CEBL  2.1
cppR_stats.hpp
Go to the documentation of this file.
1 /*
2 * CEBL : CSU EEG Brain-Computer Interface Lab
3 *
4 * Author: Jeshua Bratman - jeshuabratman@gmail.com
5 *
6 * This file is part of CEBL.
7 *
8 * CEBL is free software; you can redistribute it and/or modify it.
9 * We only ask that if you use our code that you cite the source in
10 * your project or publication.
11 *
12 * EEG Group (www.cs.colostate.edu/eeg)
13 * Department of Computer Science
14 * Colorado State University
15 *
16 */
17 
18 
19 //--------------------------------------------------
20 // cppR_stats.hpp
21 // Matrix and Vector utilities
22 
23 #ifndef CPPR_STATS_H //make sure this only gets included once
24 #define CPPR_STATS_H
25 
26 #include <cppR/cppR_includes.hpp>
27 
28 //--------------------------------------------------
29 namespace cppR
30 {
31  //==============================
32 
38  template < typename T >
39  ublas::vector<T>
40  rowMeans(ublas::matrix<T> &data)
41  {
42  unsigned int rows = data.size1();
43  unsigned int cols = data.size2();
44  ublas::vector<T> means(rows);
45 
46  for(unsigned int i=0; i<rows; i++)
47  {
48  ublas::matrix_row<ublas::matrix<T> > mr (data, i);
49  T mean = T(ublas::sum(mr))/T(cols);
50  means(i) = mean;
51  }
52  return means;
53  }
54 
55  //==============================
61  template < typename T >
62  ublas::vector<T>
63  colMeans(ublas::matrix<T> &data)
64  {
65  int rows = data.size1();
66  int cols = data.size2();
67  ublas::vector<T> means(cols);
68 
69  for(int i=0; i<cols; i++)
70  {
71  ublas::matrix_column<ublas::matrix<T> > mc (data, i);
72  T mean = T(ublas::sum(mc))/T(rows);
73  means(i) = mean;
74  }
75  return means;
76  }
77 
78  //==============================
79 
85  template < typename T >
86  ublas::vector<T>
87  rowSums(ublas::matrix<T> &data)
88  {
89  int rows = data.size1();
90  ublas::vector<T> sums(rows);
91 
92  for(int i=0; i<rows; i++)
93  {
94  ublas::matrix_row<ublas::matrix<T> > mc (data, i);
95  T s = T(ublas::sum(mc));
96  sums(i) = s;
97  }
98  return sums;
99  }
100  //==============================
106  template < typename T >
107  ublas::vector<T>
108  colSums(ublas::matrix<T> &data)
109  {
110  int cols = data.size2();
111  ublas::vector<T> sums(cols);
112 
113  for(int i=0; i<cols; i++)
114  {
115  ublas::matrix_column<ublas::matrix<T> > mc (data, i);
116  T s = T(ublas::sum(mc));
117  sums(i) = s;
118  }
119  return sums;
120  }
121 
122 
123  //==============================
129  template < typename T >
130  ublas::matrix<T> t(const ublas::matrix<T> &m) { return trans(m); };
131 
132  //==============================
138  template < typename T >
139  int ncol(const ublas::matrix<T> &m) { return m.size2(); };
140 
141  //==============================
147  template < typename T >
148  int nrow(const ublas::matrix<T> &m) { return m.size1(); };
149 
150 
151 
152  //==============================
161  template < typename T >
162  double frobeniusNorm(ublas::matrix<T> m)
163  {
164  return sqrt(sum(square(m)));
165  }
166 
167 
168 
169  //==============================
175  template < typename T >
176  ublas::vector<T> unique(const ublas::vector<T> &v)
177  {
178  ublas::vector<T> ret = v;
179  typename ublas::vector<T>::iterator it;
180 
181  std::sort(ret.begin(), ret.end());
182  it = std::unique(ret.begin(), ret.end());
183  ret.resize(it - ret.begin());
184 
185  return ret;
186  }
187 
188 
189  //==============================
196  template < typename T >
197  int count(const T &value, const ublas::vector<T> &v)
198  {
199  int c = 0;
200  for(unsigned int i=0; i<v.size(); i++)
201  if(v[i]==value)
202  c++;
203  return c;
204  }
205 
206 
207  //==============================
213  template < typename T >
214  ublas::matrix<T> square(const ublas::matrix<T> &m)
215  {
216  ublas::matrix<T> s = m;
217  for(unsigned int row=0; row<m.size1(); row++)
218  for(unsigned int col=0; col<m.size2(); col++)
219  s(row,col)*=m(row,col);
220  return s;
221  }
222 
223 
224  //==============================
230  template < typename T >
231  T sum(const ublas::vector<T> & v)
232  {
233  T sum = 0;
234  for(unsigned int i=0;i<v.size();i++)
235  sum+=v[i];
236  return sum;
237  }
238 
239  //==============================
245  template < typename T >
246  T sum(const ublas::matrix<T> & m)
247  {
248  T s = T(0);
249  for(unsigned int row=0; row<m.size1(); row++)
250  for(unsigned int col=0; col<m.size2(); col++)
251  s+=m(row,col);
252 
253  return s;
254  }
255 
256  //==============================
262  template < typename T >
263  ublas::vector<T> vsqrt(const ublas::vector<T> & v1)
264  {
265  ublas::vector<T> roots(v1.size());
266  for(unsigned int i=0;i<v1.size();i++)
267  {
268  double m = static_cast<double>(v1[i]);
269  roots[i] = static_cast<T>(sqrt(m));
270  }
271  return roots;
272  }
273 
274  //==============================
280  template < typename T >
281  T min(const ublas::matrix<T> & m)
282  {
283  T s = m(0,0);
284  for(unsigned int row=0; row<m.size1(); row++)
285  for(unsigned int col=0; col<m.size2(); col++)
286  if(m(row,col) < s)
287  s = m(row,col);
288  return s;
289  }
290 
291  //==============================
297  template < typename T >
298  T min(const ublas::vector<T> & v)
299  {
300  T s = v[0];
301  for(unsigned int row=1; row<v.size(); row++)
302  if(v[row] < s)
303  s = v[row];
304  return s;
305  }
306 
307  //==============================
313  template < typename T >
314  T max(const ublas::matrix<T> & m)
315  {
316  T s = m(0,0);
317  for(unsigned int row=0; row<m.size1(); row++)
318  for(unsigned int col=0; col<m.size2(); col++)
319  if(m(row,col) > s)
320  s = m(row,col);
321  return s;
322  }
323 
324  //==============================
330  template < typename T >
331  T max(const ublas::vector<T> & v)
332  {
333  T s = v[0];
334  for(unsigned int row=1; row<v.size(); row++)
335  if(v[row] > s)
336  s = v[row];
337  return s;
338  }
339 
340  //==============================
346  template < typename T >
347  int whichMax(const ublas::vector<T> &v)
348  {
349  T mx = max(v);
350  for(unsigned int i=0; i<v.size(); i++)
351  if(v[i]==mx)
352  return i;
353  return 0;
354  }
355 
356  //==============================
362  template < typename T >
363  int whichMin(const ublas::vector<T> &v)
364  {
365  T mn = min(v);
366  for(unsigned int i=0; i<v.size(); i++)
367  if(v[i]==mn)
368  return i;
369  return 0;
370  }
371  //==============================
377  template < typename T >
378  T mean(const ublas::vector<T> & v)
379  {
380  T mean = sum(v);
381  mean/=v.size();
382  return mean;
383  }
384 
385  //==============================
391  template < typename T >
392  T mean(const ublas::matrix<T> & m)
393  {
394  T mean = sum(m);
395  mean/=m.size1() * m.size2();
396  return mean;
397  }
398 
399 
400  //==============================
407  template < typename T >
408  double
409  var(const ublas::vector<T> & v, double m)
410  {
411  double d;
412  double sum = 0;
413  for(unsigned int i=0; i<v.size(); i++)
414  {
415  sum+=(v[i]-m) * (v[i]-m);
416  }
417  sum/=v.size();
418  return sum;
419  }
420 
426  template < typename T >
427  double
428  var(const ublas::vector<T> & v)
429  {
430  return(var(v,mean(v)));
431  }
432 
433 
439  template < typename T >
440  double sd(const ublas::vector<T> & v)
441  {
442  return sqrt(var(v));
443  }
444 
450  template < typename T >
451  ublas::vector<double> sd(const ublas::matrix<T> & m)
452  {
453  ublas::vector<double> ret(ncol(m));
454  for(unsigned int i=0;i<ncol(m);i++)
455  {
456  ublas::vector<double> temp = column(m,i);
457  ret[i] = sd(temp);
458  }
459  return ret;
460  }
461 
462 }//end of namespace
463 
464 
465 #endif