private void Reduce(MutableInteger z) { // var qhat = (z >> (bLength * (k - 1))) * mu >> (bLength * (k + 1)); var reg1 = store.Allocate().Set(z); reg1.RightShift(bToTheKMinusOneLength); #if false var reg2.store.Allocate().SetProductShifted(reg1, muRep, bToTheKPlusOneLength); #else var reg2 = store.Allocate().SetProduct(reg1, muRep); reg2.RightShift(bToTheKPlusOneLength); #endif // var r = z % bToTheKPlusOne - qhat * p % bToTheKPlusOne; z.Mask(bToTheKPlusOneLength); #if true reg1.SetProductMasked(reg2, pRep, bToTheKPlusOneLength); #else reg1.SetProduct(reg2, pRep); reg1.Mask(bToTheKPlusOneLength); #endif // if (r.Sign == -1) r += bToTheKPlusOne; if (z < reg1) { z.SetBit(bToTheKPlusOneLength, true); } z.Subtract(reg1); // while (r >= p) r -= p; while (z >= pRep) { z.Subtract(pRep); } store.Release(reg1); store.Release(reg2); }
internal override void ParseHeader() { // Parse "@@@ -55,12 -163,13 +163,15 @@@ protected boolean" // byte[] buf = file.buf; MutableInteger ptr = new MutableInteger(); ptr.value = RawParseUtils.NextLF(buf, startOffset, ' '); for (int n = 0; n < old.Length; n++) { old[n].startLine = -RawParseUtils.ParseBase10(buf, ptr.value, ptr); if (buf[ptr.value] == ',') { old[n].lineCount = RawParseUtils.ParseBase10(buf, ptr.value + 1, ptr); } else { old[n].lineCount = 1; } } newStartLine = RawParseUtils.ParseBase10(buf, ptr.value + 1, ptr); if (buf[ptr.value] == ',') { newLineCount = RawParseUtils.ParseBase10(buf, ptr.value + 1, ptr); } else { newLineCount = 1; } }
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 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; }
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); }
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); }
/** * Removes a specified number of copies of an object from the bag. * * @param object the object to remove * @param nCopies the number of copies to remove * @return true if the bag changed */ public virtual bool remove(Object obj, int nCopies) { MutableInteger mut = (MutableInteger)map.get(obj); if (mut == null) { return(false); } if (nCopies <= 0) { return(false); } modCount++; if (nCopies < mut.value) { mut.value -= nCopies; sizeJ -= nCopies; } else { map.remove(obj); sizeJ -= mut.value; } return(true); }
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 Residue(Reducer reducer, BigInteger x) : this(reducer) { r = reducer.CreateRep(); r.Set(x); reducer.Reduce(r); }
public virtual string ToString(NumberFormat nf) { StringBuilder sb = new StringBuilder(); sb.Append("{"); IList <E> list = new List <E>(map.Keys); try { (IList)list.Sort(); } catch (Exception) { } // see if it can be sorted for (IEnumerator <E> iter = list.GetEnumerator(); iter.MoveNext();) { object key = iter.Current; MutableInteger d = map[key]; sb.Append(key + "="); sb.Append(nf.Format(d)); if (iter.MoveNext()) { sb.Append(", "); } } sb.Append("}"); return(sb.ToString()); }
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); } } }
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 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 virtual void ParseHeader() { // Parse "@@ -236,9 +236,9 @@ protected boolean" // byte[] buf = file.buf; MutableInteger ptr = new MutableInteger(); ptr.value = RawParseUtils.NextLF(buf, startOffset, ' '); old.startLine = -RawParseUtils.ParseBase10(buf, ptr.value, ptr); if (buf[ptr.value] == ',') { old.lineCount = RawParseUtils.ParseBase10(buf, ptr.value + 1, ptr); } else { old.lineCount = 1; } newStartLine = RawParseUtils.ParseBase10(buf, ptr.value + 1, ptr); if (buf[ptr.value] == ',') { newLineCount = RawParseUtils.ParseBase10(buf, ptr.value + 1, ptr); } else { newLineCount = 1; } }
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); }
private static MutableInteger ActivationCounter(IObjectContainer container) { var activationCounter = new MutableInteger(); EventRegistryFactory.ForObjectContainer(container) .Activating += (sender, args) => activationCounter.Increment(); return(activationCounter); }
/// <exception cref="NGit.Errors.CorruptObjectException"></exception> internal virtual void SetType(string typeStr) { byte[] typeRaw = Constants.Encode(typeStr + " "); MutableInteger ptr = new MutableInteger(); this.type = Constants.DecodeTypeString(this.id, typeRaw, unchecked ((byte)' '), ptr ); }
internal DirCacheTree(byte[] @in, MutableInteger off, NGit.Dircache.DirCacheTree myParent) { parent = myParent; int ptr = RawParseUtils.Next(@in, off.value, '\0'); int nameLen = ptr - off.value - 1; if (nameLen > 0) { encodedName = new byte[nameLen]; System.Array.Copy(@in, off.value, encodedName, 0, nameLen); } else { encodedName = NO_NAME; } entrySpan = RawParseUtils.ParseBase10(@in, ptr, off); int subcnt = RawParseUtils.ParseBase10(@in, off.value, off); off.value = RawParseUtils.Next(@in, off.value, '\n'); if (entrySpan >= 0) { // Valid trees have a positive entry count and an id of a // tree object that should exist in the object database. // id = ObjectId.FromRaw(@in, off.value); off.value += Constants.OBJECT_ID_LENGTH; } if (subcnt > 0) { bool alreadySorted = true; children = new NGit.Dircache.DirCacheTree[subcnt]; for (int i = 0; i < subcnt; i++) { children[i] = new NGit.Dircache.DirCacheTree(@in, off, this); // C Git's ordering differs from our own; it prefers to // sort by length first. This sometimes produces a sort // we do not desire. On the other hand it may have been // created by us, and be sorted the way we want. // if (alreadySorted && i > 0 && TREE_CMP.Compare(children[i - 1], children[i]) > 0) { alreadySorted = false; } } if (!alreadySorted) { Arrays.Sort(children, 0, subcnt, TREE_CMP); } } else { // Leaf level trees have no children, only (file) entries. // children = NO_CHILDREN; } childCnt = subcnt; }
private void Reduce(MutableInteger t, MutableInteger u, MutableInteger v) { t.MontgomeryCIOS(u, v, nRep, k0); if (t >= nRep) { t.Subtract(nRep); } Debug.Assert(t < nRep); }
private void Reduce(MutableInteger t) { t.MontgomerySOS(nRep, k0); if (t >= nRep) { t.Subtract(nRep); } Debug.Assert(t < nRep); }
/** * Returns the number of occurrence of the given element in this bag * by looking up its count in the underlying map. * * @param object the object to search for * @return the number of occurrences of the object, zero if not found */ public virtual int getCount(Object obj) { MutableInteger count = (MutableInteger)map.get(obj); if (count != null) { return(count.value); } return(0); }
public Parameters(String alias, String connective, MutableInteger queryParamCounter) { this.alias = alias; this.connective = connective; this.queryParamCounter = queryParamCounter; subParameters = new List<Parameters>(); negatedParameters = new List<Parameters>(); expressions = new List<String>(); localQueryParamValues = new Dictionary<String, Object>(); }
public Parameters(String alias, String connective, MutableInteger queryParamCounter) { this.alias = alias; this.connective = connective; this.queryParamCounter = queryParamCounter; subParameters = new List <Parameters>(); negatedParameters = new List <Parameters>(); expressions = new List <String>(); localQueryParamValues = new Dictionary <String, Object>(); }
/// <summary> /// Returns the current count for the given key, which is 0 if it hasn't /// been /// seen before. /// </summary> /// <remarks> /// Returns the current count for the given key, which is 0 if it hasn't /// been /// seen before. This is a convenient version of /// <c>get</c> /// that casts /// and extracts the primitive value. /// </remarks> public virtual int GetIntCount(object key) { MutableInteger count = map[key]; if (count == null) { return(defaultValue); } // haven't seen this object before -> 0 count return(count); }
/** * Gets a hash code for the Bag compatible with the definition of equals. * The hash code is defined as the sum total of a hash code for each element. * The per element hash code is defined as * <code>(e==null ? 0 : e.hashCode()) ^ noOccurances)</code>. * This hash code is compatible with the Set interface. * * @return the hash code of the Bag */ public override int GetHashCode() { int total = 0; for (java.util.Iterator <java.util.MapNS.Entry <Object, Object> > it = map.entrySet().iterator(); it.hasNext();) { java.util.MapNS.Entry <Object, Object> entry = (java.util.MapNS.Entry <Object, Object>)it.next(); Object element = entry.getKey(); MutableInteger count = (MutableInteger)entry.getValue(); total += (element == null ? 0 : element.GetHashCode()) ^ count.value; } return(total); }
/** * Removes all copies of the specified object from the bag. * * @param object the object to remove * @return true if the bag changed */ public virtual bool remove(Object obj) { MutableInteger mut = (MutableInteger)map.get(obj); if (mut == null) { return(false); } modCount++; map.remove(obj); sizeJ -= mut.value; return(true); }
/// <summary> /// Returns the positional index of the left edge of a tree <i>t</i> /// within a given root, as defined by the size of the yield of all /// material preceding <i>t</i>. /// </summary> public static int LeftEdge(Tree t, Tree root) { MutableInteger i = new MutableInteger(0); if (LeftEdge(t, root, i)) { return(i); } else { throw new Exception("Tree is not a descendant of root."); } }
// return -1; /// <summary> /// Returns the positional index of the left edge of a tree <i>t</i> /// within a given root, as defined by the size of the yield of all /// material preceding <i>t</i>. /// </summary> /// <remarks> /// Returns the positional index of the left edge of a tree <i>t</i> /// within a given root, as defined by the size of the yield of all /// material preceding <i>t</i>. /// This method returns -1 if no path is found, rather than exceptioning. /// </remarks> /// <seealso cref="LeftEdge(Tree, Tree)"/> public static int LeftEdgeUnsafe(Tree t, Tree root) { MutableInteger i = new MutableInteger(0); if (LeftEdge(t, root, i)) { return(i); } else { return(-1); } }
// return root.yield().size() + 1; /// <summary> /// Returns the positional index of the right edge of a tree /// <i>t</i> within a given root, as defined by the size of the yield /// of all material preceding <i>t</i> plus all the material /// contained in <i>t</i>. /// </summary> /// <remarks> /// Returns the positional index of the right edge of a tree /// <i>t</i> within a given root, as defined by the size of the yield /// of all material preceding <i>t</i> plus all the material /// contained in <i>t</i>. /// This method returns root.yield().size() + 1 if no path is found, rather than exceptioning. /// </remarks> /// <seealso cref="RightEdge(Tree, Tree)"/> public static int RightEdgeUnsafe(Tree t, Tree root) { MutableInteger i = new MutableInteger(root.Yield().Count); if (RightEdge(t, root, i)) { return(i); } else { return(root.Yield().Count + 1); } }
/// <summary> /// Returns the positional index of the right edge of a tree /// <i>t</i> within a given root, as defined by the size of the yield /// of all material preceding <i>t</i> plus all the material /// contained in <i>t</i>. /// </summary> public static int RightEdge(Tree t, Tree root) { MutableInteger i = new MutableInteger(root.Yield().Count); if (RightEdge(t, root, i)) { return(i); } else { throw new Exception("Tree is not a descendant of root."); } }
/// <summary>Sets the current count for the given key.</summary> /// <remarks> /// Sets the current count for the given key. This will wipe out any existing /// count for that key. /// <p> /// To add to a count instead of replacing it, use /// <see cref="IntCounter{E}.IncrementCount(object, int)"/> /// . /// </remarks> public virtual void SetCount(E key, int count) { if (tempMInteger == null) { tempMInteger = new MutableInteger(); } tempMInteger.Set(count); tempMInteger = map[key] = tempMInteger; totalCount += count; if (tempMInteger != null) { totalCount -= tempMInteger; } }
/// <summary>Removes the given key from this Counter.</summary> /// <remarks> /// Removes the given key from this Counter. Its count will now be 0 and it /// will no longer be considered previously seen. /// </remarks> public override double Remove(E key) { totalCount -= GetCount(key); // subtract removed count from total (may be 0) MutableInteger val = Sharpen.Collections.Remove(map, key); if (val == null) { return(double.NaN); } else { return(val); } }
private QueryBuilder(String entityName, String alias, MutableInteger aliasCounter, MutableInteger paramCounter) { this.entityName = entityName; this.alias = alias; this.aliasCounter = aliasCounter; this.paramCounter = paramCounter; rootParameters = new Parameters(alias, "and", paramCounter); froms = new List <Pair <String, String> >(); orders = new List <Pair <String, Boolean> >(); projections = new List <String>(); AddFrom(entityName, alias); }
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; }