public IObservable <Mat> Process(IObservable <Tuple <short, short, short, short, short, short> > source)
{
var skip = Skip;
var sourceBuffer = skip.HasValue ? source.Buffer(Count, skip.Value) : source.Buffer(Count);
return(sourceBuffer.Select(buffer => Mat.FromArray(ToArray(buffer))));
}
public static void TimedWindowsWithBuffer()
{
IObservable <int> wordGroupCounts =
from wordGroup in words.Buffer(TimeSpan.FromSeconds(6))
select wordGroup.Count * 10;
wordGroupCounts.Subscribe(c => Console.WriteLine("Words per minute: " + c));
keySource.Run();
}
/// <summary>
/// Projects each element of an observable sequence into zero or more buffers
/// based on element count information.
/// </summary>
/// <typeparam name="TSource">The type of the elements in the source sequence.</typeparam>
/// <param name="source">The source sequence to produce buffers over.</param>
/// <returns>An observable sequence of buffers.</returns>
public IObservable <IList <TSource> > Process <TSource>(IObservable <TSource> source)
{
var skip = Skip;
if (skip.HasValue)
{
return(source.Buffer(Count, skip.Value));
}
else
{
return(source.Buffer(Count));
}
}
public MainWindow()
{
IObservable <EventPattern <MouseEventArgs> > move = Observable.FromEventPattern <MouseEventArgs>(this, "MouseMove");
IObservable <int> data = from evt in move select(int) evt.EventArgs.GetPosition(this).X;
var stats = data.Buffer(50, 1).Scan(0, (cur, acc) =>
{
stdDev = acc.StdDev();
mean = acc.Average();
return(0);
});
stats.Subscribe();
Dictionary <string, IObservable <int> > rules = new Dictionary <string, IObservable <int> >();
rules.Add("Rule1", data.Buffer(1, 1).Scan(0, (cur, acc) => (Math.Abs((acc.Last() - mean)) > Math.Abs(((3 * stdDev) - mean))) ? 1 : 0));
rules.Add("Rule2", data.Buffer(9, 1).Scan(0, (cur, acc) => (acc.All(x => x < mean) || acc.All(x => x > mean)) ? 1 : 0));
rules.Add("Rule3", data.Buffer(6, 1).Scan(0, (cur, acc) => (acc.IsDecreasing() || acc.IsIncreasing()) ? 1 : 0));
rules.Add("Rule4", data.Buffer(14, 1).Scan(0, (cur, acc) => (acc.Where((x, i) => i % 2 == 0).All(p => p > mean) ||
acc.Where((x, i) => i % 2 == 0).All(p => p < mean)) ? 1 : 0));
rules.Add("Rule5", data.Buffer(3, 1).Scan(0, (cur, acc) => (((acc.Where(p => p > mean).Where(p => Math.Abs(p - mean) > (2 * stdDev)).Count() > 1) ||
(acc.Where(p => p < mean).Where(p => Math.Abs(p - mean) > (2 * stdDev)).Count() > 1)))
? 1 : 0));
rules.Add("Rule6", data.Buffer(5, 1).Scan(0, (cur, acc) => (((acc.Where(p => p > mean).Where(p => Math.Abs(p - mean) > stdDev).Count() > 3) ||
(acc.Where(p => p < mean).Where(p => Math.Abs(p - mean) > stdDev).Count() > 3)))
? 1 : 0));
rules.Add("Rule7", data.Buffer(15, 1).Scan(0, (cur, acc) => (((acc.Where(p => p > mean).Where(p => Math.Abs(p - mean) < stdDev).Count() > 14) ||
(acc.Where(p => p < mean).Where(p => Math.Abs(p - mean) < stdDev).Count() > 14)))
? 1 : 0));
rules.Add("Rule8", data.Buffer(8, 1).Scan(0, (cur, acc) => ((acc.Where(p => p >= mean).Count() < 8 && acc.Where(p => p <= mean).Count() < 8) &&
(acc.Count(p => (Math.Abs(p - mean) < stdDev)) > 7))
? 1 : 0));
_results = new ObservableCollection <ItemEntry>();
for (int i = 1; i <= 8; i++)
{
_results.Add(new ItemEntry("Rule" + i, false));
}
for (int p = 0; p <= 7; p++)
{
ItemEntry e = _results[p];
rules["Rule" + (p + 1)].Subscribe(x => e.IsSelected = (x == 1) ? true : false);
}
this.DataContext = this;
}
/// <summary>
/// ZLEMA = EMA of (close + (close-close[lag]))
/// </summary>
/// <param name="source"></param>
/// <param name="period"></param>
/// <returns></returns>
public static IObservable <double> ZLEMA(this IObservable <double> source, uint period)
{
int lagP = (int)(period - 1) / 2;
lagP = lagP + 1;
return(source.Buffer(lagP, 1).Where(x => x.Count == lagP).Select(x => 2 * x[lagP - 1] - x[0]).EMA(period));
}
public BME280Sensor(I2CBusPI bus, IObservable <Unit> pollingTrigger)
{
var sensor = new BoschDevices.BME280Sensor(bus, 1014);
var delay = TimeSpan.FromMilliseconds(500);
CurrentTemperature = pollingTrigger.Buffer(delay).Select(_ => (double)sensor.ReadTemperature().Result);
}
public IObservable <IChangeSet <TObject> > Run()
{
return(Observable.Create <IChangeSet <TObject> >(
observer =>
{
var locker = new object();
var allItems = new List <ObjWithFilterValue>();
var shared = _source.Synchronize(locker).Transform(v => new ObjWithFilterValue(v, true)) // we default to true (include all items)
.Clone(allItems) // clone all items so we can look up the index when a change has been made
.Publish();
// monitor each item observable and create change, carry the value of the observable property
IObservable <ObjWithFilterValue> itemHasChanged = shared.MergeMany(v => _filter(v.Obj).Select(prop => new ObjWithFilterValue(v.Obj, prop)));
// create a change set, either buffered or one item at the time
IObservable <IEnumerable <ObjWithFilterValue> > itemsChanged = _buffer is null ?
itemHasChanged.Select(t => new[] { t }) :
itemHasChanged.Buffer(_buffer.Value, _scheduler ?? Scheduler.Default).Where(list => list.Count > 0);
IObservable <IChangeSet <ObjWithFilterValue> > requiresRefresh = itemsChanged.Synchronize(locker).Select(
items =>
{
// catch all the indices of items which have been refreshed
return IndexOfMany(allItems, items, v => v.Obj, (t, idx) => new Change <ObjWithFilterValue>(ListChangeReason.Refresh, t, idx));
}).Select(changes => new ChangeSet <ObjWithFilterValue>(changes));
// publish refreshes and underlying changes
var publisher = shared.Merge(requiresRefresh).Filter(v => v.Filter).Transform(v => v.Obj).SuppressRefresh() // suppress refreshes from filter, avoids excessive refresh messages for no-op filter updates
.SubscribeSafe(observer);
return new CompositeDisposable(publisher, shared.Connect());
}));
}
/// <summary>
/// Buffers a sequence of characters based on a pair of delimiters.
/// </summary>
/// <param name="source">The source sequence.</param>
/// <param name="initiator">The initiator character. Optional; default is ':'."</param>
/// <param name="terminator">The terminator character. Optional; default is '#'."</param>
/// <returns><see cref="IObservable{T}" /> - an observable sequence of buffers.</returns>
public static IObservable <IList <char> > BufferByDelimiters(IObservable <char> source, char initiator = ':',
char terminator = '#')
{
Contract.Requires(source != null);
Contract.Ensures(Contract.Result <IObservable <IList <char> > >() != null);
return(source.Buffer(source.Where(c => c == initiator), x => source.Where(c => c == terminator)));
}
public static IObservable <IList <T> > Buffer <T>(
this IObservable <T> source, TimeSpan?timeSpan, int?count, IScheduler scheduler)
{
if (!timeSpan.HasValue)
{
return(count.HasValue ? source.Buffer(count.Value) : source.ToList());
}
// Need to consider timespan
if (!count.HasValue) // No count either
{
return(scheduler is null?source.Buffer(timeSpan.Value) : source.Buffer(timeSpan.Value, scheduler));
}
return(scheduler is null
? source.Buffer(timeSpan.Value, count.Value)
: Observable.Buffer(source, timeSpan.Value, count.Value, scheduler));
}
public IObservable<FileSystemChange> Configure(IObservable<FileSystemChange> observable)
{
// http://stackoverflow.com/questions/9985125/in-rx-how-to-group-latest-items-after-a-period-of-time
return observable.Buffer(() => observable.Throttle(TimeSpan.FromSeconds(2)).Timeout(TimeSpan.FromMinutes(1)))
.PrioritizeFileSystemChanges()
.SelectMany(x => x);
}
public Window1()
{
//Setup twitter
//IFluentTwitter twitclient = FluentTwitter.CreateRequest().AuthenticateAs("uid", "pwd");
//ITwitterStatuses twitStatuses = twitclient.Statuses();
//generate temperature alerts
ObservableUsbTemper temperature = new ObservableUsbTemper();
IObservable <double> ts = temperature.TemperatureStreamFarenheight;
IObservable <IList <double> > tsSlidingWindow = ts.Buffer(TimeSpan.FromSeconds(5));
IObservable <double> avgTempOverTime = tsSlidingWindow.Select(buff => buff.Average());
IObservable <double> tempAlerts = avgTempOverTime.Where(avgtemp => avgtemp < 80);
// Send to twitter
IObservable <string> twitterResponses = tempAlerts.Sample(TimeSpan.FromMinutes(1))
.Select(cold => string.Format("It's cold here. Avg temp is {0:0.00}", cold));
// now wire-up the UI
InitializeComponent();
this.DataContext = this;
OCFarenheightReadings = new ObservableCollection <double>();
OCSlidingWindow = new ObservableCollection <IList <double> >();
OCavgTempOverTime = new ObservableCollection <double>();
OCtempAlerts = new ObservableCollection <double>();
OCtwitterResponses = new ObservableCollection <string>();
OCFarenheightReadings.Insert(ts);
OCSlidingWindow.Insert(tsSlidingWindow);
OCavgTempOverTime.Insert(avgTempOverTime);
OCtempAlerts.Insert(tempAlerts);
OCtwitterResponses.Insert(twitterResponses);
}
public AutoTrackingTable
(DatabaseFront database, string name,
double trackIntervalTime, IObservable <TRecord> itemAddedObservable,
int version)
{
this.Table = new TypedTable <TRecord, TKey>(database, name)
{
IsIdAuto = false,
Version = version,
};
this.Tracker = new Tracker <TRecord, TKey>(this.Table).AddTo(this.Disposables);
itemAddedObservable
.Buffer(itemAddedObservable.Throttle(TimeSpan.FromMilliseconds(trackIntervalTime)))
.Subscribe(items =>
{
Task.Run(async() =>
{
await this.Table.Parent.RequestThreadSafeTransactionAsync
(context => this.Table.AddRangeAsync(items, context.Connection, context.Transaction))
.ConfigureAwait(false);
items.ForEach(x => this.Tracker.Track(x));
});
})
.AddTo(this.Disposables);
}
public static IObservable <SentimentDelta> ProbabilityDeltas(this IObservable <SentimentProbabilities> source, int count, int skip, Match match)
{
return(Observable.Create <SentimentDelta>(observer =>
{
return source.Buffer(count, skip).Subscribe(buffer =>
{
var first = buffer.FirstOrDefault();
var last = buffer.LastOrDefault();
var lastInSequence = buffer.Count == 1;
observer.OnNext(new SentimentDelta
{
TeamA = match.TeamA,
TeamB = match.TeamB,
HomeWinProbabilityDelta = (first == null || last == null) ? 0m : last.HomeWinProbability - first.HomeWinProbability,
DrawProbabilityDelta = (first == null || last == null) ? 0m : last.DrawProbability - first.DrawProbability,
AwayWinProbabilityDelta = (first == null || last == null) ? 0m : last.AwayWinProbability - first.AwayWinProbability,
HomeWinProbabilityCurrent = last == null ? 0m : last.HomeWinProbability,
DrawProbabilityCurrent = last == null ? 0m : last.DrawProbability,
AwayWinProbabilityCurrent = last == null ? 0m : last.AwayWinProbability,
ClosingPrediction = lastInSequence
});
},
observer.OnCompleted);
}));
}
public HazardSpawner(
UniRx.IObservable <float> time,
float spawnInterval,
RandomFloat randomService,
float minHazardHeight,
float maxHazardHeight,
float initialPosition,
float hazardSpeed
)
{
this.randomService = randomService;
this.minHazardHeight = minHazardHeight;
this.maxHazardHeight = maxHazardHeight;
this.initialPosition = initialPosition;
this.hazardSpeed = hazardSpeed;
this.time = time;
spawning = true;
// Transform the time to emit events every 'spawnInterval' seconds
Hazards = time
.Buffer(Span(spawnInterval))
// Put an event at the beginning of the time-line
.StartWith(FirstSpawnEvent())
// Only spawn if 'spawning' is on
.Where(_ => spawning)
// transform the spawn events into hazards
.Select(l => HazardFactory());
}
public static IObservable <TSource> BufferUntilCompatibilityChecked <TSource>(this XafApplication application, IObservable <TSource> source)
{
var compatibilityCheckefd = application.WhenCompatibilityChecked().Select(xafApplication => xafApplication).FirstAsync();
return(source.Buffer(compatibilityCheckefd).FirstAsync().SelectMany(list => list)
.Concat(Observable.Defer(() => source)).Select(source1 => source1));
}
private void Init(FileSystemWatcher watcher, IEnumerable <FileInfo> files, int bufferTime, int intervalTime, Predicate <FileInfo> inactive)
{
this.states = new FileStateManager(files, inactive);
watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size;
watcher.Created += this.OnObjectChanged;
watcher.Renamed += this.OnObjectRenamed;
watcher.Deleted += this.OnObjectChanged;
IObservable <FileSystemEventArgs> listener = Observable.FromEvent <FileSystemEventHandler, FileSystemEventArgs>(
handler => (sender, e) => { handler(e); },
h => watcher.Changed += h,
h => watcher.Changed -= h);
var triggerInterval = TimeSpan.FromMilliseconds(intervalTime);
IObservable <IList <FileSystemEventArgs> > listener2 = Observable.Interval(triggerInterval)
// .Debug(() => "Interval listener triggered {0}.".FormatWith(DateTime.Now.ToLongTimeString()))
.SelectMany(l => this.states.Files)
.Where(this.SizeChanged)
.Select(file => new FileSystemEventArgs(WatcherChangeTypes.Changed, file.DirectoryName, file.Name))
.Buffer(triggerInterval);
this.subscription = listener
.Buffer(TimeSpan.FromMilliseconds(bufferTime))
.Merge(listener2)
.Subscribe(OnObjectChanged);
watcher.EnableRaisingEvents = true;
this.watcher = watcher;
Debug.WriteLine("Initialized \"{0}\" with {1} active files.".FormatWith(watcher.Path, this.states.Files.Count));
}
public static IObservable <IList <TSource> > Buffer <TSource> (
this IObservable <TSource> source,
TimeSpan timeSpan,
IScheduler scheduler)
{
return(source.Buffer(timeSpan, int.MaxValue, scheduler));
}
public static IObservable <IList <TSource> > BufferNotEmpty <TSource>(
this IObservable <TSource> source,
TimeSpan timeSpan,
int count)
{
return(source.Buffer(timeSpan, count).Where(_ => _.Any()));
}
public SmoothingWithBuffer()
{
InitializeComponent();
IObservable <EventPattern <MouseEventArgs> > downs =
Observable.FromEventPattern <MouseEventArgs>(
background, nameof(background.MouseDown));
IObservable <EventPattern <MouseEventArgs> > ups =
Observable.FromEventPattern <MouseEventArgs>(
background, nameof(background.MouseUp));
IObservable <EventPattern <MouseEventArgs> > allMoves =
Observable.FromEventPattern <MouseEventArgs>(
background, nameof(background.MouseMove));
IObservable <EventPattern <MouseEventArgs> > dragMoves =
from down in downs
join move in allMoves
on ups equals allMoves
select move;
IObservable <EventPattern <MouseEventArgs> > allDragPositionEvents =
Observable.Merge(downs, ups, dragMoves);
IObservable <Point> dragPositions =
from move in allDragPositionEvents
select move.EventArgs.GetPosition(background);
IObservable <Point> smoothed = from points in dragPositions.Buffer(5, 2)
let x = points.Average(p => p.X)
let y = points.Average(p => p.Y)
select new Point(x, y);
smoothed.Subscribe(point => { line.Points.Add(point); });
}
public static T WaitFirstValue <T>(this IObservable <T> observable, TimeSpan timeout)
{
return(observable.Buffer(timeout, 1)
.ToEnumerable()
.First()
.First());
}
private static void ObserveScenarioOuput(IObservable<int> count)
{
count
.Sum()
.Subscribe(total => ScenarioSimulatorEventSource.Log.FinalEventCountForAllDevices(total));
count
.Buffer(TimeSpan.FromMinutes(5))
.Scan(0, (total, next) => total + next.Sum())
.Subscribe(total => ScenarioSimulatorEventSource.Log.CurrentEventCountForAllDevices(total));
count
.Buffer(TimeSpan.FromMinutes(0.1))
.TimeInterval()
.Select(x => x.Value.Sum() / x.Interval.TotalSeconds)
.Subscribe(rate => ScenarioSimulatorEventSource.Log.CurrentEventsPerSecond(rate));
}
public override void ObserveResponse(IObservable <char> source)
{
source.Buffer(completeAfter)
.Select(p => new string(p.ToArray()))
//.ObserveOn(NewThreadScheduler.Default)
.Take(1)
.Subscribe(OnNext, OnError, OnCompleted);
}
/// <summary>
/// Bulks the trigger.
/// </summary>
/// <param name="streamRate">The stream rate.</param>
/// <param name="scheduler">The scheduler.</param>
/// <returns></returns>
public IObservable<Unit> BulkTrigger(
IObservable<Unit> streamRate,
IScheduler scheduler)
{
var result = streamRate.Buffer(3)
.Select(_ => Unit.Default);
return result;
}
private static void ObserveScenarioOuput(IObservable <int> count)
{
count
.Sum()
.Subscribe(total => ScenarioSimulatorEventSource.Log.FinalEventCountForAllDevices(total));
count
.Buffer(TimeSpan.FromMinutes(5))
.Scan(0, (total, next) => total + next.Sum())
.Subscribe(total => ScenarioSimulatorEventSource.Log.CurrentEventCountForAllDevices(total));
count
.Buffer(TimeSpan.FromMinutes(0.1))
.TimeInterval()
.Select(x => x.Value.Sum() / x.Interval.TotalSeconds)
.Subscribe(rate => ScenarioSimulatorEventSource.Log.CurrentEventsPerSecond(rate));
}
public static void ShouldStartWithIn <T>(this IObservable <T> observable, TimeSpan timeout, params T[] values)
{
observable.Buffer(timeout, values.Length)
.ToEnumerable()
.First()
.Should()
.Equal(values);
}
// .-|.-|.-|
public static IObservable <EyeMovement> MergeAdjacentFixations(this IObservable <EyeMovement> movements, TimeSpan maxTimeBetweenFixations, double maxAngleBetweenFixations)
{
return(movements.Buffer(m => m.MovementType == EyeMovementType.Fixation)
.Scan((aggregate, buffer) =>
{
if (aggregate.Any())
{
var lastFixation = aggregate.FirstOrDefault(m => m.MovementType == EyeMovementType.Fixation);
var nextFixation = buffer.FirstOrDefault(m => m.MovementType == EyeMovementType.Fixation);
var nextMovements = buffer.Except(new[] { nextFixation }).ToArray();
if (lastFixation != null && nextFixation != null)
{
var timeBetweenFixations = (nextFixation.Timestamp - lastFixation.EndTimestamp);
if (timeBetweenFixations <= maxTimeBetweenFixations)
{
var lastSample = lastFixation.Samples.Last().Eye;
var nextSample = nextFixation.Samples.First().Eye;
var averageSample = EyeSampleUtils.Average(lastSample, nextSample);
double angle = averageSample.GetVisualAngle(lastFixation.AverageSample, nextFixation.AverageSample);
if (angle <= maxAngleBetweenFixations)
{
var mergedSamples = aggregate.SelectMany(m => m.Samples).Concat(nextFixation.Samples);
var newAverageSample = EyeSampleUtils.Average(lastFixation.Samples.Concat(nextFixation.Samples).Select(s => s.Eye));
// merge
var mergedFixation = new List <EyeMovement>()
{
new EyeMovement
(
EyeMovementType.Fixation,
mergedSamples,
newAverageSample,
lastFixation.Timestamp,
nextFixation.EndTimestamp
)
};
if (nextMovements != null && nextMovements.Any())
{
mergedFixation.AddRange(nextMovements);
}
return mergedFixation;
}
}
}
}
return buffer;
})
.Where(b => b.Any())
.Buffer((first, current) => first.First().Timestamp != current.First().Timestamp)
.Where(b => b.Any())
.Select(b => b.Last())
.SelectMany(b => b));
}
public static IObservable <IOhlcvv> Ohlcvv(this IObservable <IExecution> source, TimeSpan frameSpan, bool insertMissingFrames = false)
{
if (!insertMissingFrames)
{
return(source
.Buffer(e => e.Time, frameSpan)
.Select(e => new Ohlcvv(frameSpan, e)));
}
return(Observable.Create <IOhlcvv>(observer =>
{
var prev = default(Ohlcvv);
var disposable = source
.Buffer(e => e.Time, frameSpan)
.Select(e => new Ohlcvv(frameSpan, e))
.Subscribe(current =>
{
if (prev == default)
{
observer.OnNext(current);
}
else if (current.Start == prev.Start + frameSpan)
{
observer.OnNext(current);
}
else
{
var ohlc = prev;
while (true)
{
ohlc = ohlc.CreateMissingFrame();
observer.OnNext(ohlc);
if (ohlc.Start == current.Start - frameSpan)
{
break;
}
}
observer.OnNext(current);
}
prev = current;
});
return Disposable.Create(disposable.Dispose);
}));
}
/// <summary>
/// Bulks the trigger.
/// </summary>
/// <param name="streamRate">The stream rate.</param>
/// <param name="scheduler">The scheduler.</param>
/// <returns></returns>
public IObservable <Unit> BulkTrigger(
IObservable <Unit> streamRate,
IScheduler scheduler)
{
var result = streamRate.Buffer(3)
.Select(_ => Unit.Default);
return(result);
}
private IObservable <IList <SwatcherCreatedEventArgs> > CreateCreatedEventWindowStream(
IObservable <SwatcherCreatedEventArgs> createdEventStream)
{
return(createdEventStream
.Buffer(OneSecond, QuarterSecond)
.CombineWithPreviousBuffer()
.Publish()
.RefCount());
}
public static IObservable <double> ToDistance(this IObservable <MouseEventArgs> e)
{
return(e.Buffer(2, 1)
.Select(b =>
{
var d = Distance(b[0].Location, b[1].Location);
return d;
}));
}
protected override IObservable <RHD2164DataFrame> Process(IObservable <ONIManagedFrame <ushort> > source, ulong frameOffset)
{
var ephysDataFormat = EphysDataFormat;
var auxDataFormat = AuxDataFormat;
return(source
.Buffer(BlockSize)
.Select(block => { return new RHD2164DataFrame(block, frameOffset, ephysDataFormat, auxDataFormat); }));
}
internal static IObservable <double> AroonUp_V1(this IObservable <double> source, int period)
{
return(source.Buffer(period, 1).Where(x => x.Count == period)
.Select(lt => {
var y = lt.Max();
var idx = period - (lt.IndexOf(y) + 1);
return (period - idx) * (100.0 / period);
}));
}
public static IObservable <TResult> MovingAverageWithBuffer <TItem, TAccumulate, TResult>
(
this IObservable <TItem> source,
TAccumulate seed,
int windowSize,
Func <TAccumulate, TItem, TAccumulate> addAccumulate,
Func <TAccumulate, TItem, TAccumulate> subtractAccumulate,
Func <TAccumulate, int, TItem, TResult> average
)
{
return(Observable.Create <TResult>(observer =>
{
return source.Buffer(windowSize * 2 + 1, 1)
.Scan
(
seed: new MovingAverageBuffer <TAccumulate, TItem>
(
accumulate: seed,
add: addAccumulate,
subtract: subtractAccumulate
),
accumulator: (aggregate, buffer) =>
{
if (aggregate.IsInitialized == false)
{
aggregate.Initialize(buffer);
}
else if (buffer.Count < aggregate.Count)
{
aggregate.First = buffer.First();
}
else
{
aggregate.Last = buffer.Last();
aggregate.First = buffer.First();
}
int count = buffer.Count;
//if (count != aggregate.Count)
//{
// Console.WriteLine("xxxx");
//}
if (count % 2 == 1)
{
var current = buffer[count / 2];
observer.OnNext(average(aggregate.Accumulate, count, current));
}
return aggregate;
}
).Subscribe(_ => { }, () => observer.OnCompleted());
}));
}
public IObservable<bool> DetectCorrectKeypass(IObservable<string> keypresses, string password, TimeSpan delay, IScheduler scheduler)
{
return keypresses
.Buffer(delay, password.Length, scheduler)
.Select(listStr => string.Join(string.Empty, listStr.ToArray()))
.Do(guess => EnteredPassKey = guess)
.Where(guess => guess != string.Empty)
.Select(guess => guess == password)
.DistinctUntilChanged();
}
public static IObservable<float> Filter(IObservable<float> src, int bufferSize, int dropSize, int takeSize)
{
return src.Buffer(bufferSize).Select((buffered, index) => ApplyFilter(buffered, index, dropSize, takeSize));
}
public IObservable<IEnumerable<DataPoint>> Apply(IObservable<DataPoint> dataPoints)
{
return dataPoints.Buffer(BufferSize);
}
