void test() { const uint32_t data[] = { 0, 3, 5, 6, 9, 13 }; AV av; for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(data); i++) { av.append(data[i]); } const struct { uint32_t pos; uint32_t v; } tbl[] = { { 0, 0 }, { 1, 0 }, { 2, 0 }, { 3, 1 }, { 4, 1 }, { 5, 2 }, { 6, 3 }, { 7, 3 }, { 8, 3 }, { 9, 4 }, {10, 4 }, {11, 4 }, {12, 4 }, {13, 5 }, {14, 5 }, }; for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) { CYBOZU_TEST_EQUAL(av.get(tbl[i].pos), tbl[i].v); } }
void test_push_back() { IntVec1 v1; IntVec2 v2; const struct { unsigned int pos; int val; } tbl[] = { { 2, 4 }, { 5, 2 }, { 100, 4 }, { 101, 3}, { 999, 4 }, { 1000, 1 }, { 1896, 3 }, { 2793, 511 }, { 4000, 100 }, { 100000, 999 }, { 116384, 33 }, { 2397152, 123459 }, { 278435456, 9 }, { 378435456, 9 }, { 1378435456, 9 }, { 2378435456U, 1234 }, { 3378435456U, 1234 }, { 4294967295U, 56789 }, }; for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) { v1.push_back(tbl[i].pos, tbl[i].val); v2.push_back(tbl[i].pos, tbl[i].val); } CYBOZU_TEST_EQUAL(v1.size(), CYBOZU_NUM_OF_ARRAY(tbl)); CYBOZU_TEST_EQUAL(v2.size(), CYBOZU_NUM_OF_ARRAY(tbl)); int j = 0; for (typename IntVec1::const_iterator i = v1.begin(), ie = v1.end(); i != ie; ++i) { CYBOZU_TEST_EQUAL(i->pos(), tbl[j].pos); CYBOZU_TEST_EQUAL(i->val(), tbl[j].val); j++; } j = 0; for (typename IntVec2::const_iterator i = v2.begin(), ie = v2.end(); i != ie; ++i) { CYBOZU_TEST_EQUAL(i->pos(), tbl[j].pos); CYBOZU_TEST_EQUAL(i->val(), tbl[j].val); j++; } { std::stringstream ss; cybozu::save(ss, v1); IntVec1 out1; cybozu::load(out1, ss); CYBOZU_TEST_ASSERT(v1 == out1); } }
int main() { const char *pTbl[] = { "0x2523648240000001ba344d80000000086121000000000013a700000000000013", "0xfffffffffffffffffffffffffffffffffffffffeffffee37", }; for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(pTbl); i++) { const mpz_class p(pTbl[i]); test(p); } }
static inline Name getName(const std::string& nameStr) { static const struct { const char *nameStr; Name name; } tbl[] = { { "sha1", N_SHA1 }, { "sha224", N_SHA224 }, { "sha256", N_SHA256 }, { "sha384", N_SHA384 }, { "sha512", N_SHA512 }, }; for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) { if (nameStr == tbl[i].nameStr) return tbl[i].name; } throw cybozu::Exception("crypto:Hash:getName") << nameStr; }
int main() { const struct { int row; int col; int rank; int tryRank; } tbl[] = { { 100, 100, 10, 10 }, { 100, 100, 10, 9 }, { 100, 100, 10, 9 }, { 100, 100, 10, 8 }, { 100, 100, 10, 8 }, { 100, 100, 50, 50 }, { 100, 100, 50, 50 }, { 100, 100, 50, 49 }, { 100, 100, 50, 48 }, { 100, 100, 50, 10 }, { 300, 300, 50, 48 }, { 300, 300, 50, 48 }, { 600, 600, 100, 95 }, { 600, 600, 100, 95 }, { 1000, 1000, 10, 10 }, { 1000, 1000, 10, 9 }, { 1000, 1000, 10, 8 }, { 1000, 1000, 20, 20 }, { 1000, 1000, 20, 19 }, { 1000, 1000, 20, 18 }, { 1000, 1000, 100, 100 }, { 1000, 1000, 100, 99 }, { 1000, 1000, 100, 90 }, { 10000, 10000, 100, 100 }, { 10000, 10000, 100, 91 }, { 10000, 10000, 300, 100 }, { 10000, 10000, 1000, 100 }, }; printf("( row, col, rank, r, f) msec eigen-max min diff\n"); for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) { test<Eigen::MatrixXd, Eigen::VectorXd>(tbl[i].row, tbl[i].col, tbl[i].rank, tbl[i].tryRank, false); if (tbl[i].row <= 1000) { test<Eigen::MatrixXd, Eigen::VectorXd>(tbl[i].row, tbl[i].col, tbl[i].rank, tbl[i].tryRank, true); } } }
void benchRaw(const char *p, mcl::fp::Mode mode) { Fp::init(1, p, mode); Fp2::init(); const size_t maxN = sizeof(Fp) / sizeof(Unit); const mcl::fp::Op& op = Fp::getOp(); cybozu::XorShift rg; Fp fx, fy; fx.setRand(rg); fy.setRand(rg); Unit ux[maxN * 2] = {}; Unit uy[maxN * 2] = {}; Unit uz[maxN * 2] = {}; memcpy(ux, fx.getUnit(), sizeof(Unit) * op.N); memcpy(ux + op.N, fx.getUnit(), sizeof(Unit) * op.N); memcpy(uy, fy.getUnit(), sizeof(Unit) * op.N); memcpy(ux + op.N, fx.getUnit(), sizeof(Unit) * op.N); double fp_addT, fp_subT; double fp_addPreT, fp_subPreT; double fp_sqrT, fp_mulT; double fp_mulUnitT; double mul9T; double fp_mulUnitPreT; double fpN1_modT; double fpDbl_addT, fpDbl_subT; double fpDbl_sqrPreT, fpDbl_mulPreT, fpDbl_modT; double fp2_sqrT, fp2_mulT; CYBOZU_BENCH_T(fp_addT, op.fp_add, uz, ux, uy, op.p); CYBOZU_BENCH_T(fp_subT, op.fp_sub, uz, uy, ux, op.p); CYBOZU_BENCH_T(fp_addPreT, op.fp_addPre, uz, ux, uy); CYBOZU_BENCH_T(fp_subPreT, op.fp_subPre, uz, uy, ux); CYBOZU_BENCH_T(fp_sqrT, op.fp_sqr, uz, ux, op.p); CYBOZU_BENCH_T(fp_mulT, op.fp_mul, uz, ux, uy, op.p); CYBOZU_BENCH_T(fp_mulUnitT, op.fp_mulUnit, uz, ux, 9, op.p); CYBOZU_BENCH_T(mul9T, mul9, op, uz, ux, op.p); CYBOZU_BENCH_T(fp_mulUnitPreT, op.fp_mulUnitPre, ux, ux, 9); CYBOZU_BENCH_T(fpN1_modT, op.fpN1_mod, ux, uy, op.p); CYBOZU_BENCH_T(fpDbl_addT, op.fpDbl_add, uz, ux, uy, op.p); CYBOZU_BENCH_T(fpDbl_subT, op.fpDbl_sub, uz, uy, ux, op.p); CYBOZU_BENCH_T(fpDbl_sqrPreT, op.fpDbl_sqrPre, uz, ux); CYBOZU_BENCH_T(fpDbl_mulPreT, op.fpDbl_mulPre, uz, ux, uy); CYBOZU_BENCH_T(fpDbl_modT, op.fpDbl_mod, uz, ux, op.p); Fp2 f2x, f2y; f2x.a = fx; f2x.b = fy; f2y = f2x; CYBOZU_BENCH_T(fp2_sqrT, Fp2::sqr, f2x, f2x); CYBOZU_BENCH_T(fp2_mulT, Fp2::mul, f2x, f2x, f2y); printf("%s\n", mcl::fp::ModeToStr(mode)); const char *tStrTbl[] = { "fp_add", "fp_sub", "addPre", "subPre", "fp_sqr", "fp_mul", "mulUnit", "mul9", "mulUnitP", "fpN1_mod", "D_add", "D_sub", "D_sqrPre", "D_mulPre", "D_mod", "fp2_sqr", "fp2_mul", }; for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tStrTbl); i++) { printf(" %8s", tStrTbl[i]); } printf("\n"); const double tTbl[] = { fp_addT, fp_subT, fp_addPreT, fp_subPreT, fp_sqrT, fp_mulT, fp_mulUnitT, mul9T, fp_mulUnitPreT, fpN1_modT, fpDbl_addT, fpDbl_subT, fpDbl_sqrPreT, fpDbl_mulPreT, fpDbl_modT, fp2_sqrT, fp2_mulT, }; for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tTbl); i++) { printf(" %8.2f", tTbl[i]); } printf("\n"); }
int main(int argc, char *argv[]) try { cybozu::Option opt; size_t bitSize; opt.appendOpt(&bitSize, 0, "s", ": bitSize"); opt.appendHelp("h", ": show this message"); if (!opt.parse(argc, argv)) { opt.usage(); return 1; } const char *tbl[] = { // N = 2 "0x0000000000000001000000000000000d", "0x7fffffffffffffffffffffffffffffff", "0x8000000000000000000000000000001d", "0xffffffffffffffffffffffffffffff61", // N = 3 "0x000000000000000100000000000000000000000000000033", // min prime "0x70000000000000000000000000000000000000000000001f", "0x800000000000000000000000000000000000000000000005", "0xfffffffffffffffffffffffe26f2fc170f69466a74defd8d", "0xfffffffffffffffffffffffffffffffeffffffffffffffff", "0xffffffffffffffffffffffffffffffffffffffffffffff13", // max prime // N = 4 "0x0000000000000001000000000000000000000000000000000000000000000085", // min prime "0x2523648240000001ba344d80000000086121000000000013a700000000000013", // BN254 "0x30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47", // Snark "0x7523648240000001ba344d80000000086121000000000013a700000000000017", "0x800000000000000000000000000000000000000000000000000000000000005f", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff43", // max prime // N = 5 "0x80000000000000000000000000000000000000000000000000000000000000000000000000000009", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff3b", // N = 6 "0x800000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000171", "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec3", // N = 7 "0x8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000063", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff35", // N = 8 "0x8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006f", "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc7", #if MCL_MAX_BIT_SIZE == 1024 "0xc70b1ddda9b96e3965e5855942aa5852d8f8e052c760ac32cdfec16a2ed3d56981e1a475e20a70144ed2f5061ba64900f69451492803f815d446ee133d0668f7a7f3276d6301c95ce231f0e4b0d0f3882f10014fca04454cff55d2e2d4cfc1aad33b8d38397e2fc8b623177e63d0b783269c40a85b8f105654783b8ed2e737df", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff97", #endif }; for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) { const char *p = tbl[i]; if (bitSize > 0 && (strlen(p) - 2) * 4 != bitSize) { continue; } printf("prime=%s\n", p); benchRaw(tbl[i], mcl::fp::FP_GMP); benchRaw(tbl[i], mcl::fp::FP_GMP_MONT); #ifdef MCL_USE_LLVM benchRaw(tbl[i], mcl::fp::FP_LLVM); benchRaw(tbl[i], mcl::fp::FP_LLVM_MONT); #endif #ifdef MCL_USE_XBYAK if (bitSize <= 384) { benchRaw(tbl[i], mcl::fp::FP_XBYAK); } #endif } } catch (std::exception& e) { printf("ERR %s\n", e.what()); return 1; }
void test_intersect() { DoubleVec dv; IntVec iv; const struct { unsigned int pos; double val; } dTbl[] = { { 5, 3.14 }, { 10, 2 }, { 12, 1.4 }, { 100, 2.3 }, { 1000, 4 }, }; const struct { unsigned int pos; int val; } iTbl[] = { { 2, 4 }, { 5, 2 }, { 100, 4 }, { 101, 3}, { 999, 4 }, { 1000, 1 }, { 2000, 3 }, }; const struct { unsigned int pos; double d; int i; } interTbl[] = { { 5, 3.14, 2 }, { 100, 2.3, 4 }, { 1000, 4, 1 } }; for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(dTbl); i++) { dv.push_back(dTbl[i].pos, dTbl[i].val); } for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(iTbl); i++) { iv.push_back(iTbl[i].pos, iTbl[i].val); } int j = 0; for (typename DoubleVec::const_iterator i = dv.begin(), ie = dv.end(); i != ie; ++i) { CYBOZU_TEST_EQUAL(i->pos(), dTbl[j].pos); CYBOZU_TEST_EQUAL(i->val(), dTbl[j].val); j++; } j = 0; for (typename IntVec::const_iterator i = iv.begin(), ie = iv.end(); i != ie; ++i) { CYBOZU_TEST_EQUAL(i->pos(), iTbl[j].pos); CYBOZU_TEST_EQUAL(i->val(), iTbl[j].val); j++; } int sum = 0; for (typename IntVec::const_iterator i = iv.begin(), ie = iv.end(); i != ie; ++i) { sum += i->val() * i->val(); } CYBOZU_TEST_EQUAL(sum, 71); typedef cybozu::nlp::Intersection<DoubleVec, IntVec> InterSection; InterSection inter(dv, iv); j = 0; for (typename InterSection::const_iterator i = inter.begin(), ie = inter.end(); i != ie; ++i) { CYBOZU_TEST_EQUAL(i->pos(), interTbl[j].pos); CYBOZU_TEST_EQUAL(i->val1(), interTbl[j].d); CYBOZU_TEST_EQUAL(i->val2(), interTbl[j].i); j++; } }
void initTable() { static const struct { uint64_t v; uint32_t len; } tbl[] = { #if 1 { 0x0, 16384 }, { 0xffffffffffffffff, 8192 }, { 0x0, 8192 }, { 0xffffffffffffffff, 4096 }, { 0x0, 4096 }, { 0xffffffffffffffff, 2048 }, { 0x0, 2048 }, { 0xffffffffffffffff, 1024 }, { 0x0, 1024 }, { 0xffffffffffffffff, 512 }, { 0x0, 512 }, { 0x0, 384 }, { 0xffffffffffffffff, 256 }, { 0x0, 256 }, { 0x0, 224 }, { 0xffffffffffffffff, 192 }, { 0xffffffffffffffff, 128 }, { 0x0, 128 }, { 0x0, 96 }, { 0x0, 85 }, { 0xffffffffffffffff, 64 }, { 0x0, 64 }, { 0x1fffffffffffff, 53 }, { 0x0, 53 }, { 0x3fffffffffff, 46 }, { 0x0, 46 }, { 0x7fffffffff, 39 }, { 0x4000000, 35 }, { 0x2000000, 35 }, { 0x1000000, 35 }, { 0x800000, 35 }, { 0x400000, 35 }, { 0x200000, 35 }, { 0xffffffff, 32 }, { 0x0, 32 }, { 0xfffffff, 28 }, { 0x8000000, 28 }, { 0x7ffffff, 28 }, { 0x4000000, 28 }, { 0x0, 28 }, { 0x1fffff, 21 }, { 0x1fff7f, 21 }, { 0x1dffff, 21 }, { 0x1bffff, 21 }, { 0x180000, 21 }, { 0x17ffff, 21 }, { 0x100000, 21 }, { 0xfffff, 21 }, { 0x80000, 21 }, { 0x40000, 21 }, { 0x20000, 21 }, { 0x10000, 21 }, { 0x8000, 21 }, { 0x4000, 21 }, { 0x81, 21 }, { 0x0, 21 }, { 0x3fff, 14 }, { 0x3ffe, 14 }, { 0x3f7f, 14 }, { 0x3eff, 14 }, { 0x3dff, 14 }, { 0x3c00, 14 }, { 0x3bff, 14 }, { 0x3800, 14 }, { 0x37ff, 14 }, { 0x3000, 14 }, { 0x2fff, 14 }, { 0x2800, 14 }, { 0x2400, 14 }, { 0x2200, 14 }, { 0x2100, 14 }, { 0x2080, 14 }, { 0x2040, 14 }, { 0x2020, 14 }, { 0x2010, 14 }, { 0x2008, 14 }, { 0x2004, 14 }, { 0x2002, 14 }, { 0x2001, 14 }, { 0x2000, 14 }, { 0x1fff, 14 }, { 0x1800, 14 }, { 0x1400, 14 }, { 0x1200, 14 }, { 0x1100, 14 }, { 0x1080, 14 }, { 0x1020, 14 }, { 0x1010, 14 }, { 0x1008, 14 }, { 0x1004, 14 }, { 0x1002, 14 }, { 0x1001, 14 }, { 0x1000, 14 }, { 0xfff, 14 }, { 0xc00, 14 }, { 0xa00, 14 }, { 0x900, 14 }, { 0x880, 14 }, { 0x808, 14 }, { 0x804, 14 }, { 0x802, 14 }, { 0x801, 14 }, { 0x800, 14 }, { 0x7ff, 14 }, { 0x600, 14 }, { 0x500, 14 }, { 0x480, 14 }, { 0x401, 14 }, { 0x400, 14 }, { 0x300, 14 }, { 0x280, 14 }, { 0x208, 14 }, { 0x202, 14 }, { 0x201, 14 }, { 0x200, 14 }, { 0x180, 14 }, { 0x102, 14 }, { 0x101, 14 }, { 0x100, 14 }, { 0x80, 14 }, { 0x40, 14 }, { 0x20, 14 }, { 0x10, 14 }, { 0x8, 14 }, { 0x4, 14 }, { 0x2, 14 }, { 0x1, 14 }, { 0x0, 14 }, #else { 0, 64 * 32 }, { uint64_t(-1), 64 * 16 }, { uint64_t(-1), 256 }, { 0, 256 }, { 0, 32 }, { 0xffffffff, 32 }, #endif }; encTbl.clear(); for (size_t i = 0; i < CYBOZU_NUM_OF_ARRAY(tbl); i++) { encTbl.push_back(csucvector_util::Encoding(tbl[i].v, tbl[i].len)); } for (int i = 0; i < 128; i++) { encTbl.push_back(csucvector_util::Encoding(i, 7)); } std::sort(encTbl.begin(), encTbl.end()); if (encTbl.size() > csucvector_util::maxTblSize) { throw cybozu::Exception("CSucVector:initTable:bad size") << encTbl.size(); } }