void VerifyEnumerator(IEnumerator <Quote> e, long tickStart, long tickEnd, IterationOrder order = IterationOrder.AscentOrder) { int n = 0; long tickCurr = 0; if (order == IterationOrder.DescentOrder) { tickCurr = long.MaxValue; } while (e.MoveNext()) { Quote q = e.Current; Tests.Assert(q.Ticks >= tickStart); Tests.Assert(q.Ticks <= tickEnd); // TODO: FAILED_TEST if (order == IterationOrder.AscentOrder) { Tests.Assert(q.Ticks >= tickCurr); } else { Tests.Assert(q.Ticks <= tickCurr); } tickCurr = q.Ticks; n++; } Tests.Assert(!e.MoveNext()); Tests.AssertException <InvalidOperationException>( () => { long ticks = e.Current.Ticks; }); e.Reset(); Tests.Assert(e.MoveNext()); }
/// <summary> /// Creates an instance whose range is the k-element subsets of /// {0, ..., n - 1} represented as <c>int[]</c> arrays. /// <para> /// If the <c>iterationOrder</c> argument is set to /// <see cref="IterationOrder.LEXICOGRAPHIC"/>, the arrays returned by the /// <see cref="iterator()"/> are sorted in descending order and /// they are visited in lexicographic order with significance from /// right to left. /// For example, <c>new Combinations(4, 2).iterator()</c> returns /// an iterator that will generate the following sequence of arrays /// on successive calls to /// <c>next()</c>:<para/> /// <c>[0, 1], [0, 2], [1, 2], [0, 3], [1, 3], [2, 3]</c> /// </para> /// If <c>k == 0</c> an iterator containing an empty array is returned; /// if <c>k == n</c> an iterator containing [0, ..., n - 1] is returned. /// /// </summary> /// <param name="n">Size of the set from which subsets are selected.</param> /// <param name="k">Size of the subsets to be enumerated.></param> /// <param name="iterationOrder">Specifies the <see cref="iterator()"/>.</param> /// <exception cref="NotPositiveException"> if <c>n < 0</c>.</exception> /// <exception cref="NumberIsTooLargeException"> if <c>k > n</c>.</exception> private Combinations(int n, int k, IterationOrder iterationOrder) { CombinatoricsUtils.checkBinomial(n, k); this.n = n; this.k = k; this.iterationOrder = iterationOrder; }
private IEnumerable iterator(long from, long till, IterationOrder order) { IEnumerator enumerator = index.GetEnumerator(from - maxBlockTimeInterval, till, order); return(order == IterationOrder.AscentOrder ? (IEnumerable) new TimeSeriesEnumerator(enumerator, from, till) : (IEnumerable) new TimeSeriesReverseEnumerator(enumerator, from, till)); }
private IEnumerable <T> iterator(long from, long till, IterationOrder order) { IEnumerable <TimeSeriesBlock> enumerable = index.Range(from - maxBlockTimeInterval, till, order); return(order == IterationOrder.AscentOrder ? (IEnumerable <T>) new TimeSeriesEnumerable(enumerable, from, till) : (IEnumerable <T>) new TimeSeriesReverseEnumerable(enumerable, from, till)); }
/// <summary> /// Get all items containing specified attribute in desired order /// </summary> /// <param name="name">attribute name</param> /// <param name="order">ascending or descending sort order</param> /// <returns>iterator through all items containing specified attribute or null if there is not such attribute in the database</returns> public IEnumerable <Item> GetOccurrences(String name, IterationOrder order) { checkIfActive(); int id; if (!db.name2id.TryGetValue(name, out id)) { return(null); } Index index = (Index)db.storage.GetObjectByOID(id); return(new Item.ItemEnumerable(index.Range(null, null, order))); }
static int VerifyDictionaryEnumerator(IDictionaryEnumerator de, IterationOrder order) { long prev = long.MinValue; if (order == IterationOrder.DescentOrder) { prev = long.MaxValue; } int i = 0; while (de.MoveNext()) { DictionaryEntry e1 = (DictionaryEntry)de.Current; DictionaryEntry e2 = de.Entry; Tests.Assert(e1.Equals(e2)); long k = (long)e1.Key; long k2 = (long)de.Key; Tests.Assert(k == k2); RecordFull v1 = (RecordFull)e1.Value; RecordFull v2 = (RecordFull)de.Value; Tests.Assert(v1.Equals(v2)); Tests.Assert(v1.Int32Val == k); if (order == IterationOrder.AscentOrder) { Tests.Assert(k >= prev); } else { Tests.Assert(k <= prev); } prev = k; i++; } Tests.VerifyDictionaryEnumeratorDone(de); return(i); }
static int VerifyDictionaryEnumerator(IDictionaryEnumerator de, IterationOrder order) { string prev = ""; if (order == IterationOrder.DescentOrder) { prev = "9999999999999999999"; } int i = 0; while (de.MoveNext()) { DictionaryEntry e1 = (DictionaryEntry)de.Current; DictionaryEntry e2 = de.Entry; Tests.Assert(e1.Equals(e2)); string k = (string)e1.Key; string k2 = (string)de.Key; Tests.Assert(k == k2); RecordFull v1 = (RecordFull)e1.Value; RecordFull v2 = (RecordFull)de.Value; Tests.Assert(v1.Equals(v2)); Tests.Assert(v1.StrVal == k); if (order == IterationOrder.AscentOrder) { Tests.Assert(k.CompareTo(prev) >= 0); } else { Tests.Assert(k.CompareTo(prev) <= 0); } prev = k; i++; } Tests.VerifyDictionaryEnumeratorDone(de); return(i); }
public IEnumerator GetEnumerator(object from, object till, IterationOrder order) #endif { return(Range(from, till, order).GetEnumerator()); }
void VerifyEnumerator(IEnumerator<Quote> e, long tickStart, long tickEnd, IterationOrder order = IterationOrder.AscentOrder) { int n = 0; long tickCurr = 0; if (order == IterationOrder.DescentOrder) tickCurr = long.MaxValue; while (e.MoveNext()) { Quote q = e.Current; Tests.Assert(q.Ticks >= tickStart); Tests.Assert(q.Ticks <= tickEnd); // TODO: FAILED_TEST if (order == IterationOrder.AscentOrder) Tests.Assert(q.Ticks >= tickCurr); else Tests.Assert(q.Ticks <= tickCurr); tickCurr = q.Ticks; n++; } Tests.Assert(!e.MoveNext()); Tests.AssertException<InvalidOperationException>( () => { long ticks = e.Current.Ticks; }); e.Reset(); Tests.Assert(e.MoveNext()); }
/// <summary> /// Constructor of order-by component with specified sort order /// </summary> /// <param name="name">attribute name</param> /// <param name="order">sort ascending or descebding sort order</param> public OrderBy(String name, IterationOrder order) { this.name = name; this.order = order; }
public IEnumerable <V> Range(K from, K till, IterationOrder order)
public IEnumerable Range(DateTime from, DateTime till, IterationOrder order) { return(iterator(from.Ticks, till.Ticks, order)); }
public IEnumerator <V> GetEnumerator(K from, K till, IterationOrder order)
public IEnumerator <T> GetEnumerator(DateTime from, DateTime till, IterationOrder order)
public IEnumerator <T> GetEnumerator(IterationOrder order)
public IEnumerable StartsWith(string prefix, IterationOrder order) #endif { return(new ExtendEnumerable(index.StartsWith(transformStringKey(prefix), order))); }
public virtual IDictionaryEnumerator GetDictionaryEnumerator(Key from, Key till, IterationOrder order) { return(new ExtendDictionaryEnumerator(index.GetDictionaryEnumerator(transformKey(from), transformKey(till), order))); }
public IEnumerable <V> StartsWith(string prefix, IterationOrder order)
IEnumerable GenericIndex.StartsWith(string prefix, IterationOrder order) { return((IEnumerable)StartsWith(prefix, order)); }
public IEnumerable Range(object from, object till, IterationOrder order) #endif { return(Range(KeyBuilder.getKeyFromObject(from), KeyBuilder.getKeyFromObject(till), order)); }
public IEnumerator GetEnumerator(DateTime from, DateTime till, IterationOrder order) { return(iterator(from.Ticks, till.Ticks, order).GetEnumerator()); }
public virtual IEnumerable Range(Key from, Key till, IterationOrder order) #endif { return(new ExtendEnumerable(index.Range(transformKey(from), transformKey(till), order))); }
public IEnumerator GetEnumerator(IterationOrder order) { return(iterator(0, Int64.MaxValue, order).GetEnumerator()); }
public override IEnumerable Range(Key from, Key till, IterationOrder order) #endif { return(base.Range(convertKey(from), convertKey(till), order)); }
public IEnumerable Range(IterationOrder order) { return(iterator(0, Int64.MaxValue, order)); }
static int VerifyDictionaryEnumerator(IDictionaryEnumerator de, IterationOrder order) { long prev = long.MinValue; if (order == IterationOrder.DescentOrder) prev = long.MaxValue; int i = 0; while (de.MoveNext()) { DictionaryEntry e1 = (DictionaryEntry)de.Current; DictionaryEntry e2 = de.Entry; Tests.Assert(e1.Equals(e2)); long k = (long)e1.Key; long k2 = (long)de.Key; Tests.Assert(k == k2); RecordFull v1 = (RecordFull)e1.Value; RecordFull v2 = (RecordFull)de.Value; Tests.Assert(v1.Equals(v2)); Tests.Assert(v1.Int32Val == k); if (order == IterationOrder.AscentOrder) Tests.Assert(k >= prev); else Tests.Assert(k <= prev); prev = k; i++; } Tests.VerifyDictionaryEnumeratorDone(de); return i; }
public virtual IEnumerable <V> Range(Key from, Key till, IterationOrder order)
public IEnumerable <T> Range(DateTime from, DateTime till, IterationOrder order)
IEnumerable GenericIndex.Range(Key from, Key till, IterationOrder order) { return((IEnumerable)Range(from, till, order)); }
public override IEnumerable <T> Range(Key from, Key till, IterationOrder order)
public IEnumerable <T> Range(IterationOrder order)
public override IDictionaryEnumerator GetDictionaryEnumerator(Key from, Key till, IterationOrder order) { return(base.GetDictionaryEnumerator(convertKey(from), convertKey(till), order)); }
static int VerifyDictionaryEnumerator(IDictionaryEnumerator de, IterationOrder order) { string prev = ""; if (order == IterationOrder.DescentOrder) prev = "9999999999999999999"; int i = 0; while (de.MoveNext()) { DictionaryEntry e1 = (DictionaryEntry)de.Current; DictionaryEntry e2 = de.Entry; Tests.Assert(e1.Equals(e2)); string k = (string)e1.Key; string k2 = (string)de.Key; Tests.Assert(k == k2); RecordFull v1 = (RecordFull)e1.Value; RecordFull v2 = (RecordFull)de.Value; Tests.Assert(v1.Equals(v2)); Tests.Assert(v1.StrVal == k); if (order == IterationOrder.AscentOrder) Tests.Assert(k.CompareTo(prev) >= 0); else Tests.Assert(k.CompareTo(prev) <= 0); prev = k; i++; } Tests.VerifyDictionaryEnumeratorDone(de); return i; }