source: trunk/test/kernel_lookup_test.cc @ 1658

Last change on this file since 1658 was 1487, checked in by Jari Häkkinen, 13 years ago

Addresses #436. GPL license copy reference should also be updated.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 5.2 KB
Line 
1// $Id: kernel_lookup_test.cc 1487 2008-09-10 08:41:36Z jari $
2
3/*
4  Copyright (C) 2006, 2007 Jari Häkkinen, Peter Johansson
5  Copyright (C) 2008 Peter Johansson
6
7  This file is part of the yat library, http://dev.thep.lu.se/yat
8
9  The yat library is free software; you can redistribute it and/or
10  modify it under the terms of the GNU General Public License as
11  published by the Free Software Foundation; either version 3 of the
12  License, or (at your option) any later version.
13
14  The yat library is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  General Public License for more details.
18
19  You should have received a copy of the GNU General Public License
20  along with yat. If not, see <http://www.gnu.org/licenses/>.
21*/
22
23#include "Suite.h"
24
25#include "yat/utility/Matrix.h"
26#include "yat/classifier/DataLookup1D.h"
27#include "yat/classifier/KernelLookup.h"
28#include "yat/classifier/Kernel_SEV.h"
29#include "yat/classifier/MatrixLookup.h"
30#include "yat/classifier/PolynomialKernelFunction.h"
31
32#include <fstream>
33#include <iostream>
34#include <vector>
35
36using namespace theplu::yat;
37
38int main(int argc, char* argv[])
39{
40  using namespace theplu::yat::classifier;
41
42  theplu::yat::test::Suite suite(argc, argv);
43
44  suite.err() << "\nTesting KernelLookup" << std::endl;
45  utility::Matrix data_core(1,5);
46  for (size_t i=0; i<data_core.columns(); i++)
47    data_core(0,i)=i;
48  classifier::MatrixLookup data(data_core);
49  classifier::PolynomialKernelFunction kf;
50  classifier::Kernel_SEV kernel(data,kf);
51
52  suite.err() << "KernelLookup::KernelLookup(const Kernel&)...";
53  classifier::KernelLookup k1(kernel);
54  if (k1.rows()!=kernel.size() || k1.columns()!=kernel.size()) {
55    suite.add(false);
56    suite.err() <<  "ERROR:" << std::endl;
57    suite.err() << "Dimensions do not agree." << std::endl;
58  }
59  else {
60    for (size_t i=0; i<k1.rows(); i++) 
61      for (size_t j=0; j<k1.columns(); j++) 
62        if (k1(i,j)!=kernel(i,j)) {
63          suite.add(false);
64          suite.err() << "ERROR:\n"
65                 << "KernelLookup::KernelLookup(const Kernel& data)"
66                 << std::endl;
67          suite.err() << "k(" << i << "," << j << ") is " << k1(i,j) 
68                 << "expected " << kernel(i,j) << std::endl;
69        }
70    if (suite.ok())
71      suite.err() << "Ok." << std::endl;
72  }
73
74  std::vector<size_t> index_odd;
75  index_odd.push_back(1);
76  index_odd.push_back(3);
77  std::vector<size_t> index_even;
78  index_even.push_back(2);
79  index_even.push_back(0);
80  index_even.push_back(4);
81  suite.err() << "KernelLookup::KernelLookup(const Kernel&,\n"
82         << "                           const vector<size_t>&,\n"
83         << "                           const vector<size_t>&)...";
84  classifier::KernelLookup k2(kernel,utility::Index(index_odd),
85                              utility::Index(index_even));
86  if (k2.rows()!=index_odd.size() || k2.columns()!=index_even.size()) {
87    suite.add(false);
88    suite.err() << "ERROR:" << std::endl;
89    suite.err() << "Dimensions do not agree." << std::endl;
90  }
91  for (size_t i=0; i<k2.rows(); i++) 
92    for (size_t j=0; j<k2.columns(); j++) 
93      if (k2(i,j)!=kernel(index_odd[i],index_even[j])) {
94        suite.add(false);
95        suite.err() << "ERROR:\n"
96               << "KernelLookup::KernelLookup(const Kernel& data)"
97               << std::endl;
98        suite.err() << "k(" << i << "," << j << ") is " << k2(i,j) 
99               << "expected " << kernel(index_odd[i],index_even[j]) << std::endl;
100      }
101  if (suite.ok())
102    suite.err() << "Ok." << std::endl;
103 
104  suite.err() << "KernelLookup::KernelLookup(const KernelLookup&,\n"
105         << "                           const vector<size_t>&,\n"
106         << "                           const vector<size_t>&)...";
107  std::vector<size_t> one(1,1);
108  classifier::KernelLookup k3(k2,utility::Index(one),utility::Index(one));
109  if (k3.rows()!=one.size() || k3.columns()!=one.size()) {
110    suite.add(false);
111    suite.err() <<  "ERROR:" << std::endl;
112    suite.err() << "Dimensions do not agree." << std::endl;
113  }
114  else if (k3(0,0)!=k2(1,1)){
115    suite.add(false);
116    suite.err() << "ERROR:\n k3(0,0) found to be " << k3(0,0) 
117           << " expected " << k2(1,1) << std::endl;
118  }
119  else
120    suite.err() << "Ok." << std::endl;
121
122  suite.err() << "KernelLookup::KernelLookup(const KernelLookup&)...";
123  classifier::KernelLookup k4(k2);
124  if (k4.rows()!=k2.rows() || k4.columns()!=k2.columns()) {
125    suite.add(false);
126    suite.err() <<  "ERROR:" << std::endl;
127    suite.err() << "Dimensions do not agree." << std::endl;
128    suite.err() << "Dimension: rows " << k4.rows() << " columns " << k4.columns()
129           << "\nOriginal: rows " << k2.rows() << " columns " << k2.columns()
130           << std::endl;
131  }
132  else {
133    for (size_t i=0; i<k4.rows(); i++) 
134      for (size_t j=0; j<k4.columns(); j++) 
135        if (k4(i,j)!=k2(i,j)) {
136          suite.add(false);
137          suite.err() << "ERROR:\n"
138                 << "KernelLookup::KernelLookup(const KernelLookup&)"
139                 << std::endl;
140          suite.err() << "k(" << i << "," << j << ") is " << k4(i,j) 
141                 << "expected " << k2(i,j) << std::endl;
142        }
143  }
144 
145  KernelLookup k5(k1,utility::Index(index_even),utility::Index(index_even));
146  std::vector<size_t> index5;
147  index5.push_back(0);
148  index5.push_back(2);
149  const KernelLookup* k6 = new KernelLookup(k5,utility::Index(index5),
150                                            utility::Index(index5)); 
151  for (size_t s=0; s<k6->rows(); s++) 
152    for (size_t t=0; t<k6->rows(); t++) 
153      suite.add((*k6)(s,t)==(*k6)(t,s));
154
155  return suite.return_value();
156}
157
Note: See TracBrowser for help on using the repository browser.