void __bin_iter_compilation_test__()
{
RichBinary bin("testcode");
BinConstIter1<Int32> ic1(bin, "one", 1);
BinIter1<Int32> i1(bin, "one", 1);
BinConstIter2<Int32, double> ic2(bin, "one", 1, "two", 1);
BinIter2<Int32, double> i2(bin, "one", 1, "two", 1);
BinConstIter3<Int32, double, char> ic3(bin, "one", 1, "two", 1, "three", 1);
BinIter3<Int32, double, char> i3(bin, "one", 1, "two", 1, "three", 1);
};
TestCase1::TestCase1() {
std::vector<LearningUnit*> learn_units_train;
std::vector<LearningUnit*> learn_units_test;
//collect sin wave data
//double dataset [number_of_data_points][2];
LearningUnit* ln;
for (int i=0; i<100; i++) {
double in = (((double)rand()/RAND_MAX)*6) - 3; //-3 --> +3
double out = sin(in); //-3 --> +3
ln = new LearningUnit();
ln->inputs.push_back(in);
ln->outputs.push_back(out);
if (i > 80)
learn_units_test.push_back(ln);
else
learn_units_train.push_back(ln);
}
vector<InputConfigs*> inputs_confis;
//set up configuration for each dimension
InputConfigs ic1(3.14 // max number
, -3.14 // min number
, 10 // number of centers on this dimension
);
inputs_confis.push_back(&ic1); //add it to the list of dimensions
//make an instance of the network and pass the configurations
RBFNetwork RBFnet(1, 1, inputs_confis);
RBFnet.print_RBF_hidden_neurons_information();
cout<<"/////////////////////////////////////////////////"<<endl;
cout<<"learning:"<<endl;
cout<<"/////////////////////////////////////////////////"<<endl;
double final_error = RBFnet.learn(learn_units_train, 0.05, 1000, 0.5, true);
cout<<"/////////////////////////////////////////////////"<<endl;
cout<<"testing:"<<endl;
cout<<"/////////////////////////////////////////////////"<<endl;
//////test results on the test data
for (int i=0; i< learn_units_test.size(); i++)
cout<<"Network output = "<<RBFnet.get_output(learn_units_test[i]->inputs)[0]
<<", Desired output = "<<learn_units_test[i]->outputs[0]<<endl;
}
void CopyImageSection(Image* img1, Image* img2, int x1, int y1, int x2, int y2, int w, int h)
{
if(img1 != NULL && img2 != NULL && w > 0 && h > 0)
{
Image* img = new Image(MC->flags.opaqueFlag ? Image::RGB : Image::ARGB, w, h, true);
Graphics ic1(*img);
ic1.setOrigin (-x1, -y1);
ic1.drawImageAt(img1, 0, 0);
Graphics ic2(*img2);
ic2.drawImageAt(img, x2, y2, false);
}
}
void CheckConstructors(void)
{
char a[20];
std::string name = "abc";
file_position_without_column pos(name,1);
file_position posc(name,1,1);
typedef IterC iterc_t;
typedef Iter iter_t;
BOOST_TEST(iterc_t(a,a+20,name).get_position() == posc);
BOOST_TEST(iterc_t(a,a+20,name,1).get_position() == posc);
BOOST_TEST(iterc_t(a,a+20,name,1,1).get_position() == posc);
BOOST_TEST(iterc_t(a,a+20,posc).get_position() == posc);
BOOST_TEST(iter_t(a,a+20,name).get_position() == pos);
BOOST_TEST(iter_t(a,a+20,name,1).get_position() == pos);
BOOST_TEST(iter_t(a,a+20,pos).get_position() == pos);
// Check copy constructor and assignment. Notice that we want
// an implicit copy constructor.
iterc_t ic1(a,a+20,name);
iterc_t ic2 = ic1;
iterc_t ic3;
ic3 = ic1;
BOOST_TEST(ic1 == ic2);
BOOST_TEST(ic1 == ic3);
BOOST_TEST(ic1.get_position() == ic2.get_position());
BOOST_TEST(ic1.get_position() == ic3.get_position());
iter_t i1(a,a+20,name);
iter_t i2 = i1;
iter_t i3;
i3 = i1;
BOOST_TEST(i1 == i2);
BOOST_TEST(i1 == i3);
BOOST_TEST(i1.get_position() == i2.get_position());
BOOST_TEST(i1.get_position() == i3.get_position());
// Check construction with an empty sequence
CheckEmptySequence<iter_t>();
CheckEmptySequence<iterc_t>();
}
ICopy<SetSource<pair<T,T> > > TripleList<T>::operator()() {
blankit();
bool use_first = !d_first.empty();
bool use_second = !d_second.empty();
list<ICopy<SetSource<pair<T,T> > > > LL;
SetSource<pair<T,T> > * p = 0;
if(use_first && use_second) {
p = new CartesianSource<T,T>(d_first,d_second);
ICopy<SetSource<pair<T,T> > > ic1(p,Adopt::s_dummy);
LL.push_back(ic1);
p = new CartesianSource<T,T>(d_second,d_first);
ICopy<SetSource<pair<T,T> > > ic2(p,Adopt::s_dummy);
LL.push_back(ic2);
};
if(use_second) {
p = new CartesianSource<T,T>(d_second,d_second);
ICopy<SetSource<pair<T,T> > > ic3(p,Adopt::s_dummy);
LL.push_back(ic3);
};
ICopy<SetSource<pair<T,T> > > ic(new UnionSource<pair<T,T> >(LL),
Adopt::s_dummy);
return ic;
};
