From 758469279bda5810ed7cef45b5f301234bfc7596 Mon Sep 17 00:00:00 2001 From: "Nicolas \"Pixel\" Noble" Date: Mon, 12 Aug 2013 17:54:43 +0200 Subject: Adding more bindings to LuaBigInt - isPrime and the export / import functions are missing. --- src/LuaBigInt.cc | 285 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 285 insertions(+) (limited to 'src') diff --git a/src/LuaBigInt.cc b/src/LuaBigInt.cc index 18ddeea..53b9f5e 100644 --- a/src/LuaBigInt.cc +++ b/src/LuaBigInt.cc @@ -8,6 +8,7 @@ enum BigInt_functions_t { enum BigInt_methods_t { BIGINT_SET, + BIGINT_SET2EXPT, BIGINT_TOSTRING, BIGINT_ADD, @@ -15,6 +16,43 @@ enum BigInt_methods_t { BIGINT_MUL, BIGINT_DIV, BIGINT_MOD, + BIGINT_SHL, + BIGINT_SHR, + + BIGINT_DO_ADD, + BIGINT_DO_SUB, + BIGINT_DO_MUL, + BIGINT_DO_DIV, + BIGINT_DO_MOD, + BIGINT_DO_SHL, + BIGINT_DO_SHR, + + BIGINT_UNM, + BIGINT_DO_NEG, + + BIGINT_SQRT, + BIGINT_DO_SQRT, + + BIGINT_GCD, + BIGINT_LCM, + + BIGINT_EQ, + BIGINT_LT, + BIGINT_LE, + + BIGINT_MODADD, + BIGINT_MODSUB, + BIGINT_MODMUL, + BIGINT_MODSQR, + BIGINT_MODINV, + BIGINT_MODPOW, + + BIGINT_DO_MODADD, + BIGINT_DO_MODSUB, + BIGINT_DO_MODMUL, + BIGINT_DO_MODSQR, + BIGINT_DO_MODINV, + BIGINT_DO_MODPOW, }; struct lua_functypes_t BigInt_functions[] = { @@ -24,6 +62,7 @@ struct lua_functypes_t BigInt_functions[] = { struct lua_functypes_t BigInt_methods[] = { { BIGINT_SET, "set", 1, 2, { BLUA_STRING | BLUA_NUMBER, BLUA_NUMBER } }, + { BIGINT_SET2EXPT, "set2expt", 1, 1, { BLUA_NUMBER } }, { BIGINT_TOSTRING, "tostring", 0, 1, { BLUA_NUMBER } }, { BIGINT_ADD, "add", 1, 1, { BLUA_OBJECT } }, @@ -31,6 +70,43 @@ struct lua_functypes_t BigInt_methods[] = { { BIGINT_MUL, "mul", 1, 1, { BLUA_OBJECT } }, { BIGINT_DIV, "div", 1, 1, { BLUA_OBJECT } }, { BIGINT_MOD, "mod", 1, 1, { BLUA_OBJECT } }, + { BIGINT_SHL, "shl", 1, 1, { BLUA_NUMBER } }, + { BIGINT_SHR, "shr", 1, 1, { BLUA_NUMBER } }, + + { BIGINT_DO_ADD, "do_add", 1, 1, { BLUA_OBJECT } }, + { BIGINT_DO_SUB, "do_sub", 1, 1, { BLUA_OBJECT } }, + { BIGINT_DO_MUL, "do_mul", 1, 1, { BLUA_OBJECT } }, + { BIGINT_DO_DIV, "do_div", 1, 1, { BLUA_OBJECT } }, + { BIGINT_DO_MOD, "do_mod", 1, 1, { BLUA_OBJECT } }, + { BIGINT_DO_SHL, "do_shl", 1, 1, { BLUA_NUMBER } }, + { BIGINT_DO_SHR, "do_shr", 1, 1, { BLUA_NUMBER } }, + + { BIGINT_UNM, "unm", 0, 0, { } }, + { BIGINT_DO_NEG, "do_neg", 0, 0, { } }, + + { BIGINT_SQRT, "sqrt", 0, 0, { } }, + { BIGINT_DO_SQRT, "do_sqrt", 0, 0, { } }, + + { BIGINT_GCD, "gcd", 1, 1, { BLUA_OBJECT } }, + { BIGINT_LCM, "lcm", 1, 1, { BLUA_OBJECT } }, + + { BIGINT_EQ, "eq", 1, 1, { BLUA_OBJECT } }, + { BIGINT_LT, "lt", 1, 1, { BLUA_OBJECT } }, + { BIGINT_LE, "le", 1, 1, { BLUA_OBJECT } }, + + { BIGINT_MODADD, "modadd", 2, 2, { BLUA_OBJECT, BLUA_OBJECT } }, + { BIGINT_MODSUB, "modsub", 2, 2, { BLUA_OBJECT, BLUA_OBJECT } }, + { BIGINT_MODMUL, "modmul", 2, 2, { BLUA_OBJECT, BLUA_OBJECT } }, + { BIGINT_MODSQR, "modsqr", 1, 1, { BLUA_OBJECT } }, + { BIGINT_MODINV, "modinv", 1, 1, { BLUA_OBJECT } }, + { BIGINT_MODPOW, "modpow", 2, 2, { BLUA_OBJECT, BLUA_OBJECT } }, + + { BIGINT_DO_MODADD, "do_modadd", 2, 2, { BLUA_OBJECT, BLUA_OBJECT } }, + { BIGINT_DO_MODSUB, "do_modsub", 2, 2, { BLUA_OBJECT, BLUA_OBJECT } }, + { BIGINT_DO_MODMUL, "do_modmul", 2, 2, { BLUA_OBJECT, BLUA_OBJECT } }, + { BIGINT_DO_MODSQR, "do_modsqr", 1, 1, { BLUA_OBJECT } }, + { BIGINT_DO_MODINV, "do_modinv", 1, 1, { BLUA_OBJECT } }, + { BIGINT_DO_MODPOW, "do_modpow", 2, 2, { BLUA_OBJECT, BLUA_OBJECT } }, { -1, 0, 0, 0, 0 }, }; @@ -87,6 +163,9 @@ int sLua_BigInt::BigInt_proceed(Lua & L, int n, BigInt * a, int caller) { } r = 0; break; + case BIGINT_SET2EXPT: + a->set2expt(L.tonumber()); + break; case BIGINT_TOSTRING: if (n == 3) radix = L.tonumber(-1); @@ -138,6 +217,189 @@ int sLua_BigInt::BigInt_proceed(Lua & L, int n, BigInt * a, int caller) { *c = *a % *b; r = 1; break; + case BIGINT_SHL: + { + LuaBigIntFactory cf(c = new BigInt()); + cf.pushDestruct(L); + } + *c = *a << L.tonumber(); + r = 1; + break; + case BIGINT_SHR: + { + LuaBigIntFactory cf(c = new BigInt()); + cf.pushDestruct(L); + } + *c = *a >> L.tonumber(); + r = 1; + break; + case BIGINT_DO_ADD: + b = L.recast(); + *a += *b; + break; + case BIGINT_DO_SUB: + b = L.recast(); + *a -= *b; + break; + case BIGINT_DO_MUL: + b = L.recast(); + *a *= *b; + break; + case BIGINT_DO_DIV: + b = L.recast(); + *a /= *b; + break; + case BIGINT_DO_MOD: + b = L.recast(); + *a %= *b; + break; + case BIGINT_DO_SHL: + *a <<= L.tonumber(); + break; + case BIGINT_DO_SHR: + *a >>= L.tonumber(); + break; + case BIGINT_UNM: + { + LuaBigIntFactory cf(c = new BigInt()); + cf.pushDestruct(L); + } + *c = a->neg(); + r = 1; + break; + case BIGINT_DO_NEG: + a->do_neg(); + break; + case BIGINT_SQRT: + { + LuaBigIntFactory cf(c = new BigInt()); + cf.pushDestruct(L); + } + *c = a->sqrt(); + r = 1; + break; + case BIGINT_DO_SQRT: + a->do_sqrt(); + break; + case BIGINT_GCD: + b = L.recast(); + { + LuaBigIntFactory cf(c = new BigInt()); + cf.pushDestruct(L); + } + *c = a->gcd(*b); + r = 1; + break; + case BIGINT_LCM: + b = L.recast(); + { + LuaBigIntFactory cf(c = new BigInt()); + cf.pushDestruct(L); + } + *c = a->lcm(*b); + r = 1; + break; + case BIGINT_EQ: + b = L.recast(); + L.push(*a == *b); + r = 1; + break; + case BIGINT_LT: + b = L.recast(); + L.push(*a < *b); + r = 1; + break; + case BIGINT_LE: + b = L.recast(); + L.push(*a <= *b); + r = 1; + break; + case BIGINT_MODADD: + b = L.recast(-2); + m = L.recast(-1); + { + LuaBigIntFactory cf(c = new BigInt()); + cf.pushDestruct(L); + } + *c = a->modadd(*b, *m); + r = 1; + break; + case BIGINT_MODSUB: + b = L.recast(-2); + m = L.recast(-1); + { + LuaBigIntFactory cf(c = new BigInt()); + cf.pushDestruct(L); + } + *c = a->modsub(*b, *m); + r = 1; + break; + case BIGINT_MODMUL: + b = L.recast(-2); + m = L.recast(-1); + { + LuaBigIntFactory cf(c = new BigInt()); + cf.pushDestruct(L); + } + *c = a->modmul(*b, *m); + r = 1; + break; + case BIGINT_MODSQR: + m = L.recast(-1); + { + LuaBigIntFactory cf(c = new BigInt()); + cf.pushDestruct(L); + } + *c = a->modsqr(*m); + r = 1; + break; + case BIGINT_MODINV: + m = L.recast(-1); + { + LuaBigIntFactory cf(c = new BigInt()); + cf.pushDestruct(L); + } + *c = a->modinv(*m); + r = 1; + break; + case BIGINT_MODPOW: + b = L.recast(-2); + m = L.recast(-1); + { + LuaBigIntFactory cf(c = new BigInt()); + cf.pushDestruct(L); + } + *c = a->modpow(*b, *m); + r = 1; + break; + case BIGINT_DO_MODADD: + b = L.recast(-2); + m = L.recast(-1); + a->do_modadd(*b, *m); + break; + case BIGINT_DO_MODSUB: + b = L.recast(-2); + m = L.recast(-1); + a->do_modsub(*b, *m); + break; + case BIGINT_DO_MODMUL: + b = L.recast(-2); + m = L.recast(-1); + a->do_modmul(*b, *m); + break; + case BIGINT_DO_MODSQR: + m = L.recast(-1); + a->do_modsqr(*m); + break; + case BIGINT_DO_MODINV: + m = L.recast(-1); + a->do_modinv(*m); + break; + case BIGINT_DO_MODPOW: + b = L.recast(-2); + m = L.recast(-1); + a->do_modpow(*b, *m); + break; } return r; @@ -176,6 +438,10 @@ void LuaBigIntFactory::pushStatics(Lua & L) { METAMETHOD_WRAPPER(mul); METAMETHOD_WRAPPER(mod); PUSH_METAMETHOD(BigInt, BIGINT_TOSTRING); + PUSH_METAMETHOD(BigInt, BIGINT_UNM); + PUSH_METAMETHOD(BigInt, BIGINT_EQ); + PUSH_METAMETHOD(BigInt, BIGINT_LT); + PUSH_METAMETHOD(BigInt, BIGINT_LE); L.settable(LUA_REGISTRYINDEX); @@ -190,6 +456,7 @@ void LuaBigIntFactory::pushObjectAndMembers(Lua & L) { L.setmetatable(); PUSH_METHOD(BigInt, BIGINT_SET); + PUSH_METHOD(BigInt, BIGINT_SET2EXPT); PUSH_METHOD(BigInt, BIGINT_TOSTRING); PUSH_METHOD(BigInt, BIGINT_ADD); @@ -197,6 +464,24 @@ void LuaBigIntFactory::pushObjectAndMembers(Lua & L) { PUSH_METHOD(BigInt, BIGINT_MUL); PUSH_METHOD(BigInt, BIGINT_DIV); PUSH_METHOD(BigInt, BIGINT_MOD); + PUSH_METHOD(BigInt, BIGINT_SHL); + PUSH_METHOD(BigInt, BIGINT_SHR); + + PUSH_METHOD(BigInt, BIGINT_DO_ADD); + PUSH_METHOD(BigInt, BIGINT_DO_SUB); + PUSH_METHOD(BigInt, BIGINT_DO_MUL); + PUSH_METHOD(BigInt, BIGINT_DO_DIV); + PUSH_METHOD(BigInt, BIGINT_DO_MOD); + PUSH_METHOD(BigInt, BIGINT_DO_SHL); + PUSH_METHOD(BigInt, BIGINT_DO_SHR); + + PUSH_METHOD(BigInt, BIGINT_DO_NEG); + + PUSH_METHOD(BigInt, BIGINT_SQRT); + PUSH_METHOD(BigInt, BIGINT_DO_SQRT); + + PUSH_METHOD(BigInt, BIGINT_GCD); + PUSH_METHOD(BigInt, BIGINT_LCM); } void Balau::registerLuaBigInt(Lua & L) { -- cgit v1.2.3