public void LongRange_ConstructorWithoutStepParam_StepDefaultsToOne()
{
long length = RandomLong(1, long.MaxValue);
long start = RandomLong(long.MinValue, long.MaxValue - length);
long end = start + length;
LongRange longRange = new LongRange(start, end);
Assert.AreEqual(start, longRange.Start, "Starting point field must match the value supplied");
Assert.AreEqual(end, longRange.End, "End point field must match the value supplied");
Assert.AreEqual(1, longRange.Step, "Step amount must default to one");
}
public void validate_multi_count_returns_multiple_values_for_matched_start_stop()
{
var r = new LongRange(10L, 10L, 3);
var values = r.AsEnumerable().ToArray();
Assert.AreEqual(values.Length, 3);
for (int i = 0; i < values.Length; i++)
{
Assert.AreEqual(values[i], 10L);
}
}
public override ValidationResult Validate(object value, System.Globalization.CultureInfo cultureInfo)
{
LongRange lr;
if (LongRange.TryParse(value as string, out lr))
{
return(new ValidationResult(true, null));
}
else
{
return(new ValidationResult(false, "数値範囲に変換できません。"));
}
}
public void validate_deserialized_class_is_correct()
{
var r = new LongRange(0L, 9L, 10);
var deserializedR = Clone(r);
Assert.IsNotNull(deserializedR);
Assert.AreEqual(deserializedR.Start, 0L);
Assert.AreEqual(deserializedR.Stop, 9L);
Assert.AreEqual(deserializedR.Delta, 1L);
Assert.AreEqual(deserializedR.Count, 10);
}
public void CreateOnISeqWithManyItemsWorks()
{
// Want to bust out of the first tail, so need to insert more than 32 elements.
ISeq r = LongRange.create(2, 1000);
PersistentVector v = PersistentVector.create(r);
Expect(v.count(), EqualTo(r.count()));
for (int i = 0; i < v.count(); ++i)
{
Expect(v.nth(i), EqualTo(i + 2));
}
}
public void LongRange_StepIsLargerThanLongRange_ParametersMatchThoseGiven()
{
long length = RandomLong(1, long.MaxValue / 2);
long start = RandomLong(long.MinValue, long.MaxValue - length);
long end = start + length;
long step = length + RandomLong(1, long.MaxValue / 3);
LongRange longRange = new LongRange(start, end, step);
Assert.AreEqual(start, longRange.Start, "Starting point field must match the value supplied");
Assert.AreEqual(end, longRange.End, "End point field must match the value supplied");
Assert.AreEqual(step, longRange.Step, "Step amount field must match the value supplied");
}
public GroupInfo[] Marge(GroupInfo[][] summaryInfos)
{
for (int i = 0; i < Consts.MaxGroupsCount; i++)
{
int j = 0;
var acc = default(GroupInfo);
while (j < summaryInfos.Length &&
GroupInfo.IsZero(acc = summaryInfos[j++][i]))
{
;
}
var mappingBlocksCount = 0;
while (j < summaryInfos.Length)
{
var info = summaryInfos[j++][i];
if (!GroupInfo.IsZero(info))
{
mappingBlocksCount += info.Mapping.Count;
acc.BytesCount += info.BytesCount;
acc.LinesCount += info.LinesCount;
}
}
if (!GroupInfo.IsZero(acc))
{
if (mappingBlocksCount != 0)
{
int k = 0;
var mapping = new LongRange[mappingBlocksCount + acc.Mapping.Count];
for (j = 0; j < summaryInfos.Length; j++)
{
var infoMapping = summaryInfos[j][i].Mapping;
if (infoMapping != null)
{
for (int h = 0; h < infoMapping.Count; h++, k++)
{
mapping[k] = infoMapping[h];
}
}
}
acc.Mapping = mapping;
}
summaryInfos[0][i] = acc;
}
}
return(summaryInfos[0]);
}
public override LongRange GetFinishRange()
{
if (this.finish == null)
{
YarnServiceProtos.GetApplicationsRequestProtoOrBuilder p = viaProto ? proto : builder;
if (p.HasFinishBegin() || p.HasFinishEnd())
{
long begin = p.HasFinishBegin() ? p.GetFinishBegin() : 0L;
long end = p.HasFinishEnd() ? p.GetFinishEnd() : long.MaxValue;
this.finish = new LongRange(begin, end);
}
}
return(this.finish);
}
public void PopOnBigWorks()
{
ISeq r = LongRange.create(0, 100000);
PersistentVector v = PersistentVector.create(r);
IPersistentStack s = v;
for (int i = 16; i < 100000; i++)
{
s = s.pop();
}
Expect(v.count(), EqualTo(r.count()));
Expect(s.count(), EqualTo(16));
}
public void LongRange_UsingLargestPossibleParameters_IteratesSuccessfully()
{
// Step chosen to avoid an unfeasible number of iterations
LongRange longRange = new LongRange(long.MinValue, long.MaxValue, long.MaxValue / 16);
bool iterated = false;
foreach (long i in longRange)
{
iterated = true;
}
Assert.AreEqual(true, iterated, "When iterating across full range, at least one value should be returned");
}
public static IEnumerable <object[]> LongScalarData()
{
yield return(new object[] { LongRange.Of(0, 1) });
yield return(new object[] { LongRange.Of(0, 10) });
yield return(new object[] { LongRange.Of(1, 2) });
yield return(new object[] { LongRange.Of(0, 100) });
yield return(new object[] { LongRange.Of(10, 1000) });
yield return(new object[] { LongRange.Of(1000, 10000) });
}
public void CreateOnISeqWithManyManyItemsWorks()
{
// Want to bust out of the first tail, so need to insert more than 32 elements.
// Let's get out of the second level, too.
ISeq r = LongRange.create(2, 100000);
PersistentVector v = PersistentVector.create(r);
Expect(v.count()).To.Equal(r.count());
for (int i = 0; i < v.count(); ++i)
{
Expect((long)v.nth(i)).To.Equal(i + 2L);
}
}
public void OfLongScalar(LongRange domain)
{
var codec = Codecs.OfScalar(domain);
var gt = codec.Encoding()();
Assert.Equal(1, gt.Length);
Assert.Equal(1, gt.GetChromosome().Length);
Assert.Equal(domain.Min, gt.Gene.Min);
Assert.Equal(domain.Max, gt.Gene.Max);
var f = codec.Decoder();
Assert.Equal(gt.Gene.LongValue(), f(gt));
}
public void AssocNReplacesInRangeForSmall()
{
ISeq r = LongRange.create(2, 5);
PersistentVector v1 = PersistentVector.create(r);
IPersistentVector v2 = v1.assocN(1, 10L);
Expect((long)v1.nth(0)).To.Equal(2);
Expect((long)v1.nth(1)).To.Equal(3);
Expect((long)v1.nth(2)).To.Equal(4);
Expect((long)v1.count()).To.Equal(3);
Expect((long)v2.nth(0)).To.Equal(2);
Expect((long)v2.nth(1)).To.Equal(10);
Expect((long)v2.nth(2)).To.Equal(4);
Expect((long)v2.count()).To.Equal(3);
}
public void AssocNReplacesInRangeForSmall()
{
ISeq r = LongRange.create(2, 5);
PersistentVector v1 = PersistentVector.create(r);
IPersistentVector v2 = v1.assocN(1, 10);
Expect(v1.nth(0), EqualTo(2));
Expect(v1.nth(1), EqualTo(3));
Expect(v1.nth(2), EqualTo(4));
Expect(v1.count(), EqualTo(3));
Expect(v2.nth(0), EqualTo(2));
Expect(v2.nth(1), EqualTo(10));
Expect(v2.nth(2), EqualTo(4));
Expect(v2.count(), EqualTo(3));
}
public static void Main()
{
var domain1 = IntRange.Of(0, 100);
var domain2 = LongRange.Of(0, 1000000000000L);
var domain3 = DoubleRange.Of(0, 1);
var codec = Codec(domain1, domain2, domain3);
var engine = Engine.Engine.Builder(F, codec).Build();
var gt = engine.Stream().Take(100).ToBestGenotype();
var param = codec.Decoder()(gt);
Console.WriteLine($"Result:\t{param}");
}
public static long OutputLongRange(LongRange name)
{
switch (name)
{
case LongRange.Max:
{
return((long)LongRange.Max);
}
case LongRange.Min:
{
return((long)LongRange.Min);
}
default:
{
return(default(long));
}
}
}
public void AssocNChangesForBig()
{
ISeq r = LongRange.create(2, 100000);
PersistentVector v1 = PersistentVector.create(r);
IPersistentVector v2 = v1;
for (int i = 0; i < 110000; i++)
{
v2 = v2.assocN(i, i + 20);
}
for (int i = 0; i < v1.count(); ++i)
{
Expect(v1.nth(i), EqualTo(i + 2));
}
for (int i = 0; i < v2.count(); ++i)
{
Expect(v2.nth(i), EqualTo(i + 20));
}
}
public void LongRange_Iterating_ValuesStayWithinRange()
{
long length = RandomLong(1, long.MaxValue);
long start = RandomLong(long.MinValue, long.MaxValue - length);
long end = start + length;
// note that the number of steps is limited to 100 or fewer
long step = length / RandomLong(4, Math.Max(4, Math.Min(length / 2, 100)));
// nsure the step is at least 1 (as length of less than four causes it to round down to zero)
if (step < 1)
{
step = 1;
}
LongRange longRange = new LongRange(start, end, step);
foreach (long i in longRange)
{
Assert.IsTrue(i >= start, "Value from iterator must by equal or above start parameter");
Assert.IsTrue(i <= end, "Value from iterator must be equal or below end parameter");
}
}
public void AssocNChangesForBig()
{
ISeq r = LongRange.create(2, 100000);
PersistentVector v1 = PersistentVector.create(r);
IPersistentVector v2 = v1;
for (int i = 0; i < 110000; i++)
{
v2 = v2.assocN(i, i + 20L);
}
for (int i = 0; i < v1.count(); ++i)
{
Expect((long)v1.nth(i)).To.Equal(i + 2L);
}
for (int i = 0; i < v2.count(); ++i)
{
object o = v2.nth(i);
Expect(o).To.Be.An.Instance.Of <long>();
Expect((long)o).To.Equal(i + 20L);
}
}
public FilterStatusId(long pivot, bool getStatus)
{
this.Range = LongRange.FromPivotValue(pivot);
if (getStatus)
{
if (TweetStorage.Contains(pivot) != TweetExistState.Exists)
{
Task.Factory.StartNew(() =>
{
try
{
var status = ApiHelper.ExecApi(() => AccountStorage.GetRandom().GetStatus(pivot));
if (status != null)
{
TweetStorage.Register(status);
RaisePartialRequireReaccept(status);
}
}
catch { }
});
}
}
}
private static ICodec <Tuple <int, long, double>, DoubleGene> Codec(IntRange v1Domain, LongRange v2Domain, DoubleRange v3Domain)
{
return(Engine.Codec.Of(
() => Genotype.Of(
DoubleChromosome.Of(DoubleRange.Of(v1Domain.Min, v1Domain.Max)),
DoubleChromosome.Of(DoubleRange.Of(v2Domain.Min, v2Domain.Max)),
DoubleChromosome.Of(v3Domain)
),
gt => Tuple.Create(
gt.GetChromosome(0).GetGene().IntValue(),
gt.GetChromosome(0).GetGene().LongValue(),
gt.GetChromosome(0).GetGene().DoubleValue())
));
}
public void Setup()
{
_createFn = (start, end) => (object)LongRange.create((long)start, (long)end);
}
public CatergorySelectorIntRange(XmlNode node)
: base(node)
{
Range = new LongRange(node.ReadStr("@intrange"));
}
public SqlLongRange(LongRange range)
{
_value = range;
}
public FilterFavoriteCount(LongRange range) : this()
{
this.Range = range;
}
public static SqlLongRange Parse(SqlString s)
{
return(s.IsNull ? Null : new SqlLongRange(LongRange.Parse(s.Value)));
}
public virtual bool Equals(LongRange other)
{
return(this.Min == other.Min && this.Max == other.Max);
}
public FilterFavoriteCount(long pivot) : this()
{
this.Range = LongRange.FromPivotValue(pivot);
}
public FilterRetweetCount(long pivot)
: this()
{
this.Range = LongRange.FromPivotValue(pivot);
}
