mirror of
https://github.com/rdkit/rdkit.git
synced 2026-06-04 21:54:27 +08:00
372 lines
10 KiB
C++
372 lines
10 KiB
C++
// $Id$
|
|
//
|
|
// Copyright (C) 2001-2006 Rational Discovery LLC
|
|
//
|
|
// @@ All Rights Reserved @@
|
|
//
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <fstream>
|
|
#include <ios>
|
|
#include "BitVects.h"
|
|
#include "BitOps.h"
|
|
#include "BitVectUtils.h"
|
|
#include <cmath>
|
|
#include "DiscreteValueVect.h"
|
|
#include <RDGeneral/Invariant.h>
|
|
#include <RDGeneral/RDLog.h>
|
|
#include <RDBoost/Exceptions.h>
|
|
|
|
|
|
using namespace std;
|
|
template< typename T >
|
|
inline void TXTMSG(const char *__a__,T __b__){ BOOST_LOG(rdInfoLog) << (__a__) << " " << (__b__) << std::endl; }
|
|
|
|
template<typename T> void Test(T arg){
|
|
T t1(20);
|
|
TXTMSG("Set 10:",t1.SetBit(10));
|
|
TXTMSG("Set 11:",t1.SetBit(11));
|
|
TXTMSG("Set 14:",t1.SetBit(14));
|
|
TXTMSG("Set 10:",t1.SetBit(10));
|
|
TXTMSG("Get 14:",t1.GetBit(14));
|
|
TXTMSG("Num:",t1.GetNumBits());
|
|
TXTMSG("NumOn:",t1.GetNumOnBits());
|
|
TXTMSG("NumOff:",t1.GetNumOffBits());
|
|
|
|
IntVect onBits;
|
|
t1.GetOnBits(onBits);
|
|
std::copy(onBits.begin(),onBits.end(),std::ostream_iterator<int>(std::cout,", "));
|
|
std::cout << std::endl;
|
|
|
|
T t2(t1);
|
|
//onBits = t2.GetOnBits();
|
|
TXTMSG("t2[19]:",t2[19]);
|
|
TXTMSG("t2[14]:",t2[14]);
|
|
|
|
t2 = t1;
|
|
//onBits = t2.GetOnBits();
|
|
TXTMSG("t2[19]:",t2[19]);
|
|
t2.UnSetBit(14);
|
|
TXTMSG("t2[14]:",t2[14]);
|
|
t2.SetBit(15);
|
|
t2.SetBit(17);
|
|
|
|
|
|
cout << "t1: ";
|
|
t1.GetOnBits(onBits);
|
|
std::copy(onBits.begin(),onBits.end(),std::ostream_iterator<int>(std::cout,", "));
|
|
std::cout << std::endl;
|
|
|
|
cout << "t2: ";
|
|
t2.GetOnBits(onBits);
|
|
std::copy(onBits.begin(),onBits.end(),std::ostream_iterator<int>(std::cout,", "));
|
|
std::cout << std::endl;
|
|
|
|
cout << "t1|t2: ";
|
|
T t3=t1|t2;
|
|
t3.GetOnBits(onBits);
|
|
std::copy(onBits.begin(),onBits.end(),std::ostream_iterator<int>(std::cout,", "));
|
|
std::cout << std::endl;
|
|
|
|
cout << "t1&t2: ";
|
|
t3=t1 & t2;
|
|
t3.GetOnBits(onBits);
|
|
std::copy(onBits.begin(),onBits.end(),std::ostream_iterator<int>(std::cout,", "));
|
|
std::cout << std::endl;
|
|
|
|
cout << "t1^t2: ";
|
|
t3=t1 ^ t2;
|
|
t3.GetOnBits(onBits);
|
|
std::copy(onBits.begin(),onBits.end(),std::ostream_iterator<int>(std::cout,", "));
|
|
std::cout << std::endl;
|
|
|
|
cout << "~t1: ";
|
|
t3= ~t1;
|
|
t3.GetOnBits(onBits);
|
|
std::copy(onBits.begin(),onBits.end(),std::ostream_iterator<int>(std::cout,", "));
|
|
std::cout << std::endl;
|
|
|
|
try{
|
|
t3.GetBit(4000);
|
|
} catch (IndexErrorException) {
|
|
cout << " except " << endl;
|
|
} catch (...) {
|
|
cout << " ERROR EXCEPT " << endl;
|
|
}
|
|
|
|
T t4(t1.ToString());
|
|
cout << "tan(t1,t4): " << TanimotoSimilarity(t1,t4) << endl;
|
|
|
|
T *t5 = FoldFingerprint(t1);
|
|
TEST_ASSERT(t5->GetNumBits() == t1.GetNumBits()/2);
|
|
TEST_ASSERT(t5->GetBit(0));
|
|
TEST_ASSERT(t5->GetBit(1));
|
|
TEST_ASSERT(t5->GetBit(4));
|
|
TEST_ASSERT(!t5->GetBit(2));
|
|
TEST_ASSERT(!t5->GetBit(3));
|
|
delete t5;
|
|
}
|
|
|
|
|
|
template<typename T> void TaniTest(T &arg){
|
|
std::string fps[4] = {
|
|
".b+HHa.EgU6+ibEIr89.CpX0g8FZiXH+R0+Ps.mr6tg.2",
|
|
".b7HEa..ccc+gWEIr89.8lV8gOF3aXFFR.+Ps.mZ6lg.2",
|
|
".H+nHq2EcY09y5EIr9e.8p50h0NgiWGNx4+Hm+Gbslw.2",
|
|
".1.HHa..cUI6i5E2rO8.Op10d0NoiWGVx.+Hm.Gb6lo.2",
|
|
};
|
|
double dists[] = {
|
|
1.0,0.788991,0.677165,0.686957,
|
|
1.0,0.578125,0.591304,
|
|
1.0,0.732759,
|
|
1.0
|
|
};
|
|
int idx=0;
|
|
for(int i=0;i<4;i++){
|
|
T v1(256);
|
|
FromDaylightString(v1,fps[i]);
|
|
for(int j=i;j<4;j++){
|
|
T v2(256);
|
|
FromDaylightString(v2,fps[j]);
|
|
double tani=TanimotoSimilarity(v1,v2);
|
|
TEST_ASSERT(abs(tani-dists[idx])<1e-4);
|
|
idx++;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
template<typename T> void ProbeTest(T &arg){
|
|
int sz=1000;
|
|
T t1(sz),t2(sz);
|
|
for(int i=0;i<sz;i+=2){
|
|
t1.SetBit(i);
|
|
if(i<3*sz/4) t2.SetBit(i);
|
|
}
|
|
std::string pkl=t1.ToString();
|
|
TEST_ASSERT(AllProbeBitsMatch(t1,pkl));
|
|
TEST_ASSERT(AllProbeBitsMatch(t2,pkl));
|
|
TEST_ASSERT(AllProbeBitsMatch(t1.ToString(),pkl));
|
|
TEST_ASSERT(AllProbeBitsMatch(t2.ToString(),pkl));
|
|
TEST_ASSERT(AllProbeBitsMatch(t1.ToString().c_str(),pkl.c_str()));
|
|
TEST_ASSERT(AllProbeBitsMatch(t2.ToString().c_str(),pkl.c_str()));
|
|
pkl = t2.ToString();
|
|
TEST_ASSERT(!AllProbeBitsMatch(t1,pkl));
|
|
TEST_ASSERT(AllProbeBitsMatch(t2,pkl));
|
|
TEST_ASSERT(!AllProbeBitsMatch(t1.ToString(),pkl));
|
|
TEST_ASSERT(AllProbeBitsMatch(t2.ToString(),pkl));
|
|
TEST_ASSERT(!AllProbeBitsMatch(t1.ToString().c_str(),pkl.c_str()));
|
|
TEST_ASSERT(AllProbeBitsMatch(t2.ToString().c_str(),pkl.c_str()));
|
|
}
|
|
|
|
|
|
void test1DiscreteVect() {
|
|
DiscreteValueVect vect1(DiscreteValueVect::ONEBITVALUE, 30);
|
|
unsigned int i;
|
|
for (i = 0; i < 15; ++i) {
|
|
vect1.setVal(2*i, 1);
|
|
}
|
|
|
|
CHECK_INVARIANT(vect1.getLength() == 30, "");
|
|
CHECK_INVARIANT(vect1.getTotalVal() == 15, "");
|
|
for (i = 0; i < vect1.getLength(); ++i) {
|
|
CHECK_INVARIANT(vect1.getVal(i) == (i+1)%2, "");
|
|
}
|
|
try {
|
|
vect1.setVal(28,2);
|
|
} catch (ValueErrorException &dexp) {
|
|
std::cout << "Expected failure: " << dexp.message() << "\n";
|
|
}
|
|
|
|
// all these tests should fail if unsigned int changes from being
|
|
// 32 bits
|
|
DiscreteValueVect vect2(DiscreteValueVect::TWOBITVALUE, 30);
|
|
for (i = 0; i < vect2.getLength(); ++i) {
|
|
vect2.setVal(i, i%4);
|
|
}
|
|
|
|
for (i = 0; i < vect2.getLength(); ++i) {
|
|
CHECK_INVARIANT(vect2.getVal(i) == i%4, "");
|
|
}
|
|
CHECK_INVARIANT(vect2.getTotalVal() == 43, "");
|
|
try {
|
|
vect2.setVal(28,10);
|
|
} catch (ValueErrorException &dexp) {
|
|
std::cout << "Expected failure: " << dexp.message() << "\n";
|
|
}
|
|
|
|
DiscreteValueVect vect4(DiscreteValueVect::FOURBITVALUE, 30);
|
|
for (i = 0; i < vect4.getLength(); ++i) {
|
|
vect4.setVal(i, i%16);
|
|
}
|
|
|
|
for (i = 0; i < vect4.getLength(); ++i) {
|
|
CHECK_INVARIANT(vect4.getVal(i) == i%16, "");
|
|
}
|
|
CHECK_INVARIANT(vect4.getTotalVal() == 211, "");
|
|
try {
|
|
vect4.setVal(28,16);
|
|
} catch (ValueErrorException &dexp) {
|
|
std::cout << "Expected failure: " << dexp.message() << "\n";
|
|
}
|
|
|
|
DiscreteValueVect vect8(DiscreteValueVect::EIGHTBITVALUE, 32);
|
|
for (i = 0; i < vect8.getLength(); ++i) {
|
|
vect8.setVal(i, i%256);
|
|
}
|
|
|
|
for (i = 0; i < vect8.getLength(); ++i) {
|
|
CHECK_INVARIANT(vect8.getVal(i) == i%256, "");
|
|
}
|
|
CHECK_INVARIANT(vect8.getTotalVal() == 496, "");
|
|
try {
|
|
vect8.setVal(28,257);
|
|
} catch (ValueErrorException &dexp) {
|
|
std::cout << "Expected failure: " << dexp.message() << "\n";
|
|
}
|
|
|
|
DiscreteValueVect vect16(DiscreteValueVect::SIXTEENBITVALUE, 300);
|
|
for (i = 0; i < vect16.getLength(); ++i) {
|
|
vect16.setVal(i, i%300);
|
|
}
|
|
|
|
for (i = 0; i < vect16.getLength(); ++i) {
|
|
CHECK_INVARIANT(vect16.getVal(i) == i%300, "");
|
|
}
|
|
|
|
CHECK_INVARIANT(vect16.getTotalVal() == 44850, "");
|
|
vect16.setVal(28,65535);
|
|
try {
|
|
vect16.setVal(28,65536);
|
|
} catch (ValueErrorException &dexp) {
|
|
std::cout << "Expected failure: " << dexp.message() << "\n";
|
|
}
|
|
|
|
}
|
|
|
|
void test2DiscreteVectDists() {
|
|
DiscreteValueVect v1(DiscreteValueVect::ONEBITVALUE, 30);
|
|
DiscreteValueVect v2(DiscreteValueVect::ONEBITVALUE, 30);
|
|
unsigned int i;
|
|
for (i = 0; i < 15; ++i) {
|
|
v1.setVal(2*i, 1);
|
|
v2.setVal(2*i, 1);
|
|
}
|
|
CHECK_INVARIANT(computeL1Norm(v1, v2) == 0, " ");
|
|
for (i = 0; i < 30; ++i) {
|
|
v2.setVal(i, i%2);
|
|
}
|
|
|
|
CHECK_INVARIANT(computeL1Norm(v1, v2) == 30, " ");
|
|
|
|
for (i = 0; i < 30; ++i) {
|
|
if (i%3 == 0) {
|
|
v2.setVal(i, 1);
|
|
} else {
|
|
v2.setVal(i,0);
|
|
}
|
|
}
|
|
|
|
CHECK_INVARIANT(computeL1Norm(v1, v2) == 15, " ");
|
|
|
|
DiscreteValueVect v21(DiscreteValueVect::TWOBITVALUE, 30);
|
|
DiscreteValueVect v22(DiscreteValueVect::TWOBITVALUE, 30);
|
|
for (i = 0; i < 30; ++i) {
|
|
v21.setVal(i, i%4);
|
|
v22.setVal(i, i%4);
|
|
}
|
|
CHECK_INVARIANT(computeL1Norm(v21, v22) == 0, " ");
|
|
for (i = 0; i < 30; ++i) {
|
|
v22.setVal(i, (i+1)%4);
|
|
}
|
|
CHECK_INVARIANT(computeL1Norm(v21, v22) == 44, " ");
|
|
|
|
DiscreteValueVect v41(DiscreteValueVect::FOURBITVALUE, 16);
|
|
DiscreteValueVect v42(DiscreteValueVect::FOURBITVALUE, 16);
|
|
for (i = 0; i < 16; ++i) {
|
|
v41.setVal(i, i%16);
|
|
v42.setVal(i, i%16);
|
|
}
|
|
CHECK_INVARIANT(computeL1Norm(v41, v42) == 0, " ");
|
|
|
|
for (i = 0; i < 16; ++i) {
|
|
v42.setVal(i, i%5);
|
|
}
|
|
CHECK_INVARIANT(computeL1Norm(v41, v42) ==90, " ");
|
|
|
|
DiscreteValueVect v43(v42);
|
|
CHECK_INVARIANT(computeL1Norm(v42, v43) == 0, " ");
|
|
|
|
DiscreteValueVect v81(DiscreteValueVect::EIGHTBITVALUE, 5);
|
|
DiscreteValueVect v82(DiscreteValueVect::EIGHTBITVALUE, 5);
|
|
v81.setVal(0, 34); v82.setVal(0, 34);
|
|
v81.setVal(1, 167); v82.setVal(1, 167);
|
|
v81.setVal(2, 3); v82.setVal(2, 3);
|
|
v81.setVal(3, 56); v82.setVal(3, 56);
|
|
v81.setVal(4, 128); v82.setVal(4, 128);
|
|
CHECK_INVARIANT(computeL1Norm(v81, v82) == 0, " ");
|
|
|
|
v82.setVal(0, 14); v82.setVal(1, 67);
|
|
v82.setVal(2, 103); v82.setVal(3, 6);
|
|
v82.setVal(4, 228);
|
|
CHECK_INVARIANT(computeL1Norm(v81, v82) == 370, "");
|
|
|
|
DiscreteValueVect v161(DiscreteValueVect::SIXTEENBITVALUE, 3);
|
|
DiscreteValueVect v162(DiscreteValueVect::SIXTEENBITVALUE, 3);
|
|
v161.setVal(0, 2345); v162.setVal(0, 2345);
|
|
v161.setVal(1, 64578); v162.setVal(1, 64578);
|
|
v161.setVal(2, 34); v162.setVal(2, 34);
|
|
CHECK_INVARIANT(computeL1Norm(v161, v162) == 0, " ");
|
|
|
|
v162.setVal(0, 1345);
|
|
v162.setVal(1, 54578);
|
|
v162.setVal(2, 10034);
|
|
CHECK_INVARIANT(computeL1Norm(v161, v162) == 21000, " ");
|
|
|
|
}
|
|
|
|
int main(){
|
|
try{
|
|
throw IndexErrorException(3);
|
|
} catch (IndexErrorException) {
|
|
cerr << "pass" << endl;
|
|
}
|
|
|
|
stringstream ss(ios_base::binary|ios_base::out|ios_base::in);
|
|
int v1=4,v2=5,v3,v4;
|
|
|
|
ss.write((const char *)&v1,sizeof(v1));
|
|
ss.write((const char *)&v2,sizeof(v2));
|
|
#if 0
|
|
ss.close();
|
|
fstream ss2("blah.bin",ios_base::binary|ios_base::in);
|
|
ss2.read((char *)&v3,sizeof(v3));
|
|
ss2.read((char *)&v4,sizeof(v4));
|
|
#endif
|
|
ss.seekp(0,ios_base::beg);
|
|
ss.read((char *)&v3,sizeof(v3));
|
|
ss.read((char *)&v4,sizeof(v4));
|
|
|
|
TXTMSG("v3",v3);
|
|
TXTMSG("v4",v4);
|
|
|
|
cerr << " SPARSE -----------------------------------------" << endl;
|
|
SparseBitVect sparseFoo(10);
|
|
Test(sparseFoo);
|
|
TaniTest(sparseFoo);
|
|
ProbeTest(sparseFoo);
|
|
cerr << " Explicit -----------------------------------------" << endl;
|
|
ExplicitBitVect explicitFoo(10);
|
|
Test(explicitFoo);
|
|
TaniTest(explicitFoo);
|
|
cerr << " Done" << endl;
|
|
|
|
std::cout << " Test DiscreteValue Vectors 1 ------------------------------------" << endl;
|
|
test1DiscreteVect();
|
|
std::cout << " Test DiscreteValue Vectors 2 ------------------------------------" << endl;
|
|
test2DiscreteVectDists();
|
|
|
|
return 0;
|
|
|
|
}
|