void
gen(FILE * stream)
{
register int i;
#ifdef AFS_DARWIN80_ENV
int j;
#define swap_long_bytes_bit_number _darwin_swap_long_bytes_bit_number
#endif /* AFS_DARWIN80_ENV */
/* clear the output */
fprintf(stream, " L2 = 0; R2 = 0;\n");
/*
* NOTE: As part of the final permutation, we also have to adjust
* for host bit order via "swap_bit_pos_0()". Since L2,R2 are
* the output from this, we adjust the bit positions written into
* L2,R2.
*/
#define SWAP(i,j) \
swap_long_bytes_bit_number(swap_bit_pos_0_to_ansi((unsigned)i)-j)
#ifdef AFS_DARWIN80_ENV
for(j = 0;; j++) {
fprintf(stream, _darwin_whichstr[j]);
if (j == 2)
break;
#endif /* AFS_DARWIN80_ENV */
/* first setup FP */
fprintf(stream, "/* FP operations */\n/* first left to left */\n");
/* first list mapping from left to left */
for (i = 0; i <= 31; i++)
if (FP[i] < 32)
test_set(stream, "L1", FP[i], "L2", SWAP(i, 0));
/* now mapping from right to left */
fprintf(stream, "\n\n/* now from right to left */\n");
for (i = 0; i <= 31; i++)
if (FP[i] >= 32)
test_set(stream, "R1", FP[i] - 32, "L2", SWAP(i, 0));
fprintf(stream, "\n/* now from left to right */\n");
/* list mapping from left to right */
for (i = 32; i <= 63; i++)
if (FP[i] < 32)
test_set(stream, "L1", FP[i], "R2", SWAP(i, 32));
/* now mapping from right to right */
fprintf(stream, "\n/* last from right to right */\n");
for (i = 32; i <= 63; i++)
if (FP[i] >= 32)
test_set(stream, "R1", FP[i] - 32, "R2", SWAP(i, 32));
#ifdef AFS_DARWIN80_ENV
_darwin_which = !_darwin_which;
}
#endif /* AFS_DARWIN80_ENV */
}
bool sparse_sub_hes(void)
{ bool ok = true;
ok &= test_set("cppad.symmetric");
ok &= test_set("cppad.general");
//
ok &= test_bool("cppad.symmetric");
ok &= test_bool("cppad.general");
return ok;
}
void
gen(FILE * stream)
{
register int i;
#ifdef AFS_DARWIN80_ENV
int j;
#define swap_long_bytes_bit_number _darwin_swap_long_bytes_bit_number
#endif /* AFS_DARWIN80_ENV */
/* clear the output */
fprintf(stream, " L2 = 0; R2 = 0;\n");
#ifdef AFS_DARWIN80_ENV
for(j = 0;; j++) {
fprintf(stream, _darwin_whichstr[j]);
if (j == 2)
break;
#endif /* AFS_DARWIN80_ENV */
/* first setup IP */
fprintf(stream, "/* IP operations */\n/* first left to left */\n");
/* first list mapping from left to left */
for (i = 0; i <= 31; i++)
if (IP[i] < 32)
test_set(stream, "L1", SWAP(IP[i]), "L2", i);
/* now mapping from right to left */
fprintf(stream, "\n/* now from right to left */\n");
for (i = 0; i <= 31; i++)
if (IP[i] >= 32)
test_set(stream, "R1", SWAP(IP[i] - 32), "L2", i);
fprintf(stream, "\n/* now from left to right */\n");
/* list mapping from left to right */
for (i = 32; i <= 63; i++)
if (IP[i] < 32)
test_set(stream, "L1", SWAP(IP[i]), "R2", i - 32);
/* now mapping from right to right */
fprintf(stream, "\n/* last from right to right */\n");
for (i = 32; i <= 63; i++)
if (IP[i] >= 32)
test_set(stream, "R1", SWAP(IP[i] - 32), "R2", i - 32);
#ifdef AFS_DARWIN80_ENV
_darwin_which = !_darwin_which;
}
#endif /* AFS_DARWIN80_ENV */
exit(0);
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose:
*
* Return: Success:
*
* Failure:
*
* Programmer: Robb Matzke
* Tuesday, June 16, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main (void)
{
int nerrors=0;
/*
* Open the library explicitly for thread-safe builds, so per-thread
* things are initialized correctly.
*/
#ifdef H5_HAVE_THREADSAFE
H5open();
#endif /* H5_HAVE_THREADSAFE */
nerrors += test_find ()<0?1:0;
nerrors += test_set ()<0?1:0;
nerrors += test_clear()<0?1:0;
nerrors += test_copy ()<0?1:0;
nerrors += test_shift()<0?1:0;
nerrors += test_increment ()<0?1:0;
nerrors += test_decrement ()<0?1:0;
nerrors += test_negate ()<0?1:0;
if (nerrors) {
printf("***** %u FAILURE%s! *****\n",
nerrors, 1==nerrors?"":"S");
exit(1);
}
printf("All bit tests passed.\n");
#ifdef H5_HAVE_THREADSAFE
H5close();
#endif /* H5_HAVE_THREADSAFE */
return 0;
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose:
*
* Return: Success:
*
* Failure:
*
* Programmer: Robb Matzke
* Tuesday, June 16, 1998
*
*-------------------------------------------------------------------------
*/
int
main(void)
{
int nerrors = 0;
/*
* Open the library explicitly.
*/
H5open();
nerrors += test_find() < 0 ? 1 : 0;
nerrors += test_set() < 0 ? 1 : 0;
nerrors += test_clear() < 0 ? 1 : 0;
nerrors += test_copy() < 0 ? 1 : 0;
nerrors += test_shift() < 0 ? 1 : 0;
nerrors += test_increment() < 0 ? 1 : 0;
nerrors += test_decrement() < 0 ? 1 : 0;
nerrors += test_negate() < 0 ? 1 : 0;
if(nerrors) {
printf("***** %u FAILURE%s! *****\n",
nerrors, 1 == nerrors ? "" : "S");
exit(1);
}
printf("All bit tests passed.\n");
H5close();
return 0;
}
int main() {
test_set();
// test_fire();
/*
vtest1();
utest1();
utest2();
utest3();
utest4();
*/
// BSLegend l(legend);
// std::cout << l << std::endl;
// l.remove(3);
// l.remove(3);
// std::cout << l << std::endl;
// for(BSLegend::uniqiter i(l); i(); ++i) {
// std::cout << ">" << *i << std::endl;
// }
// BSArenaKey ky(10, legend);
// ky.auto_setup();
return 0;
}
TEST(test_encode_decode, test_set) {
test_set(std::set<int>(), "");
{
std::set<int> s;
s.insert(1);
test_set(s, "0a0101");
}
{
std::set<int> s;
s.insert(1);
s.insert(2);
s.insert(3);
s.insert(4);
test_set(s, "0a01010a01020a01030a0104");
}
}
int main() {
test_get();
test_set();
test_write_out();
std::cout << "All tests finished! \n";
return 0;
}
int main(int argc, char **argv)
{
err_setarg0(argv[argc-argc]);
test_set();
test_ops();
return 0;
}
int run_vanilla_nolemma(unsigned epochs, float alpha){
//Data set (Ratnaparkhi's 94 RRR data set)
vector<string> ydict;
vector<string> xdict;
PPADataEncoder data_set("PPAttachData/training");
data_set.add_data("PPAttachData/devset");
data_set.add_data("PPAttachData/test");
data_set.getYdictionary(ydict);
data_set.getXdictionary(xdict);
//External Word vectors
Word2vec w2v;
vector<string> wvdict;
af::array w2v_embeddings;
w2v.load_dictionary("PPAttachData/embeddings/deps.words");
w2v.filter(xdict);
//training set
data_set.clear();
data_set.add_data("PPAttachData/training");
data_set.getXdictionary(xdict);
//build network
cerr << "building network"<<endl;
SymbolicFeedForwardNetwork<string,string> net;
net.set_output_layer("loss",new SoftMaxLoss<string>(ydict));
net.add_layer("top",new LinearLayer());
net.add_layer("hidden",new ReLUActivation(400));
net.add_layer("A",new LinearLayer());
net.add_input_layer("lookupA",new LinearLookup<string>(w2v.get_keys(),w2v.get_values(),data_set.x_vocab_size(),true));
net.connect_layers("loss","top");
net.connect_layers("top","hidden");
net.connect_layers("hidden","A");
net.connect_layers("A","lookupA");
vector<string> ydata;
vector<vector<string>> xdata(1,vector<string>());
data_set.getYdata(ydata);
data_set.getXdata(xdata[0]);
net.set_batch_data(ydata,xdata);
net.train_all(ydata,xdata,epochs,100,alpha,true,epochs/2);//10 epochs, batch size= 100,alpha=0.01, Adagrad=On, start averaging at 50th epoch
PPADataEncoder dev_set("PPAttachData/devset");
dev_set.getYdata(ydata);
dev_set.getXdata(xdata[0]);
float dev_acc = net.eval_avg(ydata,xdata);
cout << "dev acc = " << dev_acc << endl;
PPADataEncoder test_set("PPAttachData/test");
test_set.getYdata(ydata);
test_set.getXdata(xdata[0]);
float test_acc = net.eval_avg(ydata,xdata);
cout << "test acc = " << test_acc << endl;
return 0;
}
static int proc_args(int argc, char *argv[]) {
unsigned short base_addr;
unsigned long returnVal, bits, stop,parity, rate;
if (strncmp(argv[1], "conf", strlen("conf")) == 0) {
if (argc != 3) {
printf("test_conf: wrong number of arguments for test of test_conf() \n");
return 1;
}
if ((base_addr = parse_ulong(argv[2], 16)) == ULONG_MAX)
return 1;
returnVal = test_conf((unsigned short)base_addr);
printf("\n");
return returnVal;
} else if (strncmp(argv[1], "set", strlen("set")) == 0) {
if (argc != 7) {
printf("test_set: wrong number of arguments for test of test_set() \n");
return 1;
}
if ((base_addr = parse_ulong(argv[2], 10)) == ULONG_MAX)
return 1;
if ((bits = parse_ulong(argv[3], 10)) == ULONG_MAX)
return 1;
if ((stop = parse_ulong(argv[4], 10)) == ULONG_MAX)
return 1;
if ((parity = parse_ulong(argv[5], 10)) == ULONG_MAX)
return 1;
if ((rate = parse_ulong(argv[6], 10)) == ULONG_MAX)
return 1;
returnVal = test_set(base_addr, bits,stop,parity,rate);
printf("\n");
return returnVal;
}
else if (strncmp(argv[1], "poll", strlen("poll")) == 0) {
return 0;
}
else if (strncmp(argv[1], "int", strlen("int")) == 0) {
return 0;
}
else if (strncmp(argv[1], "fifo", strlen("fifo")) == 0) {
return 0;
}
else {
printf("test: non valid function \"%s\" to test\n", argv[1]);
return 1;
}
}
int main()
{
switch(nondet_int())
{
case 0: test_vector(); break;
case 1: test_list(); break;
case 2: test_set(); break;
default:;
}
}
std::vector<std::string> storage::test_sequence(
const google::protobuf::RepeatedPtrField<problem::single::TestQuery>
&queries) {
const std::unordered_set<std::string> full_set = test_set();
std::vector<std::string> sequence;
for (const problem::single::TestQuery &query : queries) {
const problem::single::test::matcher matcher(query);
sequence.insert(sequence.end(),
boost::make_filter_iterator(matcher, full_set.begin()),
boost::make_filter_iterator(matcher, full_set.end()));
}
return sequence;
}
int main() {
string a = checked_malloc(10);
for(int i=0; i<9; i++) {
a[i] = '*';
}
a[9] = '\0';
bool b = FALSE;
if(b) {
;
}
else {
printf("%s++\n", a);
}
test_list();
test_set();
//free(s);
}
int
main (int argc,
char *argv[])
{
/* run tests in legacy (pre-session support) mode */
setenv ("UPSTART_NO_SESSIONS", "1", 1);
test_add ();
test_append ();
test_set ();
test_lookup ();
test_get ();
test_getn ();
test_all_valid ();
test_expand ();
return 0;
}
int main( int argc, char *argv[] )
{
struct mem_server server;
int ret;
if( argc < 3 )
{
fprintf( stderr, "Usage : %s -server_ip -server_port\n", argv[0] );
return -1;
}
mem_set_error_handler( error_handler );
{
/* startup the winsock */
WSADATA wd;
WSAStartup( MAKEWORD( 2, 0 ), &wd );
}
ret = mem_connect( &server, argv[1], atoi( argv[2] ) );
/* test */
{
test_stats( &server );
test_set( &server );
test_add( &server );
test_replace( &server );
/*test_delete( &server, "TestSet" );*/
test_get( &server );
test_inc_dec( &server );
}
mem_disconnect( &server );
/* shutdown the winsock */
WSACleanup();
return 0;
}
int main()
{
int values[4] = { 2, 3, 5, 7 };
set_type test_set(values, values+4);
powerset_type test_powerset = powerset(test_set);
for (powerset_type::iterator iter = test_powerset.begin();
iter != test_powerset.end();
++iter)
{
std::cout << "{ ";
char const* prefix = "";
for (set_type::iterator iter2 = iter->begin();
iter2 != iter->end();
++iter2)
{
std::cout << prefix << *iter2;
prefix = ", ";
}
std::cout << " }\n";
}
}
int Test::all() {
clock_t begin = clock();
exeTime = 0;
test_general();
test_types();
test_booleans();
test_numbers();
test_strings();
test_arrays();
test_intervals();
test_map();
test_set();
test_objects();
test_functions();
test_classes();
test_loops();
test_operators();
test_references();
test_exceptions();
test_operations();
test_system();
test_json();
test_files();
test_doc();
test_utils();
double elapsed_secs = double(clock() - begin) / CLOCKS_PER_SEC;
int errors = (total - success_count);
int leaks = (obj_created - obj_deleted);
int mpz_leaks = (mpz_obj_created - mpz_obj_deleted);
std::ostringstream line1, line2, line3, line4;
line1 << "Total : " << total << ", success : " << success_count << ", errors : " << errors;
line2 << "Total time : " << elapsed_secs * 1000 << " ms";
line3 << "Objects destroyed : " << obj_deleted << " / " << obj_created << " (" << leaks << " leaked)";
line4 << "MPZ objects destroyed : " << mpz_obj_deleted << " / " << mpz_obj_created << " (" << mpz_leaks << " leaked)";
unsigned w = std::max(line1.str().size(), std::max(line2.str().size(), std::max(line3.str().size(), line4.str().size())));
auto pad = [](std::string s, int l) {
l -= s.size();
while (l-- > 0) s += " ";
return s;
};
std::cout << "┌";
for (unsigned i = 0; i < w + 2; ++i) std::cout << "─";
std::cout << "┐" << std::endl;
std::cout << "│ " << pad(line1.str(), w) << " │" << std::endl;
std::cout << "│ " << pad(line2.str(), w) << " │" << std::endl;
std::cout << "│ " << pad(line3.str(), w) << " │" << std::endl;
std::cout << "│ " << pad(line4.str(), w) << " │" << std::endl;
std::cout << "├";
for (unsigned i = 0; i < w + 2; ++i) std::cout << "─";
std::cout << "┤";
std::cout << std::endl;
int result = abs(errors) + abs(leaks) + abs(mpz_leaks);
if (result == 0) {
std::cout << "│ " << pad("GOOD! ✔", w + 2) << " │" << std::endl;
} else {
std::cout << "│ " << pad("BAD! : " + std::to_string(result) + " error(s) ✘", w + 2) << " │" << std::endl;
}
std::cout << "└";
for (unsigned i = 0; i < w + 2; ++i) std::cout << "─";
std::cout << "┘" << std::endl;
for (const auto& error : failed_tests) {
std::cout << " " << error << std::endl;
}
if (failed_tests.size()) {
std::cout << std::endl;
}
return result;
}
int main(int argc, char *argv[])
{
int ans;
char *str, *strout;
fmpz_poly_t zpoly;
fmpz_poly_q_t qpoly1;
mpz_t mpzzero, mpzone, mpztwo;
mpq_t mpqzero, mpqone, mpqtwo, mpqtwoinv;
FLINT_TEST_INIT(state);
flint_printf("all... ");
fflush(stdout);
/* Accessing numerator and denominator ***********************************/
fmpz_poly_q_init(qpoly1);
fmpz_poly_q_set_str(qpoly1, "2 -1 1/2 0 1");
str = "2 -1 1";
strout = fmpz_poly_get_str(fmpz_poly_q_numref(qpoly1));
ans = !strcmp(str, strout);
if (!ans)
{
flint_printf("test_numref: failed\n");
flint_printf(" Expected \"%s\", got \"%s\"\n", str, strout);
flint_printf(" qpoly1 = \""), fmpz_poly_q_print(qpoly1), flint_printf("\"\n");
abort();
}
fmpz_poly_q_clear(qpoly1);
flint_free(strout);
fmpz_poly_q_init(qpoly1);
fmpz_poly_q_set_str(qpoly1, "2 -1 1/2 0 1");
str = "2 0 1";
strout = fmpz_poly_get_str(fmpz_poly_q_denref(qpoly1));
ans = !strcmp(str, strout);
if (!ans)
{
flint_printf("test_denref: failed\n");
flint_printf(" Expected \"%s\", got \"%s\"\n", str, strout);
abort();
}
fmpz_poly_q_clear(qpoly1);
flint_free(strout);
fmpz_poly_q_init(qpoly1);
fmpz_poly_init(zpoly);
fmpz_poly_q_set_str(qpoly1, "2 -1 1/2 0 1");
fmpz_poly_set(zpoly, fmpz_poly_q_numref(qpoly1));
str = "2 -1 1";
strout = fmpz_poly_get_str(zpoly);
ans = !strcmp(str, strout);
if (!ans)
{
flint_printf("test_get_num: failed\n");
flint_printf(" Expected \"%s\", got \"%s\"\n", str, strout);
abort();
}
fmpz_poly_q_clear(qpoly1);
fmpz_poly_clear(zpoly);
flint_free(strout);
fmpz_poly_q_init(qpoly1);
fmpz_poly_init(zpoly);
fmpz_poly_q_set_str(qpoly1, "2 -1 1/2 0 1");
fmpz_poly_set(zpoly, fmpz_poly_q_denref(qpoly1));
str = "2 0 1";
strout = fmpz_poly_get_str(zpoly);
ans = !strcmp(str, strout);
if (!ans)
{
flint_printf("test_get_den: failed\n");
flint_printf(" Expected \"%s\", got \"%s\"\n", str, strout);
abort();
}
fmpz_poly_q_clear(qpoly1);
fmpz_poly_clear(zpoly);
flint_free(strout);
fmpz_poly_q_init(qpoly1);
fmpz_poly_init(zpoly);
fmpz_poly_q_set_str(qpoly1, "1 1/1 1");
fmpz_poly_set_str(zpoly, "2 0 1");
fmpz_poly_set(fmpz_poly_q_numref(qpoly1), zpoly);
str = "2 0 1";
strout = fmpz_poly_get_str(fmpz_poly_q_numref(qpoly1));
ans = !strcmp(str, strout);
if (!ans)
{
flint_printf("test_set_num: failed\n");
flint_printf(" Expected \"%s\", got \"%s\"\n", str, strout);
abort();
}
fmpz_poly_q_clear(qpoly1);
fmpz_poly_clear(zpoly);
flint_free(strout);
fmpz_poly_q_init(qpoly1);
fmpz_poly_init(zpoly);
fmpz_poly_q_set_str(qpoly1, "1 1/1 1");
fmpz_poly_set_str(zpoly, "2 0 1");
fmpz_poly_set(fmpz_poly_q_denref(qpoly1), zpoly);
str = "2 0 1";
strout = fmpz_poly_get_str(fmpz_poly_q_denref(qpoly1));
ans = !strcmp(str, strout);
if (!ans)
{
flint_printf("test_set_den: failed\n");
flint_printf(" Expected \"%s\", got \"%s\"\n", str, strout);
abort();
}
fmpz_poly_q_clear(qpoly1);
fmpz_poly_clear(zpoly);
flint_free(strout);
/* Canonicalise **********************************************************/
fmpz_poly_q_init(qpoly1);
str = "2 -1 1/2 0 1";
fmpz_poly_q_set_str(qpoly1, str);
strout = fmpz_poly_q_get_str(qpoly1);
ans = !strcmp(str, strout);
if (!ans)
{
flint_printf("test_canonicalize: failed\n");
flint_printf(" Expected \"%s\", got \"%s\"\n", str, strout);
abort();
}
fmpz_poly_q_clear(qpoly1);
flint_free(strout);
fmpz_poly_q_init(qpoly1);
str = "2 -1 -1/2 0 1";
fmpz_poly_q_set_str(qpoly1, "2 1 1/2 0 -1");
strout = fmpz_poly_q_get_str(qpoly1);
ans = !strcmp("2 -1 -1/2 0 1", strout);
if (!ans)
{
flint_printf("test_canonicalize: failed\n");
flint_printf(" Expected \"%s\", got \"%s\"\n", str, strout);
abort();
}
flint_free(strout);
fmpz_poly_q_clear(qpoly1);
/* Initialization, memory management and basic operations ****************/
test_set("0", "0");
test_set("0/1 1", "0");
test_set("3 -1 0 1/2 0 1", "3 -1 0 1/2 0 1");
test_set("3 -1 0 1/2 1 1", "2 -1 1");
test_set_si(-1, "1 -1");
test_set_si(13, "1 13");
test_set_si(0, "0");
test_swap("3 -1 0 1/2 0 1", "1 2/1 3", "1 2/1 3", "3 -1 0 1/2 0 1");
test_zero("0", "0");
test_zero("0/1 1", "0");
test_zero("3 -1 0 1/2 0 1", "0");
test_neg("0", "0");
test_neg("1 1/1 2", "1 -1/1 2");
test_neg("3 -1 0 1/2 0 1", "3 1 0 -1/2 0 1");
test_inv("1 1/1 2", "1 2");
test_inv("3 -1 0 1/2 0 1", "2 0 1/3 -1 0 1");
test_inv("3 -1 0 -1/2 0 1", "2 0 -1/3 1 0 1");
test_inv_inplace("1 1/1 2", "1 2");
test_inv_inplace("3 -1 0 1/2 0 1", "2 0 1/3 -1 0 1");
test_inv_inplace("3 -1 0 -1/2 0 1", "2 0 -1/3 1 0 1");
test_is_zero("0", 1);
test_is_zero("0/1 1", 1);
test_is_zero("3 -1 0 1/2 0 1", 0);
test_is_zero("3 -1 0 1/2 1 1", 0);
test_is_one("0", 0);
test_is_one("0/1 1", 0);
test_is_one("1 1/1 1", 1);
test_is_one("2 1 1/2 1 1", 1);
test_is_one("3 -1 0 1/2 0 1", 0);
test_equal("1 1/1 2", "1 1/1 2", 1);
test_equal("1 1/1 2", "1 1/1 2", 1);
test_equal("3 -1 0 1/2 1 1", "2 -1 1", 1);
test_equal("3 -1 0 1/2 -1 1", "2 -1 1", 0);
/* Addition and subtraction **********************************************/
test_add("3 1 0 1/2 0 1", "2 0 -1/3 1 0 1", "5 1 0 1 0 1/4 0 1 0 1");
test_add("3 -1 0 1/2 1 1", "1 2/2 -1 1", "3 3 -2 1/2 -1 1");
test_add("0/2 1 1", "1 2/1 1", "1 2");
test_add("1 -3/1 4", "0/3 1 0 1", "1 -3/1 4");
test_add("2 1 1/1 1", "2 -1 1/1 1", "2 0 2");
test_add("2 1 1/2 0 1", "2 2 1/2 -1 1", "3 -1 2 2/3 0 -1 1");
test_add("2 -1 1/2 2 1", "3 4 4 1/2 1 1", "4 7 12 7 1/3 2 3 1");
test_add("2 1 1/2 -1 1", "2 1 1", "3 0 1 1/2 -1 1");
test_add("1 1/2 1 1", "2 0 1/2 1 1", "1 1");
test_add("2 1 1/3 4 -4 1", "1 1/2 -2 1", "2 -1 2/3 4 -4 1");
test_add("3 0 1 1/3 1 2 1", "2 0 -1/2 1 1", "0");
test_add("2 1 1/2 0 1", "2 -1 1/2 0 1", "1 2");
test_add("1 1/3 3 5 2", "1 1/3 6 7 2", "1 1/3 2 3 1");
test_add_in_place1("3 1 0 1/2 0 1", "2 0 -1/3 1 0 1", "5 1 0 1 0 1/4 0 1 0 1");
test_add_in_place1("3 -1 0 1/2 1 1", "1 2/2 -1 1", "3 3 -2 1/2 -1 1");
test_add_in_place1("0/2 1 1", "1 2/1 1", "1 2");
test_add_in_place1("1 -3/1 4", "0/3 1 0 1", "1 -3/1 4");
test_add_in_place1("2 1 1/1 1", "2 -1 1/1 1", "2 0 2");
test_add_in_place1("2 1 1/2 0 1", "2 2 1/2 -1 1", "3 -1 2 2/3 0 -1 1");
test_add_in_place1("2 -1 1/2 2 1", "3 4 4 1/2 1 1", "4 7 12 7 1/3 2 3 1");
test_add_in_place1("2 1 1/2 -1 1", "2 1 1", "3 0 1 1/2 -1 1");
test_add_in_place1("1 1/2 1 1", "2 0 1/2 1 1", "1 1");
test_add_in_place1("2 1 1/3 4 -4 1", "1 1/2 -2 1", "2 -1 2/3 4 -4 1");
test_add_in_place1("3 0 1 1/3 1 2 1", "2 0 -1/2 1 1", "0");
test_add_in_place1("2 1 1/2 0 1", "2 -1 1/2 0 1", "1 2");
test_add_in_place2("3 1 0 1/2 0 1", "2 0 -1/3 1 0 1", "5 1 0 1 0 1/4 0 1 0 1");
test_add_in_place2("3 -1 0 1/2 1 1", "1 2/2 -1 1", "3 3 -2 1/2 -1 1");
test_add_in_place2("0/2 1 1", "1 2/1 1", "1 2");
test_add_in_place2("1 -3/1 4", "0/3 1 0 1", "1 -3/1 4");
test_add_in_place2("2 1 1/1 1", "2 -1 1/1 1", "2 0 2");
test_add_in_place2("2 1 1/2 0 1", "2 2 1/2 -1 1", "3 -1 2 2/3 0 -1 1");
test_add_in_place2("2 -1 1/2 2 1", "3 4 4 1/2 1 1", "4 7 12 7 1/3 2 3 1");
test_add_in_place2("2 1 1/2 -1 1", "2 1 1", "3 0 1 1/2 -1 1");
test_add_in_place2("1 1/2 1 1", "2 0 1/2 1 1", "1 1");
test_add_in_place2("2 1 1/3 4 -4 1", "1 1/2 -2 1", "2 -1 2/3 4 -4 1");
test_add_in_place2("3 0 1 1/3 1 2 1", "2 0 -1/2 1 1", "0");
test_add_in_place2("2 1 1/2 0 1", "2 -1 1/2 0 1", "1 2");
test_add_in_place3("2 1 1", "2 2 2");
test_add_in_place3("2 1 1/1 2", "2 1 1");
test_sub("3 1 0 1/2 0 1", "2 0 -1/3 1 0 1", "5 1 0 3 0 1/4 0 1 0 1");
test_sub("3 -1 0 1/2 1 1", "1 2/2 -1 1", "3 -1 -2 1/2 -1 1");
test_sub("0/2 1 1", "1 2/1 1", "1 -2");
test_sub("1 -3/1 4", "0/3 1 0 1", "1 -3/1 4");
test_sub("2 1 1/1 1", "2 -1 1/1 1", "1 2");
test_sub("2 1 1/2 0 1", "2 2 1/2 -1 1", "2 -1 -2/3 0 -1 1");
test_sub("2 -1 1/2 2 1", "3 4 4 1/2 1 1", "4 -9 -12 -5 -1/3 2 3 1");
test_sub("2 -1 1/2 0 1", "1 1", "1 -1/2 0 1");
test_sub("3 1 0 1/2 0 1", "2 0 -1/3 1 0 1", "5 1 0 3 0 1/4 0 1 0 1");
test_sub("3 -1 0 1/2 1 1", "1 2/2 -1 1", "3 -1 -2 1/2 -1 1");
test_sub("0/2 1 1", "1 2/1 1", "1 -2");
test_sub("1 -3/1 4", "0/3 1 0 1", "1 -3/1 4");
test_sub("2 1 1/1 1", "2 -1 1/1 1", "1 2");
test_sub("2 1 1/2 0 1", "2 2 1/2 -1 1", "2 -1 -2/3 0 -1 1");
test_sub("2 -1 1/2 2 1", "3 4 4 1/2 1 1", "4 -9 -12 -5 -1/3 2 3 1");
test_sub("2 1 1/2 -1 1", "2 1 1", "3 2 1 -1/2 -1 1");
test_sub("1 1/2 1 1", "2 0 1/2 1 1", "2 1 -1/2 1 1");
test_sub("2 1 1/3 4 -4 1", "1 1/2 -2 1", "1 3/3 4 -4 1");
test_sub("3 0 1 1/3 1 2 1", "2 0 -1/2 1 1", "2 0 2/2 1 1");
test_sub("2 1 1/2 0 1", "2 -1 1/2 0 1", "1 2/2 0 1");
test_sub("1 1/3 3 5 2", "1 1/3 6 7 2", "1 1/4 6 13 9 2");
test_sub("2 1 1/2 0 2", "2 1 1/2 0 2", "0");
test_sub("2 -1 2/2 0 1", "2 -1 1/2 0 1", "1 1");
test_sub_in_place1("3 1 0 1/2 0 1", "2 0 -1/3 1 0 1", "5 1 0 3 0 1/4 0 1 0 1");
test_sub_in_place1("3 -1 0 1/2 1 1", "1 2/2 -1 1", "3 -1 -2 1/2 -1 1");
test_sub_in_place1("0/2 1 1", "1 2/1 1", "1 -2");
test_sub_in_place1("1 -3/1 4", "0/3 1 0 1", "1 -3/1 4");
test_sub_in_place1("2 1 1/1 1", "2 -1 1/1 1", "1 2");
test_sub_in_place1("2 1 1/2 0 1", "2 2 1/2 -1 1", "2 -1 -2/3 0 -1 1");
test_sub_in_place1("2 -1 1/2 2 1", "3 4 4 1/2 1 1", "4 -9 -12 -5 -1/3 2 3 1");
test_sub_in_place2("3 1 0 1/2 0 1", "2 0 -1/3 1 0 1", "5 1 0 3 0 1/4 0 1 0 1");
test_sub_in_place2("3 -1 0 1/2 1 1", "1 2/2 -1 1", "3 -1 -2 1/2 -1 1");
test_sub_in_place2("0/2 1 1", "1 2/1 1", "1 -2");
test_sub_in_place2("1 -3/1 4", "0/3 1 0 1", "1 -3/1 4");
test_sub_in_place2("2 1 1/1 1", "2 -1 1/1 1", "1 2");
test_sub_in_place2("2 1 1/2 0 1", "2 2 1/2 -1 1", "2 -1 -2/3 0 -1 1");
test_sub_in_place2("2 -1 1/2 2 1", "3 4 4 1/2 1 1", "4 -9 -12 -5 -1/3 2 3 1");
test_sub_in_place3("2 -1 1/2 2 1", "0");
test_addmul("1 1/2 0 2", "2 3 1/1 4", "3 1 0 1/4 -2 0 0 1", "5 -4 3 1 5 1/5 0 -8 0 0 4");
test_submul("1 1/2 0 2", "2 3 1/1 4", "3 1 0 1/4 -2 0 0 1", "5 -4 -3 -1 -1 -1/5 0 -8 0 0 4");
/* Scalar multiplication and devision ************************************/
flint_mpz_init_set_si(mpzzero, 0);
flint_mpz_init_set_si(mpzone, 1);
flint_mpz_init_set_si(mpztwo, 2);
mpq_init(mpqzero); flint_mpq_set_si(mpqzero, 0, 1);
mpq_init(mpqone); flint_mpq_set_si(mpqone, 1, 1);
mpq_init(mpqtwo); flint_mpq_set_si(mpqtwo, 2, 1);
mpq_init(mpqtwoinv); flint_mpq_set_si(mpqtwoinv, 1, 2);
test_scalar_mul_si("0", 1, "0");
test_scalar_mul_si("0", 0, "0");
test_scalar_mul_si("1 2", 0, "0");
test_scalar_mul_si("1 1/1 2", -2, "1 -1");
test_scalar_mul_si("2 1 1/2 -2 3", 5, "2 5 5/2 -2 3");
test_scalar_mul_si("2 1 1/2 -2 2", 3, "2 3 3/2 -2 2");
test_scalar_mul_mpz("0", mpzone, "0");
test_scalar_mul_mpz("0", mpzzero, "0");
test_scalar_mul_mpz("1 2", mpzzero, "0");
test_scalar_mul_mpz("1 1/1 2", mpztwo, "1 1");
test_scalar_mul_mpq("0", mpqone, "0");
test_scalar_mul_mpq("0", mpqzero, "0");
test_scalar_mul_mpq("1 2", mpqzero, "0");
test_scalar_mul_mpq("1 1/1 2", mpqtwo, "1 1");
test_scalar_mul_mpq("1 -2/1 1", mpqtwoinv, "1 -1");
test_scalar_div_si("0", 1, "0");
test_scalar_div_si("1 2", 2, "1 1");
test_scalar_div_si("1 1/1 2", -2, "1 -1/1 4");
test_scalar_div_si("3 -5 0 3/2 1 1", 2, "3 -5 0 3/2 2 2");
test_scalar_div_si("3 2 8 4/2 0 1", 3, "3 2 8 4/2 0 3");
test_scalar_div_si("3 2 8 4/2 0 1", -3, "3 -2 -8 -4/2 0 3");
test_scalar_div_si("3 -27 0 9/2 0 1", -3, "3 9 0 -3/2 0 1");
test_scalar_div_mpz("0", mpzone, "0");
test_scalar_div_mpz("1 2", mpztwo, "1 1");
test_scalar_div_mpz("1 1/1 2", mpztwo, "1 1/1 4");
test_scalar_div_mpq("0", mpqone, "0");
test_scalar_div_mpq("1 2", mpqone, "1 2");
test_scalar_div_mpq("1 1/1 2", mpqtwo, "1 1/1 4");
test_scalar_div_mpq("1 -2/1 1", mpqtwoinv, "1 -4");
mpz_clear(mpzzero);
mpz_clear(mpzone);
mpz_clear(mpztwo);
mpq_clear(mpqzero);
mpq_clear(mpqone);
mpq_clear(mpqtwo);
mpq_clear(mpqtwoinv);
/* Multiplication, division and powing *********************************/
test_mul("3 1 0 1/2 0 1", "2 0 -1/3 1 0 1", "1 -1");
test_mul("3 -1 0 1/2 1 1", "1 2/2 -1 1", "1 2");
test_mul("0/2 1 1", "1 2/1 1", "0");
test_mul("1 -3/1 4", "0/3 1 0 1", "0");
test_mul("2 1 1/1 1", "2 -1 1/1 1", "3 -1 0 1");
test_mul("2 1 1/2 0 1", "2 2 1/2 -1 1", "3 2 3 1/3 0 -1 1");
test_mul("2 -1 1/2 2 1", "3 4 4 1/2 1 1", "3 -2 1 1/2 1 1");
test_mul_in_place1("3 1 0 1/2 0 1", "2 0 -1/3 1 0 1", "1 -1");
test_mul_in_place1("3 -1 0 1/2 1 1", "1 2/2 -1 1", "1 2");
test_mul_in_place1("0/2 1 1", "1 2/1 1", "0");
test_mul_in_place1("1 -3/1 4", "0/3 1 0 1", "0");
test_mul_in_place1("2 1 1/1 1", "2 -1 1/1 1", "3 -1 0 1");
test_mul_in_place1("2 1 1/2 0 1", "2 2 1/2 -1 1", "3 2 3 1/3 0 -1 1");
test_mul_in_place1("2 -1 1/2 2 1", "3 4 4 1/2 1 1", "3 -2 1 1/2 1 1");
test_mul_in_place2("3 1 0 1/2 0 1", "2 0 -1/3 1 0 1", "1 -1");
test_mul_in_place2("3 -1 0 1/2 1 1", "1 2/2 -1 1", "1 2");
test_mul_in_place2("0/2 1 1", "1 2/1 1", "0");
test_mul_in_place2("1 -3/1 4", "0/3 1 0 1", "0");
test_mul_in_place2("2 1 1/1 1", "2 -1 1/1 1", "3 -1 0 1");
test_mul_in_place2("2 1 1/2 0 1", "2 2 1/2 -1 1", "3 2 3 1/3 0 -1 1");
test_mul_in_place2("2 -1 1/2 2 1", "3 4 4 1/2 1 1", "3 -2 1 1/2 1 1");
test_mul_in_place3("2 0 1/2 1 1", "3 0 0 1/3 1 2 1");
test_div("3 -1 0 1/1 2", "2 1 1/1 1", "2 -1 1/1 2");
test_div("0/2 1 1", "2 1 1/1 1", "0");
test_div("3 -1 0 1/1 4", "2 -1 -1/1 2", "2 1 -1/1 2");
test_div("2 1 1", "2 1 -1/2 1 -1", "2 1 1");
test_div("2 1 1/3 4 4 1", "2 -1 1/3 6 5 1", "3 3 4 1/3 -2 1 1");
test_div_in_place1("3 -1 0 1/1 2", "2 1 1/1 1", "2 -1 1/1 2");
test_div_in_place1("0/2 1 1", "2 1 1/1 1", "0");
test_div_in_place1("3 -1 0 1/1 4", "2 -1 -1/1 2", "2 1 -1/1 2");
test_div_in_place1("2 1 1", "2 1 -1/2 1 -1", "2 1 1");
test_div_in_place1("2 1 1/3 4 4 1", "2 -1 1/3 6 5 1", "3 3 4 1/3 -2 1 1");
test_div_in_place1("0", "1 2/2 3 5", "0");
test_div_in_place2("3 -1 0 1/1 2", "2 1 1/1 1", "2 -1 1/1 2");
test_div_in_place2("0/2 1 1", "2 1 1/1 1", "0");
test_div_in_place2("3 -1 0 1/1 4", "2 -1 -1/1 2", "2 1 -1/1 2");
test_div_in_place2("2 1 1", "2 1 -1/2 1 -1", "2 1 1");
test_div_in_place2("2 1 1/3 4 4 1", "2 -1 1/3 6 5 1", "3 3 4 1/3 -2 1 1");
test_div_in_place3("3 -1 0 1/1 2", "1 1");
test_pow("2 0 -1/1 2", 3, "4 0 0 0 -1/1 8");
test_pow("0", 0, "1 1");
test_pow("2 1 -1", 0, "1 1");
test_pow("2 1 1/2 0 1", 0, "1 1");
/* Derivative ************************************************************/
test_derivative("0", "0");
test_derivative("1 2", "0");
test_derivative("1 -1/1 2", "0");
test_derivative("2 0 1", "1 1");
test_derivative("3 1 0 1", "2 0 2");
test_derivative("1 1/2 0 1", "1 -1/3 0 0 1");
test_derivative("2 2 1/2 -1 1", "1 -3/3 1 -2 1");
test_derivative("2 0 1/3 1 2 1", "2 1 -1/4 1 3 3 1");
/* Bug which allowed constant factors */
test_derivative("3 5 1 -2/2 10 2", "3 0 -10 -1/3 25 10 1");
/* Evaluation ************************************************************/
test_evaluate("1 1/1 2", -2, 3, "1/2");
test_evaluate("3 1 0 1/2 0 1", -1, 2, "-5/2");
test_evaluate("2 3 1/2 -1 1", 1, 1, "P");
test_evaluate("2 3 1/2 -1 1", 2, 3, "-11");
test_evaluate("2 3 1/2 -1 2", 1, 2, "P");
test_evaluate("2 1 1/2 -1 1", 2, 1, "3");
/* String methods ********************************************************/
fmpz_poly_q_init(qpoly1);
ans = fmpz_poly_q_set_str(qpoly1, "1 3/xyz");
if ((ans == 0) || !fmpz_poly_q_is_zero(qpoly1))
{
flint_printf("test_set_str: failed\n");
abort();
}
fmpz_poly_q_clear(qpoly1);
fmpz_poly_q_init(qpoly1);
ans = fmpz_poly_q_set_str(qpoly1, "abc/1 3");
if ((ans == 0) || !fmpz_poly_q_is_zero(qpoly1))
{
flint_printf("test_set_str: failed\n");
abort();
}
fmpz_poly_q_clear(qpoly1);
fmpz_poly_q_init(qpoly1);
ans = fmpz_poly_q_set_str(qpoly1, "abc/xyz");
if ((ans == 0) || !fmpz_poly_q_is_zero(qpoly1))
{
flint_printf("test_set_str: failed\n");
abort();
}
fmpz_poly_q_clear(qpoly1);
test_get_str_pretty("1 -3", "-3");
test_get_str_pretty("3 1 2 1", "t^2+2*t+1");
test_get_str_pretty("1 -2/2 1 1", "-2/(t+1)");
test_get_str_pretty("2 1 1/2 -1 1", "(t+1)/(t-1)");
test_get_str_pretty("2 1 1/1 2", "(t+1)/2");
test_get_str_pretty("1 1/1 2", "1/2");
FLINT_TEST_CLEANUP(state);
flint_printf("PASS\n");
return EXIT_SUCCESS;
}
int run_sampler(unsigned epochs,float alpha,unsigned batch_size){
//load sampler
string training_path = "PPAttachData/training.lemma";
string param_path = "PPAttachData/wordsketches/";
string vpath = param_path + string("vdistrib");
string x1vpath = param_path + string("x1givenv");
string pvpath = param_path + string("pgivenv");
string x2vppath = param_path + string("x2givenvp");
string px1path = param_path + string("pgivenx1");
string x2x1ppath = param_path + string("x2givenx1p");
DataSampler samp(training_path.c_str(),
vpath.c_str(),
x1vpath.c_str(),
pvpath.c_str(),
x2vppath.c_str(),
px1path.c_str(),
x2x1ppath.c_str());
//load dev and test
PPADataEncoder dev_set("PPAttachData/devset.lemma");
PPADataEncoder test_set("PPAttachData/test.lemma");
//load Word vectors
Word2vec w2v;
vector<string> wvdict;
af::array w2v_embeddings;
w2v.load_dictionary("PPAttachData/embeddings/deps.words.lemmatized");
//w2v.filter(xdict);
//make network
vector<string> ydict;
samp.getYdictionary(ydict);
SymbolicFeedForwardNetwork<string,string> net;
net.set_output_layer("loss",new SoftMaxLoss<string>(ydict));
net.add_layer("top",new LinearLayer());
net.add_layer("hidden",new ReLUActivation(400));
net.add_layer("A",new LinearLayer());
net.add_input_layer("lookupA",new LinearLookup<string>(w2v.get_keys(),w2v.get_values(),4,false));
net.connect_layers("loss","top");
net.connect_layers("top","hidden");
net.connect_layers("hidden","A");
net.connect_layers("A","lookupA");
for(int E = 0; E < epochs;++E){
vector<string> ydata;
vector<vector<string>> xdata;
//af::timer start1 = af::timer::start();
samp.generate_sample(ydata,xdata,batch_size);
//printf("elapsed seconds (sampling): %g\n", af::timer::stop(start1));
PPADataEncoder sampdata(ydata,xdata);
vector<string> enc_ydata;
vector<vector<string>> enc_xdata(1,vector<string>());
sampdata.getYdata(enc_ydata);
sampdata.getXdata(enc_xdata[0]);
//af::timer start2 = af::timer::start();
net.set_batch_data(enc_ydata,enc_xdata);
float loss = net.train_one(alpha,true,true);
//printf("elapsed seconds (backprop): %g\n", af::timer::stop(start2));
if (E % 20 == 0){
vector<string> devy;
vector<vector<string>> devx(1,vector<string>());
dev_set.getYdata(devy);
dev_set.getXdata(devx[0]);
float acc = net.eval_avg(devy,devx); //auto-eval on dev data
cout << "epoch " << E << ", loss= " << loss << ", eval (dev) = " << acc << endl;
}else {
cout << "epoch" << E <<endl;
}
}
vector<string> testy;
vector<vector<string>> testx(1,vector<string>());
test_set.getYdata(testy);
test_set.getXdata(testx[0]);
float acc = net.eval_avg(testy,testx);
cout << "final eval (test) = " << acc << endl;
return 0;
}
int main(int argc, char **argv)
{
struct bitvec bv;
uint8_t i = 8, test[i];
memset(test, 0, i);
bv.data_len = i;
bv.data = test;
bv.cur_bit = 0;
printf("test shifting...\n");
bitvec_set_uint(&bv, 0x0E, 7);
test_shift(&bv, 3);
test_shift(&bv, 17);
bitvec_set_uint(&bv, 0, 32);
bitvec_set_uint(&bv, 0x0A, 7);
test_shift(&bv, 24);
printf("checking RL functions...\n");
bitvec_zero(&bv);
test_rl(&bv);
bitvec_set_uint(&bv, 0x000F, 32);
test_rl(&bv);
bitvec_shiftl(&bv, 18);
test_rl(&bv);
bitvec_set_uint(&bv, 0x0F, 8);
test_rl(&bv);
bitvec_zero(&bv);
bitvec_set_uint(&bv, 0xFF, 8);
test_rl(&bv);
bitvec_set_uint(&bv, 0xFE, 7);
test_rl(&bv);
bitvec_set_uint(&bv, 0, 17);
test_rl(&bv);
bitvec_shiftl(&bv, 18);
test_rl(&bv);
printf("probing bit access...\n");
bitvec_zero(&bv);
bitvec_set_uint(&bv, 0x3747817, 32);
bitvec_shiftl(&bv, 10);
test_get(&bv, 2);
test_get(&bv, 7);
test_get(&bv, 9);
test_get(&bv, 13);
test_get(&bv, 16);
test_get(&bv, 42);
printf("feeling bit fills...\n");
test_set(&bv, ONE);
test_fill(&bv, 3, ZERO);
test_spare(&bv, 38);
test_spare(&bv, 43);
test_spare(&bv, 1);
test_spare(&bv, 7);
test_fill(&bv, 5, ONE);
test_fill(&bv, 3, L);
printf("byte me...\n");
test_byte_ops();
test_unhex("48282407a6a074227201000b2b2b2b2b2b2b2b2b2b2b2b");
test_unhex("47240c00400000000000000079eb2ac9402b2b2b2b2b2b");
test_unhex("47283c367513ba333004242b2b2b2b2b2b2b2b2b2b2b2b");
test_unhex("DEADFACE000000000000000000000000000000BEEFFEED");
test_unhex("FFFFFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB");
printf("arrr...\n");
test_array();
printf("\nbitvec ok.\n");
return 0;
}
void VectorTest::run_test_case(void)
{
message += "Running vector test case...\n";
// Constructor and destructor methods
test_constructor();
test_destructor();
// Arithmetic operators
test_sum_operator();
test_rest_operator();
test_multiplication_operator();
test_division_operator();
// Operation and assignment operators
test_sum_assignment_operator();
test_rest_assignment_operator();
test_multiplication_assignment_operator();
test_division_assignment_operator();
// Equality and relational operators
test_equal_to_operator();
test_not_equal_to_operator();
test_greater_than_operator();
test_greater_than_or_equal_to_operator();
test_less_than_operator();
test_less_than_or_equal_to_operator();
// Output operator
test_output_operator();
// Get methods
test_get_display();
// Set methods
test_set();
test_set_display();
// Resize methods
test_resize();
test_tuck_in();
test_take_out();
test_remove_element();
test_get_assembly();
// Initialization methods
test_initialize();
test_initialize_sequential();
test_randomize_uniform();
test_randomize_normal();
// Checking methods
test_contains();
test_is_in();
test_is_constant();
test_is_crescent();
test_is_decrescent();
// Mathematical methods
test_dot_vector();
test_dot_matrix();
test_calculate_sum();
test_calculate_partial_sum();
test_calculate_product();
test_calculate_mean();
test_calculate_standard_deviation();
test_calculate_covariance();
test_calculate_mean_standard_deviation();
test_calculate_minimum();
test_calculate_maximum();
test_calculate_minimum_maximum();
test_calculate_minimum_missing_values();
test_calculate_maximum_missing_values();
test_calculate_minimum_maximum_missing_values();
test_calculate_explained_variance();
test_calculate_histogram();
test_calculate_bin();
test_calculate_frequency();
test_calculate_total_frequencies();
test_calculate_minimal_index();
test_calculate_maximal_index();
test_calculate_minimal_indices();
test_calculate_maximal_indices();
test_calculate_minimal_maximal_index();
test_calculate_cumulative_index();
test_calculate_closest_index();
test_calculate_norm();
test_calculate_normalized();
test_calculate_sum_squared_error();
test_calculate_mean_squared_error();
test_calculate_root_mean_squared_error();
test_apply_absolute_value();
test_calculate_lower_bounded();
test_calculate_upper_bounded();
test_calculate_lower_upper_bounded();
test_apply_lower_bound();
test_apply_upper_bound();
test_apply_lower_upper_bounds();
test_calculate_less_rank();
test_calculate_greater_rank();
test_calculate_linear_correlation();
test_calculate_linear_correlation_missing_values();
test_calculate_linear_regression_parameters();
// Scaling and unscaling
test_scale_minimum_maximum();
test_scale_mean_standard_deviation();
// Parsing methods
test_parse();
// Serialization methods
test_save();
test_load();
message += "End vector test case\n";
}
void MatrixTest::run_test_case(void)
{
message += "Running matrix test case...\n";
// Constructor and destructor methods
test_constructor();
test_destructor();
// Assignment operators methods
test_assignment_operator();
// Reference operator methods
test_reference_operator();
// Arithmetic operators
test_sum_operator();
test_rest_operator();
test_multiplication_operator();
test_division_operator();
// Arithmetic and assignment operators
test_sum_assignment_operator();
test_rest_assignment_operator();
test_multiplication_assignment_operator();
test_division_assignment_operator();
// Equality and relational operators
test_equal_to_operator();
test_not_equal_to_operator();
test_greater_than_operator();
test_less_than_operator();
test_greater_than_or_equal_to_operator();
test_less_than_or_equal_to_operator();
// Output operators
test_output_operator();
// Get methods
test_get_rows_number();
test_get_columns_number();
test_arrange_row();
test_arrange_column();
test_arrange_submatrix();
// Set methods
test_set();
test_set_rows_number();
test_set_columns_number();
test_set_row();
test_set_column();
// Diagonal methods
test_get_diagonal();
test_set_diagonal();
test_sum_diagonal();
// Resize methods
test_append_row();
test_append_column();
test_insert_row();
test_insert_column();
test_subtract_row();
test_subtract_column();
test_sort_less_rows();
test_sort_greater_rows();
// Initialization methods
test_initialize();
test_randomize_uniform();
test_randomize_normal();
test_set_to_identity();
// Mathematical methods
test_calculate_sum();
test_calculate_rows_sum();
test_dot_vector();
test_dot_matrix();
test_calculate_eigenvalues();
test_calculate_eigenvectors();
test_direct();
test_calculate_minimum_maximum();
test_calculate_mean_standard_deviation();
test_calculate_statistics();
test_calculate_histogram();
test_calculate_covariance_matrix();
test_calculate_minimal_indices();
test_calculate_maximal_indices();
test_calculate_minimal_maximal_indices();
test_calculate_sum_squared_error();
test_calculate_mean_squared_error();
test_calculate_root_mean_squared_error();
test_calculate_determinant();
test_calculate_transpose();
test_calculate_cofactor();
test_calculate_inverse();
test_is_symmetric();
test_is_antisymmetric();
// Scaling methods
test_scale_mean_standard_deviation();
test_scale_rows_mean_standard_deviation();
test_scale_columns_mean_standard_deviation();
test_scale_rows_columns_mean_standard_deviation();
test_scale_minimum_maximum();
test_scale_rows_minimum_maximum();
test_scale_columns_minimum_maximum();
test_scale_rows_columns_minimum_maximum();
// Unscaling methods
test_unscale_mean_standard_deviation();
test_unscale_rows_mean_standard_deviation();
test_unscale_columns_mean_standard_deviation();
test_unscale_rows_columns_mean_standard_deviation();
test_unscale_minimum_maximum();
test_unscale_rows_minimum_maximum();
test_unscale_columns_minimum_maximum();
test_unscale_rows_columns_minimum_maximum();
test_convert_angular_variables_degrees();
test_convert_angular_variables_radians();
// Serialization methods
test_print();
test_load();
test_save();
test_parse();
message += "End of matrix test case.\n";
}
int test_main( int /* argc */, char* /* argv */[] ){
test_set();
test_multiset();
return EXIT_SUCCESS;
}
int main()
{
sio << "short: " << sizeof(short) << " long: " << sizeof(long)
<< " long long: " << sizeof(long long) << " int: " << sizeof(int)
<< " void*: " << sizeof(void*) << " float: " << sizeof(float)
<< " double: " << sizeof(double) << '\n';
sio << "integer: " << sizeof(integer) << " memint: " << sizeof(memint)
<< " real: " << sizeof(real) << " variant: " << sizeof(variant)
<< " object: " << sizeof(object) << " rtobject: " << sizeof(rtobject) << '\n';
sio << "stateobj: " << sizeof(stateobj) << " Type: " << sizeof(Type)
<< " State: " << sizeof(State) << " opcodes: " << opMaxCode << '\n';
check(sizeof(memint) == sizeof(void*));
check(sizeof(memint) == sizeof(size_t));
#ifdef SHN_64
check(sizeof(integer) == 8);
check(sizeof(variant) <= 16);
#else
check(sizeof(integer) == 4);
check(sizeof(variant) <= 12);
#endif
initRuntime();
initTypeSys();
initVm();
int exitcode = 0;
try
{
test_common();
test_object();
test_ordset();
test_bytevec();
test_string();
test_strutils();
test_podvec();
test_vector();
test_dict();
test_set();
test_symtbl();
test_variant();
test_fifos();
test_parser();
// test_typesys();
// test_codegen();
}
catch (exception& e)
{
fprintf(stderr, "Exception: %s\n", e.what());
exitcode = 201;
}
doneVm();
doneTypeSys();
doneRuntime();
if (object::allocated != 0)
{
fprintf(stderr, "Error: object::allocated = %d\n", object::allocated);
exitcode = 202;
}
return exitcode;
}
virtual void* run()
{
bool ret;
acl::redis cmd;
cmd.set_cluster(&cluster_, max_conns_);
for (int i = 0; i < n_; i++)
{
if (cmd_ == "set")
ret = test_set(cmd, i);
else if (cmd_ == "get")
ret = test_get(cmd, i);
else if (cmd_ == "del")
ret = test_del(cmd, i);
else if (cmd_ == "expire")
ret = test_expire(cmd, i);
else if (cmd_ == "ttl")
ret = test_ttl(cmd, i);
else if (cmd_ == "exists")
ret = test_exists(cmd, i);
else if (cmd_ == "type")
ret = test_type(cmd, i);
else if (cmd_ == "all")
{
if (test_set(cmd, i) == false
|| test_get(cmd, i) == false
|| test_exists(cmd, i) == false
|| test_type(cmd, i) == false
|| test_expire(cmd, i) == false
|| test_ttl(cmd, i) == false
|| test_del(cmd, i) == false)
{
ret = false;
}
else
ret = true;
}
else
{
printf("unknown cmd: %s\r\n", cmd_.c_str());
break;
}
if (ret == false)
{
printf("cmd: %s error, tid: %lu\r\n",
cmd_.c_str(), thread_self());
break;
}
if (i > 0 && i % 1000 == 0)
{
char tmp[128];
acl::safe_snprintf(tmp, sizeof(tmp), "%d", i);
acl::meter_time(__FILE__, __LINE__, tmp);
}
}
locker_.lock();
__threads_exit++;
locker_.unlock();
return NULL;
}
int _STLP_CALL main(int argc, char** argv)
{
#if defined(_WIN32_WCE) || defined(__SYMBIAN32__)
std::ofstream file( "c:\\eh_test.txt" );
std::streambuf* old_cout_buf = cout.rdbuf(file.rdbuf());
std::streambuf* old_cerr_buf = cerr.rdbuf(file.rdbuf());
#endif
#if defined( __MWERKS__ ) && defined( macintosh ) // Get command line.
argc = ccommand(&argv);
// Allow the i/o window to be repositioned.
// EH_STD::string s;
// getline(EH_STD::cin, s);
#endif
unsigned int niters=2;
bool run_all=true;
bool run_slist = false;
bool run_list = false;
bool run_vector = false;
bool run_bit_vector = false;
bool run_deque = false;
bool run_hash_map = false;
bool run_hash_set = false;
bool run_set = false;
bool run_map = false;
bool run_algo = false;
bool run_algobase = false;
bool run_rope = false;
bool run_string = false;
bool run_bitset = false;
bool run_valarray = false;
int cur_argv;
char *p, *p1;
#if defined (EH_NEW_IOSTREAMS)
std::ios_base::sync_with_stdio(false);
#endif
cerr << argv[0]<<" : Exception handling testsuite.\n";
cerr.flush();
bool track_allocations = false;
// parse parameters :
// leak_test [-iterations] [-test] ...
for (cur_argv=1; cur_argv<argc; cur_argv++) {
p = argv[cur_argv];
if (*p == '-') {
switch (p[1]) {
case 'q':
gTestController.SetVerbose(false);
break;
case 'v':
gTestController.SetVerbose(true);
break;
#if 0 // This option was never actually used -- dwa 9/22/97
case 'i':
gTestController.IgnoreLeaks(true);
break;
#endif
case 'n':
p1 = argv[++cur_argv];
if (p1 && EH_CSTD::sscanf(p1, "%i", &niters)==1)
cerr <<" Doing "<<niters<<" iterations\n";
else
usage(argv[0]);
break;
case 't':
track_allocations = true;
break;
case 'e':
gTestController.TurnOffExceptions();
break;
case 's':
p1 = argv[++cur_argv];
if (p1 && EH_CSTD::sscanf(p1, "%i", &random_base)==1)
cerr <<" Setting "<<random_base<<" as base for random sizes.\n";
else
usage(argv[0]);
break;
default:
usage(argv[0]);
break;
}
} else {
run_all = false;
// test name
if (EH_CSTD::strcmp(p, "algo")==0) {
run_algo=true;
} else if (EH_CSTD::strcmp(p, "vector")==0) {
run_vector=true;
} else if (EH_CSTD::strcmp(p, "bit_vector")==0) {
run_bit_vector=true;
} else if (EH_CSTD::strcmp(p, "list")==0) {
run_list=true;
} else if (EH_CSTD::strcmp(p, "slist")==0) {
run_slist=true;
} else if (EH_CSTD::strcmp(p, "deque")==0) {
run_deque=true;
} else if (EH_CSTD::strcmp(p, "set")==0) {
run_set=true;
} else if (EH_CSTD::strcmp(p, "map")==0) {
run_map=true;
} else if (EH_CSTD::strcmp(p, "hash_set")==0) {
run_hash_set=true;
} else if (EH_CSTD::strcmp(p, "hash_map")==0) {
run_hash_map=true;
} else if (EH_CSTD::strcmp(p, "rope")==0) {
run_rope=true;
} else if (EH_CSTD::strcmp(p, "string")==0) {
run_string=true;
} else if (EH_CSTD::strcmp(p, "bitset")==0) {
run_bitset=true;
} else if (EH_CSTD::strcmp(p, "valarray")==0) {
run_valarray=true;
} else {
usage(argv[0]);
}
}
}
gTestController.TrackAllocations( track_allocations );
// Over and over...
for ( unsigned i = 0; i < niters ; i++ )
{
cerr << "iteration #" << i << "\n";
if (run_all || run_algobase) {
gTestController.SetCurrentContainer("algobase");
cerr << "EH test : algobase" << endl;
test_algobase();
}
if (run_all || run_algo) {
gTestController.SetCurrentContainer("algo");
cerr << "EH test : algo" << endl;
test_algo();
}
if (run_all || run_vector) {
gTestController.SetCurrentContainer("vector");
cerr << "EH test : vector" << endl;
test_vector();
}
#if defined( EH_BIT_VECTOR_IMPLEMENTED )
if (run_all || run_bit_vector) {
gTestController.SetCurrentContainer("bit_vector");
cerr << "EH test : bit_vector" << endl;
test_bit_vector();
}
#endif
if (run_all || run_list) {
gTestController.SetCurrentContainer("list");
cerr << "EH test : list" << endl;
test_list();
}
#if defined( EH_SLIST_IMPLEMENTED )
if (run_all || run_slist) {
gTestController.SetCurrentContainer("slist");
cerr << "EH test : slist" << endl;
test_slist();
}
#endif // EH_SLIST_IMPLEMENTED
if (run_all || run_deque) {
gTestController.SetCurrentContainer("deque");
cerr << "EH test : deque" << endl;
test_deque();
}
if (run_all || run_set) {
gTestController.SetCurrentContainer("set");
cerr << "EH test : set" << endl;
test_set();
gTestController.SetCurrentContainer("multiset");
cerr << "EH test : multiset" << endl;
test_multiset();
}
if (run_all || run_map) {
gTestController.SetCurrentContainer("map");
cerr << "EH test : map" << endl;
test_map();
gTestController.SetCurrentContainer("multimap");
cerr << "EH test : multimap" << endl;
test_multimap();
}
#if defined( EH_HASHED_CONTAINERS_IMPLEMENTED )
if (run_all || run_hash_map) {
gTestController.SetCurrentContainer("hash_map");
cerr << "EH test : hash_map" << endl;
test_hash_map();
gTestController.SetCurrentContainer("hash_multimap");
cerr << "EH test : hash_multimap" << endl;
test_hash_multimap();
}
if (run_all || run_hash_set) {
gTestController.SetCurrentContainer("hash_set");
cerr << "EH test : hash_set" << endl;
test_hash_set();
gTestController.SetCurrentContainer("hash_multiset");
cerr << "EH test : hash_multiset" << endl;
test_hash_multiset();
}
#endif // EH_HASHED_CONTAINERS_IMPLEMENTED
#if defined( EH_ROPE_IMPLEMENTED )
// CW1.8 can't compile this for some reason!
#if !( defined(__MWERKS__) && __MWERKS__ < 0x1900 )
if (run_all || run_rope) {
gTestController.SetCurrentContainer("rope");
cerr << "EH test : rope" << endl;
test_rope();
}
#endif
#endif // EH_ROPE_IMPLEMENTED
#if defined( EH_STRING_IMPLEMENTED )
if (run_all || run_string) {
gTestController.SetCurrentContainer("string");
cerr << "EH test : string" << endl;
test_string();
}
#endif
#if defined( EH_BITSET_IMPLEMENTED )
if (run_all || run_bitset) {
gTestController.SetCurrentContainer("bitset");
cerr << "EH test : bitset" << endl;
test_bitset();
}
#endif
#if defined( EH_VALARRAY_IMPLEMENTED )
if (run_all || run_bitset) {
gTestController.SetCurrentContainer("valarray");
cerr << "EH test : valarray" << endl;
test_valarray();
}
#endif
}
gTestController.TrackAllocations( false );
cerr << "EH test : Done\n";
#if defined(_WIN32_WCE) || defined(__SYMBIAN32__)
cout.rdbuf(old_cout_buf);
cerr.rdbuf(old_cerr_buf);
file.close();
#endif
return 0;
}
double test_set(DBN& dbn, const Samples& images, const Labels& labels, Functor&& f) {
return test_set(dbn, images.begin(), images.end(), labels.begin(), labels.end(), std::forward<Functor>(f));
}
int main(int argc, char* argv[])
{
int ch, n = 1, conn_timeout = 10, rw_timeout = 10, ttl = 10;
acl::string addr("127.0.0.1:6379"), cmd;
while ((ch = getopt(argc, argv, "hs:n:C:I:a:t:")) > 0)
{
switch (ch)
{
case 'h':
usage(argv[0]);
return 0;
case 's':
addr = optarg;
break;
case 'n':
n = atoi(optarg);
break;
case 'C':
conn_timeout = atoi(optarg);
break;
case 'I':
rw_timeout = atoi(optarg);
break;
case 'a':
cmd = optarg;
break;
case 't':
ttl = atoi(optarg);
break;
default:
break;
}
}
acl::acl_cpp_init();
acl::log::stdout_open(true);
acl::redis_client client(addr.c_str(), conn_timeout, rw_timeout);
acl::redis_string option(&client);
bool ret;
if (cmd == "set")
ret = test_set(option, n);
else if (cmd == "setex")
ret = test_setex(option, n, ttl);
else if (cmd == "setnx")
ret = test_setnx(option, n);
else if (cmd == "append")
ret = test_append(option, n);
else if (cmd == "get")
ret = test_get(option, n);
else if (cmd == "getset")
ret = test_getset(option, n);
else if (cmd == "strlen")
ret = test_strlen(option, n);
else if (cmd == "mset")
ret = test_mset(option, n);
else if (cmd == "mget")
ret = test_mget(option, n);
else if (cmd == "msetnx")
ret = test_msetnx(option, n);
else if (cmd == "setrange")
ret = test_setrange(option, n);
else if (cmd == "getrange")
ret = test_getrange(option, n);
else if (cmd == "setbit")
ret = test_setbit(option, n);
else if (cmd == "getbit")
ret = test_getbit(option, n);
else if (cmd == "bitcount")
ret = test_bitcount(option, n);
else if (cmd == "bitop_and")
ret = test_bitop_and(option, n);
else if (cmd == "bitop_or")
ret = test_bitop_or(option, n);
else if (cmd == "bitop_xor")
ret = test_bitop_xor(option, n);
else if (cmd == "incr")
ret = test_incr(option, n);
else if (cmd == "incrby")
ret = test_incrby(option, n);
else if (cmd == "incrbyfloat")
ret = test_incrbyfloat(option, n);
else if (cmd == "decr")
ret = test_decr(option, n);
else if (cmd == "decrby")
ret = test_decrby(option, n);
else if (cmd == "all")
{
ret = test_set(option, n)
&& test_setex(option, n, ttl)
&& test_setnx(option, n)
&& test_append(option, n)
&& test_get(option, n)
&& test_getset(option, n)
&& test_strlen(option, n)
&& test_mset(option, n)
&& test_mget(option, n)
&& test_msetnx(option, n)
&& test_setrange(option, n)
&& test_getrange(option, n)
&& test_setbit(option, n)
&& test_getbit(option, n)
&& test_bitcount(option, n)
&& test_bitop_and(option, n)
&& test_bitop_or(option, n)
&& test_bitop_xor(option, n)
&& test_incr(option, n)
&& test_incrby(option, n)
&& test_incrbyfloat(option, n)
&& test_decr(option, n)
&& test_decrby(option, n);
}
else
{
ret = false;
printf("unknown cmd: %s\r\n", cmd.c_str());
}
if (ret == true)
printf("test OK!\r\n");
else
printf("test failed!\r\n");
#ifdef WIN32
printf("enter any key to exit\r\n");
getchar();
#endif
return 0;
}
