#define PROG_NAME "TestWalks" #define PROG_DESC "Creates various 3D maps for testing" #define PROG_VERS "1.0" /* Last edited on 2015-10-18 03:00:42 by stolfilocal */ #define TestWalks_C_COPYRIGHT \ "Copyright © 2001 Universidade Estadual de Campinas (UNICAMP)" #define PROG_HELP \ " " PROG_NAME " \\\n" \ " -input {NAME}" #define PROG_INFO \ "NAME\n" \ " " PROG_NAME " - " PROG_DESC "\n" \ "\n" \ "SYNOPSIS\n" \ PROG_HELP "\n" \ "\n" \ "DESCRIPTION\n" \ " Reads a \".fe\" file and tests the validity of\n" \ " the various walking procedures\n"\ "\n" \ "OPTIONS\n" \ "\n" \ " -input {NAME}\n" \ " The name of the input file, sans the \".fe\" prefix.\n" \ "\n" \ "DOCUMENTATION OPTIONS\n" \ argparser_help_info_HELP_INFO "\n" \ "\n" \ "SEE ALSO\n" \ " ??? (1).\n" \ "\n" \ "AUTHOR\n" \ " J. Stolfi, UNICAMP.\n" \ "\n" \ "MODIFICATION HISTORY\n" \ " 2007-02-04 Created by J. Stolfi.\n" \ "\n" \ "WARRANTY\n" \ argparser_help_info_NO_WARRANTY "\n" \ "\n" \ "RIGHTS\n" \ " " TestWalks_C_COPYRIGHT ".\n" \ "\n" \ argparser_help_info_STANDARD_RIGHTS ".\n" \ "\n" \ "UNINCORPORATED DESCRIPTIONS\n" #include #include #include #include #include #include #include #define _GNU_SOURCE #include #include #include typedef struct Options_t { /* Parameters that define the topology: */ char *input; /* Input file name, sans ".fe" extension. */ } Options_t; typedef Place_t (*MultiStepFunc_t)(Place_t p, int n); int main(int argc, char **argv); Options_t *GetOptions(int argc, char **argv); void TestDual(Place_t p); /* Basic tests of the {Dual} operator on {p}. */ void TestSingleFlips(Place_t p); /* Basic tests of generic {Flip} and {Flip0,Flip1,Flip2,Flip3} on {p}. */ void TestDoubleFlips(Place_t p); /* Basic tests of generic {FlipIJ} and {Flip01,Flip02,... ,Flip23} on {p}. */ void TestDLOperators(Place_t p); /* Basic tests of the original D&L operators: {Spin,Clock,NextE,...}. */ void TestMultiStepFunc(Place_t p, MultiStepFunc_t jump, StepFunc_t step, int n); /* If {n>=0}, tests whether {p=jump(p,n)} is indeed equivalent to {p=step(q)} repeated {n} times. If {n<=0} tests whether the effect of {p=jump(p,n)} gets undone by {p=step(p)} repeated {-n} times. */ #define stringify(x) strngf(x) #define strngf(x) #x #define Check(P) affirm((P),stringify(P)) int main(int argc, char **argv) { Options_t *o = GetOptions(argc, argv); Place_vec_t root = Place_vec_new(0); OctfRead(o->input, "", &root, &topo_cmt); Place_vec_t pv = Place_vec_new(0); (void)EnumPlaces(root, NULL, &pv); int i; for (i = 0; i < pv.nel; i++) { Place_t p = pv.el[i]; uint d; for (d = 0; d < 2; d++) { uint f0; for (f0 = 0; f0 < 2; f0++) { uint f3; for (f3 = 0; f3 < 2; f3++) { TestDual(p); TestSingleFlips(p); TestDoubleFlips(p); TestDLOperators(p); p = Flip3(p); } p = Flip3(p); } p = Dual(p); } affirm(p == pv.el[i], "bug in Flip0/Flip3/Dual"); } fprintf(stderr, "done\n"); return 0; } void TestDual(Place_t p) { /* Idempotence: */ Check(Dual(Dual(p)) == p); /* Bipartition: */ Check(DualBit(Dual(p)) != DualBit(p)); } void TestSingleFlips(Place_t p) { /* Equivalence of general flip with specific ones: */ Check(Flip(p,0) == Flip0(p)); Check(Flip(p,1) == Flip1(p)); Check(Flip(p,2) == Flip2(p)); Check(Flip(p,3) == Flip3(p)); /* Consistency of general single flip: */ uint i; for (i = 0; i < 4; i++) { /* Idempotence: */ Check(Flip(Flip(p,i), i) == p); /* Derangement: */ Check(Flip(p,i) != p); /* Commutativity: */ uint j; for (j = 0; j < 4; j++) { if (abs(i - j) >= 2) { Check(Flip(Flip(p,i), j) == Flip(Flip(p,j), i)); } } /* Dualization: */ Check(Flip(Dual(p),i) == Dual(Flip(p,3-i))); } } void TestDoubleFlips(Place_t p) { /* Equivalence of general double flip with specific ones: */ Check(FlipIJ(p,0,0) == p); Check(FlipIJ(p,0,1) == Flip01(p)); Check(FlipIJ(p,0,2) == Flip02(p)); Check(FlipIJ(p,0,3) == Flip03(p)); Check(FlipIJ(p,1,0) == Flip10(p)); Check(FlipIJ(p,1,1) == p); Check(FlipIJ(p,1,2) == Flip12(p)); Check(FlipIJ(p,1,3) == Flip13(p)); Check(FlipIJ(p,2,0) == Flip20(p)); Check(FlipIJ(p,2,1) == Flip21(p)); Check(FlipIJ(p,2,2) == p); Check(FlipIJ(p,2,3) == Flip23(p)); Check(FlipIJ(p,3,0) == Flip30(p)); Check(FlipIJ(p,3,1) == Flip31(p)); Check(FlipIJ(p,3,2) == Flip32(p)); Check(FlipIJ(p,3,3) == p); /* Consistency of general double flip: */ uint i; for (i = 0; i < 4; i++) { uint j; for (j = 0; j < 4; j++) { /* Equivalence with two single flips: */ Check(FlipIJ(p,i,j) == Flip(Flip(p,i),j)); /* Inversion: */ Check(FlipIJ(FlipIJ(p,i,j),j,i) == p); /* Commutativity: */ if (abs(i - j) >= 2) { Check(FlipIJ(p,i,j) == FlipIJ(p,j,i)); } /* Dualization: */ Check(FlipIJ(Dual(p),i,j) == Dual(FlipIJ(p,3-i,3-j))); } } } void TestDLOperators(Place_t p) { Check(Spin(p) == Flip3(p)); Check(Clock(p) == Flip03(p)); Check(NextF(p) == Flip32(p)); Check(PrevF(p) == Flip23(p)); Check(NextE(p) == Flip01(p)); Check(PrevE(p) == Flip10(p)); Check(SymVF(p) == Flip02(p)); Check(SymEC(p) == Flip13(p)); Check(ONext(p) == Flip21(p)); Check(OPrev(p) == Flip12(p)); Check(Srot(p) == Flip3(Dual(p))); Check(Srot(Srot(p)) == Flip03(p)); Check(Tors(p) == Flip0(Dual(p))); Check(Tors(Tors(p)) == Flip03(p)); int i; for (i = -3; i <= +3; i++) { TestMultiStepFunc(p, &NextEK, &NextE, i); TestMultiStepFunc(p, &NextFK, &NextF, i); } } void TestMultiStepFunc(Place_t p, MultiStepFunc_t jump, StepFunc_t step, int n) { Place_t q = jump(p, n); if (n < 0) { do { q = step(q); n++; } while (n < 0); } else if (n > 0) { do { p = step(p); n--; } while (n > 0); } affirm(p == q, "bug in multistep function"); } Options_t *GetOptions(int argc, char **argv) { Options_t *o = (Options_t *)malloc(sizeof(Options_t)); argparser_t *pp = argparser_new(stderr, argc, argv); argparser_set_help(pp, PROG_NAME " version " PROG_VERS ", usage:\n" PROG_HELP); argparser_set_info(pp, PROG_INFO); argparser_process_help_info_options(pp); argparser_get_keyword(pp, "-input"); o->input = argparser_get_next(pp); argparser_finish(pp); return o; } #define TestWalks_C_author \ "Created by J. Stolfi, feb/2007.\n" \ "Revisions:" \