Changeset 680


Ignore:
Timestamp:
Oct 11, 2006, 7:49:03 PM (15 years ago)
Author:
Jari Häkkinen
Message:

Addresses #153. Introduced yat namespace. Removed alignment namespace. Clean up of code.

Location:
trunk
Files:
1 deleted
178 edited

Legend:

Unmodified
Added
Removed
  • trunk/doc/namespaces.doxygen

    r675 r680  
    2424///
    2525/// @namespace theplu
    26 /// All our C++ projects should ideally be defined within theplu namespace.
    2726///
    28 /// @brief
     27/// All C++ projects at the Department of Theoretical Physics should
     28/// ideally be defined within a common namespace. We use theplu for
     29/// this common namespace.
     30///
     31/// @brief The Department of Theoretical Physics namespace as we
     32/// define it.
     33///
    2934
     35///
     36/// @namespace theplu::yat
    3037///
    31 /// @namespace theplu::random
     38/// All classes and functions are for the yat project is placed in sub
     39/// namespaces of the yat namespace.
    3240///
    33 /// @brief Random number distributions
     41/// @brief yat project namespace.
    3442///
    3543
    3644///
    37 /// @namespace theplu::utility
     45/// @namespace theplu::yat::random
    3846///
    39 /// @brief Miscellaneous
     47/// The yat random number related functionality is placed with the
     48/// random namespace.
     49///
     50/// @brief Random number distributions.
    4051///
    4152
    4253///
    43 /// @namespace theplu::utility::alignment
    44 /// All alignment algorithm should go into the aligment namespace
     54/// @namespace theplu::yat::utility
    4555///
    46 /// @brief Container for alignment algorithms
     56/// Needed yat functionality that we don't know where to put usually
     57/// ends up in the utility namespace until we figure out their proper
     58/// namespace location.
     59///
     60/// @brief Miscellaneous functionality.
    4761///
    4862
    4963///
    50 /// @namespace theplu::classifier
    51 /// All classes associated with usage of
    52 /// classifiers should be defined within this namespace
     64/// @namespace theplu::yat::classifier
     65///
     66/// All classes associated with usage of classifiers are defined
     67/// within this namespace.
    5368///
    54 /// @brief Classifier related classes
     69/// @brief Classifier related classes.
    5570///
    5671
    5772///
    58 /// @namespace theplu::statistics All classes and functions related to
    59 /// statistical methods or functions should be defined within this
    60 /// namespace.
    61 /// See <a href="Statistics/index.html">Weighted Statistics document</a><br>
     73/// @namespace theplu::yat::statistics
    6274///
    63 /// @brief Statistical methods and functions
     75/// All classes and functions related to statistical methods or
     76/// functions are defined within this namespace. See <a
     77/// href="Statistics/index.html">Weighted Statistics document</a><br>.
     78///
     79/// @brief Statistical methods, classes, and functions.
     80///
    6481
    6582///
    66 /// @namespace theplu::statistics::regression
     83/// @namespace theplu::yat::regression
    6784///
    68 /// @brief Statistical modeling of data
     85/// @brief Statistical modeling of data.
     86///
    6987
    70 
  • trunk/test/alignment_test.cc

    r675 r680  
    3636#include <vector>
    3737
    38 using namespace theplu;
     38using namespace theplu::yat;
    3939
    4040void read_vector(std::vector<double>& v,std::string& str)
     
    7575             const std::vector<double>& l2,
    7676             const double sigma,
    77              theplu::utility::matrix& dot_matrix,
     77             theplu::yat::utility::matrix& dot_matrix,
    7878             std::vector<std::pair<size_t,size_t> >& path)
    7979{
    80   dot_matrix  = theplu::utility::matrix(l1.size(),l2.size());
     80  dot_matrix  = theplu::yat::utility::matrix(l1.size(),l2.size());
    8181  for (size_t i=0; i<l1.size(); i++)
    8282    for (size_t j=0; j<l2.size(); j++) {
     
    8585      dot_matrix(i,j)=match(l1[i],l2[j],sigma);
    8686    }
    87   return theplu::utility::alignment::NeedlemanWunsch(dot_matrix,path,0);
     87  return theplu::yat::utility::NeedlemanWunsch(dot_matrix,path,0);
    8888}
    8989
  • trunk/test/averager_test.cc

    r675 r680  
    3232#include <iostream>
    3333
    34 using namespace theplu::statistics;
     34using namespace theplu::yat::statistics;
    3535
    3636//Forward declarations
     
    122122  // Testing AveragerWeighted
    123123  *error << "testing AveragerWeighted" << std::endl;
    124   theplu::utility::vector x(3,0);
     124  theplu::yat::utility::vector x(3,0);
    125125  x(0)=0;
    126126  x(1)=1;
    127127  x(2)=2;
    128   theplu::utility::vector w(3,1);
    129   theplu::statistics::AveragerWeighted aw;
     128  theplu::yat::utility::vector w(3,1);
     129  theplu::yat::statistics::AveragerWeighted aw;
    130130  aw.add_values(x,w);
    131131  a.reset();
     
    183183  AveragerPairWeighted apw;
    184184  x(0)=0; x(1)=1; x(2)=2;
    185   theplu::utility::vector y(3,0);
     185  theplu::yat::utility::vector y(3,0);
    186186  x(0)=0; x(1)=0; x(2)=2;
    187187  apw.add_values(x,y,w,w);
  • trunk/test/commandline_test.cc

    r675 r680  
    2727#include <iostream>
    2828
    29 using namespace theplu;
     29using namespace theplu::yat;
    3030
    3131int main(const int argc,const char* argv[])
  • trunk/test/consensus_inputranker_test.cc

    r675 r680  
    5050
    5151  ifstream is("data/rank_data.txt");
    52   theplu::utility::matrix data_tmp(is);
    53   theplu::classifier::MatrixLookup data(data_tmp);
     52  theplu::yat::utility::matrix data_tmp(is);
     53  theplu::yat::classifier::MatrixLookup data(data_tmp);
    5454  is.close();
    5555
    5656  is.open("data/rank_target.txt");
    57   theplu::classifier::Target target(is);
     57  theplu::yat::classifier::Target target(is);
    5858  is.close();
    5959
    6060 
    61   theplu::statistics::ROC roc;
    62   theplu::classifier::CrossValidationSampler sampler(target,30,3);
     61  theplu::yat::statistics::ROC roc;
     62  theplu::yat::classifier::CrossValidationSampler sampler(target,30,3);
    6363  *error << "Building Consensus_Inputranker" << std::endl;
    64   theplu::classifier::IRRank retrieve;
    65   theplu::classifier::ConsensusInputRanker cir(sampler,data,roc,retrieve);
     64  theplu::yat::classifier::IRRank retrieve;
     65  theplu::yat::classifier::ConsensusInputRanker cir(sampler,data,roc,retrieve);
    6666  *error << "Done" << std::endl;
    6767
     
    7676  }
    7777
    78   theplu::utility::matrix flag(data.rows(),data.columns(),1);
     78  theplu::yat::utility::matrix flag(data.rows(),data.columns(),1);
    7979  // Peter, fix weighted version instead
    80   theplu::classifier::ConsensusInputRanker cir2(sampler,data,roc,retrieve);
     80  theplu::yat::classifier::ConsensusInputRanker cir2(sampler,data,roc,retrieve);
    8181
    8282  if (cir2.id(0)!=2 || cir2.id(1)!=0 || cir2.id(2)!=1){
     
    8989    ok=false;
    9090  }
    91  
    92  
     91
    9392  if (error!=&std::cerr)
    9493    delete error;
  • trunk/test/crossvalidation_test.cc

    r675 r680  
    4141int main(const int argc,const char* argv[])
    4242
    43   using namespace theplu;
     43  using namespace theplu::yat;
    4444 
    4545  std::ostream* error;
  • trunk/test/data_lookup_1d_test.cc

    r679 r680  
    3333#include <cmath>
    3434
    35 using namespace theplu;
     35using namespace theplu::yat;
    3636
    3737utility::matrix matrix(size_t n);
     
    4040int main(const int argc,const char* argv[])
    4141{
    42   using namespace theplu::classifier;
     42  using namespace theplu::yat::classifier;
    4343
    4444  std::ostream* error;
  • trunk/test/ensemble_test.cc

    r675 r680  
    4545int main(const int argc,const char* argv[])
    4646
    47   using namespace theplu;
     47  using namespace theplu::yat;
    4848
    4949  std::ostream* error;
  • trunk/test/feature_selection_test.cc

    r675 r680  
    3030#include <string>
    3131
    32 using namespace theplu;
     32using namespace theplu::yat;
    3333
    3434int main(const int argc,const char* argv[])
  • trunk/test/inputranker_test.cc

    r675 r680  
    3636int main(const int argc,const char* argv[])
    3737{
    38   using namespace theplu;
     38  using namespace theplu::yat;
    3939  std::ostream* error;
    4040  if (argc>1 && argv[1]==std::string("-v"))
     
    4949
    5050  std::ifstream is("data/rank_data.txt");
    51   theplu::utility::matrix data_tmp(is);
    52   theplu::classifier::MatrixLookup data(data_tmp);
     51  theplu::yat::utility::matrix data_tmp(is);
     52  theplu::yat::classifier::MatrixLookup data(data_tmp);
    5353  is.close();
    5454
  • trunk/test/kernel_lookup_test.cc

    r675 r680  
    3333#include <vector>
    3434
    35 using namespace theplu;
     35using namespace theplu::yat;
    3636
    3737int main(const int argc,const char* argv[])
    3838{
    39   using namespace theplu::classifier;
     39  using namespace theplu::yat::classifier;
    4040
    4141  std::ostream* error;
  • trunk/test/kernel_test.cc

    r679 r680  
    3636#include <vector>
    3737
    38 using namespace theplu;
     38using namespace theplu::yat;
    3939
    4040bool test_MEV(const classifier::MatrixLookup& data,
  • trunk/test/matrix_lookup_test.cc

    r675 r680  
    2929#include <vector>
    3030
    31 using namespace theplu;
     31using namespace theplu::yat;
    3232
    3333utility::matrix matrix(size_t n);
     
    3535int main(const int argc,const char* argv[])
    3636{
    37   using namespace theplu::classifier;
     37  using namespace theplu::yat::classifier;
    3838
    3939  std::ostream* error;
  • trunk/test/matrix_test.cc

    r679 r680  
    3434    : m_(i,j,value) {}
    3535
    36   inline theplu::utility::vector
    37   row(const size_t& i) { return theplu::utility::vector(m_,i); }
    38 
    39   inline const theplu::utility::matrix& matrix(void) const { return m_; }
     36  inline theplu::yat::utility::vector
     37  row(const size_t& i) { return theplu::yat::utility::vector(m_,i); }
     38
     39  inline const theplu::yat::utility::matrix& matrix(void) const { return m_; }
    4040
    4141private:
    42   theplu::utility::matrix m_;
     42  theplu::yat::utility::matrix m_;
    4343};
    4444
     
    4646int main(const int argc,const char* argv[])
    4747{
    48   using namespace theplu;
     48  using namespace theplu::yat;
    4949  std::ostream* error;
    5050  if (argc>1 && argv[1]==std::string("-v"))
  • trunk/test/ncc_test.cc

    r675 r680  
    3939#include <cmath>
    4040
    41 using namespace theplu;
     41using namespace theplu::yat;
    4242
    4343int main(const int argc,const char* argv[])
  • trunk/test/nni_test.cc

    r675 r680  
    3232#include <string>
    3333
    34 using namespace theplu;
     34using namespace theplu::yat;
    3535
    3636void check_file_access(std::string& str)
  • trunk/test/pca_test.cc

    r675 r680  
    3131
    3232
    33 using namespace theplu;
     33using namespace theplu::yat;
    3434int main()
    3535{
  • trunk/test/regression_test.cc

    r675 r680  
    3939
    4040
    41 using namespace theplu;
     41using namespace theplu::yat;
    4242
    4343bool Local_test(statistics::regression::OneDimensionalWeighted&,
     
    4747int main(const int argc,const char* argv[])
    4848{
    49   using namespace theplu;
    5049  std::ostream* error;
    5150  if (argc>1 && argv[1]==std::string("-v"))
  • trunk/test/rnd_test.cc

    r675 r680  
    3030int main(const int argc,const char* argv[])
    3131{
    32   using namespace theplu;
    3332  std::ostream* error;
    3433  if (argc>1 && argv[1]==std::string("-v"))
     
    4241  bool ok = true;
    4342
    44   theplu::random::RNG* rng=theplu::random::RNG::instance();
     43  theplu::yat::random::RNG* rng=theplu::yat::random::RNG::instance();
    4544  // testing that minimal integer is zero for the generator
    4645  if (rng->min()){
  • trunk/test/score_test.cc

    r675 r680  
    3737
    3838
    39 using namespace theplu;
     39using namespace theplu::yat;
    4040
    4141int main(const int argc,const char* argv[])
  • trunk/test/statistics_test.cc

    r675 r680  
    3232int main()
    3333
    34   using namespace theplu;
     34  using namespace theplu::yat;
    3535  utility::vector gsl_vec(10);
    3636  std::vector<double> data;
  • trunk/test/stl_utility_test.cc

    r675 r680  
    3030
    3131
    32   using namespace theplu;
     32  using namespace theplu::yat;
    3333  bool ok = true;
    3434
  • trunk/test/subset_generator_test.cc

    r675 r680  
    4040#include <string>
    4141
    42 using namespace theplu;
     42using namespace theplu::yat;
    4343
    4444int main(const int argc,const char* argv[])
  • trunk/test/svd_test.cc

    r675 r680  
    2727#include "yat/utility/vector.h"
    2828
    29 using namespace theplu;
     29using namespace theplu::yat;
    3030
    3131double this_norm(const utility::matrix& A)
     
    4646
    4747  // initialise a random test-matrix
    48   theplu::random::ContinuousUniform rnd;
     48  theplu::yat::random::ContinuousUniform rnd;
    4949  utility::matrix A(m,n);
    5050  for (size_t i=0; i<m; ++i)
     
    5454  utility::SVD svd(A);
    5555  svd.decompose(algo);
    56   theplu::utility::vector s(svd.s());
     56  theplu::yat::utility::vector s(svd.s());
    5757  utility::matrix S(s.size(),s.size());
    5858  for (size_t i=0; i<s.size(); ++i)
  • trunk/test/svm_test.cc

    r675 r680  
    3737#include <limits>
    3838
    39 using namespace theplu;
     39using namespace theplu::yat;
    4040
    4141int main(const int argc,const char* argv[])
     
    123123
    124124  is.open("data/nm_alpha_linear_matlab.txt");
    125   theplu::utility::vector alpha_matlab(is);
     125  theplu::yat::utility::vector alpha_matlab(is);
    126126  is.close();
    127127
    128128  classifier::KernelLookup kv(kernel);
    129   theplu::classifier::SVM svm(kv, target);
     129  theplu::yat::classifier::SVM svm(kv, target);
    130130  if (!svm.train()){
    131131    ok=false;
     
    133133  }
    134134
    135   theplu::utility::vector alpha = svm.alpha();
     135  theplu::yat::utility::vector alpha = svm.alpha();
    136136     
    137137  // Comparing alpha to alpha_matlab
    138   theplu::utility::vector diff_alpha(alpha);
     138  theplu::yat::utility::vector diff_alpha(alpha);
    139139  diff_alpha-=alpha_matlab;
    140140  if (diff_alpha*diff_alpha> 1e-10 ){
     
    144144
    145145  // Comparing output to target
    146   theplu::utility::vector output(svm.output());
     146  theplu::yat::utility::vector output(svm.output());
    147147  double slack = 0;
    148148  for (unsigned int i=0; i<target.size(); i++){
  • trunk/test/target_test.cc

    r675 r680  
    2929#include <vector>
    3030
    31 using namespace theplu;
     31using namespace theplu::yat;
    3232
    3333int main(const int argc,const char* argv[])
  • trunk/test/utility_test.cc

    r676 r680  
    3131
    3232
    33   using namespace theplu;
     33  using namespace theplu::yat;
    3434
    3535  std::ostream* error;
  • trunk/test/vector_test.cc

    r675 r680  
    3030#include <sstream>
    3131
    32 using namespace theplu;
     32using namespace theplu::yat;
    3333
    3434void check_file_access(std::string& str)
  • trunk/yat/classifier/ConsensusInputRanker.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/ConsensusInputRanker.h"
    25 
    26 #include "yat/classifier/InputRanker.h"
    27 #include "yat/classifier/IRRetrieve.h"
    28 #include "yat/classifier/MatrixLookup.h"
    29 #include "yat/classifier/MatrixLookupWeighted.h"
    30 #include "yat/classifier/Sampler.h"
    31 #include "yat/classifier/Target.h"
     24#include "ConsensusInputRanker.h"
     25#include "InputRanker.h"
     26#include "IRRetrieve.h"
     27#include "MatrixLookup.h"
     28#include "MatrixLookupWeighted.h"
     29#include "Sampler.h"
     30#include "Target.h"
    3231#include "yat/statistics/Score.h"
    3332#include "yat/statistics/utility.h"
     
    4241
    4342namespace theplu {
     43namespace yat {
    4444namespace classifier { 
    4545
     
    111111
    112112
    113 }} // of namespace classifier and namespace theplu
     113}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/ConsensusInputRanker.h

    r677 r680  
    1 #ifndef _theplu_classifier_consensusinputranker_
    2 #define _theplu_classifier_consensusinputranker_
     1#ifndef _theplu_yat_classifier_consensusinputranker_
     2#define _theplu_yat_classifier_consensusinputranker_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/InputRanker.h"
     27#include "InputRanker.h"
    2828
    2929namespace theplu {
     30namespace yat {
    3031
    3132  class statistics::Score;
     
    128129  };
    129130
    130 }} // of namespace classifier and namespace theplu
     131}}} // of namespace classifier, yat, and theplu
    131132
    132133#endif
  • trunk/yat/classifier/CrossValidationSampler.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/CrossValidationSampler.h"
    25 #include "yat/classifier/Target.h"
     24#include "CrossValidationSampler.h"
     25#include "Target.h"
    2626#include "yat/random/random.h"
    2727
     
    3232
    3333namespace theplu {
     34namespace yat {
    3435namespace classifier { 
    3536
     
    9697  }
    9798
    98 }} // of namespace classifier and namespace theplu
     99}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/CrossValidationSampler.h

    r675 r680  
    1 #ifndef _theplu_classifier_crossvalidation_sampler_
    2 #define _theplu_classifier_crossvalidation_sampler_
     1#ifndef _theplu_yat_classifier_crossvalidation_sampler_
     2#define _theplu_yat_classifier_crossvalidation_sampler_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/Sampler.h"
     27#include "Sampler.h"
    2828
    2929namespace theplu {
     30namespace yat {
    3031namespace classifier { 
    3132
     
    6566  };
    6667
    67 }} // of namespace classifier and namespace theplu
     68}}} // of namespace classifier, yat, and theplu
    6869
    6970#endif
  • trunk/yat/classifier/DataLookup1D.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/DataLookup1D.h"
    25 #include "yat/classifier/DataLookup2D.h"
    26 #include "yat/classifier/MatrixLookup.h"
     24#include "DataLookup1D.h"
     25#include "DataLookup2D.h"
     26#include "MatrixLookup.h"
    2727
    2828#include <cassert>
     
    3131
    3232namespace theplu {
     33namespace yat {
    3334namespace classifier {
    3435
     
    8384  }
    8485
    85 }} // of namespace classifier and namespace theplu
     86}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/DataLookup1D.h

    r675 r680  
    1 #ifndef _theplu_classifier_dataLookup1D_
    2 #define _theplu_classifier_dataLookup1D_
     1#ifndef _theplu_yat_classifier_dataLookup1D_
     2#define _theplu_yat_classifier_dataLookup1D_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/DataLookup2D.h"
     27#include "DataLookup2D.h"
    2828
    2929#include <cassert>
     
    3232
    3333namespace theplu {
     34namespace yat {
    3435namespace classifier { 
    3536
     
    123124  std::ostream& operator<<(std::ostream& s, const DataLookup1D& v);
    124125 
    125 }} // of namespace classifier and namespace theplu
     126}}} // of namespace classifier, yat, and theplu
    126127
    127128#endif
  • trunk/yat/classifier/DataLookup2D.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/DataLookup2D.h"
     24#include "DataLookup2D.h"
    2525
    2626#include <vector>
     
    3131#endif
    3232
    33 
    3433namespace theplu {
     34namespace yat {
    3535namespace classifier {
    3636
     
    125125  }
    126126
    127 }} // of namespace classifier and namespace theplu
     127}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/DataLookup2D.h

    r675 r680  
    1 #ifndef _theplu_classifier_DataLookup2D_
    2 #define _theplu_classifier_DataLookup2D_
     1#ifndef _theplu_yat_classifier_DataLookup2D_
     2#define _theplu_yat_classifier_DataLookup2D_
    33
    44// $Id$
     
    2929
    3030namespace theplu {
     31namespace yat {
    3132namespace classifier { 
    3233
     
    165166  }; 
    166167 
    167 }} // of namespace classifier and namespace theplu
     168}}} // of namespace classifier, yat, and theplu
    168169
    169170#endif
  • trunk/yat/classifier/DataLookupWeighted1D.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/DataLookupWeighted1D.h"
    25 #include "yat/classifier/MatrixLookupWeighted.h"
     24#include "DataLookupWeighted1D.h"
     25#include "MatrixLookupWeighted.h"
    2626
    2727#include <cassert>
     
    3030
    3131namespace theplu {
     32namespace yat {
    3233namespace classifier {
    3334
     
    6465
    6566
    66 }} // of namespace classifier and namespace theplu
     67}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/DataLookupWeighted1D.h

    r675 r680  
    1 #ifndef _theplu_classifier_dataLookup_weighted_1D_
    2 #define _theplu_classifier_dataLookup_weighted_1D_
     1#ifndef _theplu_yat_classifier_dataLookup_weighted_1D_
     2#define _theplu_yat_classifier_dataLookup_weighted_1D_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/MatrixLookupWeighted.h"
     27#include "MatrixLookupWeighted.h"
    2828
    2929#include <iostream>
     
    3131
    3232namespace theplu {
     33namespace yat {
    3334namespace classifier { 
    3435
     
    119120  };
    120121
    121 }} // of namespace classifier and namespace theplu
     122}}} // of namespace classifier, yat, and theplu
    122123
    123124#endif
  • trunk/yat/classifier/EnsembleBuilder.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/EnsembleBuilder.h"
    25 
    26 #include "yat/classifier/DataLookup2D.h"
    27 #include "yat/classifier/KernelLookup.h"
    28 #include "yat/classifier/SubsetGenerator.h"
    29 #include "yat/classifier/SupervisedClassifier.h"
    30 #include "yat/classifier/Target.h"
    31 
     24#include "EnsembleBuilder.h"
     25#include "DataLookup2D.h"
     26#include "KernelLookup.h"
     27#include "SubsetGenerator.h"
     28#include "SupervisedClassifier.h"
     29#include "Target.h"
    3230#include "yat/utility/matrix.h"
    3331
    3432namespace theplu {
     33namespace yat {
    3534namespace classifier {
    3635
     
    125124  }
    126125
    127 }} // of namespace classifier and namespace theplu
     126}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/EnsembleBuilder.h

    r677 r680  
    1 #ifndef _theplu_classifier_ensemblebuilder_
    2 #define _theplu_classifier_ensemblebuilder_
     1#ifndef _theplu_yat_classifier_ensemblebuilder_
     2#define _theplu_yat_classifier_ensemblebuilder_
    33
    44// $Id$
     
    3030
    3131namespace theplu {
     32namespace yat {
    3233namespace classifier { 
    3334
     
    105106  };
    106107 
    107 }} // of namespace classifier and namespace theplu
     108}}} // of namespace classifier, yat, and theplu
    108109
    109110#endif
  • trunk/yat/classifier/FeatureSelector.cc

    r675 r680  
    2323
    2424#include "FeatureSelector.h"
    25 
    2625#include "MatrixLookup.h"
    2726#include "MatrixLookupWeighted.h"
     
    3029
    3130namespace theplu {
     31namespace yat {
    3232namespace classifier {
    3333
     
    6565  }
    6666
    67 } // end of namespace classifier
    68 } // end of namespace theplu
     67}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/FeatureSelector.h

    r675 r680  
    1 #ifndef _theplu_classifier_featureselector_
    2 #define _theplu_classifier_featureselector_
     1#ifndef _theplu_yat_classifier_featureselector_
     2#define _theplu_yat_classifier_featureselector_
    33
    44// $Id$
     
    2929
    3030namespace theplu {
     31namespace yat {
    3132namespace classifier {
    3233  class MatrixLookup;
     
    100101  };
    101102
    102 } // end of namespace classifier
    103 } // end of namespace theplu
     103}}} // of namespace classifier, yat, and theplu
    104104
    105105#endif
  • trunk/yat/classifier/FeatureSelectorIR.cc

    r675 r680  
    2323
    2424#include "FeatureSelectorIR.h"
    25 
    2625#include "FeatureSelector.h"
    2726#include "MatrixLookup.h"
     
    3130
    3231namespace theplu {
     32namespace yat {
    3333namespace classifier {
    3434
     
    7676  }
    7777
    78 
    79 } // end of namespace classifier
    80 } // end of namespace theplu
     78}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/FeatureSelectorIR.h

    r675 r680  
    1 #ifndef _theplu_classifier_featureselectorir_
    2 #define _theplu_classifier_featureselectorir_
     1#ifndef _theplu_yat_classifier_featureselectorir_
     2#define _theplu_yat_classifier_featureselectorir_
    33
    44// $Id$
     
    3030
    3131namespace theplu {
     32namespace yat {
    3233namespace classifier {
    3334
     
    6465  };
    6566
    66 } // end of namespace classifier
    67 } // end of namespace theplu
     67}}} // of namespace classifier, yat, and theplu
    6868
    6969#endif
  • trunk/yat/classifier/FeatureSelectorRandom.cc

    r675 r680  
    3131
    3232namespace theplu {
     33namespace yat {
    3334namespace classifier {
    3435
     
    6970  }
    7071
    71 
    72 } // end of namespace classifier
    73 } // end of namespace theplu
     72}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/FeatureSelectorRandom.h

    r675 r680  
    1 #ifndef _theplu_classifier_featureselector_random_
    2 #define _theplu_classifier_featureselector_random_
     1#ifndef _theplu_yat_classifier_featureselector_random_
     2#define _theplu_yat_classifier_featureselector_random_
    33
    44// $Id$
     
    2828
    2929namespace theplu {
     30namespace yat {
    3031namespace classifier {
    3132
     
    6465  };
    6566
    66 } // end of namespace classifier
    67 } // end of namespace theplu
     67}}} // of namespace classifier, yat, and theplu
    6868
    6969#endif
  • trunk/yat/classifier/GaussianKernelFunction.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/GaussianKernelFunction.h"
    25 
    26 #include "yat/classifier/KernelFunction.h"
    27 #include "yat/classifier/DataLookup1D.h"
    28 #include "yat/classifier/DataLookupWeighted1D.h"
     24#include "GaussianKernelFunction.h"
     25#include "KernelFunction.h"
     26#include "DataLookup1D.h"
     27#include "DataLookupWeighted1D.h"
    2928
    3029#include <math.h>
    3130
    3231namespace theplu {
     32namespace yat {
    3333namespace classifier { 
    3434
     
    9090
    9191
    92 }} // of namespace svn and namespace theplu
     92}}} // of namespace svn, yat, and theplu
  • trunk/yat/classifier/GaussianKernelFunction.h

    r675 r680  
    1 #ifndef _theplu_classifier_gaussian_kernel_function_
    2 #define _theplu_classifier_gaussian_kernel_function_
     1#ifndef _theplu_yat_classifier_gaussian_kernel_function_
     2#define _theplu_yat_classifier_gaussian_kernel_function_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/KernelFunction.h"
    28 #include "yat/classifier/DataLookup1D.h"
     27#include "KernelFunction.h"
     28#include "DataLookup1D.h"
    2929
    3030#include <cmath>
    3131
    3232namespace theplu {
     33namespace yat {
    3334namespace classifier {
    3435
     
    7879  }; // class GaussianKernelFunction
    7980
    80 }} // of namespace classifier and namespace theplu
     81}}} // of namespace classifier, yat, and theplu
    8182
    8283#endif
  • trunk/yat/classifier/IGP.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/IGP.h"
    25 
    26 #include "yat/classifier/DataLookup1D.h"
    27 #include "yat/classifier/MatrixLookup.h"
    28 #include "yat/classifier/Target.h"
    29 #include "yat/classifier/utility.h"
     24#include "IGP.h"
     25#include "DataLookup1D.h"
     26#include "MatrixLookup.h"
     27#include "Target.h"
     28#include "utility.h"
    3029#include "yat/utility/vector.h"
    3130#include "yat/statistics/Distance.h"
     
    3635
    3736namespace theplu {
     37namespace yat {
    3838namespace classifier {
    3939 
     
    8383  {
    8484  }
    85  
    86  
    87 }} // of namespace classifier and namespace theplu
     85
     86}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/IGP.h

    r675 r680  
    1 #ifndef _theplu_classifier_igp_
    2 #define _theplu_classifier_igp_
     1#ifndef _theplu_yat_classifier_igp_
     2#define _theplu_yat_classifier_igp_
    33
    44// $Id$
     
    2828
    2929namespace theplu {
     30namespace yat {
    3031
    3132  namespace statistics {
     
    7172  }; 
    7273 
    73 }} // of namespace classifier and namespace theplu
     74}}} // of namespace classifier, yat, and theplu
    7475
    7576#endif
  • trunk/yat/classifier/IRRank.h

    r675 r680  
    1 #ifndef _theplu_classifier_ir_rank_
    2 #define _theplu_classifier_ir_rank_
     1#ifndef _theplu_yat_classifier_ir_rank_
     2#define _theplu_yat_classifier_ir_rank_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/InputRanker.h"
    28 #include "yat/classifier/IRRetrieve.h"
     27#include "InputRanker.h"
     28#include "IRRetrieve.h"
    2929
    3030namespace theplu {
     31namespace yat {
    3132namespace classifier { 
    3233
     
    5051
    5152
    52 }} // of namespace classifier and namespace theplu
     53}}} // of namespace classifier, yat, and theplu
    5354
    5455#endif
  • trunk/yat/classifier/IRRetrieve.h

    r675 r680  
    1 #ifndef _theplu_classifier_ir_retrieve_
    2 #define _theplu_classifier_ir_retrieve_
     1#ifndef _theplu_yat_classifier_ir_retrieve_
     2#define _theplu_yat_classifier_ir_retrieve_
    33
    44// $Id$
     
    2626
    2727namespace theplu {
     28namespace yat {
    2829namespace classifier { 
    2930
     
    5152
    5253
    53 }} // of namespace classifier and namespace theplu
     54}}} // of namespace classifier, yat, and theplu
    5455
    5556#endif
  • trunk/yat/classifier/IRScore.h

    r675 r680  
    1 #ifndef _theplu_classifier_ir_score_
    2 #define _theplu_classifier_ir_score_
     1#ifndef _theplu_yat_classifier_ir_score_
     2#define _theplu_yat_classifier_ir_score_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/InputRanker.h"
     27#include "InputRanker.h"
    2828
    2929namespace theplu {
     30namespace yat {
    3031namespace classifier { 
    3132
     
    4950
    5051
    51 }} // of namespace classifier and namespace theplu
     52}}} // of namespace classifier, yat, and theplu
    5253
    5354#endif
  • trunk/yat/classifier/InputRanker.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/InputRanker.h"
    25 
    26 #include "yat/classifier/MatrixLookup.h"
    27 #include "yat/classifier/MatrixLookupWeighted.h"
    28 #include "yat/classifier/DataLookup1D.h"
    29 #include "yat/classifier/DataLookupWeighted1D.h"
    30 #include "yat/classifier/Target.h"
     24#include "InputRanker.h"
     25#include "MatrixLookup.h"
     26#include "MatrixLookupWeighted.h"
     27#include "DataLookup1D.h"
     28#include "DataLookupWeighted1D.h"
     29#include "Target.h"
    3130#include "yat/statistics/ROC.h"
    3231#include "yat/utility/stl_utility.h"
    3332
     33#include <cmath>
    3434#include <functional>
    3535#include <utility>
    3636#include <vector>
    3737
    38 #include <cmath>
    39 
    4038namespace theplu {
     39namespace yat {
    4140namespace classifier { 
    4241
     
    9998
    10099
    101 }} // of namespace classifier and namespace theplu
     100}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/InputRanker.h

    r675 r680  
    1 #ifndef _theplu_classifier_inputranker_
    2 #define _theplu_classifier_inputranker_
     1#ifndef _theplu_yat_classifier_inputranker_
     2#define _theplu_yat_classifier_inputranker_
    33
    44// $Id$
     
    2828
    2929namespace theplu {
     30namespace yat {
    3031namespace statistics {
    3132  class Score;
     
    9394
    9495
    95 }} // of namespace classifier and namespace theplu
     96}}} // of namespace classifier, yat, and theplu
    9697
    9798#endif
  • trunk/yat/classifier/Kernel.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/Kernel.h"
    25 
    26 #include "yat/classifier/DataLookup1D.h"
    27 #include "yat/classifier/DataLookupWeighted1D.h"
    28 #include "yat/classifier/KernelFunction.h"
    29 #include "yat/classifier/MatrixLookup.h"
     24#include "Kernel.h"
     25#include "DataLookup1D.h"
     26#include "DataLookupWeighted1D.h"
     27#include "KernelFunction.h"
     28#include "MatrixLookup.h"
    3029
    3130#include <vector>
    3231
    3332namespace theplu {
     33namespace yat {
    3434namespace classifier {
    3535
     
    107107  }
    108108
    109 }} // of namespace classifier and namespace theplu
     109}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/Kernel.h

    r675 r680  
    1 #ifndef _theplu_classifier_kernel_
    2 #define _theplu_classifier_kernel_
     1#ifndef _theplu_yat_classifier_kernel_
     2#define _theplu_yat_classifier_kernel_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/DataLookup2D.h"
    28 #include "yat/classifier/KernelFunction.h"
    29 #include "yat/classifier/MatrixLookupWeighted.h"
     27#include "DataLookup2D.h"
     28#include "KernelFunction.h"
     29#include "MatrixLookupWeighted.h"
    3030
    3131#include <cctype>
     
    3333
    3434namespace theplu {
     35namespace yat {
    3536namespace classifier {
    3637
     
    198199  }; // class Kernel
    199200
    200 }} // of namespace classifier and namespace theplu
     201}}} // of namespace classifier, yat, and theplu
    201202
    202203#endif
  • trunk/yat/classifier/KernelFunction.h

    r675 r680  
    1 #ifndef _theplu_classifier_kernel_function_
    2 #define _theplu_classifier_kernel_function_
     1#ifndef _theplu_yat_classifier_kernel_function_
     2#define _theplu_yat_classifier_kernel_function_
    33
    44// $Id$
     
    2626
    2727namespace theplu {
     28namespace yat {
    2829namespace classifier {
    2930  class DataLookup1D;
     
    7475  }; // class KernelFunction
    7576
    76 }} // of namespace classifier and namespace theplu
     77}}} // of namespace classifier, yat, and theplu
    7778
    7879#endif
  • trunk/yat/classifier/KernelLookup.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/KernelLookup.h"
    25 #include "yat/classifier/DataLookup2D.h"
    26 #include "yat/classifier/MatrixLookup.h"
    27 #include "yat/classifier/MatrixLookupWeighted.h"
    28 
     24#include "KernelLookup.h"
     25#include "DataLookup2D.h"
     26#include "MatrixLookup.h"
     27#include "MatrixLookupWeighted.h"
    2928
    3029#include <cassert>
     
    3433
    3534namespace theplu {
     35namespace yat {
    3636namespace classifier { 
    3737
     
    263263  }
    264264
    265 }} // of namespace classifier and namespace theplu
     265}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/KernelLookup.h

    r675 r680  
    1 #ifndef _theplu_classifier_kernel_lookup_
    2 #define _theplu_classifier_kernel_lookup_
     1#ifndef _theplu_yat_classifier_kernel_lookup_
     2#define _theplu_yat_classifier_kernel_lookup_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/Kernel.h"
    28 #include "yat/classifier/DataLookup2D.h"
    29 #include "yat/classifier/MatrixLookup.h"
     27#include "Kernel.h"
     28#include "DataLookup2D.h"
     29#include "MatrixLookup.h"
    3030
    3131#include <vector>
    3232
    3333namespace theplu {
     34namespace yat {
    3435namespace classifier {
    3536
     
    275276  }; // class KernelLookup
    276277
    277 }} // of namespace classifier and namespace theplu
     278}}} // of namespace classifier, yat, and theplu
    278279
    279280#endif
  • trunk/yat/classifier/Kernel_MEV.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/Kernel_MEV.h"
    25 
    26 #include "yat/classifier/DataLookup1D.h"
    27 #include "yat/classifier/DataLookupWeighted1D.h"
     24#include "Kernel_MEV.h"
     25#include "DataLookup1D.h"
     26#include "DataLookupWeighted1D.h"
    2827
    2928namespace theplu {
     29namespace yat {
    3030namespace classifier { 
    3131
     
    8383
    8484
    85 }} // of namespace classifier and namespace theplu
     85}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/Kernel_MEV.h

    r675 r680  
    1 #ifndef _theplu_classifier_kernel_mev_
    2 #define _theplu_classifier_kernel_mev_
     1#ifndef _theplu_yat_classifier_kernel_mev_
     2#define _theplu_yat_classifier_kernel_mev_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/DataLookup1D.h"
    28 #include "yat/classifier/Kernel.h"
    29 #include "yat/classifier/KernelFunction.h"
     27#include "DataLookup1D.h"
     28#include "Kernel.h"
     29#include "KernelFunction.h"
    3030
    3131namespace theplu {
     32namespace yat {
    3233namespace classifier {
    3334  class MatrixLookup;
     
    123124  }; // class Kernel_MEV
    124125
    125 }} // of namespace classifier and namespace theplu
     126}}} // of namespace classifier, yat, and theplu
    126127
    127128#endif
  • trunk/yat/classifier/Kernel_SEV.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/Kernel_SEV.h"
    25 
    26 #include "yat/classifier/DataLookup1D.h"
    27 #include "yat/classifier/DataLookupWeighted1D.h"
    28 #include "yat/classifier/Kernel.h"
    29 #include "yat/classifier/KernelFunction.h"
    30 #include "yat/classifier/MatrixLookup.h"
     24#include "Kernel_SEV.h"
     25#include "DataLookup1D.h"
     26#include "DataLookupWeighted1D.h"
     27#include "Kernel.h"
     28#include "KernelFunction.h"
     29#include "MatrixLookup.h"
    3130#include "yat/utility/matrix.h"
    3231
    3332namespace theplu {
     33namespace yat {
    3434namespace classifier { 
    3535
     
    100100
    101101
    102 }} // of namespace classifier and namespace theplu
     102}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/Kernel_SEV.h

    r675 r680  
    1 #ifndef _theplu_classifier_kernel_sev_
    2 #define _theplu_classifier_kernel_sev_
     1#ifndef _theplu_yat_classifier_kernel_sev_
     2#define _theplu_yat_classifier_kernel_sev_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/Kernel.h"
     27#include "Kernel.h"
    2828#include "yat/utility/matrix.h"
    2929
    3030namespace theplu {
     31namespace yat {
    3132namespace classifier {
    3233
     
    119120  }; // class Kernel_SEV
    120121
    121 }} // of namespace classifier and namespace theplu
     122}}} // of namespace classifier, yat, and theplu
    122123
    123124#endif
  • trunk/yat/classifier/MatrixLookup.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/MatrixLookup.h"
    25 
     24#include "MatrixLookup.h"
    2625#include "yat/utility/matrix.h"
    2726
     
    3332
    3433namespace theplu {
     34namespace yat {
    3535namespace classifier {
    3636
     
    223223
    224224
    225 }} // of namespace classifier and namespace theplu
     225}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/MatrixLookup.h

    r675 r680  
    1 #ifndef _theplu_classifier_matrix_lookup_
    2 #define _theplu_classifier_matrix_lookup_
     1#ifndef _theplu_yat_classifier_matrix_lookup_
     2#define _theplu_yat_classifier_matrix_lookup_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/DataLookup2D.h"
     27#include "DataLookup2D.h"
    2828#include "yat/utility/matrix.h"
    2929
     
    3131
    3232namespace theplu {
     33namespace yat {
    3334namespace classifier { 
    34 
    35  
    3635
    3736  ///
     
    257256  std::ostream& operator<< (std::ostream& s, const MatrixLookup&);
    258257
    259 }} // of namespace classifier and namespace theplu
     258}}} // of namespace classifier, yat, and theplu
    260259
    261260#endif
  • trunk/yat/classifier/MatrixLookupWeighted.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/MatrixLookupWeighted.h"
    25 
     24#include "MatrixLookupWeighted.h"
    2625#include "yat/utility/matrix.h"
    2726
     
    3332
    3433namespace theplu {
     34namespace yat {
    3535namespace classifier {
    3636
     
    302302
    303303
    304 }} // of namespace classifier and namespace theplu
     304}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/MatrixLookupWeighted.h

    r675 r680  
    1 #ifndef _theplu_classifier_matrix_lookup_weighted_
    2 #define _theplu_classifier_matrix_lookup_weighted_
     1#ifndef _theplu_yat_classifier_matrix_lookup_weighted_
     2#define _theplu_yat_classifier_matrix_lookup_weighted_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/DataLookup2D.h"
     27#include "DataLookup2D.h"
    2828#include "yat/utility/matrix.h"
    2929
     
    3131
    3232namespace theplu {
     33namespace yat {
    3334namespace classifier { 
    3435
    35  
    3636  ///
    3737  /// A MatrixLookupWeighted is very similar to a MatrixLookup, but
     
    290290  std::ostream& operator<< (std::ostream& s, const MatrixLookupWeighted&);
    291291
    292 }} // of namespace classifier and namespace theplu
     292}}} // of namespace classifier, yat, and theplu
    293293
    294294#endif
  • trunk/yat/classifier/NBC.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/NBC.h"
    25 
    26 #include "yat/classifier/DataLookup2D.h"
    27 #include "yat/classifier/MatrixLookup.h"
    28 #include "yat/classifier/MatrixLookupWeighted.h"
    29 #include "yat/classifier/Target.h"
     24#include "NBC.h"
     25#include "DataLookup2D.h"
     26#include "MatrixLookup.h"
     27#include "MatrixLookupWeighted.h"
     28#include "Target.h"
    3029#include "yat/statistics/AveragerWeighted.h"
    3130#include "yat/utility/matrix.h"
     
    3433
    3534namespace theplu {
     35namespace yat {
    3636namespace classifier {
    3737
     
    100100
    101101
    102 }} // of namespace classifier and namespace theplu
     102}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/NBC.h

    r675 r680  
    1 #ifndef _theplu_classifier_nbc_
    2 #define _theplu_classifier_nbc_
     1#ifndef _theplu_yat_classifier_nbc_
     2#define _theplu_yat_classifier_nbc_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/SupervisedClassifier.h"
     27#include "SupervisedClassifier.h"
    2828#include "yat/utility/matrix.h"
    2929
    3030namespace theplu {
     31namespace yat {
    3132namespace classifier { 
    3233
     
    8485  };
    8586 
    86 }} // of namespace classifier and namespace theplu
     87}}} // of namespace classifier, yat, and theplu
    8788
    8889#endif
  • trunk/yat/classifier/NCC.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/NCC.h"
    25 
    26 #include "yat/classifier/DataLookup1D.h"
    27 #include "yat/classifier/DataLookup2D.h"
    28 #include "yat/classifier/MatrixLookup.h"
    29 #include "yat/classifier/MatrixLookupWeighted.h"
    30 #include "yat/classifier/Target.h"
     24#include "NCC.h"
     25#include "DataLookup1D.h"
     26#include "DataLookup2D.h"
     27#include "MatrixLookup.h"
     28#include "MatrixLookupWeighted.h"
     29#include "Target.h"
    3130#include "yat/utility/matrix.h"
    3231#include "yat/utility/vector.h"
     
    4039
    4140namespace theplu {
     41namespace yat {
    4242namespace classifier {
    4343
     
    165165//  }
    166166
    167 }} // of namespace classifier and namespace theplu
     167}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/NCC.h

    r675 r680  
    1 #ifndef _theplu_classifier_ncc_
    2 #define _theplu_classifier_ncc_
     1#ifndef _theplu_yat_classifier_ncc_
     2#define _theplu_yat_classifier_ncc_
    33
    44// $Id$
     
    2626
    2727#include "yat/utility/matrix.h"
    28 
    29 #include "yat/classifier/SupervisedClassifier.h"
     28#include "SupervisedClassifier.h"
    3029
    3130#include <map>
    3231
    3332namespace theplu {
     33namespace yat {
    3434
    3535  namespace utlitity {
     
    114114 
    115115 
    116 }} // of namespace classifier and namespace theplu
     116}}} // of namespace classifier, yat, and theplu
    117117
    118118#endif
  • trunk/yat/classifier/PolynomialKernelFunction.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/PolynomialKernelFunction.h"
    25 #include "yat/classifier/DataLookup1D.h"
    26 #include "yat/classifier/DataLookupWeighted1D.h"
    27 
     24#include "PolynomialKernelFunction.h"
     25#include "DataLookup1D.h"
     26#include "DataLookupWeighted1D.h"
    2827#include "yat/statistics/AveragerPairWeighted.h"
    2928
    3029#include <cmath>
    3130
    32 
    3331namespace theplu {
     32namespace yat {
    3433namespace classifier { 
    3534
     
    7271
    7372
    74 }} // of namespace cpptools and namespace theplu
     73}}} // of namespace cpptools, yat, and theplu
  • trunk/yat/classifier/PolynomialKernelFunction.h

    r675 r680  
    1 #ifndef _theplu_classifier_polynomial_kernel_function_
    2 #define _theplu_classifier_polynomial_kernel_function_
     1#ifndef _theplu_yat_classifier_polynomial_kernel_function_
     2#define _theplu_yat_classifier_polynomial_kernel_function_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/KernelFunction.h"
    28 #include "yat/classifier/DataLookup1D.h"
    29 
     27#include "KernelFunction.h"
     28#include "DataLookup1D.h"
    3029
    3130#include <cmath>
    3231
    33 
    3432namespace theplu {
     33namespace yat {
    3534namespace classifier {
    3635
     
    8685  }; // class PolynomialKernelFunction
    8786
    88 }} // of namespace classifier and namespace theplu
     87}}} // of namespace classifier, yat, and theplu
    8988
    9089#endif
  • trunk/yat/classifier/SVM.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/SVM.h"
    25 
    26 #include "yat/classifier/DataLookup2D.h"
     24#include "SVM.h"
     25#include "DataLookup2D.h"
    2726#include "yat/random/random.h"
    2827#include "yat/statistics/Averager.h"
     
    3837#include <vector>
    3938
    40 
    4139namespace theplu {
     40namespace yat {
    4241namespace classifier { 
    4342
     
    240239
    241240
    242   bool SVM::choose(const theplu::utility::vector& E)
     241  bool SVM::choose(const theplu::yat::utility::vector& E)
    243242  {
    244243    // First check for violation among SVs
     
    374373
    375374
    376 }} // of namespace classifier and namespace theplu
     375}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/SVM.h

    r675 r680  
    1 #ifndef _theplu_classifier_svm_
    2 #define _theplu_classifier_svm_
     1#ifndef _theplu_yat_classifier_svm_
     2#define _theplu_yat_classifier_svm_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/KernelLookup.h"
    28 #include "yat/classifier/SupervisedClassifier.h"
    29 #include "yat/classifier/SVindex.h"
    30 #include "yat/classifier/Target.h"
     27#include "KernelLookup.h"
     28#include "SupervisedClassifier.h"
     29#include "SVindex.h"
     30#include "Target.h"
    3131#include "yat/utility/vector.h"
    3232
     
    3434#include <vector>
    3535
    36 
    3736namespace theplu {
     37namespace yat {
    3838namespace classifier { 
    3939
     
    107107    /// @return output
    108108    ///
    109     inline const theplu::utility::vector& output(void) const { return output_; }
     109    inline const theplu::yat::utility::vector&
     110    output(void) const { return output_; }
    110111
    111112    ///
     
    192193    ///  can be found
    193194    ///
    194     bool choose(const theplu::utility::vector&);
     195    bool choose(const theplu::yat::utility::vector&);
    195196
    196197    ///
     
    217218  };
    218219
    219 }} // of namespace classifier and namespace theplu
     220}}} // of namespace classifier, yat, and theplu
    220221
    221222#endif
  • trunk/yat/classifier/SVindex.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/SVindex.h"
    25 
    26 #include "yat/classifier/DataLookup2D.h"
     24#include "SVindex.h"
     25#include "DataLookup2D.h"
    2726#include "yat/random/random.h"
    2827#include "yat/statistics/Averager.h"
     
    3837#include <vector>
    3938
    40 
    4139namespace theplu {
     40namespace yat {
    4241namespace classifier { 
    4342
     
    158157  }
    159158
    160 }} // of namespace classifier and namespace theplu
     159}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/SVindex.h

    r675 r680  
    1 #ifndef _theplu_classifier_sv_index_
    2 #define _theplu_classifier_sv_index_
     1#ifndef _theplu_yat_classifier_sv_index_
     2#define _theplu_yat_classifier_sv_index_
    33
    44// $Id$
     
    3030#include <vector>
    3131
    32 
    3332namespace theplu {
     33namespace yat {
    3434namespace classifier { 
    3535
     
    110110#endif /* DOXYGEN_SHOULD_SKIP_THIS */
    111111
    112 }} // of namespace classifier and namespace theplu
     112}}} // of namespace classifier, yat, and theplu
    113113
    114114#endif
  • trunk/yat/classifier/Sampler.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/Sampler.h"
    25 #include "yat/classifier/Target.h"
     24#include "Sampler.h"
     25#include "Target.h"
    2626
    2727namespace theplu {
     28namespace yat {
    2829namespace classifier { 
    2930
     
    3738  }
    3839
    39 
    40 }} // of namespace classifier and namespace theplu
     40}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/Sampler.h

    r675 r680  
    1 #ifndef _theplu_classifier_sampler_
    2 #define _theplu_classifier_sampler_
     1#ifndef _theplu_yat_classifier_sampler_
     2#define _theplu_yat_classifier_sampler_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/Target.h"
     27#include "Target.h"
    2828
    2929#include <vector>
    3030
    3131namespace theplu {
     32namespace yat {
    3233namespace classifier { 
    3334
     
    111112  };
    112113
    113 }} // of namespace classifier and namespace theplu
     114}}} // of namespace classifier, yat, and theplu
    114115
    115116#endif
  • trunk/yat/classifier/SubsetGenerator.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/SubsetGenerator.h"
    25 #include "yat/classifier/DataLookup2D.h"
    26 #include "yat/classifier/FeatureSelector.h"
    27 #include "yat/classifier/KernelLookup.h"
    28 #include "yat/classifier/MatrixLookup.h"
    29 #include "yat/classifier/MatrixLookupWeighted.h"
    30 #include "yat/classifier/Target.h"
     24#include "SubsetGenerator.h"
     25#include "DataLookup2D.h"
     26#include "FeatureSelector.h"
     27#include "KernelLookup.h"
     28#include "MatrixLookup.h"
     29#include "MatrixLookupWeighted.h"
     30#include "Target.h"
    3131
    3232#include <algorithm>
     
    3737
    3838namespace theplu {
     39namespace yat {
    3940namespace classifier { 
    4041
     
    206207  }
    207208
    208 }} // of namespace classifier and namespace theplu
     209}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/SubsetGenerator.h

    r675 r680  
    1 #ifndef _theplu_classifier_subset_generator_
    2 #define _theplu_classifier_subset_generator_
     1#ifndef _theplu_yat_classifier_subset_generator_
     2#define _theplu_yat_classifier_subset_generator_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/classifier/Target.h"
    28 #include "yat/classifier/Sampler.h"
     27#include "Target.h"
     28#include "Sampler.h"
    2929
    3030#include <vector>
    3131
    3232namespace theplu {
     33namespace yat {
    3334namespace classifier { 
    3435  class DataLookup2D;
     
    164165  };
    165166
    166 }} // of namespace classifier and namespace theplu
     167}}} // of namespace classifier, yat, and theplu
    167168
    168169#endif
  • trunk/yat/classifier/SupervisedClassifier.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/SupervisedClassifier.h"
    25 #include "yat/classifier/InputRanker.h"
     24#include "SupervisedClassifier.h"
     25#include "InputRanker.h"
    2626
    2727namespace theplu {
     28namespace yat {
    2829namespace classifier {
    2930
     
    3334  }
    3435
    35   SupervisedClassifier::~SupervisedClassifier()
     36  SupervisedClassifier::~SupervisedClassifier(void)
    3637  {
    3738  }
    3839
    39 
    40 }}
     40}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/SupervisedClassifier.h

    r675 r680  
    1 #ifndef _theplu_classifier_supervisedclassifier_
    2 #define _theplu_classifier_supervisedclassifier_
     1#ifndef _theplu_yat_classifier_supervisedclassifier_
     2#define _theplu_yat_classifier_supervisedclassifier_
    33
    44// $Id$
     
    2828
    2929namespace theplu {
     30namespace yat {
    3031
    3132  namespace utility {
     
    4748  public:
    4849    ///
    49     /// Constructor. Taking a Target object.
     50    /// @brief Constructor taking a Target object.
    5051    ///
    5152    SupervisedClassifier(const Target&);
     
    5354
    5455    ///
    55     /// Destructor
     56    /// @brief Destructor
    5657    ///
    57     virtual ~SupervisedClassifier();
     58    virtual ~SupervisedClassifier(void);
    5859
    5960    ///
     
    9091  }; 
    9192 
    92 }} // of namespace classifier and namespace theplu
     93}}} // of namespace classifier, yat, and theplu
    9394
    9495#endif
  • trunk/yat/classifier/Target.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/Target.h"
     24#include "Target.h"
    2525#include "yat/random/random.h"
    2626#include "yat/utility/stl_utility.h"
     
    3737
    3838namespace theplu {
     39namespace yat {
    3940namespace classifier {
    4041
     
    160161
    161162
    162 }} // of namespace classifier and namespace theplu
     163}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/Target.h

    r675 r680  
    1 #ifndef _theplu_classifier_target_
    2 #define _theplu_classifier_target_
     1#ifndef _theplu_yat_classifier_target_
     2#define _theplu_yat_classifier_target_
    33
    44// $Id$
     
    2828
    2929#include <cassert>
     30#include <iosfwd>
    3031#include <map>
    3132#include <string>
    3233#include <vector>
    3334
    34 #include <iostream>
    35 
    3635namespace theplu {
     36namespace yat {
    3737namespace classifier { 
    3838
     
    171171  std::ostream& operator<<(std::ostream&, const Target& );
    172172
    173 }} // of namespace classifier and namespace theplu
     173}}} // of namespace classifier, yat, and theplu
    174174
    175175#endif
  • trunk/yat/classifier/utility.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/classifier/utility.h"
    25 
    26 
    27 #include "yat/classifier/DataLookup1D.h"
     24#include "utility.h"
     25#include "DataLookup1D.h"
    2826#include "yat/utility/vector.h"
    2927
    3028
    3129namespace theplu {
     30namespace yat {
    3231namespace classifier {
    3332
     
    3938  }
    4039
    41 }} // of namespace classifier and namespace theplu
     40}}} // of namespace classifier, yat, and theplu
  • trunk/yat/classifier/utility.h

    r675 r680  
    1 #ifndef _theplu_classifier_utility_
    2 #define _theplu_classifier_utility_
     1#ifndef _theplu_yat_classifier_utility_
     2#define _theplu_yat_classifier_utility_
    33
    44// $Id$
     
    2626
    2727namespace theplu {
     28namespace yat {
    2829
    2930  namespace utility {
     
    4041  void convert(const DataLookup1D&, utility::vector&);
    4142
    42 
    43 }} // of namespace classifier and namespace theplu
     43}}} // of namespace classifier, yat, and theplu
    4444
    4545#endif
  • trunk/yat/random/random.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/random/random.h"
     24#include "random.h"
    2525#include "yat/statistics/Histogram.h"
    2626
     
    2828#include <iostream>
    2929
    30 
    3130namespace theplu {
     31namespace yat {
    3232namespace random {
    33 
    3433
    3534  RNG* RNG::instance_ = NULL;
     
    4342
    4443
    45 
    4644  RNG::~RNG(void)
    4745  {
     
    5048    delete instance_;
    5149  }
    52 
    5350
    5451 
     
    7067
    7168
    72 
    7369  int RNG::set_state(const RNG_state& state)
    7470  {
    7571    return gsl_rng_memcpy(rng_, state.rng());
    7672  }
    77 
    7873
    7974
     
    8479 
    8580
    86 
    8781  RNG_state::~RNG_state(void)
    8882  {
     
    9084    rng_=NULL;
    9185  }
    92 
    9386
    9487
     
    10396
    10497
    105 
    10698  DiscreteGeneral::~DiscreteGeneral(void)
    10799  {
     
    111103  }
    112104
    113 
    114 }} // of namespace random and namespace theplu
     105}}} // of namespace random, yat, and theplu
  • trunk/yat/random/random.h

    r675 r680  
    1 #ifndef _theplu_random_
    2 #define _theplu_random_
     1#ifndef _theplu_yat_random_
     2#define _theplu_yat_random_
    33
    44// $Id$
     
    3333
    3434namespace theplu {
     35namespace yat {
    3536namespace random {
    3637
     
    545546  };
    546547
    547 
    548 }} // of namespace random and namespace theplu
     548}}} // of namespace random, yat, and theplu
    549549
    550550#endif
  • trunk/yat/statistics/Averager.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/Averager.h"
     24#include "Averager.h"
    2525
    2626namespace theplu {
    27 namespace statistics{
    28  
     27namespace yat {
     28namespace statistics {
     29
    2930  Averager::Averager(void)
    3031    : n_(0), x_(0), xx_(0)
     
    3637  {
    3738  }
    38  
     39
    3940  Averager::Averager(const Averager& a)
    4041    : n_(a.n_), x_(a.x_), xx_(a.xx_)
    4142  {
    4243  }
    43  
     44
    4445  const Averager& Averager::operator+=(const Averager& a)
    4546  {
     
    5051  }
    5152
    52 
    53 }} // of namespace statistics and namespace theplu
     53}}} // of namespace statistics, yat, and theplu
  • trunk/yat/statistics/Averager.h

    r675 r680  
    1 #ifndef _theplu_statistics_averager_
    2 #define _theplu_statistics_averager_
     1#ifndef _theplu_yat_statistics_averager_
     2#define _theplu_yat_statistics_averager_
    33
    44// $Id$
     
    2929
    3030namespace theplu{
     31namespace yat{
     32namespace statistics{
    3133
    32 namespace statistics{
    3334  class ostream;
    3435
     
    193194  }
    194195
    195 
    196 }} // of namespace statistics and namespace theplu
     196}}} // of namespace statistics, yat, and theplu
    197197
    198198#endif
  • trunk/yat/statistics/AveragerPair.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/AveragerPair.h"
    25 #include "yat/statistics/Averager.h"
     24#include "AveragerPair.h"
     25#include "Averager.h"
    2626
    2727#include <cassert>
     
    2929
    3030namespace theplu {
     31namespace yat {
    3132namespace statistics{
    3233 
    33 
    3434  const AveragerPair& AveragerPair::operator+=(const AveragerPair& a)
    3535  {
     
    3939    return *this;
    4040  }
    41  
    4241
    43 }} // of namespace statistics and namespace theplu
     42}}} // of namespace statistics, yat, and theplu
  • trunk/yat/statistics/AveragerPair.h

    r675 r680  
    1 #ifndef _theplu_statistics_averagerpair_
    2 #define _theplu_statistics_averagerpair_
     1#ifndef _theplu_yat_statistics_averagerpair_
     2#define _theplu_yat_statistics_averagerpair_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/Averager.h"
     27#include "Averager.h"
    2828
    2929#include <cassert>
     
    3131#include <utility>
    3232
    33 
    3433namespace theplu{
     34namespace yat{
    3535namespace statistics{
    3636
     
    183183
    184184
    185 }} // of namespace statistics and namespace theplu
     185}}} // of namespace statistics, yat, and theplu
    186186
    187187#endif
  • trunk/yat/statistics/AveragerPairWeighted.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/AveragerPairWeighted.h"
    25 #include "yat/statistics/AveragerPair.h"
    26 #include "yat/statistics/Averager.h"
     24#include "AveragerPairWeighted.h"
     25#include "AveragerPair.h"
     26#include "Averager.h"
    2727#include "yat/classifier/DataLookup1D.h"
    2828#include "yat/classifier/DataLookupWeighted1D.h"
     
    3232
    3333namespace theplu {
    34 namespace statistics{
     34namespace yat {
     35namespace statistics {
    3536 
    3637
     
    6667  }
    6768
    68 }} // of namespace statistics and namespace theplu
     69}}} // of namespace statistics, yat, and theplu
  • trunk/yat/statistics/AveragerPairWeighted.h

    r675 r680  
    1 #ifndef _theplu_statistics_averager_pair_weighted_
    2 #define _theplu_statistics_averager_pair_weighted_
     1#ifndef _theplu_yat_statistics_averager_pair_weighted_
     2#define _theplu_yat_statistics_averager_pair_weighted_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/AveragerWeighted.h"
     27#include "AveragerWeighted.h"
    2828
    2929#include <cmath>
    3030
    31 
    3231namespace theplu{
     32namespace yat{
    3333namespace classifier{
    3434  class DataLookup1D;
     
    176176
    177177
    178 }} // of namespace statistics and namespace theplu
     178}}} // of namespace statistics, yat and theplu
    179179
    180180#endif
  • trunk/yat/statistics/AveragerWeighted.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/AveragerWeighted.h"
     24#include "AveragerWeighted.h"
    2525
    2626namespace theplu {
     27namespace yat {
    2728namespace statistics{
    2829 
     
    3536
    3637
    37 }} // of namespace statistics and namespace theplu
     38}}} // of namespace statistics, yat and theplu
  • trunk/yat/statistics/AveragerWeighted.h

    r675 r680  
    1 #ifndef _theplu_statistics_averager_weighted_
    2 #define _theplu_statistics_averager_weighted_
     1#ifndef _theplu_yat_statistics_averager_weighted_
     2#define _theplu_yat_statistics_averager_weighted_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/Averager.h"
     27#include "Averager.h"
    2828
    2929#include <cmath>
    3030
    3131namespace theplu{
     32namespace yat{
    3233namespace statistics{
    3334
     
    243244///std::ostream& operator<<(std::ostream& s,const AveragerWeighted&);
    244245
    245 }} // of namespace statistics and namespace theplu
     246}}} // of namespace statistics, yat and theplu
    246247
    247248#endif
  • trunk/yat/statistics/Distance.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/Distance.h"
    25 
     24#include "Distance.h"
    2625#include "yat/classifier/DataLookup1D.h"
    2726#include "yat/classifier/utility.h"
     
    2928
    3029namespace theplu{
     30namespace yat{
    3131namespace statistics{
    3232
     
    5959
    6060
    61 }} // of namespace statistics and namespace theplu
     61}}} // of namespace statistics, yat and theplu
    6262
    6363
  • trunk/yat/statistics/Distance.h

    r675 r680  
    1 #ifndef _theplu_statistics_distance_
    2 #define _theplu_statistics_distance_
     1#ifndef _theplu_yat_statistics_distance_
     2#define _theplu_yat_statistics_distance_
    33
    44// $Id$
     
    2626
    2727namespace theplu{
     28namespace yat{
    2829
    2930  namespace utility {
     
    9495  };
    9596
    96 }} // of namespace statistics and namespace theplu
     97}}} // of namespace statistics, yat and theplu
    9798
    9899#endif
  • trunk/yat/statistics/Fisher.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/Fisher.h"
    25 #include "yat/statistics/Score.h"
    26 #include "yat/statistics/utility.h"
     24#include "Fisher.h"
     25#include "Score.h"
     26#include "utility.h"
    2727#include "yat/classifier/DataLookupWeighted1D.h"
    2828#include "yat/classifier/Target.h"
     
    3232
    3333namespace theplu {
     34namespace yat {
    3435namespace statistics {
    3536
     
    223224  }
    224225
    225 }} // of namespace statistics and namespace theplu
     226}}} // of namespace statistics, yat and theplu
  • trunk/yat/statistics/Fisher.h

    r675 r680  
    1 #ifndef _theplu_statistics_fisher_
    2 #define _theplu_statistics_fisher_
     1#ifndef _theplu_yat_statistics_fisher_
     2#define _theplu_yat_statistics_fisher_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/Score.h"
     27#include "Score.h"
    2828#include "yat/utility/vector.h"
    2929
     
    3131
    3232namespace theplu {
     33namespace yat {
    3334namespace statistics { 
    3435  /**
     
    185186  };
    186187
    187 }} // of namespace statistics and namespace theplu
     188}}} // of namespace statistics, yat and theplu
    188189
    189190#endif
  • trunk/yat/statistics/FoldChange.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/FoldChange.h"
    25 #include "yat/statistics/Score.h"
    26 #include "yat/statistics/Averager.h"
    27 #include "yat/statistics/AveragerWeighted.h"
     24#include "FoldChange.h"
     25#include "Score.h"
     26#include "Averager.h"
     27#include "AveragerWeighted.h"
    2828#include "yat/classifier/DataLookupWeighted1D.h"
    2929#include "yat/classifier/Target.h"
    3030
    3131namespace theplu {
     32namespace yat {
    3233namespace statistics {
    3334
     
    109110  }
    110111
    111 } // of namespace statistics
    112 } // of namespace theplu
     112}}} // of namespace statistics, yat, and theplu
  • trunk/yat/statistics/FoldChange.h

    r675 r680  
    1 #ifndef _theplu_statistics_foldchange_
    2 #define _theplu_statistics_foldchange_
     1#ifndef _theplu_yat_statistics_foldchange_
     2#define _theplu_yat_statistics_foldchange_
    33
    44// $Id$
     
    2828
    2929namespace theplu {
     30namespace yat {
    3031
    3132  class utility::vector;
     
    9192  };
    9293
    93 } // of namespace statistics
    94 } // of namespace theplu
     94}}} // of namespace statistics, yat, and theplu
    9595
    9696#endif
  • trunk/yat/statistics/Histogram.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/Histogram.h"
     24#include "Histogram.h"
    2525
    2626#include <cmath>
    2727#include <fstream>
    2828
    29 
    3029namespace theplu {
     30namespace yat {
    3131namespace statistics {
    3232
     
    135135}
    136136
    137 }} // of namespace statistics and namespace theplu
     137}}} // of namespace statistics, yat, and theplu
  • trunk/yat/statistics/Histogram.h

    r675 r680  
    1 #ifndef _theplu_statistics_histogram_
    2 #define _theplu_statistics_histogram_
     1#ifndef _theplu_yat_statistics_histogram_
     2#define _theplu_yat_statistics_histogram_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/AveragerWeighted.h"
     27#include "AveragerWeighted.h"
    2828
    2929#include <string>
    3030#include <vector>
    3131
    32 
    3332namespace theplu {
     33namespace yat {
    3434namespace statistics {
    3535
     
    196196std::ostream& operator<<(std::ostream& s,const Histogram&);
    197197
    198 }} // of namespace statistics and namespace theplu
     198}}} // of namespace statistics, yat and theplu
    199199
    200200#endif
  • trunk/yat/statistics/Kernel.h

    r675 r680  
    1 #ifndef _theplu_statistics_kernel_
    2 #define _theplu_statistics_kernel_
     1#ifndef _theplu_yat_statistics_kernel_
     2#define _theplu_yat_statistics_kernel_
    33
    44// $Id$
     
    2626
    2727namespace theplu {
     28namespace yat {
    2829namespace statistics {
    29 namespace regression{
     30namespace regression {
    3031  ///
    3132  /// Abstract Base Class for calculating the weights in a more
     
    5051  };
    5152
    52 } // of namespace regression
    53 } // of namespace statistics
    54 } // of namespace theplu
     53}}}} // of namespaces regression, statisitcs, yat, and theplu
    5554
    5655#endif
  • trunk/yat/statistics/KernelBox.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/KernelBox.h"
    25 #include "yat/statistics/Kernel.h"
     24#include "KernelBox.h"
    2625
    2726namespace theplu {
     27namespace yat {
    2828namespace statistics {
    2929namespace regression {
     30
    3031  KernelBox::KernelBox(void)
    3132    : Kernel()
     
    4142  }
    4243
    43 } // of namespace regression
    44 } // of namespace statistics
    45 } // of namespace theplu
    46 
     44}}}} // of namespaces regression, statisitcs, yat, and theplu
  • trunk/yat/statistics/KernelBox.h

    r675 r680  
    1 #ifndef _theplu_statistics_regression_kernel_box_
    2 #define _theplu_statistics_regression_kernel_box_
     1#ifndef _theplu_yat_statistics_regression_kernel_box_
     2#define _theplu_yat_statistics_regression_kernel_box_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/Kernel.h"
     27#include "Kernel.h"
    2828
    2929namespace theplu {
     30namespace yat {
    3031namespace statistics {
    3132namespace regression{
     
    5253  };
    5354
    54 } // of namespace regression
    55 } // of namespace statistics
    56 } // of namespace theplu
     55}}}} // of namespaces regression, statisitcs, yat, and theplu
    5756
    5857#endif
  • trunk/yat/statistics/KernelTriCube.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/KernelTriCube.h"
    25 #include "yat/statistics/Kernel.h"
     24#include "KernelTriCube.h"
     25#include "Kernel.h"
    2626
    2727#include <cmath>
    2828
    2929namespace theplu {
     30namespace yat {
    3031namespace statistics {
    3132namespace regression {
     
    4445  }
    4546
    46 } // of namespace regression
    47 } // of namespace statistics
    48 } // of namespace theplu
    49 
     47}}}} // of namespaces regression, statisitcs, yat, and theplu
  • trunk/yat/statistics/KernelTriCube.h

    r675 r680  
    1 #ifndef _theplu_statistics_kernel_tricube_
    2 #define _theplu_statistics_kernel_tricube_
     1#ifndef _theplu_yat_statistics_kernel_tricube_
     2#define _theplu_yat_statistics_kernel_tricube_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/Kernel.h"
    28 
     27#include "Kernel.h"
    2928
    3029namespace theplu {
     30namespace yat {
    3131namespace statistics {
    3232namespace regression {
     
    5353  };
    5454
    55 } // of namespace regression
    56 } // of namespace statistics
    57 } // of namespace theplu
    58 
     55}}}} // of namespaces regression, statisitcs, yat, and theplu
    5956
    6057#endif
  • trunk/yat/statistics/Linear.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/Linear.h"
    25 
    26 #include "yat/statistics/AveragerPair.h"
     24#include "Linear.h"
     25#include "AveragerPair.h"
    2726#include "yat/utility/vector.h"
    2827
     
    3130
    3231namespace theplu {
     32namespace yat {
    3333namespace statistics {
    3434namespace regression {
     
    6868  }
    6969
    70 }}} // of namespaces regression, statisitcs and thep
     70}}}} // of namespaces regression, statisitcs, yat, and theplu
  • trunk/yat/statistics/Linear.h

    r675 r680  
    1 #ifndef _theplu_statistics_regression_linear_
    2 #define _theplu_statistics_regression_linear_
     1#ifndef _theplu_yat_statistics_regression_linear_
     2#define _theplu_yat_statistics_regression_linear_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/OneDimensional.h"
     27#include "OneDimensional.h"
    2828
    2929#include <cmath>
    3030
    3131namespace theplu {
     32namespace yat {
    3233  namespace utility {
    3334    class vector;
     
    121122  };
    122123
    123 }}} // of namespaces regression, statisitcs and thep
     124}}}} // of namespaces regression,, yat statisitcs thep
    124125
    125126#endif
  • trunk/yat/statistics/LinearWeighted.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/LinearWeighted.h"
    25 
    26 #include "yat/statistics/AveragerPairWeighted.h"
     24#include "LinearWeighted.h"
     25#include "AveragerPairWeighted.h"
    2726#include "yat/utility/vector.h"
    2827
    2928#include <gsl/gsl_fit.h>
    3029
    31 
    3230namespace theplu {
     31namespace yat {
    3332namespace statistics {
    3433namespace regression {
     
    6766
    6867
    69 }}} // of namespaces regression, statisitcs and thep
     68}}}} // of namespaces regression,, yat statisitcs thep
  • trunk/yat/statistics/LinearWeighted.h

    r675 r680  
    1 #ifndef _theplu_statistics_regression_linear_weighted_
    2 #define _theplu_statistics_regression_linear_weighted_
     1#ifndef _theplu_yat_statistics_regression_linear_weighted_
     2#define _theplu_yat_statistics_regression_linear_weighted_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/OneDimensionalWeighted.h"
     27#include "OneDimensionalWeighted.h"
    2828
    2929#include <cmath>
    3030
    3131namespace theplu {
     32namespace yat {
    3233  namespace utility {
    3334    class vector;
     
    129130  };
    130131
    131 }}} // of namespaces regression, statisitcs and thep
     132}}}} // of namespaces regression,, yat statisitcs thep
    132133
    133134#endif
  • trunk/yat/statistics/Local.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/Local.h"
    25 
     24#include "Local.h"
     25#include "Kernel.h"
     26#include "OneDimensionalWeighted.h"
    2627#include "yat/utility/vector.h"
    27 #include "yat/statistics/Kernel.h"
    28 #include "yat/statistics/OneDimensionalWeighted.h"
    2928
    3029#include <algorithm>
     
    3332
    3433namespace theplu {
     34namespace yat {
    3535namespace statistics {
    3636namespace regression {
     
    120120    return os;
    121121  }
    122 }}} // of namespaces regression, statisitcs and thep
     122}}}} // of namespaces regression,, yat statisitcs thep
  • trunk/yat/statistics/Local.h

    r675 r680  
    1 #ifndef _theplu_statistics_regression_local_
    2 #define _theplu_statistics_regression_local_
     1#ifndef _theplu_yat_statistics_regression_local_
     2#define _theplu_yat_statistics_regression_local_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/Kernel.h"
    28 #include "yat/statistics/OneDimensionalWeighted.h"
     27#include "Kernel.h"
     28#include "OneDimensionalWeighted.h"
    2929#include "yat/utility/vector.h"
    3030
     
    3232
    3333namespace theplu {
     34namespace yat {
    3435namespace statistics {
    3536namespace regression {
     
    111112
    112113
    113 }}} // of namespaces regression, statistics and thep
     114}}}} // of namespaces regression,, yat statistics thep
    114115
    115116#endif
  • trunk/yat/statistics/Makefile.am

    r675 r680  
    2929  Distance.cc \
    3030  Fisher.cc FoldChange.cc \
    31   Histogram.cc Kernel.cc KernelBox.cc KernelTriCube.cc Linear.cc \
     31  Histogram.cc KernelBox.cc KernelTriCube.cc Linear.cc \
    3232  LinearWeighted.cc Local.cc \
    3333  MultiDimensional.cc \
  • trunk/yat/statistics/MultiDimensional.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/MultiDimensional.h"
     24#include "MultiDimensional.h"
    2525#include "yat/utility/matrix.h"
    2626#include "yat/utility/vector.h"
    2727
    2828namespace theplu {
     29namespace yat {
    2930namespace statistics {
    3031namespace regression {
     
    6768  }
    6869
    69 }}} // of namespaces regression, statisitcs and thep
     70}}}} // of namespaces regression,, yat statisitcs thep
  • trunk/yat/statistics/MultiDimensional.h

    r675 r680  
    1 #ifndef _theplu_statistics_regression_multidimensional_
    2 #define _theplu_statistics_regression_multidimensional_
     1#ifndef _theplu_yat_statistics_regression_multidimensional_
     2#define _theplu_yat_statistics_regression_multidimensional_
    33
    44// $Id$
     
    3030#include <gsl/gsl_multifit.h>
    3131
    32 
    3332namespace theplu {
     33namespace yat {
    3434namespace statistics {
    3535namespace regression {
     
    8888
    8989
    90 }}} // of namespaces regression, statisitcs and thep
     90}}}} // of namespaces regression,, yat statisitcs thep
    9191
    9292#endif
  • trunk/yat/statistics/MultiDimensionalWeighted.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/MultiDimensionalWeighted.h"
     24#include "MultiDimensionalWeighted.h"
    2525#include "yat/utility/matrix.h"
    2626#include "yat/utility/vector.h"
     
    2929
    3030namespace theplu {
     31namespace yat {
    3132namespace statistics {
    3233namespace regression {
     
    7475  }
    7576
    76 }}} // of namespaces regression, statisitcs and thep
     77}}}} // of namespaces regression,, yat statisitcs thep
  • trunk/yat/statistics/MultiDimensionalWeighted.h

    r675 r680  
    1 #ifndef _theplu_statistics_regression_multidimensional_weighted_
    2 #define _theplu_statistics_regression_multidimensional_weighted_
     1#ifndef _theplu_yat_statistics_regression_multidimensional_weighted_
     2#define _theplu_yat_statistics_regression_multidimensional_weighted_
    33
    44// $Id$
     
    3030#include <gsl/gsl_multifit.h>
    3131
    32 
    3332namespace theplu {
     33namespace yat {
    3434namespace statistics {
    3535namespace regression {
     
    8989
    9090
    91 }}} // of namespaces regression, statisitcs and thep
     91}}}} // of namespaces regression,, yat statisitcs thep
    9292
    9393#endif
  • trunk/yat/statistics/Naive.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/Naive.h"
    25 
    26 #include "yat/statistics/Averager.h"
    27 #include "yat/statistics/AveragerWeighted.h"
    28 #include "yat/statistics/OneDimensional.h"
     24#include "Naive.h"
     25#include "Averager.h"
     26#include "AveragerWeighted.h"
     27#include "OneDimensional.h"
    2928#include "yat/utility/vector.h"
    3029
     
    3231#include <iostream>
    3332
    34 
    3533namespace theplu {
     34namespace yat {
    3635namespace statistics {
    3736namespace regression {
     
    6160
    6261
    63 }}} // of namespaces regression, statisitcs and thep
     62}}}} // of namespaces regression,, yat statisitcs thep
  • trunk/yat/statistics/Naive.h

    r675 r680  
    1 #ifndef _theplu_statistics_regression_naive_
    2 #define _theplu_statistics_regression_naive_
     1#ifndef _theplu_yat_statistics_regression_naive_
     2#define _theplu_yat_statistics_regression_naive_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/OneDimensional.h"
     27#include "OneDimensional.h"
    2828
    2929#include <iostream>
     
    3131
    3232namespace theplu {
     33namespace yat {
    3334  namespace utility {
    3435    class vector;
     
    9394
    9495
    95 }}} // of namespaces regression, statisitcs and thep
     96}}}} // of namespaces regression,, yat statisitcs thep
    9697
    9798#endif
  • trunk/yat/statistics/NaiveWeighted.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/NaiveWeighted.h"
    25 
    26 #include "yat/statistics/AveragerWeighted.h"
    27 #include "yat/statistics/OneDimensional.h"
     24#include "NaiveWeighted.h"
     25#include "AveragerWeighted.h"
     26#include "OneDimensional.h"
    2827#include "yat/utility/vector.h"
    2928
    30 
    3129namespace theplu {
     30namespace yat {
    3231namespace statistics {
    3332namespace regression {
     
    4746
    4847
    49 }}} // of namespaces regression, statisitcs and thep
     48}}}} // of namespaces regression,, yat statisitcs thep
  • trunk/yat/statistics/NaiveWeighted.h

    r675 r680  
    1 #ifndef _theplu_statistics_regression_naive_weighted_
    2 #define _theplu_statistics_regression_naive_weighted_
     1#ifndef _theplu_yat_statistics_regression_naive_weighted_
     2#define _theplu_yat_statistics_regression_naive_weighted_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/OneDimensionalWeighted.h"
     27#include "OneDimensionalWeighted.h"
    2828
    2929#include <cmath>
     
    3131#include <utility>
    3232
    33 
    3433namespace theplu {
     34namespace yat {
    3535  namespace utility {
    3636    class vector;
     
    100100
    101101
    102 }}} // of namespaces regression, statisitcs and thep
     102}}}} // of namespaces regression,, yat statisitcs thep
    103103
    104104#endif
  • trunk/yat/statistics/OneDimensional.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/OneDimensional.h"
     24#include "OneDimensional.h"
    2525
    2626namespace theplu {
     27namespace yat {
    2728namespace statistics {
    2829namespace regression {
     
    4748  }
    4849
    49 }}} // of namespaces regression, statisitcs and thep
     50}}}} // of namespaces regression,, yat statisitcs thep
  • trunk/yat/statistics/OneDimensional.h

    r675 r680  
    1 #ifndef _theplu_statistics_regression_onedimensioanl_
    2 #define _theplu_statistics_regression_onedimensioanl_
     1#ifndef _theplu_yat_statistics_regression_onedimensioanl_
     2#define _theplu_yat_statistics_regression_onedimensioanl_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/AveragerPair.h"
     27#include "AveragerPair.h"
    2828
    2929#include <ostream>
    3030
    3131namespace theplu {
     32namespace yat {
    3233namespace utility {
    3334  class vector;
     
    9697  };
    9798
    98 }}} // of namespaces regression, statisitcs and thep
     99}}}} // of namespaces regression,, yat statisitcs thep
    99100
    100101#endif
  • trunk/yat/statistics/OneDimensionalWeighted.h

    r675 r680  
    1 #ifndef _theplu_statistics_regression_onedimensioanlweighted_
    2 #define _theplu_statistics_regression_onedimensioanlweighted_
     1#ifndef _theplu_yat_statistics_regression_onedimensioanlweighted_
     2#define _theplu_yat_statistics_regression_onedimensioanlweighted_
    33
    44// $Id$
     
    2828
    2929namespace theplu {
     30namespace yat {
    3031namespace utility {
    3132  class vector;
     
    8990  };
    9091
    91 }}} // of namespaces regression, statisitcs and thep
     92}}}} // of namespaces regression,, yat statisitcs thep
    9293
    9394#endif
  • trunk/yat/statistics/Pearson.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/Pearson.h"
    25 #include "yat/statistics/AveragerPair.h"
    26 #include "yat/statistics/AveragerPairWeighted.h"
     24#include "Pearson.h"
     25#include "AveragerPair.h"
     26#include "AveragerPairWeighted.h"
    2727#include "yat/utility/vector.h"
    2828#include "yat/classifier/DataLookupWeighted1D.h"
     
    3232#include <gsl/gsl_cdf.h>
    3333
    34 
    3534namespace theplu {
     35namespace yat {
    3636namespace statistics { 
    3737
     
    119119  }
    120120
    121 }} // of namespace statistics and namespace theplu
     121}}} // of namespace statistics, yat and theplu
  • trunk/yat/statistics/Pearson.h

    r675 r680  
    1 #ifndef _theplu_statistics_pearson_
    2 #define _theplu_statistics_pearson_
     1#ifndef _theplu_yat_statistics_pearson_
     2#define _theplu_yat_statistics_pearson_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/Score.h"
     27#include "Score.h"
    2828
    2929namespace theplu {
     30namespace yat {
    3031namespace utility {
    3132  class vector;
     
    106107  };
    107108
    108 }} // of namespace statistics and namespace theplu
     109}}} // of namespace statistics, yat and theplu
    109110
    110111#endif
  • trunk/yat/statistics/PearsonDistance.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/PearsonDistance.h"
    25 
    26 #include "yat/statistics/AveragerPair.h"
    27 #include "yat/statistics/AveragerPairWeighted.h"
     24#include "PearsonDistance.h"
     25#include "AveragerPair.h"
     26#include "AveragerPairWeighted.h"
    2827#include "yat/utility/vector.h"
    2928
    3029namespace theplu{
     30namespace yat{
    3131namespace statistics{
    3232
     
    5353
    5454
    55 }} // of namespace statistics and namespace theplu
     55}}} // of namespace statistics, yat and theplu
    5656
    5757
  • trunk/yat/statistics/PearsonDistance.h

    r675 r680  
    1 #ifndef _theplu_statistics_pearson_distance_
    2 #define _theplu_statistics_pearson_distance_
     1#ifndef _theplu_yat_statistics_pearson_distance_
     2#define _theplu_yat_statistics_pearson_distance_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/Distance.h"
     27#include "Distance.h"
    2828
    2929namespace theplu{
     30namespace yat{
    3031 
    3132  namespace utility {
     
    7273  };
    7374
    74 }} // of namespace statistics and namespace theplu
     75}}} // of namespace statistics, yat and theplu
    7576
    7677#endif
  • trunk/yat/statistics/Polynomial.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/Polynomial.h"
     24#include "Polynomial.h"
    2525#include "yat/utility/matrix.h"
    2626#include "yat/utility/vector.h"
    2727
    2828namespace theplu {
     29namespace yat {
    2930namespace statistics {
    3031namespace regression {
     
    6465  }
    6566
    66 }}} // of namespaces regression, statisitcs and thep
     67}}}} // of namespaces regression,, yat statisitcs thep
  • trunk/yat/statistics/Polynomial.h

    r675 r680  
    1 #ifndef _theplu_statistics_regression_polynomial_
    2 #define _theplu_statistics_regression_polynomial_
     1#ifndef _theplu_yat_statistics_regression_polynomial_
     2#define _theplu_yat_statistics_regression_polynomial_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/OneDimensional.h"
    28 #include "yat/statistics/MultiDimensional.h"
    29 
     27#include "OneDimensional.h"
     28#include "MultiDimensional.h"
    3029#include "yat/utility/vector.h"
    3130
     
    3433#include <cassert>
    3534
    36 
    3735namespace theplu {
     36namespace yat {
    3837namespace statistics {
    3938namespace regression {
     
    9089
    9190
    92 }}} // of namespaces regression, statisitcs and thep
     91}}}} // of namespaces regression,, yat statisitcs thep
    9392
    9493#endif
  • trunk/yat/statistics/PolynomialWeighted.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/PolynomialWeighted.h"
     24#include "PolynomialWeighted.h"
    2525#include "yat/utility/matrix.h"
    2626#include "yat/utility/vector.h"
     
    2929
    3030namespace theplu {
     31namespace yat {
    3132namespace statistics {
    3233namespace regression {
     
    7172  }
    7273
    73 }}} // of namespaces regression, statisitcs and thep
     74}}}} // of namespaces regression,, yat statisitcs thep
  • trunk/yat/statistics/PolynomialWeighted.h

    r675 r680  
    1 #ifndef _theplu_statistics_regression_polynomial_weighted_
    2 #define _theplu_statistics_regression_polynomial_weighted_
     1#ifndef _theplu_yat_statistics_regression_polynomial_weighted_
     2#define _theplu_yat_statistics_regression_polynomial_weighted_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/OneDimensionalWeighted.h"
    28 #include "yat/statistics/MultiDimensionalWeighted.h"
    29 
     27#include "OneDimensionalWeighted.h"
     28#include "MultiDimensionalWeighted.h"
    3029#include "yat/utility/vector.h"
    3130
    3231#include <cassert>
    3332
    34 
    3533namespace theplu {
     34namespace yat {
    3635namespace statistics {
    3736namespace regression {
     
    9392
    9493
    95 }}} // of namespaces regression, statisitcs and thep
     94}}}} // of namespaces regression,, yat statisitcs thep
    9695
    9796#endif
  • trunk/yat/statistics/ROC.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/ROC.h"
    25 
     24#include "ROC.h"
    2625#include "yat/classifier/DataLookupWeighted1D.h"
    2726#include "yat/utility/stl_utility.h"
     
    3433#include <vector>
    3534
    36 
    3735namespace theplu {
     36namespace yat {
    3837namespace statistics { 
    3938
     
    223222
    224223
    225 }} // of namespace statistics and namespace theplu
     224}}} // of namespace statistics, yat and theplu
  • trunk/yat/statistics/ROC.h

    r675 r680  
    1 #ifndef _theplu_statistics_roc_
    2 #define _theplu_statistics_roc_
     1#ifndef _theplu_yat_statistics_roc_
     2#define _theplu_yat_statistics_roc_
    33
    44// $Id$
     
    2525*/
    2626
     27#include "Score.h"
    2728#include "yat/classifier/Target.h"
    28 #include "yat/statistics/Score.h"
    2929
    3030#include <utility>
     
    3232
    3333namespace theplu {
     34namespace yat {
    3435  namespace utility {
    3536    class vector;
     
    164165
    165166
    166 }} // of namespace statistics and namespace theplu
     167}}} // of namespace statistics, yat and theplu
    167168
    168169#endif
  • trunk/yat/statistics/SAM.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/SAM.h"
    25 #include "yat/statistics/Averager.h"
    26 #include "yat/statistics/AveragerWeighted.h"
     24#include "SAM.h"
     25#include "Averager.h"
     26#include "AveragerWeighted.h"
    2727#include "yat/classifier/DataLookupWeighted1D.h"
    2828#include "yat/classifier/Target.h"
     
    3232
    3333namespace theplu {
     34namespace yat {
    3435namespace statistics { 
    3536
     
    113114
    114115
    115 }} // of namespace statistics and namespace theplu
     116}}} // of namespace statistics, yat and theplu
  • trunk/yat/statistics/SAM.h

    r675 r680  
    1 #ifndef _theplu_statistics_sam
    2 #define _theplu_statistics_sam
     1#ifndef _theplu_yat_statistics_sam
     2#define _theplu_yat_statistics_sam
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/Score.h"
     27#include "Score.h"
    2828
    2929namespace theplu {
     30namespace yat {
    3031  namespace utility {
    3132    class vector;
     
    100101  };
    101102
    102 }} // of namespace statistics and namespace theplu
     103}}} // of namespace statistics, yat and theplu
    103104
    104105#endif
  • trunk/yat/statistics/SNR.cc

    r676 r680  
    2222*/
    2323
    24 #include "yat/statistics/SNR.h"
    25 #include "yat/statistics/Averager.h"
    26 #include "yat/statistics/AveragerWeighted.h"
     24#include "SNR.h"
     25#include "Averager.h"
     26#include "AveragerWeighted.h"
    2727#include "yat/classifier/DataLookupWeighted1D.h"
    2828#include "yat/classifier/Target.h"
    2929
    3030namespace theplu {
     31namespace yat {
    3132namespace statistics { 
    3233
     
    109110
    110111
    111 }} // of namespace statistics and namespace theplu
     112}}} // of namespace statistics, yat and theplu
  • trunk/yat/statistics/SNR.h

    r675 r680  
    1 #ifndef _theplu_statistics_snr
    2 #define _theplu_statistics_snr
     1#ifndef _theplu_yat_statistics_snr
     2#define _theplu_yat_statistics_snr
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/Score.h"
     27#include "Score.h"
    2828
    2929#include <gsl/gsl_cdf.h>
    3030
    3131namespace theplu {
     32namespace yat {
    3233  namespace utility {
    3334    class vector;
     
    8283  };
    8384
    84 }} // of namespace statistics and namespace theplu
     85}}} // of namespace statistics, yat and theplu
    8586
    8687#endif
  • trunk/yat/statistics/Score.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/Score.h"
     24#include "Score.h"
    2525
    2626namespace theplu {
     27namespace yat {
    2728namespace statistics { 
    2829
     
    3233  }
    3334
    34 }} // of namespace statistics and namespace theplu
     35}}} // of namespace statistics, yat and theplu
  • trunk/yat/statistics/Score.h

    r675 r680  
    1 #ifndef _theplu_statistics_score_
    2 #define _theplu_statistics_score_
     1#ifndef _theplu_yat_statistics_score_
     2#define _theplu_yat_statistics_score_
    33
    44// $Id$
     
    3535
    3636namespace theplu {
     37namespace yat {
    3738namespace classifier {
    3839  class Target;
     
    150151  }; // class Score
    151152
    152 }} // of namespace statistics and namespace theplu
     153}}} // of namespace statistics, yat and theplu
    153154
    154155#endif
  • trunk/yat/statistics/WilcoxonFoldChange.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/WilcoxonFoldChange.h"
    25 #include "yat/statistics/utility.h"
     24#include "WilcoxonFoldChange.h"
     25#include "utility.h"
    2626#include "yat/classifier/Target.h"
    2727
     
    3131
    3232namespace theplu {
     33namespace yat {
    3334namespace statistics {
    3435
     
    3839  {
    3940  }
    40 
    4141
    4242
     
    7676  }
    7777
    78 } // of namespace statistics
    79 } // of namespace theplu
     78}}} // of namespace statistics, yat, and theplu
  • trunk/yat/statistics/WilcoxonFoldChange.h

    r675 r680  
    1 #ifndef _theplu_statistics_wilcoxonfoldchange_
    2 #define _theplu_statistics_wilcoxonfoldchange_
     1#ifndef _theplu_yat_statistics_wilcoxonfoldchange_
     2#define _theplu_yat_statistics_wilcoxonfoldchange_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/Score.h"
     27#include "Score.h"
    2828
    2929namespace theplu {
     30namespace yat {
    3031  namespace utility {
    3132    class vector;
     
    8990    ///
    9091    WilcoxonFoldChange& operator=(const WilcoxonFoldChange&);
    91 
    9292  };
    9393
    94 } // of namespace statistics
    95 } // of namespace theplu
     94}}} // of namespace statistics, yat, and theplu
    9695
    9796#endif
  • trunk/yat/statistics/tScore.cc

    r676 r680  
    2222*/
    2323
    24 #include "yat/statistics/tScore.h"
    25 #include "yat/statistics/Averager.h"
    26 #include "yat/statistics/AveragerWeighted.h"
     24#include "tScore.h"
     25#include "Averager.h"
     26#include "AveragerWeighted.h"
    2727#include "yat/classifier/DataLookupWeighted1D.h"
    2828#include "yat/classifier/Target.h"
     
    3131#include <cmath>
    3232
    33 
    3433namespace theplu {
     34namespace yat {
    3535namespace statistics { 
    3636
     
    122122  }
    123123
    124 
    125 
    126 }} // of namespace statistics and namespace theplu
     124}}} // of namespace statistics, yat, and theplu
  • trunk/yat/statistics/tScore.h

    r675 r680  
    1 #ifndef _theplu_statistics_tscore_
    2 #define _theplu_statistics_tscore_
     1#ifndef _theplu_yat_statistics_tscore_
     2#define _theplu_yat_statistics_tscore_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/statistics/Score.h"
     27#include "Score.h"
    2828
    2929#include <gsl/gsl_cdf.h>
     
    3131
    3232namespace theplu {
     33namespace yat {
    3334  namespace utility {
    3435    class vector;
     
    124125  };
    125126
    126 }} // of namespace statistics and namespace theplu
     127}}} // of namespace statistics, yat and theplu
    127128
    128129#endif
  • trunk/yat/statistics/utility.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/statistics/utility.h"
     24#include "utility.h"
    2525
    2626#include <gsl/gsl_randist.h>
     
    2828
    2929namespace theplu {
     30namespace yat {
    3031namespace statistics { 
    3132
     
    8182  }
    8283
    83 }} // of namespace statistics and namespace theplu
     84}}} // of namespace statistics, yat and theplu
  • trunk/yat/statistics/utility.h

    r675 r680  
    1 #ifndef _theplu_statistics_utility_
    2 #define _theplu_statistics_utility_
     1#ifndef _theplu_yat_statistics_utility_
     2#define _theplu_yat_statistics_utility_
    33
    44// $Id$
     
    3535
    3636namespace theplu {
     37namespace yat {
    3738namespace statistics { 
    3839
     
    182183 
    183184
    184 }} // of namespace statistics and namespace theplu
     185}}} // of namespace statistics, yat and theplu
    185186
    186187#endif
    187 
  • trunk/yat/utility/Alignment.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/utility/Alignment.h"
    25 #include "yat/utility/matrix.h"
     24#include "Alignment.h"
     25#include "matrix.h"
    2626
    2727#include <utility>
     
    2929
    3030namespace theplu {
     31namespace yat {
    3132namespace utility {
    32 namespace alignment {
    3333
    3434  double NeedlemanWunsch(const utility::matrix& s,
     
    8282  }
    8383
    84 }}} // of namespace alignment namespace utility and namespace theplu
     84}}} // of namespace utility, yat and theplu
  • trunk/yat/utility/Alignment.h

    r675 r680  
    1 #ifndef _theplu_utility_alignment_
    2 #define _theplu_utility_alignment_
     1#ifndef _theplu_yat_utility_alignment_
     2#define _theplu_yat_utility_alignment_
    33
    44// $Id$
     
    2929
    3030namespace theplu {
     31namespace yat {
     32namespace utility {
    3133
    32 namespace utility {
    3334  class matrix;
    34 }
    35 
    36 namespace utility {
    37 namespace alignment {
    3835
    3936  ///
     
    6158                         const double gap);
    6259
    63 }}} // of namespace alignment namespace utility and namespace theplu
     60}}} // of namespace utility, yat and theplu
    6461
    6562#endif
  • trunk/yat/utility/CommandLine.cc

    r675 r680  
    1 //$Id$
     1// $Id$
    22
    33/*
     
    3535
    3636namespace theplu {
     37namespace yat {
    3738namespace utility {
    3839
     
    292293  }
    293294
    294 }} // of namespace svm_ensemble and namespace theplu
     295}}} // of namespace utility, yat and theplu
  • trunk/yat/utility/CommandLine.h

    r679 r680  
    1 #ifndef _theplu_utility_commandline_
    2 #define _theplu_utility_commandline_
     1#ifndef _theplu_yat_utility_commandline_
     2#define _theplu_yat_utility_commandline_
    33
    44//$Id$
     
    3535
    3636namespace theplu {
     37namespace yat {
    3738namespace utility {
    3839
     
    248249    std::list<Option*> options_;
    249250    std::vector<std::string> arguments_;
    250    
    251251  };
    252252
    253253
    254 }} // end of namespace utility and namespace theplu
    255 
    256 #endif
    257 
    258 
    259 
    260 
     254}}} // end of namespace utility, yat and theplu
     255
     256#endif
  • trunk/yat/utility/Exception.h

    r675 r680  
    1 #ifndef _theplu_utility_exception_
    2 #define _theplu_utility_exception_
     1#ifndef _theplu_yat_utility_exception_
     2#define _theplu_yat_utility_exception_
    33
    44// $Id$
     
    3030
    3131namespace theplu {
     32namespace yat {
    3233namespace utility {
    3334
     
    5152
    5253
    53 }} // of namespace utility and namespace theplu
     54}}} // of namespace utility, yat and theplu
    5455
    5556#endif
  • trunk/yat/utility/FileIO.cc

    r675 r680  
    2424*/
    2525
    26 #include "yat/utility/FileIO.h"
     26#include "FileIO.h"
    2727
    2828#include <iostream>
     
    3131
    3232namespace theplu {
     33namespace yat {
    3334namespace utility {
    3435
     
    5657  }
    5758
    58 }} // of namespace utility and namespace theplu
     59}}} // of namespace utility, yat and theplu
  • trunk/yat/utility/FileIO.h

    r675 r680  
     1#ifndef _theplu_yat_utility_fileio_
     2#define _theplu_yat_utility_fileio_
     3
    14// $Id$
    25
     
    2427*/
    2528
    26 #ifndef _theplu_utility_fileio_
    27 #define _theplu_utility_fileio_
    28 
    2929#include <string>
    3030
     
    3232
    3333namespace theplu {
     34namespace yat {
    3435namespace utility {
    3536
     
    7172  };
    7273
    73 }} // of namespace utility and namespace theplu
     74}}} // of namespace utility, yat and theplu
    7475
    7576#endif
  • trunk/yat/utility/NNI.cc

    r675 r680  
    2424*/
    2525
    26 #include "yat/utility/NNI.h"
    27 
    28 #include "yat/utility/stl_utility.h"
     26#include "NNI.h"
     27#include "stl_utility.h"
    2928
    3029#include <algorithm>
     
    3231#include <fstream>
    3332
    34 
    3533namespace theplu {
     34namespace yat {
    3635namespace utility {
    3736
     
    9493
    9594
    96 }} // of namespace utility and namespace theplu
     95}}} // of namespace utility, yat and theplu
  • trunk/yat/utility/NNI.h

    r675 r680  
    1 #ifndef _theplu_utility_nni_
    2 #define _theplu_utility_nni_
     1#ifndef _theplu_yat_utility_nni_
     2#define _theplu_yat_utility_nni_
    33
    44// $Id$
     
    2727*/
    2828
    29 #include "yat/utility/matrix.h"
     29#include "matrix.h"
    3030
    3131#include <iostream>
     
    3434
    3535namespace theplu {
     36namespace yat {
    3637namespace utility {
    3738
     
    146147  };
    147148
    148 }} // of namespace utility and namespace theplu
     149}}} // of namespace utility, yat and theplu
    149150
    150151#endif
  • trunk/yat/utility/Option.cc

    r675 r680  
    2929
    3030namespace theplu {
     31namespace yat {
    3132namespace utility {
    3233
     
    6061  }
    6162
    62 } // end of namespace utility
    63 } // end of namespace theplu
     63}}} // of namespace utility, yat and theplu
  • trunk/yat/utility/Option.h

    r675 r680  
    1 #ifndef _theplu_utility_option_
    2 #define _theplu_utility_option_
     1#ifndef _theplu_yat_utility_option_
     2#define _theplu_yat_utility_option_
    33
    44// $Id$
     
    2727#include <string>
    2828
    29 
    3029namespace theplu {
     30namespace yat {
    3131namespace utility {
    3232
     
    107107  };
    108108
    109 
    110 
    111 
    112 } // end of namespace utility
    113 } // end of namespace theplu
     109}}} // of namespace utility, yat and theplu
    114110
    115111#endif
  • trunk/yat/utility/PCA.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/utility/PCA.h"
    25 #include "yat/utility/SVD.h"
     24#include "PCA.h"
     25#include "SVD.h"
    2626
    2727#include <iostream>
     
    3030
    3131namespace theplu {
     32namespace yat {
    3233namespace utility {
    3334
     
    199200
    200201
    201 }} // of namespace utility and namespace theplu
     202}}} // of namespace utility, yat and theplu
  • trunk/yat/utility/PCA.h

    r675 r680  
    1 #ifndef _theplu_utility_pca_
    2 #define _theplu_utility_pca_
     1#ifndef _theplu_yat_utility_pca_
     2#define _theplu_yat_utility_pca_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/utility/matrix.h"
    28 #include "yat/utility/vector.h"
     27#include "matrix.h"
     28#include "vector.h"
    2929
    3030namespace theplu {
     31namespace yat {
    3132namespace utility {
    3233
     
    135136
    136137
    137 }} // of namespace utility and namespace theplu
     138}}} // of namespace utility, yat and theplu
    138139
    139140#endif
  • trunk/yat/utility/SVD.cc

    r675 r680  
    2222*/
    2323
    24 #include "yat/utility/SVD.h"
    25 
     24#include "SVD.h"
    2625
    2726namespace theplu {
     27namespace yat {
    2828namespace utility {
    2929
     
    6666
    6767
    68 }} // of namespace utility and namespace theplu
     68}}} // of namespace utility, yat and theplu
  • trunk/yat/utility/SVD.h

    r675 r680  
    1 #ifndef _theplu_utility_svd_
    2 #define _theplu_utility_svd_
     1#ifndef _theplu_yat_utility_svd_
     2#define _theplu_yat_utility_svd_
    33
    44// $Id$
     
    2525*/
    2626
    27 #include "yat/utility/matrix.h"
    28 #include "yat/utility/vector.h"
     27#include "matrix.h"
     28#include "vector.h"
    2929
    3030#include <gsl/gsl_linalg.h>
    3131
    3232namespace theplu {
     33namespace yat {
    3334namespace utility {
    3435
     
    140141  }; 
    141142
    142 }} // of namespace utility and namespace theplu
     143}}} // of namespace utility, yat and theplu
    143144
    144145#endif
  • trunk/yat/utility/WeNNI.cc

    r675 r680  
    2424*/
    2525
    26 #include "yat/utility/WeNNI.h"
    27 
    28 #include "yat/utility/matrix.h"
    29 #include "yat/utility/stl_utility.h"
     26#include "WeNNI.h"
     27#include "matrix.h"
     28#include "stl_utility.h"
    3029
    3130#include <algorithm>
     
    3433
    3534namespace theplu {
     35namespace yat {
    3636namespace utility {
    3737
     
    8787
    8888
    89 }} // of namespace utility and namespace theplu
     89}}} // of namespace utility, yat and theplu
  • trunk/yat/utility/WeNNI.h

    r675 r680  
    1 #ifndef _theplu_utility_wenni_
    2 #define _theplu_utility_wenni_
     1#ifndef _theplu_yat_utility_wenni_
     2#define _theplu_yat_utility_wenni_
    33
    44// $Id$
     
    2727*/
    2828
    29 #include "yat/utility/NNI.h"
    30 
    31 #include "yat/utility/matrix.h"
     29#include "NNI.h"
     30#include "matrix.h"
    3231
    3332#include <iostream>
    3433
    35 
    36 
    3734namespace theplu {
     35namespace yat {
    3836namespace utility {
    3937
     
    7674  };
    7775
    78 }} // of namespace utility and namespace theplu
     76}}} // of namespace utility, yat and theplu
    7977
    8078#endif
  • trunk/yat/utility/kNNI.cc

    r675 r680  
    2424*/
    2525
    26 #include "yat/utility/kNNI.h"
    27 #include "yat/utility/stl_utility.h"
     26#include "kNNI.h"
     27#include "stl_utility.h"
    2828
    2929#include <algorithm>
     
    3333
    3434namespace theplu {
     35namespace yat {
    3536namespace utility {
    3637
     
    9091
    9192
    92 }} // of namespace utility and namespace theplu
     93}}} // of namespace utility, yat and theplu
  • trunk/yat/utility/kNNI.h

    r675 r680  
    1 #ifndef _theplu_utility_knni_
    2 #define _theplu_utility_knni_
     1#ifndef _theplu_yat_utility_knni_
     2#define _theplu_yat_utility_knni_
    33
    44// $Id$
     
    2727*/
    2828
    29 #include "yat/utility/NNI.h"
     29#include "NNI.h"
    3030
    3131#include <iostream>
     
    3333
    3434namespace theplu {
     35namespace yat {
    3536namespace utility {
    3637
     
    6566  };
    6667
    67 }} // of namespace utility and namespace theplu
     68}}} // of namespace utility, yat and theplu
    6869
    6970#endif
  • trunk/yat/utility/matrix.cc

    r675 r680  
    2424*/
    2525
    26 #include "yat/utility/matrix.h"
    27 
    28 #include "yat/utility/vector.h"
    29 #include "yat/utility/stl_utility.h"
    30 #include "yat/utility/utility.h"
     26#include "matrix.h"
     27#include "vector.h"
     28#include "stl_utility.h"
     29#include "utility.h"
    3130
    3231#include <cmath>
     
    3635#include <gsl/gsl_blas.h>
    3736
    38 
    3937namespace theplu {
     38namespace yat {
    4039namespace utility {
    4140
     
    241240
    242241
    243 }} // of namespace utility and namespace thep
     242}}} // of namespace utility, yat and thep
  • trunk/yat/utility/matrix.h

    r675 r680  
    1 #ifndef _theplu_utility_matrix_
    2 #define _theplu_utility_matrix_
     1#ifndef _theplu_yat_utility_matrix_
     2#define _theplu_yat_utility_matrix_
    33
    44// $Id$
     
    2828*/
    2929
    30 #include "yat/utility/vector.h"
    31 #include "yat/utility/Exception.h"
     30#include "vector.h"
     31#include "Exception.h"
    3232
    3333#include <gsl/gsl_matrix.h>
     
    3535
    3636namespace theplu {
     37namespace yat {
    3738namespace utility {
    3839
     
    463464
    464465
    465 }} // of namespace utility and namespace theplu
     466}}} // of namespace utility, yat and theplu
    466467
    467468#endif
  • trunk/yat/utility/stl_utility.cc

    r675 r680  
    2323*/
    2424
    25 #include "yat/utility/stl_utility.h"
    26 #include "yat/utility/utility.h"
     25#include "stl_utility.h"
     26#include "utility.h"
    2727
    2828#include <iostream>
     
    3333
    3434namespace theplu {
     35namespace yat {
    3536namespace utility {
    3637
     
    102103  }
    103104
    104 }} // end of namespace utility and namespace thep
     105}}} // end of namespace utility, yat and thep
  • trunk/yat/utility/stl_utility.h

    r675 r680  
    1 #ifndef _theplu_utility_stl_utility_
    2 #define _theplu_utility_stl_utility_
     1#ifndef _theplu_yat_utility_stl_utility_
     2#define _theplu_yat_utility_stl_utility_
    33
    44// $Id$
     
    5454
    5555namespace theplu {
     56namespace yat {
    5657namespace utility {
    5758
     
    133134
    134135
    135 }} // of namespace utility and namespace theplu
     136}}} // of namespace utility, yat and theplu
    136137
    137138#endif
  • trunk/yat/utility/utility.cc

    r675 r680  
    2323*/
    2424
    25 #include "yat/utility/utility.h"
    26 
     25#include "utility.h"
     26#include "stl_utility.h"
     27#include "vector.h"
    2728#include "yat/random/random.h"
    28 #include "yat/utility/stl_utility.h"
    29 #include "yat/utility/vector.h"
    3029
    3130#include <sstream>
     
    3332
    3433namespace theplu {
     34namespace yat {
    3535namespace utility {
    3636
     
    116116
    117117
    118 }} // end of namespace utility and namespace thep
     118}}} // end of namespace utility, yat and thep
  • trunk/yat/utility/utility.h

    r675 r680  
    1 #ifndef _theplu_utility_utility_
    2 #define _theplu_utility_utility_
     1#ifndef _theplu_yat_utility_utility_
     2#define _theplu_yat_utility_utility_
    33
    44// $Id$
     
    2929/// @file utility/utility.h
    3030///
    31 /// Some useful functions are placed here
     31/// @brief Some useful functions are placed here
    3232///
    3333
     
    3737
    3838namespace theplu {
     39namespace yat {
    3940namespace utility {
    4041
     
    8283
    8384
    84 }} // of namespace utility and namespace theplu
     85}}} // of namespace utility, yat and theplu
    8586
    8687#endif
  • trunk/yat/utility/vector.cc

    r675 r680  
    2525*/
    2626
    27 #include "yat/utility/vector.h"
    28 #include "yat/utility/matrix.h"
    29 #include "yat/utility/stl_utility.h"
    30 #include "yat/utility/utility.h"
    31 
     27#include "vector.h"
     28#include "matrix.h"
     29#include "stl_utility.h"
     30#include "utility.h"
    3231
    3332#include <iostream>
     
    3635#include <utility>
    3736
    38 
    3937namespace theplu {
     38namespace yat {
    4039namespace utility {
    4140
     
    264263
    265264
    266 }} // of namespace utility and namespace thep
     265}}} // of namespace utility, yat and thep
  • trunk/yat/utility/vector.h

    r675 r680  
    1 #ifndef _theplu_utility_vector_
    2 #define _theplu_utility_vector_
     1#ifndef _theplu_yat_utility_vector_
     2#define _theplu_yat_utility_vector_
    33
    44// $Id$
     
    2828*/
    2929
    30 #include "yat/utility/Exception.h"
     30#include "Exception.h"
    3131
    3232#include <iostream>
     
    3838
    3939namespace theplu {
     40namespace yat {
    4041namespace utility {
    4142
     
    490491
    491492
    492 }} // of namespace utility and namespace theplu
     493}}} // of namespace utility, yat and theplu
    493494
    494495#endif
Note: See TracChangeset for help on using the changeset viewer.