int main( int argc,
char** argv)
{
// Initialise the C-library random mechanism by seeding it with the current time
// See http://www.cplusplus.com/reference/clibrary/cstdlib/srand/
std::srand( std::time( NULL));
// For more info on exception handling: http://www.cplusplus.com/doc/tutorial/exceptions/
// and http://www.parashift.com/c++-faq/exceptions.html
try
{
GameContext game1("1");
boost::thread table1([&game1] {game1.play();});
GameContext game2("2");
boost::thread table2([&game2] {game2.play();});
GameContext game3("3");
boost::thread table3([&game3] {game3.play();});
table1.join();
table2.join();
table3.join();
}
catch (std::exception& e)
{
std::cout << "Exception caught: " << e.what() << std::endl;
}
catch (...)
{
std::cout << "Unknown exception caught: " << std::endl;
}
return 0;
}
TEST_F(HashTableTest, AssignmentOperatorWorksOnCorrectSizedMap)
{
capu::HashTable<capu::uint32_t, capu::uint32_t> table(4, true);
table.put(1, 2);
table.put(3, 4);
table.put(5, 6);
capu::HashTable<capu::uint32_t, capu::uint32_t> table2(4, false); // not resizable
table2 = table;
ASSERT_EQ(3u, table2.count()); // modification occurred
}
TEST_F(HashTableTest, AssignmentOperatorDoesNothingOnWrongSizedMap)
{
capu::HashTable<capu::uint32_t, capu::uint32_t> table(5, true);
table.put(1, 2);
table.put(3, 4);
table.put(5, 6);
capu::HashTable<capu::uint32_t, capu::uint32_t> table2(4, false); // not resizable
table2 = table;
ASSERT_EQ(0u, table2.count()); // no modification occurred
}
int
main(int argc, char** argv){
if(argc != 5){
Usage(argc,argv);
return 1;
}
// amount of mask attenuation (dB)
float amount = (float)pow(10, atof(argv[4])/20.f);
// masking file
SndWave inmask(argv[2], READ);
// input file
SndWave infile(argv[1], READ);
// Hamming window
HammingTable window(DEF_FFTSIZE, 0.54f);
// masking table
PVTable table2(DEF_FFTSIZE,&inmask,&window, 0.f, 1.f);
// input signal
SndIn in(&infile);
// PV analysis
PVA anal(&window, &in, 0.6f);
// Masking
PVMask mask(amount, &table2, &anal);
// PV synthesis
PVS synth(&window, &mask);
// output file
SndWave output(argv[3], OVERWRITE, 1);
output.SetOutput(1, &synth);
// processing loop
while(!infile.Eof()){
infile.Read();
in.DoProcess();
anal.DoProcess();
mask.DoProcess();
synth.DoProcess();
output.Write();
}
return 0;
}
static void test_emptytable(skiatest::Reporter* reporter) {
SkAutoTUnref<SkDataTable> table0(SkDataTable::NewEmpty());
SkAutoTUnref<SkDataTable> table1(SkDataTable::NewCopyArrays(NULL, NULL, 0));
SkAutoTUnref<SkDataTable> table2(SkDataTable::NewCopyArray(NULL, 0, 0));
SkAutoTUnref<SkDataTable> table3(SkDataTable::NewArrayProc(NULL, 0, 0,
NULL, NULL));
test_datatable_is_empty(reporter, table0);
test_datatable_is_empty(reporter, table1);
test_datatable_is_empty(reporter, table2);
test_datatable_is_empty(reporter, table3);
test_is_equal(reporter, table0, table1);
test_is_equal(reporter, table0, table2);
test_is_equal(reporter, table0, table3);
}
int main()
{
/*/ Create 26 Items to store in the Hash Table.
Item * A = new Item {"Apple", NULL};
Item * B = new Item {"Banana", NULL};
Item * C = new Item {"Caterpillar", NULL};
Item * D = new Item {"Dog", NULL};
Item * E = new Item {"Elephant", NULL};
Item * F = new Item {"Fedora", NULL};
Item * G = new Item {"Goosebumps", NULL};
Item * H = new Item {"House", NULL};
Item * I = new Item {"Insects", NULL};
Item * J = new Item {"Jam", NULL};
Item * K = new Item {"Kite", NULL};
Item * L = new Item {"Limestone", NULL};
Item * M = new Item {"Mountaineering", NULL};
Item * N = new Item {"Night", NULL};
Item * O = new Item {"Open Sesame", NULL};
Item * P = new Item {"Potatoes", NULL};
Item * Q = new Item {"Quantum Mechanics", NULL};
Item * R = new Item {"Rrrrrrrrrrawr", NULL};
Item * S = new Item {"Snakes", NULL};
Item * T = new Item {"Tizzy Tube", NULL};
Item * U = new Item {"Underworld", NULL};
Item * V = new Item {"Volcanic Ash", NULL};
Item * W = new Item {"Who When What Why", NULL};
Item * X = new Item {"XXX", NULL};
Item * Y = new Item {"Yellow", NULL};
Item * Z = new Item {"Zest of Lemon", NULL};
// Create a Hash Table of 13 Linked List elements.
HashTable table;
// Add 3 Items to Hash Table.
table.insertItem(A);
table.insertItem(B);
table.insertItem(C);
table.printTable();
table.printHistogram();
// Remove one item from Hash Table.
table.removeItem("Apple");
table.printTable();
table.printHistogram();
// Add 23 items to Hash Table.
table.insertItem(D);
table.insertItem(E);
table.insertItem(F);
table.insertItem(G);
table.insertItem(H);
table.insertItem(I);
table.insertItem(J);
table.insertItem(K);
table.insertItem(L);
table.insertItem(M);
table.insertItem(N);
table.insertItem(O);
table.insertItem(P);
table.insertItem(Q);
table.insertItem(R);
table.insertItem(S);
table.insertItem(T);
table.insertItem(U);
table.insertItem(V);
table.insertItem(W);
table.insertItem(X);
table.insertItem(Y);
table.insertItem(Z);
table.printTable();
table.printHistogram();
// Look up an Item in the Hash Table.
Item * result = table.getItemByKey("Snakes");
cout << result -> key << endl;
*/
int N=20, B=97;
HashTable table1(B), table2(B);
for (int i = 0; i < N;i++){
char s[10];
gen_random(s, 10);
Item * A = new Item{ s, NULL };
table1.insertItem(A);
table2.insertItem1(A);
}
// table1.printTable();
// table1.printHistogram();
cout<< table1.countHistogram(N) << endl;
// table2.printTable();
// table2.printHistogram();
cout << table2.countHistogram(N) << endl;
return 0;
}
void test_perm(int N, int NN, unsigned int M)
{
int j; unsigned long i; double sum2 = 0;
Array<long> count(0,NN-1); // count number of times each ball is drawn
Array<int> last(0,NN-1); // details of last draw
long consec = 0; // count number of consecutive balls
last = 0; count = 0; // set the arrays to zero
cout << endl;
cout << "Size of urn = " << NN << "; ";
cout << "no. of balls = " << N << "; ";
cout << "no. of trials = " << M << endl;
cout << BaseTest::Header << endl;
if (N > NN) { Throw(Runtime_error("N > NN")); }
long double S0 = 0.0; // sum of ball numbers
long double S1 = 0.0; // sum of ball * draw
double centre = (NN+1) / 2.0; // average ball number
double avj = (N+1)/2.0; // average draw number
Array2<int> table1(0,NN-1,0,N-1); // times ball i occurs at draw j
Array2<int> table2(0,NN-1,0,NN-1); // times ball i and ball j both occur
table1 = 0; table2 = 0; // clear the tables
long turnings = 0; // number of turning points
RandomPermutation RP; // reset the Urn
Array<int> Draw(0,N-1); // for the draw
for (i=1; i<=M; i++) // iterate over total number of trials
{
int last_ball = -1;
RP.Next(NN,N,Draw.base(),1); // do the draw
Array<int> check(0,NN-1); check = 0; // for checking no repeats
for (j = 1; j <= N; j++) // N balls in draw
{
int x = Draw(j-1);
if (x<1 || x>NN) Throw(Runtime_error("Invalid number"));
check(x-1)++; count(x-1)++; sum2 += last(x-1);
if (x == last_ball+1 || x == last_ball-1) consec++;
last_ball = x;
double xc = x - centre;
S0 += xc; S1 += xc * (j-avj);
table1(x-1,j-1)++;
}
for (j=0; j<NN; j++)
{
if (check(j) > 1) Throw(Runtime_error("Repeated number"));
last(j) = check(j);
if (check(j)) // increment table of pairs
{
for (int k = j+1; k<NN; k++) if (check(k)) table2(j,k)++;
}
}
// count number of turnings
for (j = 2; j < N; j++)
{
long last = Draw(j-2);
long current = Draw(j-1);
long next = Draw(j);
if ( (last < current && next < current) ||
(last > current && next > current) ) turnings++;
}
}
// do the tests
double sum1 = 0.0; double d = M * (N / (double)NN);
for (j=0; j<NN; j++) { sum1 += square(count(j) - d); }
if (N < NN)
{
sum1 /= d;
double sd = (NN - N) * sqrt( 2 * (M - 1) / (M * ((double)(NN - 1))) );
NormalTestTwoSided freq_test("Ball freq.", sum1, NN - N, square(sd));
freq_test.DoTest();
NormalTestTwoSided repeats_test("Repeats", sum2, (M - 1) * (N * N / (double)NN),
square((double)(N * (NN - N)) / (double)NN) * (M - 1) / (NN - 1) );
repeats_test.DoTest();
double V0 = ((double)N * (NN+1.0) * (NN-N))/12.0;
NormalTestTwoSided average_test("Average", S0, 0, M * V0);
average_test.DoTest();
}
if (N > 1)
{
double V1 = (double)N * (N*N - 1) * NN * (NN + 1) / 144.0;
NormalTestTwoSided ball_times_draw("Ball * draw", S1, 0, M * V1);
ball_times_draw.DoTest();
double e = 2 * M * (N - 1) / (double)NN;
// expected # of consecutive balls
NormalTestTwoSided consec_test("Consec balls", consec, e, e);
consec_test.DoTest();
}
if (N > 1)
{
// balls vs draws
double CS = 0; double ev = (double)M / NN;
for (int i = 0; i < NN; i++) for (int j = 0; j < N; j++)
CS += square(table1(i,j)-ev);
CS /= ev; ev = N * (NN - 1);
double v = 2.0 * N * (M - 1) * (N - (2 - NN) * NN) / M / (NN - 1);
NormalTestTwoSided ball_draw("Ball vs draw", CS, ev, v);
ball_draw.DoTest();
}
if (N>1 && N < NN)
{
// pairs of balls
double CS = 0; double ev = (double)M*N*(N-1)/ NN / (NN-1);
for (int i = 0; i < NN; i++) for (int j = i+1; j < NN; j++)
CS += square(table2(i,j)-ev);
CS /= ev; ev = (NN-N)*(NN+N-1)/2.0;
double v = (double)(M-1)*square(NN-N)*(-3+6*N-3.0*N*N+2*NN-6.0*N*NN+
2.0*N*N*NN+NN*NN)/(M*(NN-2)*(NN-3));
NormalTestTwoSided pairs_test("Pairs table", CS, ev, v);
pairs_test.DoTest();
}
if (N > 2)
{
double V2 = (16.0 * N - 29.0) / 90.0;
NormalTestTwoSided runs_test("Runs test", turnings,
(double)M * (N-2) / 1.5, M * V2);
runs_test.DoTest();
}
}
Status Operators::SMJ(const string& result, // Output relation name
const int projCnt, // Number of attributes in the projection
const AttrDesc attrDescArray[], // Projection list (as AttrDesc)
const AttrDesc& attrDesc1, // The left attribute in the join predicate
const Operator op, // Predicate operator
const AttrDesc& attrDesc2, // The left attribute in the join predicate
const int reclen) // The length of a tuple in the result relation
{
cout << "Algorithm: SM Join" << endl;
/* Your solution goes here */
Status status;
RID rid_old1;
Record rec_old1;
int maxitem1;
status = get_maxItems(string(attrDesc1.relName), maxitem1);
if (status != OK) return status;
SortedFile table1 (attrDesc1.relName, attrDesc1.attrOffset, attrDesc1.attrLen,
(Datatype)attrDesc1.attrType, maxitem1, status);
if (status != OK) return status;
RID rid_old2;
Record rec_old2;
int maxitem2;
status = get_maxItems(string(attrDesc2.relName), maxitem2);
if (status != OK) return status;
SortedFile table2 (attrDesc2.relName, attrDesc2.attrOffset, attrDesc2.attrLen,
(Datatype)attrDesc2.attrType, maxitem2, status);
if (status != OK) return status;
HeapFile new_hf(result, status);
if (status != OK) return status;
RID rid_new;
Record rec_new;
bool matched = false;
bool end_loop = false;
Record prev_rec1;
int diff;
status = table1.next(rec_old1);
if (status == FILEEOF) return OK;
else if (status != OK) return status;
status = table2.next(rec_old2);
if (status == FILEEOF) return OK;
else if (status != OK) return status;
//initial new_rec
rec_new.length = reclen;
rec_new.data = operator new (reclen);
while (!end_loop){
matched = false;
diff = matchRec(rec_old1, rec_old2, attrDesc1, attrDesc2);
if (diff < 0){
//next tuple in rel1
memcpy (&prev_rec1, &rec_old1, sizeof(Record)); //copy the previous rec in rel1
status = table1.next(rec_old1);
if (status == FILEEOF){
end_loop = true;
} else if (status != OK){
operator delete (rec_new.data);
return status;
}
if (matchRec(prev_rec1, rec_old1, attrDesc1, attrDesc1)==0){ //is equal
table2.gotoMark();
table2.next(rec_old2);
}
} else if (diff > 0){
//next tuple in rel2
status = table2.next(rec_old2);
if (status == FILEEOF){
end_loop = true;
} else if (status != OK){
operator delete (rec_new.data);
return status;
}
}
while ((diff == 0)&&(!end_loop)){ //match
if (!matched){
table2.setMark();
matched = true;
}
//insert new tuple
int offset = 0;
for (int i=0; i<projCnt; i++){
if (!strcmp(attrDescArray[i].relName, attrDesc1.relName)){ //in rel1
memcpy(rec_new.data+offset, rec_old1.data+attrDescArray[i].attrOffset,
attrDescArray[i].attrLen);
offset += attrDescArray[i].attrLen;
} else {
memcpy(rec_new.data+offset, rec_old2.data+attrDescArray[i].attrOffset,
attrDescArray[i].attrLen);
offset += attrDescArray[i].attrLen;
}
}
status = new_hf.insertRecord(rec_new, rid_new);
if (status != OK) {
operator delete (rec_new.data);
return status;
}
//get next tuple
status = table2.next(rec_old2);
if (status == FILEEOF){ //if end of inner loop
memcpy (&prev_rec1, &rec_old1, sizeof(Record)); //copy the previous rec in rel1
status = table1.next(rec_old1);
if (status == FILEEOF){
end_loop = true;
} else if (status != OK){
operator delete (rec_new.data);
return status;
}
if (matchRec(prev_rec1, rec_old1, attrDesc1, attrDesc1)==0){ //is equal
table2.gotoMark();
table2.next(rec_old2);
} else {
end_loop = true;
}
} else if (status != OK){
operator delete (rec_new.data);
return status;
}
diff = matchRec(rec_old1, rec_old2, attrDesc1, attrDesc2);
}
}
operator delete (rec_new.data);
return OK;
}
Status Operators::INL(const string& result, // Name of the output relation
const int projCnt, // Number of attributes in the projection
const AttrDesc attrDescArray[], // The projection list (as AttrDesc)
const AttrDesc& attrDesc1, // The left attribute in the join predicate
const Operator op, // Predicate operator
const AttrDesc& attrDesc2, // The left attribute in the join predicate
const int reclen) // Length of a tuple in the output relation
{
cout << "Algorithm: Indexed NL Join" << endl;
/* Your solution goes here */
Status status;
RID rid_old1;
Record rec_old1;
HeapFileScan table1(attrDesc1.relName, status);
if (status != OK) return status;
RID rid_old2;
Record rec_old2;
Index index(attrDesc2.relName, attrDesc2.attrOffset, attrDesc2.attrLen, (Datatype)
attrDesc2.attrType, 0, status);
if (status != OK) return status;
HeapFileScan table2(attrDesc2.relName, status);
if (status != OK) return status;
HeapFile new_hf(result, status);
if (status != OK) return status;
RID rid_new;
Record rec_new;
rec_new.length = reclen;
rec_new.data = operator new (reclen);
int i = attrDesc1.attrLen;
void* value = operator new (i);
while (table1.scanNext(rid_old1, rec_old1) == OK){
memcpy(value, rec_old1.data+attrDesc1.attrOffset, attrDesc1.attrLen); //get value
index.startScan(value);
while (index.scanNext(rid_old2) == OK){
status = table2.getRandomRecord(rid_old2, rec_old2);
if (status != OK) {
operator delete (value);
operator delete (rec_new.data);
return status;
}
//fill in rec_new.data
int offset = 0;
for (int i=0; i<projCnt; i++){
if (!strcmp(attrDescArray[i].relName, attrDesc1.relName)){ //in rel1
memcpy(rec_new.data+offset, rec_old1.data+attrDescArray[i].attrOffset,
attrDescArray[i].attrLen);
offset += attrDescArray[i].attrLen;
} else {
memcpy(rec_new.data+offset, rec_old2.data+attrDescArray[i].attrOffset,
attrDescArray[i].attrLen);
offset += attrDescArray[i].attrLen;
}
}
status = new_hf.insertRecord(rec_new, rid_new);
if (status != OK){
operator delete (value);
operator delete (rec_new.data);
return status;
}
}
index.endScan();
}
operator delete (value);
operator delete (rec_new.data);
return OK;
}
