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();
}
}
