/*
* Inverse A and output to B
*/
static void fieldInv(const uint32_t *A, const uint32_t *modulus, const uint32_t *reducer, uint32_t *B){
uint32_t u[8],v[8],x1[8],x2[8];
uint32_t tempm[8];
uint32_t tempm2[8];
setZero(tempm, 8);
setZero(tempm2, 8);
setZero(u, 8);
setZero(v, 8);
uint8_t t;
copy(A,u,arrayLength);
copy(modulus,v,arrayLength);
setZero(x1, 8);
setZero(x2, 8);
x1[0]=1;
/* While u !=1 and v !=1 */
while ((isOne(u) || isOne(v))==0) {
while(!(u[0]&1)) { /* While u is even */
rshift(u); /* divide by 2 */
if (!(x1[0]&1)) /*ifx1iseven*/
rshift(x1); /* Divide by 2 */
else {
fieldAddAndDivide(x1,modulus,reducer,tempm); /* tempm=x1+p */
copy(tempm,x1,arrayLength); /* x1=tempm */
//rshift(x1); /* Divide by 2 */
}
}
while(!(v[0]&1)) { /* While v is even */
rshift(v); /* divide by 2 */
if (!(x2[0]&1)) /*ifx1iseven*/
rshift(x2); /* Divide by 2 */
else
{
fieldAddAndDivide(x2,modulus,reducer,tempm); /* tempm=x1+p */
copy(tempm,x2,arrayLength); /* x1=tempm */
//rshift(x2); /* Divide by 2 */
}
}
t=sub(u,v,tempm,arrayLength); /* tempm=u-v */
if (t==0) { /* If u > 0 */
copy(tempm,u,arrayLength); /* u=u-v */
fieldSub(x1,x2,modulus,tempm); /* tempm=x1-x2 */
copy(tempm,x1,arrayLength); /* x1=x1-x2 */
} else {
sub(v,u,tempm,arrayLength); /* tempm=v-u */
copy(tempm,v,arrayLength); /* v=v-u */
fieldSub(x2,x1,modulus,tempm); /* tempm=x2-x1 */
copy(tempm,x2,arrayLength); /* x2=x2-x1 */
}
}
if (isOne(u)) {
copy(x1,B,arrayLength);
} else {
copy(x2,B,arrayLength);
}
}
int main(){
int c;
int i=0;
int odd=1;
//take each input separated by spaces
//odd: for leaving spaces
while((c=getchar())!='\n'){
if(odd){
a[i]=c-48;
i++;
odd=0;}
else{
odd=1;
}
}
int check = 0;
for(i=0;i<100;i++){
//if 1 has not occured yet
if(check==0){
check = isOne(i);
}
else{
printf("%d\n",i-1);
return 0;
}
}
printf("-1\n");
return 0;
}
void printBin (long int n) {
int i;
for(i = LONG_BITS - 1; i >= 0; i--) {
printf("%d", isOne(n, i));
}
puts("");
}
CEvaluationNode* CDerive::multiply(CEvaluationNode* n1, CEvaluationNode* n2, bool simplify)
{
if (simplify)
{
if (isZero(n1) || isZero(n2))
{
deleteBranch(n1);
deleteBranch(n2);
return new CEvaluationNodeNumber(CEvaluationNodeNumber::INTEGER, "0");
}
if (isOne(n1))
{
if (isOne(n2))
{
deleteBranch(n1);
deleteBranch(n2);
return new CEvaluationNodeNumber(CEvaluationNodeNumber::INTEGER, "1");
}
else
{
deleteBranch(n1);
return n2;
}
}
if (isOne(n2))
{
deleteBranch(n2);
return n1;
}
}
CEvaluationNode * tmpNode = NULL;
tmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::MULTIPLY, "*");
tmpNode->addChild(n1);
tmpNode->addChild(n2);
//tmpNode->compile(NULL);
return tmpNode;
}
CEvaluationNode* CDerive::power(CEvaluationNode* n1, CEvaluationNode* n2, bool simplify)
{
if (simplify)
{
if (isOne(n2))
{
deleteBranch(n2);
return n1;
}
if (isOne(n1))
{
deleteBranch(n1);
deleteBranch(n2);
return new CEvaluationNodeNumber(CEvaluationNodeNumber::INTEGER, "1");
}
if (isZero(n2) && !isZero(n1))
{
deleteBranch(n1);
deleteBranch(n2);
return new CEvaluationNodeNumber(CEvaluationNodeNumber::INTEGER, "1");
}
if (isZero(n1) && !isZero(n2))
{
deleteBranch(n1);
deleteBranch(n2);
return new CEvaluationNodeNumber(CEvaluationNodeNumber::INTEGER, "0");
}
}
CEvaluationNode * tmpNode = NULL;
tmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::POWER, "^");
tmpNode->addChild(n1);
tmpNode->addChild(n2);
//tmpNode->compile(NULL);
return tmpNode;
}
nro mult(nro n1, nro n2) {
int i;
nro toRet;
if (isZero(n2)) {
for(i = 0; i < 16; i++)
toRet.n[i] = 0;
return toRet;
}
if (isOne(n2))
return n1;
if (isEven(n2))
return mult(bwLeft(n1), bwRight(n2));
return add(mult(bwLeft(n1), bwRight(n2)), n1);
}
void swap(ParamItem& rhs)
{
bool b1 = isOne();
bool b2 = rhs.isOne();
std::swap(type, rhs.type);
std::swap(lookedup, rhs.lookedup);
std::swap(oneString, rhs.oneString);
std::swap(ptr, rhs.ptr);
if (b2)
ints = &oneInt;
if (b1)
rhs.ints = &rhs.oneInt;
}
void show_section(int i){
wprintf(L"\033[31m%02x\033[0m \033[32m00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F\033[0m\n",i);
for(int x=0;x<16;x++){
wprintf(L"\033[33m%02x\033[0m ",x*16);
for(int y=0;y<16;y++){
wchar_t c;
wprintf(L"\033[0;34;47m");
c=i*256+x*16+y;
if (isPrintable(c)){
if (isOne(c))
wprintf(L"%lc \033[0m ",c);
else
wprintf(L"%lc\033[0m ",c);
}else
wprintf(L"NA\033[0m ");
}
wprintf(L"\n");
}
wprintf(L"\n");
}
CEvaluationNode* CDerive::divide(CEvaluationNode* n1, CEvaluationNode* n2, bool simplify)
{
if (simplify)
{
if (isZero(n1))
{
deleteBranch(n1);
deleteBranch(n2);
return new CEvaluationNodeNumber(CEvaluationNodeNumber::INTEGER, "0");
}
/*if (isOne(n1))
{
if (isOne(n2))
{
deleteBranch(n1);
deleteBranch(n2);
return new CEvaluationNodeNumber(CEvaluationNodeNumber::INTEGER, "1");
}
else
{
deleteBranch(n1);
return n2;
}
}*/
if (isOne(n2))
{
deleteBranch(n2);
return n1;
}
}
CEvaluationNode * tmpNode = NULL;
tmpNode = new CEvaluationNodeOperator(CEvaluationNodeOperator::DIVIDE, "/");
tmpNode->addChild(n1);
tmpNode->addChild(n2);
//tmpNode->compile(NULL);
return tmpNode;
}
Func1& newRatioFunction(Func1& f1, Func1& f2)
{
if (isOne(f2)) {
return f1;
}
if (isZero(f1)) {
return *(new Const1(0.0));
}
if (f1.isIdentical(f2)) {
delete &f1;
delete &f2;
return *(new Const1(1.0));
}
if (f1.ID() == PowFuncType && f2.ID() == PowFuncType) {
return *(new Pow1(f1.c() - f2.c()));
}
if (f1.ID() == ExpFuncType && f2.ID() == ExpFuncType) {
return *(new Exp1(f1.c() - f2.c()));
}
return *(new Ratio1(f1, f2));
}
TEST_F(ResolveConditionTest, BranchConditionsAreResolved) {
{
// No runtime information is set in the specialization context. Thus the resolution of the condition must fail.
const auto resolved_condition = ResolveCondition(_branch_instruction->getCondition(), _specialization_context);
ASSERT_FALSE(resolved_condition);
}
{
// Create runtime information (i.e., an instance of the SomeStruct parameter).
const auto runtime_parameter = SomeStruct{1, 2};
// Initialize the first function argument to this value in the specialization context. This make the value
// accessible to the specialization engine.
_specialization_context.runtime_value_map.clear();
_specialization_context.runtime_value_map[_branch_instruction_fn->arg_begin()] =
std::make_shared<JitConstantRuntimePointer>(&runtime_parameter);
const auto resolved_condition = ResolveCondition(_branch_instruction->getCondition(), _specialization_context);
// The condition should now be replaced by a "false" constant (which is represented as a 1-bit integer in LLVM),
// since the resolved expression "s.a + s.b > 5" = "1 + 2 > 5" is false.
ASSERT_TRUE(resolved_condition);
ASSERT_EQ(resolved_condition->getType(), llvm::Type::getInt1Ty(*_repository->llvm_context()));
const auto resolved_int_condition = llvm::dyn_cast<llvm::ConstantInt>(resolved_condition);
ASSERT_TRUE(resolved_int_condition->isZero());
}
{
// We repeat the above procedure with a value that will cause the condition expression to evaluate to "true".
const auto runtime_parameter = SomeStruct{4, 5};
_specialization_context.runtime_value_map.clear();
_specialization_context.runtime_value_map[_branch_instruction_fn->arg_begin()] =
std::make_shared<JitConstantRuntimePointer>(&runtime_parameter);
const auto resolved_condition = ResolveCondition(_branch_instruction->getCondition(), _specialization_context);
ASSERT_TRUE(resolved_condition);
ASSERT_EQ(resolved_condition->getType(), llvm::Type::getInt1Ty(*_repository->llvm_context()));
const auto resolved_int_condition = llvm::dyn_cast<llvm::ConstantInt>(resolved_condition);
ASSERT_TRUE(resolved_int_condition->isOne());
}
}
static SEXP simplify(SEXP fun, SEXP arg1, SEXP arg2)
{
SEXP ans;
if (fun == PlusSymbol) {
if (isZero(arg1))
ans = arg2;
else if (isZero(arg2))
ans = arg1;
else if (isUminus(arg1))
ans = simplify(MinusSymbol, arg2, CADR(arg1));
else if (isUminus(arg2))
ans = simplify(MinusSymbol, arg1, CADR(arg2));
else
ans = lang3(PlusSymbol, arg1, arg2);
}
else if (fun == MinusSymbol) {
if (arg2 == R_MissingArg) {
if (isZero(arg1))
ans = Constant(0.);
else if (isUminus(arg1))
ans = CADR(arg1);
else
ans = lang2(MinusSymbol, arg1);
}
else {
if (isZero(arg2))
ans = arg1;
else if (isZero(arg1))
ans = simplify(MinusSymbol, arg2, R_MissingArg);
else if (isUminus(arg1)) {
ans = simplify(MinusSymbol,
PP(simplify(PlusSymbol, CADR(arg1), arg2)),
R_MissingArg);
UNPROTECT(1);
}
else if (isUminus(arg2))
ans = simplify(PlusSymbol, arg1, CADR(arg2));
else
ans = lang3(MinusSymbol, arg1, arg2);
}
}
else if (fun == TimesSymbol) {
if (isZero(arg1) || isZero(arg2))
ans = Constant(0.);
else if (isOne(arg1))
ans = arg2;
else if (isOne(arg2))
ans = arg1;
else if (isUminus(arg1)) {
ans = simplify(MinusSymbol,
PP(simplify(TimesSymbol, CADR(arg1), arg2)),
R_MissingArg);
UNPROTECT(1);
}
else if (isUminus(arg2)) {
ans = simplify(MinusSymbol,
PP(simplify(TimesSymbol, arg1, CADR(arg2))),
R_MissingArg);
UNPROTECT(1);
}
else
ans = lang3(TimesSymbol, arg1, arg2);
}
else if (fun == DivideSymbol) {
if (isZero(arg1))
ans = Constant(0.);
else if (isZero(arg2))
ans = Constant(NA_REAL);
else if (isOne(arg2))
ans = arg1;
else if (isUminus(arg1)) {
ans = simplify(MinusSymbol,
PP(simplify(DivideSymbol, CADR(arg1), arg2)),
R_MissingArg);
UNPROTECT(1);
}
else if (isUminus(arg2)) {
ans = simplify(MinusSymbol,
PP(simplify(DivideSymbol, arg1, CADR(arg2))),
R_MissingArg);
UNPROTECT(1);
}
else ans = lang3(DivideSymbol, arg1, arg2);
}
else if (fun == PowerSymbol) {
if (isZero(arg2))
ans = Constant(1.);
else if (isZero(arg1))
ans = Constant(0.);
else if (isOne(arg1))
ans = Constant(1.);
else if (isOne(arg2))
ans = arg1;
else
ans = lang3(PowerSymbol, arg1, arg2);
}
else if (fun == ExpSymbol) {
/* FIXME: simplify exp(lgamma( E )) = gamma( E ) */
ans = lang2(ExpSymbol, arg1);
}
else if (fun == LogSymbol) {
/* FIXME: simplify log(gamma( E )) = lgamma( E ) */
ans = lang2(LogSymbol, arg1);
}
else if (fun == CosSymbol) ans = lang2(CosSymbol, arg1);
else if (fun == SinSymbol) ans = lang2(SinSymbol, arg1);
else if (fun == TanSymbol) ans = lang2(TanSymbol, arg1);
else if (fun == CoshSymbol) ans = lang2(CoshSymbol, arg1);
else if (fun == SinhSymbol) ans = lang2(SinhSymbol, arg1);
else if (fun == TanhSymbol) ans = lang2(TanhSymbol, arg1);
else if (fun == SqrtSymbol) ans = lang2(SqrtSymbol, arg1);
else if (fun == PnormSymbol)ans = lang2(PnormSymbol, arg1);
else if (fun == DnormSymbol)ans = lang2(DnormSymbol, arg1);
else if (fun == AsinSymbol) ans = lang2(AsinSymbol, arg1);
else if (fun == AcosSymbol) ans = lang2(AcosSymbol, arg1);
else if (fun == AtanSymbol) ans = lang2(AtanSymbol, arg1);
else if (fun == GammaSymbol)ans = lang2(GammaSymbol, arg1);
else if (fun == LGammaSymbol)ans = lang2(LGammaSymbol, arg1);
else if (fun == DiGammaSymbol) ans = lang2(DiGammaSymbol, arg1);
else if (fun == TriGammaSymbol) ans = lang2(TriGammaSymbol, arg1);
else if (fun == PsiSymbol){
if (arg2 == R_MissingArg) ans = lang2(PsiSymbol, arg1);
else ans = lang3(PsiSymbol, arg1, arg2);
}
else ans = Constant(NA_REAL);
/* FIXME */
#ifdef NOTYET
if (length(ans) == 2 && isAtomic(CADR(ans)) && CAR(ans) != MinusSymbol)
c = eval(c, rho);
if (length(c) == 3 && isAtomic(CADR(ans)) && isAtomic(CADDR(ans)))
c = eval(c, rho);
#endif
return ans;
}/* simplify() */
int ecc_isOne(const uint32_t* A)
{
return isOne(A);
}
static Tree simplification (Tree sig)
{
assert(sig);
int opnum;
Tree t1, t2, t3, t4;
xtended* xt = (xtended*) getUserData(sig);
// primitive elements
if (xt)
{
//return 3;
vector<Tree> args;
for (int i=0; i<sig->arity(); i++) { args.push_back( sig->branch(i) ); }
// to avoid negative power to further normalization
if (xt != gPowPrim) {
return xt->computeSigOutput(args);
} else {
return normalizeAddTerm(xt->computeSigOutput(args));
}
} else if (isSigBinOp(sig, &opnum, t1, t2)) {
BinOp* op = gBinOpTable[opnum];
Node n1 = t1->node();
Node n2 = t2->node();
if (isNum(n1) && isNum(n2)) return tree(op->compute(n1,n2));
else if (op->isLeftNeutral(n1)) return t2;
else if (op->isRightNeutral(n2)) return t1;
else return normalizeAddTerm(sig);
} else if (isSigDelay1(sig, t1)) {
return normalizeDelay1Term (t1);
} else if (isSigFixDelay(sig, t1, t2)) {
return normalizeFixedDelayTerm (t1, t2);
} else if (isSigIntCast(sig, t1)) {
Tree tx;
int i;
double x;
Node n1 = t1->node();
if (isInt(n1, &i)) return t1;
if (isDouble(n1, &x)) return tree(int(x));
if (isSigIntCast(t1, tx)) return t1;
return sig;
} else if (isSigFloatCast(sig, t1)) {
Tree tx;
int i;
double x;
Node n1 = t1->node();
if (isInt(n1, &i)) return tree(double(i));
if (isDouble(n1, &x)) return t1;
if (isSigFloatCast(t1, tx)) return t1;
return sig;
} else if (isSigSelect2(sig, t1, t2, t3)){
Node n1 = t1->node();
if (isZero(n1)) return t2;
if (isNum(n1)) return t3;
if (t2==t3) return t2;
return sig;
} else if (isSigSelect3(sig, t1, t2, t3, t4)){
Node n1 = t1->node();
if (isZero(n1)) return t2;
if (isOne(n1)) return t3;
if (isNum(n1)) return t4;
if (t3==t4) return simplification(sigSelect2(t1,t2,t3));
return sig;
} else {
return sig;
}
}
static PyObject *
Pympq_qdiv(PyObject *self, PyObject *args)
{
PyObject *other = 0;
PyObject *s = 0;
int wasone;
if ( self && Pympq_Check(self)) {
if (!PyArg_ParseTuple(args, "|O", &other))
return NULL;
}
else {
if (!PyArg_ParseTuple(args, "O|O", &self, &other))
return NULL;
}
wasone = isOne(other);
/* optimize if self must be returned unchanged */
if (Pympq_Check(self) && wasone) {
/* optimize if self is mpq and result must==self */
if (mpz_cmp_ui(mpq_denref(Pympq_AS_MPQ(self)), 1) != 0) {
Py_INCREF(self);
return self;
}
else {
/* denominator is 1, optimize returning an mpz */
s = Pympz_new();
mpz_set(Pympz_AS_MPZ(s), mpq_numref(Pympq_AS_MPQ(self)));
return s;
}
}
else if (Pympz_Check(self) && wasone) {
/* optimize if self is mpz and result must==self */
Py_INCREF(self);
return self;
}
/* normal, non-optimized case: must make new object as result */
self = (PyObject*)Pympq_From_Rational(self);
if (!self) {
if (!PyErr_Occurred())
TYPE_ERROR("first argument cannot be converted to 'mpq'");
return NULL;
}
if (wasone) { /* self was mpf, float, int, long... */
s = self;
}
else { /* other explicitly present and !=1... must compute */
other = (PyObject*)Pympq_From_Rational(other);
if (!other) {
Py_DECREF(self);
if (!PyErr_Occurred())
TYPE_ERROR("second argument cannot be converted to 'mpq'");
return NULL;
}
if (mpq_sgn(Pympq_AS_MPQ(other))==0) {
PyObject* result = 0;
ZERO_ERROR("division or modulo by zero in qdiv");
Py_DECREF(self);
Py_DECREF(other);
return result;
}
s = Pympq_new();
mpq_div(Pympq_AS_MPQ(s), Pympq_AS_MPQ(self), Pympq_AS_MPQ(other));
Py_DECREF(self);
Py_DECREF(other);
}
if (mpz_cmp_ui(mpq_denref(Pympq_AS_MPQ(s)), 1) != 0) {
return s;
}
else {
/* denominator is 1, return an mpz */
PyObject* ss = Pympz_new();
if (ss)
mpz_set(Pympz_AS_MPZ(ss), mpq_numref(Pympq_AS_MPQ(s)));
Py_DECREF(s);
return ss;
}
}
Func1& newProdFunction(Func1& f1, Func1& f2)
{
if (isOne(f1)) {
delete &f1;
return f2;
}
if (isOne(f2)) {
delete &f2;
return f1;
}
if (isZero(f1) || isZero(f2)) {
delete &f1;
delete &f2;
return *(new Const1(0.0));
}
if (isConstant(f1) && isConstant(f2)) {
doublereal c1c2 = f1.c() * f2.c();
delete &f1;
delete &f2;
return *(new Const1(c1c2));
}
if (isConstant(f1)) {
doublereal c = f1.c();
delete &f1;
return newTimesConstFunction(f2, c);
}
if (isConstant(f2)) {
doublereal c = f2.c();
delete &f2;
return newTimesConstFunction(f1, c);
}
if (isPow(f1) && isPow(f2)) {
Func1& p = *(new Pow1(f1.c() + f2.c()));
delete &f1;
delete &f2;
return p;
}
if (isExp(f1) && isExp(f2)) {
Func1& p = *(new Exp1(f1.c() + f2.c()));
delete &f1;
delete &f2;
return p;
}
bool tc1 = isTimesConst(f1);
bool tc2 = isTimesConst(f2);
if (tc1 || tc2) {
doublereal c1 = 1.0, c2 = 1.0;
Func1* ff1 = 0, *ff2 = 0;
if (tc1) {
c1 = f1.c();
ff1 = &f1.func1_dup();
delete &f1;
} else {
ff1 = &f1;
}
if (tc2) {
c2 = f2.c();
ff2 = &f2.func1_dup();
delete &f2;
} else {
ff2 = &f2;
}
Func1& p = newProdFunction(*ff1, *ff2);
if (c1* c2 != 1.0) {
return newTimesConstFunction(p, c1*c2);
} else {
return p;
}
} else {
return *(new Product1(f1, f2));
}
}
