Changeset 582


Ignore:
Timestamp:
May 9, 2006, 3:41:40 PM (16 years ago)
Author:
Markus Ringnér
Message:

Modified addding arrays to Averagers so templates are used to allow for addition of all array types with operator[]. Modified Distance so operator() can use arrays of different types.

Location:
trunk/c++_tools/statistics
Files:
1 added
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/c++_tools/statistics/Averager.h

    r557 r582  
    4545
    4646    ///
    47     /// Adding each value in vector \a v \a n (default=1)
    48     /// number of times.
    49     ///
    50     inline void add(const gslapi::vector& v, const long n=1)
    51     { n_+=n*v.size(); x_+=n*v.sum(); xx_+=n*(v*v);}
    52 
     47    /// Adding each value in an array \a v \a n (default=1)
     48    /// number of times. The requirements for the type T of the
     49    /// array \a v are: operator[] returning an element and function
     50    /// size() returning the number of elements.
     51    ///   
     52    ///
     53    template <typename T>
     54    void  add_values(const T& v, const long n=1);
    5355
    5456    ///
     
    153155    double  x_, xx_;
    154156  };
     157 
     158  // Template implementations
     159  template <typename T>
     160  void  Averager::add_values(const T& v, const long n)
     161  {
     162    for (size_t i=0; i<v.size(); i++)
     163      add(v[i],n);
     164  }
     165
    155166
    156167}} // of namespace statistics and namespace theplu
  • trunk/c++_tools/statistics/AveragerPair.cc

    r490 r582  
    1919  }
    2020 
    21   void AveragerPair::add(const gslapi::vector& x, const gslapi::vector& y)
    22   {
    23     assert(x.size()==y.size());
    24     for (size_t i=0; i<x.size(); i++)
    25       add(x(i),y(i));
    26   }
    2721
    2822}} // of namespace statistics and namespace theplu
  • trunk/c++_tools/statistics/AveragerPair.h

    r510 r582  
    4848
    4949    ///
    50     /// Adding pairs of data points with value \a x and \a y.
     50    /// Adding pairs of arrays with data points \a x and \a y.
    5151    ///
    52     void add(const gslapi::vector& x, const gslapi::vector& y);
     52    /// The requirements for the types T1 and T2 of the arrays \a x
     53    /// and \a y are: operator[] returning an element and function
     54    /// size() returning the number of elements.
     55    ///   
     56    template <typename T1, typename T2>
     57    void add_values(const T1& x, const T2& y);
    5358
    5459    ///
     
    146151  };
    147152
     153  // Template implementations
     154  template <typename T1, typename T2>
     155  void AveragerPair::add_values(const T1& x, const T2& y)
     156  {
     157    assert(x.size()==y.size());
     158    for (size_t i=0; i<x.size(); i++)
     159      add(x[i],y[i]);
     160  }
     161
     162
    148163}} // of namespace statistics and namespace theplu
    149164
  • trunk/c++_tools/statistics/AveragerPairWeighted.cc

    r476 r582  
    2525  }
    2626
    27   void  AveragerPairWeighted::add(const gslapi::vector& x,
    28                                   const gslapi::vector& y,
    29                                   const gslapi::vector& wx,
    30                                   const gslapi::vector& wy)
    31   {
    32     for (size_t i=0; i<x.size(); i++)
    33       add(x(i),y(i),wx(i),wy(i));
    34   }
    35 
    3627}} // of namespace statistics and namespace theplu
  • trunk/c++_tools/statistics/AveragerPairWeighted.h

    r494 r582  
    4646
    4747    ///
    48     /// Adding pair of data and corresponding weight in vectors
     48    /// Adding pair of data and corresponding pair of weights in arrays
    4949    ///
    50     void add(const gslapi::vector& x,
    51              const gslapi::vector& y,
    52              const gslapi::vector& wx,
    53              const gslapi::vector& wy);
     50    ///
     51    /// The requirements for the types T1, T2, T3 and T4 of the arrays
     52    /// are: operator[] returning an element and function /// size()
     53    /// returning the number of elements.
     54    ///
     55    template <typename T1,typename T2,typename T3,typename T4>
     56    void add_values(const T1& x,
     57                    const T2& y,
     58                    const T3& wx,
     59                    const T4& wy);
    5460
    5561    ///
     
    113119  };
    114120
     121  template <typename T1,typename T2,typename T3,typename T4>
     122  void  AveragerPairWeighted::add_values(const T1& x,
     123                                         const T2& y,
     124                                         const T3& wx,
     125                                         const T4& wy)
     126  {
     127    for (size_t i=0; i<x.size(); i++)
     128      add(x[i],y[i],wx[i],wy[i]);
     129  }
     130
     131
    115132}} // of namespace statistics and namespace theplu
    116133
  • trunk/c++_tools/statistics/AveragerWeighted.cc

    r501 r582  
    1313 
    1414
    15   void AveragerWeighted::add(const gslapi::vector& x, const gslapi::vector& w)
    16   {
    17     assert(x.size()==w.size());
    18     for (size_t i=0; i<x.size(); i++)
    19       add(x(i),w(i));
    20   }
    21 
    22 
    23 
    2415  AveragerWeighted AveragerWeighted::operator+=(const AveragerWeighted& a)
    2516  {
  • trunk/c++_tools/statistics/AveragerWeighted.h

    r494 r582  
    6666
    6767    ///
    68     /// Adding each value in vector \a x and corresponding value in
    69     /// weight vector \a w.
    70     ///
    71     void add(const gslapi::vector& x, const gslapi::vector& w);
     68    /// Adding each value in an array \a x and corresponding value in
     69    /// weight array \a w.
     70    ///
     71    /// The requirements for the types T1 and T2 of the arrays \a x
     72    /// and \a w are: operator[] returning an element and function
     73    /// size() returning the number of elements.
     74    ///
     75    template <typename T1, typename T2>
     76    void add_values(const T1& x, const T2& w);
    7277
    7378    ///
     
    200205  };
    201206
     207  // Template implementations
     208  template <typename T1, typename T2>
     209  void AveragerWeighted::add_values(const T1& x, const T2& w)
     210  {
     211    assert(x.size()==w.size());
     212    for (size_t i=0; i<x.size(); i++)
     213      add(x[i],w[i]);
     214  }
     215
    202216///
    203217/// The AveragerWeighted output operator
  • trunk/c++_tools/statistics/Distance.h

    r505 r582  
    99    class vector;
    1010  }
     11  namespace classifier {
     12    class DataLookup1D;
     13  }
     14
    1115
    1216namespace statistics{
    1317  ///
    14   /// Interface class for calculating distances
     18  /// Interface class for calculating distances between arrays.
    1519  ///
    1620  class Distance
     
    2731
    2832    virtual double operator()(const gslapi::vector& x,
    29                       const gslapi::vector& y) const = 0;
     33                              const gslapi::vector& y) const = 0;
    3034
    3135
     36    virtual double operator()(const classifier::DataLookup1D& x,
     37                              const classifier::DataLookup1D& y) const;
     38       
     39   
    3240    virtual double operator()(const gslapi::vector& x,
    33                       const gslapi::vector& y,
    34                       const gslapi::vector& wx,
    35                       const gslapi::vector& wy) const = 0;
    36 
    37 
     41                              const gslapi::vector& y,
     42                              const gslapi::vector& wx,
     43                              const gslapi::vector& wy) const = 0;
     44   
     45    virtual double operator()(const classifier::DataLookup1D& x,
     46                              const classifier::DataLookup1D& y,
     47                              const classifier::DataLookup1D& wx,
     48                              const classifier::DataLookup1D& wy) const;
     49   
    3850  private:
    3951  };
  • trunk/c++_tools/statistics/LinearWeighted.cc

    r495 r582  
    2323    gslapi::vector dummie(w.size(),1);
    2424    AveragerPairWeighted ap;
    25     ap.add(x,y,w,dummie);
     25    ap.add_values(x,y,w,dummie);
    2626
    2727    double m_x = ap.x_averager().mean();
  • trunk/c++_tools/statistics/Makefile.am

    r580 r582  
    2828  Averager.cc AveragerPair.cc AveragerWeighted.cc \
    2929  AveragerPairWeighted.cc \
     30  Distance.cc \
    3031  Fisher.cc FoldChange.cc \
    3132  Histogram.cc Kernel.cc KernelBox.cc KernelTriCube.cc Linear.cc \
  • trunk/c++_tools/statistics/PearsonDistance.cc

    r505 r582  
    1010namespace statistics{
    1111
    12     double PearsonDistance::operator()(const gslapi::vector& x,
    13                       const gslapi::vector& y) const
    14     {
    15       AveragerPair ap;
    16       ap.add(x,y);
    17       return 1-ap.correlation();
    18     }
     12  double PearsonDistance::operator()(const gslapi::vector& x,
     13                                     const gslapi::vector& y) const
     14  {
     15    AveragerPair ap;
     16    ap.add_values(x,y);
     17    return 1-ap.correlation();
     18  }
    1919
    2020
    21     double PearsonDistance::operator()(const gslapi::vector& x,
    22                       const gslapi::vector& y,
    23                       const gslapi::vector& wx,
    24                       const gslapi::vector& wy) const
    25     {
    26       AveragerPairWeighted ap;
    27       ap.add(x,y,wx, wy);
    28       return 1-ap.correlation();
     21  double PearsonDistance::operator()(const gslapi::vector& x,
     22                                     const gslapi::vector& y,
     23                                     const gslapi::vector& wx,
     24                                     const gslapi::vector& wy) const
     25  {
     26    AveragerPairWeighted ap;
     27    ap.add_values(x,y,wx, wy);
     28    return 1-ap.correlation();   
     29  }
    2930
    30     }
     31
     32
     33
    3134}} // of namespace statistics and namespace theplu
    3235
  • trunk/c++_tools/statistics/PearsonDistance.h

    r505 r582  
    66#include <c++_tools/statistics/Distance.h>
    77
    8 #include <cmath>
    9 
    10 
    118namespace theplu{
    129 
     
    1411    class vector;
    1512  }
     13
     14  namespace classifier {
     15    class DataLookup1D
     16;
     17  }
     18
    1619
    1720namespace statistics{
     
    2932    }
    3033
    31     ~PearsonDistance()
     34    virtual ~PearsonDistance()
    3235    {
    3336    }   
    3437   
    35     double operator()(const gslapi::vector& x,
    36                       const gslapi::vector& y) const;
     38    // Use all operator() from Distance except the ones that are
     39    // overloaded in this class.
     40    using Distance::operator();
     41
     42    virtual double operator()(const gslapi::vector& x,
     43                              const gslapi::vector& y) const;
    3744
    3845
    39     double operator()(const gslapi::vector& x,
    40                       const gslapi::vector& y,
    41                       const gslapi::vector& wx,
    42                       const gslapi::vector& wy) const;
    43 
     46    virtual double operator()(const gslapi::vector& x,
     47                              const gslapi::vector& y,
     48                              const gslapi::vector& wx,
     49                              const gslapi::vector& wy) const;
    4450
    4551  private:
Note: See TracChangeset for help on using the changeset viewer.