public static MutableInteger SetGreatestCommonDivisor(this MutableInteger c, MutableInteger a, MutableInteger b, MutableIntegerStore store) { var reg1 = store.Allocate(); if (a.IsZero) { c.Set(b); } else if (b.IsZero) { c.Set(a); } else { reg1.Set(a); c.Set(b); while (true) { reg1.Modulo(c); if (reg1.IsZero) { break; } c.Modulo(reg1); if (c.IsZero) { c.Set(reg1); break; } } } store.Release(reg1); return(c); }
internal static bool LeftEdge(Tree t, Tree t1, MutableInteger i) { if (t == t1) { return(true); } else { if (t1.IsLeaf()) { int j = t1.Yield().Count; // so that empties don't add size i.Set(i + j); return(false); } else { foreach (Tree kid in t1.Children()) { if (LeftEdge(t, kid, i)) { return(true); } } return(false); } } }
internal static Tree GetPreTerminal(Tree tree, MutableInteger i, int n) { if (i == n) { if (tree.IsPreTerminal()) { return(tree); } else { return(GetPreTerminal(tree.Children()[0], i, n)); } } else { if (tree.IsPreTerminal()) { i.Set(i + tree.Yield().Count); return(null); } else { foreach (Tree kid in tree.Children()) { Tree result = GetPreTerminal(kid, i, n); if (result != null) { return(result); } } return(null); } } }
internal static bool RightEdge(Tree t, Tree t1, MutableInteger i) { if (t == t1) { return(true); } else { if (t1.IsLeaf()) { int j = t1.Yield().Count; // so that empties don't add size i.Set(i - j); return(false); } else { Tree[] kids = t1.Children(); for (int j = kids.Length - 1; j >= 0; j--) { if (RightEdge(t, kids[j], i)) { return(true); } } return(false); } } }
public Residue(Reducer reducer, BigInteger x) : this(reducer) { r = reducer.CreateRep(); r.Set(x); reducer.Reduce(r); }
public static MutableInteger SetModularInversePowerOfTwoModulus(this MutableInteger c, MutableInteger d, int n, MutableIntegerStore store) { // See 9.2 in: http://gmplib.org/~tege/divcnst-pldi94.pdf c.Set(d); var two = store.Allocate().Set(2); var reg1 = store.Allocate(); var reg2 = store.Allocate(); for (int m = 3; m < n; m *= 2) { reg1.Set(c); reg2.SetProduct(reg1, d); reg2.Mask(n); reg2.SetDifference(two, reg2); c.SetProduct(reg1, reg2); c.Mask(n); } if (c.Sign == -1) { c.Add(reg1.Set(1).LeftShift(n)); } store.Release(two); store.Release(reg1); store.Release(reg2); return(c); }
public static MutableInteger SetModularInverse(this MutableInteger c, MutableInteger a, MutableInteger b, MutableIntegerStore store) { var p = store.Allocate().Set(a); var q = store.Allocate().Set(b); var x0 = store.Allocate().Set(1); var x1 = store.Allocate().Set(0); var quotient = store.Allocate(); var remainder = store.Allocate(); var product = store.Allocate(); while (!q.IsZero) { remainder.Set(p).ModuloWithQuotient(q, quotient); var tmpp = p; p = q; q = tmpp.Set(remainder); var tmpx = x1; x1 = x0.Subtract(product.SetProduct(quotient, x1)); x0 = tmpx; } c.Set(x0); if (c.Sign == -1) { c.Add(b); } store.Release(p); store.Release(q); store.Release(x0); store.Release(x1); store.Release(quotient); store.Release(remainder); return(c); }
public Reducer(MutableIntegerReduction reduction, BigInteger n) : base(reduction, n) { length = (n.GetBitLength() + 31) / 32 * 2 + 1; store = new MutableIntegerStore(length); nRep = store.Allocate(); nRep.Set(n); }
/// <summary>Adds the given count to the current count for the given key.</summary> /// <remarks> /// Adds the given count to the current count for the given key. If the key /// hasn't been seen before, it is assumed to have count 0, and thus this /// method will set its count to the given amount. Negative increments are /// equivalent to calling /// <c>decrementCount</c> /// . /// <p> /// To more conveniently increment the count by 1, use /// <see cref="IntCounter{E}.IncrementCount(object)"/> /// . /// <p> /// To set a count to a specific value instead of incrementing it, use /// <see cref="IntCounter{E}.SetCount(object, int)"/> /// . /// </remarks> public virtual int IncrementCount(E key, int count) { if (tempMInteger == null) { tempMInteger = new MutableInteger(); } MutableInteger oldMInteger = map[key] = tempMInteger; totalCount += count; if (oldMInteger != null) { count += oldMInteger; } tempMInteger.Set(count); tempMInteger = oldMInteger; return(count); }
public Reducer(IReductionAlgorithm <BigInteger> reduction, BigInteger p) { this.reduction = reduction; this.p = p; bLength = 32; b = BigInteger.One << bLength; var pLength = p.GetBitLength(); k = (pLength - 1) / bLength + 1; mu = BigInteger.Pow(b, 2 * k) / p; var muLength = mu.GetBitLength(); length = (pLength + 31) / 32 * 2 + (muLength + 31) / 32; store = new MutableIntegerStore(length); muRep = store.Allocate(); pRep = store.Allocate(); muRep.Set(mu); pRep.Set(p); bToTheKMinusOneLength = bLength * (k - 1); bToTheKPlusOneLength = bLength * (k + 1); }
public IResidue <BigInteger> Set(BigInteger x) { r.Set(x); return(this); }