/// <summary> /// Perform the specified action when the specified text view is ready /// </summary> /// <param name="textView"></param> /// <param name="action"></param> public virtual void DoActionWhenTextViewReady(FSharpFunc <Unit, Unit> action, ITextView textView) { // Local functions to do the action. void doAction() { // Perform action if the text view is still open. if (!textView.IsClosed && !textView.InLayout) { action.Invoke(null); } } void doActionHandler(object sender, RoutedEventArgs e) { // Unsubscribe. if (sender is FrameworkElement element) { element.Loaded -= doActionHandler; } // Then schedule the action. _protectedOperations.BeginInvoke(doAction, DispatcherPriority.Loaded); } if (textView is IWpfTextView wpfTextView && !wpfTextView.VisualElement.IsLoaded) { // FrameworkElement.Loaded Event: // // Occurs when a FrameworkElement has been constructed and // added to the object tree, and is ready for interaction. wpfTextView.VisualElement.Loaded += doActionHandler; }
public static Deedle.Series <a, b> ofObservations <a, b>(IEnumerable <Tuple <a, b> > observations) { Tuple <a, b>[] tupleArray1 = (Tuple <a, b>[])ArrayModule.OfSeq <Tuple <a, b> >((IEnumerable <M0>)observations); FSharpFunc <Tuple <a, b>, a> fsharpFunc1 = (FSharpFunc <Tuple <a, b>, a>) new FSeriesextensions.ofObservations <a, b>(); Tuple <a, b>[] tupleArray2 = tupleArray1; if ((object)tupleArray2 == null) { throw new ArgumentNullException("array"); } a[] aArray1 = new a[tupleArray2.Length]; for (int index = 0; index < aArray1.Length; ++index) { aArray1[index] = fsharpFunc1.Invoke(tupleArray2[index]); } a[] aArray2 = aArray1; FSharpFunc <Tuple <a, b>, b> fsharpFunc2 = (FSharpFunc <Tuple <a, b>, b>) new FSeriesextensions.ofObservations <a, b>(); Tuple <a, b>[] tupleArray3 = tupleArray1; if ((object)tupleArray3 == null) { throw new ArgumentNullException("array"); } b[] values = new b[tupleArray3.Length]; a[] keys = aArray2; for (int index = 0; index < values.Length; ++index) { values[index] = fsharpFunc2.Invoke(tupleArray3[index]); } return(new Deedle.Series <a, b>(keys, values)); }
public static Frame <TRowKey, TColumnKey> GetRowsAt <TRowKey, TColumnKey>(this Frame <TRowKey, TColumnKey> frame, params int[] indices) { int[] numArray1 = indices; FSharpFunc <int, TRowKey> fsharpFunc1 = (FSharpFunc <int, TRowKey>) new FrameExtensions.keys9 <TRowKey, TColumnKey>(frame.Rows); int[] numArray2 = numArray1; if ((object)numArray2 == null) { throw new ArgumentNullException("array"); } TRowKey[] rowKeyArray1 = new TRowKey[numArray2.Length]; for (int index = 0; index < rowKeyArray1.Length; ++index) { rowKeyArray1[index] = fsharpFunc1.Invoke(numArray2[index]); } TRowKey[] rowKeyArray2 = rowKeyArray1; int[] numArray3 = indices; FSharpFunc <int, ISeries <TColumnKey> > fsharpFunc2 = (FSharpFunc <int, ISeries <TColumnKey> >) new FrameExtensions.values0 <TColumnKey, TRowKey>(frame); int[] numArray4 = numArray3; if ((object)numArray4 == null) { throw new ArgumentNullException("array"); } ISeries <TColumnKey>[] seriesArray1 = new ISeries <TColumnKey> [numArray4.Length]; for (int index = 0; index < seriesArray1.Length; ++index) { seriesArray1[index] = fsharpFunc2.Invoke(numArray4[index]); } ISeries <TColumnKey>[] seriesArray2 = seriesArray1; return(FFrameextensions.FrameofRowsStatic <TRowKey, ISeries <TColumnKey>, TColumnKey>((IEnumerable <Tuple <TRowKey, ISeries <TColumnKey> > >)SeqModule.Zip <TRowKey, ISeries <TColumnKey> >((IEnumerable <M0>)rowKeyArray2, (IEnumerable <M1>)seriesArray2))); }
public static double Mean <K, V>(this Series <K, V> series) { Series <K, V> series1 = series; int num1 = 1; OptionalValue <V>[] optionalValueArray = StatsInternal.valuesAllOpt <K, V>(series1); int num2 = num1; V[] vArray1 = ArrayModule.Choose <OptionalValue <V>, V>((FSharpFunc <M0, FSharpOption <M1> >) new SeriesStatsExtensions.Mean <V>(), (M0[])optionalValueArray); FSharpFunc <V, double> fsharpFunc = (FSharpFunc <V, double>) new SeriesStatsExtensions.Mean <V>(); V[] vArray2 = vArray1; if ((object)vArray2 == null) { throw new ArgumentNullException("array"); } double[] init = new double[vArray2.Length]; int moment = num2; for (int index = 0; index < init.Length; ++index) { init[index] = fsharpFunc.Invoke(vArray2[index]); } StatsInternal.Sums sums = StatsInternal.initSumsDense(moment, init); return(sums.sum / sums.nobs); }
public static double Median <K, V>(this Series <K, V> series) { V[] vArray1 = (V[])ArrayModule.OfSeq <V>((IEnumerable <M0>)series.Values); FSharpFunc <V, double> fsharpFunc = (FSharpFunc <V, double>) new SeriesStatsExtensions.Median <V>(); V[] vArray2 = vArray1; if ((object)vArray2 == null) { throw new ArgumentNullException("array"); } double[] numArray = new double[vArray2.Length]; for (int index = 0; index < numArray.Length; ++index) { numArray[index] = fsharpFunc.Invoke(vArray2[index]); } double[] arr = numArray; int n = arr.Length / 2; if (arr.Length == 0) { return(Operators.get_NaN()); } if (arr.Length % 2 == 1) { return(StatsInternal.quickSelectInplace(n, arr)); } return((StatsInternal.quickSelectInplace(n, arr) + StatsInternal.quickSelectInplace(n - 1, arr)) / 2.0); }
public void DoActionWhenTextViewReady(FSharpFunc <Unit, Unit> action, ITextView textView) { // Perform action if the text view is still open. if (!textView.IsClosed && !textView.InLayout) { action.Invoke(null); } }
public IPipeline <TInput, TMapped> Then <TMapped>(FSharpFunc <TOutput, TMapped> nextfunction) { var compose = FSharpFuncUtils.Create <TInput, TMapped>(value => nextfunction.Invoke(_function.Invoke(value))); return(new CsPipeline <TInput, TMapped>(compose)); }
public void FromAction() { int a = 0; FSharpFunc <Unit, Unit> ff = FSharpFunc.FromAction(() => a = 1); ff.Invoke(null); Assert.AreEqual(1, a); }
void IRunner.OnShrink ( FSharpList<object> args , FSharpFunc<FSharpList<object>, string> everyShrink ) { var msg = everyShrink.Invoke(args); if (!silent) { Console.Write(msg); } }
ChainStatus Optimizations.IHeadStart <T> .Execute(ReadOnlySpan <T> source) { var status = ChainStatus.Flow; foreach (var input in source) { var maybe = chooser.Invoke(input); if (maybe.IsSome) { status = Next(maybe.Item); if (status.IsStopped()) { break; } } } return(status); }
void IRunner.OnArguments ( int ntest , FSharpList<object> args , FSharpFunc<int, FSharpFunc<FSharpList<object>, string>> every ) { var msg = every.Invoke(ntest).Invoke(args); if (!silent) { Console.Write(msg); } }
public OptionalValue <Series <K, R> > TryAs <R>(ConversionKind conversionKind) { OptionalValue <IVector <R> > optionalValue1 = VectorHelpers.tryConvertType <R>(conversionKind, (IVector)this.vector); FSharpFunc <IVector <R>, Series <K, R> > fsharpFunc = (FSharpFunc <IVector <R>, Series <K, R> >) new \u0024Series.TryAs\u00401255 <K, R> (this); OptionalValue <IVector <R> > optionalValue2 = optionalValue1; if (optionalValue2.HasValue) { return(new OptionalValue <Series <K, R> >(fsharpFunc.Invoke(optionalValue2.Value))); } return(OptionalValue <Series <K, R> > .Missing); }
public OptionalValue <R> TryGetAs <R>(K column) { OptionalValue <object> optionalValue1 = this.TryGet(column); FSharpFunc <object, R> fsharpFunc = (FSharpFunc <object, R>) new \u0024Series.TryGetAs\u00401245 <R> (); OptionalValue <object> optionalValue2 = optionalValue1; if (optionalValue2.HasValue) { return(new OptionalValue <R>(fsharpFunc.Invoke(optionalValue2.Value))); } return(OptionalValue <R> .Missing); }
private void TestButtonClick(object sender, RoutedEventArgs e) { viewCanvas.Children.Clear(); var singleDim = TransformDrawnImageToStandartView(); DrawArray(singleDim); var predictedValue = predictor.Invoke(MatrixModule.ofList(NN.makeList(singleDim))); prediction.Content = string.Format("Prediction is {0}", predictedValue); iter++; drawingCanvas.Children.Clear(); }
void IVimHost.DoActionWhenTextViewReady(FSharpFunc <Unit, Unit> action, ITextView textView) { if (DoActionWhenTextViewReadyFunc != null) { DoActionWhenTextViewReadyFunc(action, textView); } else { // Simulate the conditions that would be true if // wpfTextView.IsLoaded were true using textView. if (!textView.IsClosed && !textView.InLayout && textView.TextViewLines != null) { action.Invoke(null); } } }
public override Reply <string> Invoke(CharStream <TUserState> stream) { var reply = CharParser1.Invoke(stream); if (reply.Status == ReplyStatus.Ok) { return(ParseRestOfString(stream, reply.Result, reply.Error)); } else { return new Reply <string> { Status = reply.Status, Error = reply.Error } }; } #if !LOW_TRUST unsafe
public void FindInFiles(string pattern, bool matchCase, string filesOfType, VimGrepFlags flags, FSharpFunc <Unit, Unit> action) { var find = new FindReplace(); var options = new FilterOptions { CaseSensitive = matchCase, RegexSearch = true, }; var scope = new ShellWildcardSearchScope(_vim.VimData.CurrentDirectory, filesOfType); using (var monitor = IdeApp.Workbench.ProgressMonitors.GetSearchProgressMonitor(true)) { var results = find.FindAll(scope, monitor, pattern, null, options, System.Threading.CancellationToken.None); foreach (var result in results) { //TODO: Cancellation? monitor.ReportResult(result); } } action.Invoke(null); }
public Size Relayout(RectangleF bounds) { if (_document != null && _document.Body != null) { if (_document.ReadyState != "complete") { return(Size.Empty); } if (_isDocumentDirty || _layout == null) { _lfun = OptimusLayout.Layout(new Layout.LayoutSettings(true, FSharpMeasureString), _document.Body); } if (_isDocumentDirty || _lastBounds != bounds || _layout == null) { _layout = _lfun.Invoke((int)bounds.Right).ToList(); _lastBounds = bounds; _isDocumentDirty = false; } } return(GetSize()); }
static public int ExtendFSharpFuncIntIntNoArg(this FSharpFunc <int, int> s1) { return(s1.Invoke(3)); }
private T Calculate(DateTime epoch, int recurse, ISession session = null, bool retry = true) { if (recurse > 60) { throw new LockRecursionException(); } bool taken = false; bool pushed = false; try { _spinLock.Enter(ref taken); if (taken) { if (_state == (int)CellState.Clean && session == null || (_epoch > epoch && session == null)) { return(_value); // don't recalculate for read } SetState(CellState.Calculating); _spinLock.Exit(true); taken = false; if (_link) { Cell.Current.Value.Push(this); pushed = true; } var t = (_func != null ? _func.Invoke(null) : _value); if (session != null) { session.SetValue <T>(this, t); } while (taken == false) { // sleep through massive contention _spinLock.Enter(ref taken); if (!taken) { Thread.Sleep(recurse++ *100); return(Calculate(epoch, recurse, session)); } } if (epoch >= _epoch) { _epoch = epoch; _value = t; } SetState(CellState.Clean); if (_pending > 0) { if (session != null) { _pending--; } } if (pushed) { Cell.Current.Value.Pop(); _link = false; pushed = false; } if (_isBool && _flip && (Convert.ToBoolean(t) != Convert.ToBoolean(_value))) { _flip = false; RaiseChange(CellEvent.Link, this, this, _epoch, session); } return(LinkReturn(t)); } else { Thread.Sleep(recurse * 100); return(Calculate(epoch, recurse + 1, session)); // edge case retry lock } } catch (Exception e) { if (retry) { if (taken) { _spinLock.Exit(true); } Thread.Sleep(0); return(Calculate(epoch, recurse + 1, session, false)); } else { _lastException = e; SetState(CellState.Error); RaiseChange(CellEvent.Error, this, this, epoch, null); throw; } } finally { if (pushed) { Cell.Current.Value.Pop(); _link = false; } if (taken) { _spinLock.Exit(true); } } }
private void connect() { string host = textBox1.Text.Substring(0,textBox1.Text.IndexOf(':')); string port = textBox1.Text.Substring(host.Length + 1); var fsharp_func = Microsoft.FSharp.Core.FSharpFunc<string, object>.FromConverter( new Converter<string, object>(AfterReceivingFunction)); writer = fsmsclient.library.initconnectionCS(fsmsclient.library.initConnection, host, Convert.ToInt32(port), fsharp_func); writer.Invoke("0\n\n"); textBox1.Text = "Connected"; }
static public U ExtendFSharpFuncGenericOneArg <T, U>(this FSharpFunc <T, U> s1, T arg) { return(s1.Invoke(arg)); }
public static TResult Invoke <TResult>(this FSharpFunc <Unit, TResult> func) { return(func.Invoke(null)); }
public static Frame <int, int> FromArray2D <T>(T[,] array) { IIndexBuilder instance1 = FIndexBuilderimplementation.IndexBuilder.Instance; int length1 = array.GetLength(0); FSharpFunc <int, int> fsharpFunc1 = (FSharpFunc <int, int>) new FrameExtensions.rowIndex(); if (length1 < 0) { throw new ArgumentException(string.Format("{0}\n{1} = {2}", new object[3] { (object)LanguagePrimitives.ErrorStrings.get_InputMustBeNonNegativeString(), (object)"count", (object)length1 }), "count"); } int[] numArray1 = new int[length1]; IIndexBuilder indexBuilder1 = instance1; for (int index = 0; index < numArray1.Length; ++index) { numArray1[index] = fsharpFunc1.Invoke(index); } IIndex <int> rowIndex = indexBuilder1.Create <int>((IEnumerable <int>)numArray1, FSharpOption <bool> .Some(true)); IIndexBuilder instance2 = FIndexBuilderimplementation.IndexBuilder.Instance; int length2 = array.GetLength(1); FSharpFunc <int, int> fsharpFunc2 = (FSharpFunc <int, int>) new FrameExtensions.colIndex(); if (length2 < 0) { throw new ArgumentException(string.Format("{0}\n{1} = {2}", new object[3] { (object)LanguagePrimitives.ErrorStrings.get_InputMustBeNonNegativeString(), (object)"count", (object)length2 }), "count"); } int[] numArray2 = new int[length2]; IIndexBuilder indexBuilder2 = instance2; for (int index = 0; index < numArray2.Length; ++index) { numArray2[index] = fsharpFunc2.Invoke(index); } IIndex <int> columnIndex = indexBuilder2.Create <int>((IEnumerable <int>)numArray2, FSharpOption <bool> .Some(true)); IVector[] vectorArray = (IVector[])ArrayModule.ZeroCreate <IVector>(array.GetLength(1)); for (int c = 0; c < vectorArray.Length; ++c) { int length3 = array.GetLength(0); FSharpFunc <int, T> fsharpFunc3 = (FSharpFunc <int, T>) new FrameExtensions.col <T>(array, c); if (length3 < 0) { throw new ArgumentException(string.Format("{0}\n{1} = {2}", new object[3] { (object)LanguagePrimitives.ErrorStrings.get_InputMustBeNonNegativeString(), (object)"count", (object)length3 }), "count"); } T[] objArray1 = new T[length3]; for (int index = 0; index < objArray1.Length; ++index) { objArray1[index] = fsharpFunc3.Invoke(index); } T[] objArray2 = objArray1; vectorArray[c] = (IVector)FVectorBuilderimplementation.VectorBuilder.Instance.Create <T>(objArray2); } IVector <IVector> data = FVectorBuilderimplementation.VectorBuilder.Instance.Create <IVector>(vectorArray); return(new Frame <int, int>(rowIndex, columnIndex, data, FIndexBuilderimplementation.IndexBuilder.Instance, FVectorBuilderimplementation.VectorBuilder.Instance)); }
protected Reply <string> ParseRestOfString(CharStream <TUserState> stream, char firstChar, ErrorMessageList error) { #if LOW_TRUST var sb = new StringBuilder(16); sb.Append(firstChar); #else _16CharBuffer buffer_; // produces more efficient code on .NET than stackalloc char[16] char * buffer = (char *)(&buffer_); buffer[0] = firstChar; char[] chars = null; uint n = 1; #endif for (;;) { var tag = stream.StateTag; var reply = CharParser.Invoke(stream); if (reply.Status == ReplyStatus.Ok) { if (tag == stream.StateTag) { throw Internal.ParserCombinatorInInfiniteLoopHelper.CreateException("manyChars", stream); } error = reply.Error; #if LOW_TRUST sb.Append(reply.Result); #else var i = n % 16; if (i != 0) { buffer[i] = reply.Result; ++n; } else { if (chars == null) { chars = new char[32]; } else if (n == chars.Length) { var newChars = new char[2 * chars.Length]; Array.Copy(chars, newChars, chars.Length); chars = newChars; } for (i = 0; i < 16; ++i) { chars[n - 16 + i] = buffer[i]; } buffer[0] = reply.Result; ++n; } #endif } else if (reply.Status == ReplyStatus.Error && tag == stream.StateTag) { string str; #if LOW_TRUST str = sb.ToString(); #else if (n <= 16) { str = new String(buffer, 0, (int)n); } else { for (uint i = (n - 1) & 0x7ffffff0u; i < n; ++i) { chars[i] = buffer[i % 16]; } str = new string(chars, 0, (int)n); } #endif error = ErrorMessageList.Merge(error, reply.Error); return(new Reply <string> { Status = ReplyStatus.Ok, Result = str, Error = error }); } else { error = tag == stream.StateTag ? ErrorMessageList.Merge(error, reply.Error) : reply.Error; return(new Reply <string> { Status = reply.Status, Error = error }); } } }
private T Calculate(DateTime epoch, int recurse, ISession session = null, bool retry = true) { if (recurse > 60) { throw new LockRecursionException(); } bool taken = false; try { _spinLock.Enter(ref taken); if (taken) { if (_state == (int)CellState.Clean && session == null) { return(_value); // don't recalculate for read } SetState(CellState.Calculating); _spinLock.Exit(true); taken = false; var t = (_func != null ? _func.Invoke(null) : _value); if (session != null) { session.SetValue <T>(this, t); } while (taken == false) { // sleep through massive contention _spinLock.Enter(ref taken); if (!taken) { Thread.Sleep(recurse++ *100); return(Calculate(epoch, recurse, session)); } } if (epoch > _epoch) { _epoch = epoch; _value = t; } SetState(CellState.Clean); if (_pending > 0) { if (session != null) { _pending--; } } return(t); } else { Thread.Sleep(recurse * 100); return(Calculate(epoch, recurse + 1, session)); // edge case retry lock } } catch (Exception e) { if (retry) { if (taken) { _spinLock.Exit(true); } Thread.Sleep(0); return(Calculate(epoch, recurse + 1, session, false)); } else { _lastException = e; SetState(CellState.Error); RaiseChange(CellEvent.Error, this, epoch, null); throw; } } finally { if (taken) { _spinLock.Exit(true); } } }
/// <summary>Applies the parser `p` to the input string.</summary> public static Reply <TResult> ParseString <TResult>( this FSharpFunc <CharStream <Unit>, Reply <TResult> > p, string chars) => p.Invoke(new CharStream <Unit>(chars, 0, chars.Length));
public void DoActionWhenTextViewReady(FSharpFunc <Unit, Unit> action, ITextView textView) { action.Invoke(null); }
/// <summary> /// <para>Applies the parser `p` to the input file.</para> /// <para> /// In case no unicode byte order mark is found, the file data is assumed to be encoded /// with the given `encoding`. `Encoding.Default` will be used if `encoding` was not /// specified. /// </para> /// </summary> public static Reply <TResult> ParseFile <TResult>( this FSharpFunc <CharStream <Unit>, Reply <TResult> > p, string path, Encoding?encoding = null) => p.Invoke(new CharStream <Unit>(path, encoding ?? Encoding.Default, detectEncodingFromByteOrderMarks: true));
/// <summary>Applies the parser `p` to the input `CharStream`.</summary> public static Reply <TResult> Parse <TResult>( this FSharpFunc <CharStream <Unit>, Reply <TResult> > p, CharStream <Unit> chars) => p.Invoke(chars);
public override TTerm Invoke(TAfterString afterString, TTerm term) { return(Mapping.Invoke(term)); }
public void OnNext(Tuple <ISession, Generic.ICell <T>, CellEvent, ICell, DateTime> value) { Log.Verbose("Session {0} Cell {1} Value {2} Event {3} Source {4} Epoch {5}", value.Item1, value.Item2.Mnemonic, _formater.Invoke(value.Item2.Value), value.Item3, value.Item4, value.Item5); }
/// <summary> /// Example of a higher order function /// </summary> public static FinalGameScore MapScore(FSharpFunc<int, int> f, FinalGameScore game) { return new FinalGameScore(game.Game, f.Invoke(game.FinalScore)); }