public void Evaluate(int SpreadMax)
{
Output1.SliceCount = Input.SliceCount;
Output2.SliceCount = Input.SliceCount;
for (var spread = 0; spread < Input.SliceCount; spread++)
{
var pairs = SeqModule.Pairwise(Input[spread]).ToArray();
Output1[spread].SliceCount = pairs.Length;
Output2[spread].SliceCount = pairs.Length;
for (var i = 0; i < pairs.Length; i++)
{
var pair = pairs[i];
Output1[spread][i] = pair.Item1;
Output2[spread][i] = pair.Item2;
}
}
}
Tuple <IIndex <TNewKey>, IVector <R> > IIndexBuilder.Resample <K, TNewKey, R>(IIndexBuilder chunkBuilder, IIndex <K> index, IEnumerable <K> keys, Deedle.Direction dir, VectorConstruction vector, Func <Tuple <K, Tuple <IIndex <K>, VectorConstruction> >, Tuple <TNewKey, R> > selector)
{
if (!index.IsOrdered)
{
throw new InvalidOperationException("Resampling is only supported on ordered indices");
}
IIndexBuilder indexBuilder = (IIndexBuilder)this;
IEnumerable <M1> m1s;
if (dir == Deedle.Direction.Forward)
{
IEnumerable <Tuple <K, long> > tuples = (IEnumerable <Tuple <K, long> >)SeqModule.Map <K, Tuple <K, long> >((Func <M0, M1>) new LinearIndex.keyLocations <K>(index), keys);
m1s = SeqModule.MapIndexed <Tuple <Tuple <K, long>, Tuple <K, long> >, Tuple <K, Tuple <long, long> > >((Func <int, Func <M0, M1> >) new LinearIndex.locations <K>(index), (IEnumerable <M0>)SeqModule.Pairwise <Tuple <K, long> >(SeqModule.Append <Tuple <K, long> >((IEnumerable <M0>)tuples, (IEnumerable <M0>)FSharpList <Tuple <K, long> > .Cons(new Tuple <K, long>(default(K), Addressing.LinearAddress.invalid), FSharpList <Tuple <K, long> > .get_Empty()))));
}
else
{
int keyLen = SeqModule.Length <K>(keys);
IEnumerable <Tuple <K, long> > tuples = (IEnumerable <Tuple <K, long> >)SeqModule.Map <K, Tuple <K, long> >((Func <M0, M1>) new LinearIndex.keyLocations <K>(index), keys);
m1s = SeqModule.MapIndexed <Tuple <Tuple <K, long>, Tuple <K, long> >, Tuple <K, Tuple <long, long> > >((Func <int, Func <M0, M1> >) new LinearIndex.locations <K>(index, keyLen), (IEnumerable <M0>)SeqModule.Pairwise <Tuple <K, long> >(SeqModule.Append <Tuple <K, long> >((IEnumerable <M0>)FSharpList <Tuple <K, long> > .Cons(new Tuple <K, long>(default(K), Addressing.LinearAddress.invalid), FSharpList <Tuple <K, long> > .get_Empty()), (IEnumerable <M0>)tuples)));
}
Tuple <K, Tuple <long, long> >[] tupleArray1 = (Tuple <K, Tuple <long, long> >[])ArrayModule.OfSeq <Tuple <K, Tuple <long, long> > >((IEnumerable <M0>)m1s);
Func <Tuple <K, Tuple <long, long> >, Tuple <K, Tuple <IIndex <K>, VectorConstruction> > > Func1 = (Func <Tuple <K, Tuple <long, long> >, Tuple <K, Tuple <IIndex <K>, VectorConstruction> > >) new LinearIndex.vectorConstructions <K>(chunkBuilder, index);
Tuple <K, Tuple <long, long> >[] tupleArray2 = tupleArray1;
if ((object)tupleArray2 == null)
{
throw new ArgumentNullException("array");
}
Tuple <K, Tuple <IIndex <K>, VectorConstruction> >[] tupleArray3 = new Tuple <K, Tuple <IIndex <K>, VectorConstruction> > [tupleArray2.Length];
for (int index1 = 0; index1 < tupleArray3.Length; ++index1)
{
tupleArray3[index1] = Func1.Invoke(tupleArray2[index1]);
}
Tuple <K, Tuple <IIndex <K>, VectorConstruction> >[] tupleArray4 = tupleArray3;
Func <Tuple <K, Tuple <IIndex <K>, VectorConstruction> >, Tuple <TNewKey, R> > Func2 = selector;
Tuple <K, Tuple <IIndex <K>, VectorConstruction> >[] tupleArray5 = tupleArray4;
if ((object)tupleArray5 == null)
{
throw new ArgumentNullException("array");
}
Tuple <TNewKey, R>[] tupleArray6 = new Tuple <TNewKey, R> [tupleArray5.Length];
for (int index1 = 0; index1 < tupleArray6.Length; ++index1)
{
tupleArray6[index1] = Func2.Invoke(tupleArray5[index1]);
}
Tuple <TNewKey, R>[] tupleArray7 = tupleArray6;
IIndex <TNewKey> index2 = indexBuilder.Create <TNewKey>(SeqModule.Map <Tuple <TNewKey, R>, TNewKey>((Func <M0, M1>) new LinearIndex.newIndex <TNewKey, R>(), (IEnumerable <M0>)tupleArray7), (FSharpOption <bool>)null);
IVectorBuilder vectorBuilder1 = this.vectorBuilder;
Func <Tuple <TNewKey, R>, R> Func3 = (Func <Tuple <TNewKey, R>, R>) new LinearIndex.vect <TNewKey, R>();
Tuple <TNewKey, R>[] tupleArray8 = tupleArray7;
if ((object)tupleArray8 == null)
{
throw new ArgumentNullException("array");
}
R[] optionalValueArray = new R[tupleArray8.Length];
IVectorBuilder vectorBuilder2 = vectorBuilder1;
for (int index1 = 0; index1 < optionalValueArray.Length; ++index1)
{
optionalValueArray[index1] = Func3.Invoke(tupleArray8[index1]);
}
IVector <R> missing = vectorBuilder2.CreateMissing <R>(optionalValueArray);
return(new Tuple <IIndex <TNewKey>, IVector <R> >(index2, missing));
}
public Filter ThingsShareItemsEfficiently(int numberOfThings)
{
return(testVariableIndexToLevelNumberAndItemIndexMap =>
{
const int numberOfTestVariablesDefiningAThing = 3;
const int offsetOfTestVariableIndexForAnItemIndexLevel = 0;
var itemIndexAndPositionPairsFromHistories =
(from testVariableIndexToLevelNumberAndLevelValuePair in
testVariableIndexToLevelNumberAndItemIndexMap
let testVariableLevelIndex = testVariableIndexToLevelNumberAndLevelValuePair.Key
where
offsetOfTestVariableIndexForAnItemIndexLevel ==
testVariableLevelIndex % numberOfTestVariablesDefiningAThing
select
new
{
ItemIndex = (int)testVariableIndexToLevelNumberAndLevelValuePair.Value.Item2,
PositionOfItemIndex = testVariableLevelIndex / numberOfTestVariablesDefiningAThing
})
.ToList();
var itemIndicesFromHistories =
(from itemIndexAndPosition in itemIndexAndPositionPairsFromHistories
select itemIndexAndPosition.ItemIndex).ToList();
var itemIndexPositionsFromHistories =
(from itemIndexAndPosition in itemIndexAndPositionPairsFromHistories
select itemIndexAndPosition.PositionOfItemIndex).ToList();
if (!itemIndicesFromHistories.Any())
{
return true;
}
if (!BargainBasement.IsSorted(itemIndicesFromHistories))
{
return false;
}
var minimumItemIndex = itemIndicesFromHistories.Min();
var maximumItemIndex = itemIndicesFromHistories.Max();
var minimumItemIndexPosition = itemIndexPositionsFromHistories.Min();
var maximumItemIndexPosition = itemIndexPositionsFromHistories.Max();
var itemIndicesCanBeAligned =
itemIndicesFromHistories.Zip(itemIndexPositionsFromHistories, (index, position) => index <= position)
.All(outcome => outcome);
if (!itemIndicesCanBeAligned)
{
return false;
}
var itemIndicesAreEitherContiguousOrCanMadeSoWithInsertions =
SeqModule.Pairwise(itemIndicesFromHistories)
.Select(pairOfAdjacentIndices => pairOfAdjacentIndices.Item2 - pairOfAdjacentIndices.Item1)
.Zip(
SeqModule.Pairwise(itemIndexPositionsFromHistories)
.Select(
pairOfAdjacentPositions =>
pairOfAdjacentPositions.Item2 - pairOfAdjacentPositions.Item1),
(indexDelta, indexPositionDelta) => indexDelta <= indexPositionDelta)
.All(outcome => outcome);
if (!itemIndicesAreEitherContiguousOrCanMadeSoWithInsertions)
{
return false;
}
var numberOfItemIndexPositions = itemIndexPositionsFromHistories.Count();
var noPositionGapsToPlaceExtraItemIndices = numberOfItemIndexPositions ==
1 + maximumItemIndexPosition - minimumItemIndexPosition;
var itemIndicesAreContiguous = itemIndicesFromHistories.Distinct().Count() ==
1 + maximumItemIndex - minimumItemIndex;
if (!itemIndicesAreContiguous && noPositionGapsToPlaceExtraItemIndices)
{
return false;
}
if (itemIndicesAreContiguous && noPositionGapsToPlaceExtraItemIndices)
{
if (numberOfItemIndexPositions == numberOfThings)
{
return
BargainBasement.IsSorted(
itemIndicesFromHistories.GroupBy(itemIndex => itemIndex).Select(group => group.Count()));
}
if (numberOfItemIndexPositions > 2)
{
return
BargainBasement.IsSorted(
itemIndicesFromHistories.Skip(1)
.Take(numberOfItemIndexPositions - 2)
.GroupBy(itemIndex => itemIndex)
.Select(group => group.Count()));
}
}
return true;
});
}
