public static IVector TransformColumn(IVector vector, IVectorBuilder vectorBuilder, IVecConstructionCmd vectorConstr) { var boxedVector = BoxVector(vector, vectorBuilder); var newVec = vectorBuilder.Build(vectorConstr, new IVector <object>[] { boxedVector }); return(newVec); }
//TODO unsafe public static IVector <T> unboxVector <T>(IVector <object> vector, IVectorBuilder vectorBuilder) { var unboxedVals = vector.Data.Values.Select(v => (T)v).ToArray(); var unboxedVec = vectorBuilder.Create <T>(unboxedVals); return(unboxedVec); }
public void Add_Should_Add(IVectorBuilder x, List <double> data) { x.Set(data); IVector v = x.Get(); Assert.Equal(data, v); }
internal f2trans(IVectorBuilder vectorBuilder, Addressing.IAddressingScheme scheme, VectorConstruction rowCmd) { this.vectorBuilder = vectorBuilder; this.scheme = scheme; this.rowCmd = rowCmd; Func = vec => Invoke(vec); }
public virtual int GenerateNext(ref IEnumerable <IVectorBuilder> next) { switch (this.pc) { case 1: label_5: this.pc = 3; LanguagePrimitives.IntrinsicFunctions.Dispose <IEnumerator <b> >((M0)this.@enum); this.@enum = (IEnumerator <b>)null; this.pc = 3; goto case 3; case 2: this.s = default(b); break; case 3: this.current = (IVectorBuilder)null; return(0); default: this.@enum = ((IEnumerable <b>) this.values).GetEnumerator(); this.pc = 1; break; } if ([email protected]()) { this.s = [email protected]; this.pc = 2; this.current = this.s.VectorBuilder; return(1); } goto label_5; }
public static Frame <c, a> frame <a, b, c>(IEnumerable <Tuple <TLeft, TRight> > columns) where b : ISeries <c> { Tuple <a[], b[]> tuple1 = ArrayModule.Unzip <TLeft, TRight>((Tuple <M0, M1>[])ArrayModule.OfSeq <Tuple <TLeft, TRight> >((IEnumerable <M0>)columns)); b[] values = tuple1.Item2; a[] keys = tuple1.Item1; Tuple <FSharpList <IVectorBuilder>, FSharpList <IIndexBuilder> > tuple2 = new Tuple <FSharpList <IVectorBuilder>, FSharpList <IIndexBuilder> >((FSharpList <IVectorBuilder>)ListModule.OfSeq <IVectorBuilder>(SeqModule.Distinct <IVectorBuilder>((IEnumerable <M0>)SeqModule.ToList <IVectorBuilder>((IEnumerable <M0>) new FFrameextensions.vbs <b, c>(values, default(b), (IEnumerator <b>)null, 0, (IVectorBuilder)null)))), (FSharpList <IIndexBuilder>)ListModule.OfSeq <IIndexBuilder>(SeqModule.Distinct <IIndexBuilder>((IEnumerable <M0>)SeqModule.ToList <IIndexBuilder>((IEnumerable <M0>) new FFrameextensions.ibs <b, c>(values, default(b), (IEnumerator <b>)null, 0, (IIndexBuilder)null))))); Tuple <IVectorBuilder, IIndexBuilder> tuple3; if (tuple2.Item1.get_TailOrNull() != null) { FSharpList <IVectorBuilder> fsharpList1 = tuple2.Item1; if (fsharpList1.get_TailOrNull().get_TailOrNull() == null && tuple2.Item2.get_TailOrNull() != null) { FSharpList <IIndexBuilder> fsharpList2 = tuple2.Item2; if (fsharpList2.get_TailOrNull().get_TailOrNull() == null) { tuple3 = new Tuple <IVectorBuilder, IIndexBuilder>(fsharpList1.get_HeadOrDefault(), fsharpList2.get_HeadOrDefault()); goto label_5; } } } tuple3 = new Tuple <IVectorBuilder, IIndexBuilder>(FVectorBuilderimplementation.VectorBuilder.Instance, FIndexBuilderimplementation.IndexBuilder.Instance); label_5: Tuple <IVectorBuilder, IIndexBuilder> tuple4 = tuple3; IVectorBuilder vectorBuilder = tuple4.Item1; return(FrameUtils.fromColumns <c, a, b>(tuple4.Item2, vectorBuilder, new Series <TLeft, TRight>(keys, values))); }
//TODO method should go to helper module or VectorModule //TODO probably not very efficient public static IVector <object> BoxVector(IVector vector, IVectorBuilder vectorBuilder) { switch (Type.GetTypeCode(vector.ElementType)) { //TODO implement conversions for all types case TypeCode.String: var strVec = (IVector <string>)vector; var boxedVals = strVec.Data.Values.Select(v => (object)v).ToArray(); var boxedVec = vectorBuilder.Create <object>(boxedVals); return(boxedVec); case TypeCode.Int32: var intVec = (IVector <int>)vector; var boxedValsInt = intVec.Data.Values.Select(v => (object)v).ToArray(); var boxedVecInt = vectorBuilder.Create <object>(boxedValsInt); return(boxedVecInt); case TypeCode.DateTime: var dtVec = (IVector <DateTime>)vector; var boxedValsDt = dtVec.Data.Values.Select(v => (object)v).ToArray(); var boxedVecDt = vectorBuilder.Create <object>(boxedValsDt); return(boxedVecDt); default: return(null); } }
public LinearIndexBuilder(IVectorBuilder vectorBuilder) { if (vectorBuilder == null) { throw new ArgumentNullException(nameof(vectorBuilder)); //TODO Log } }
public ColumnSeries(IIndex <TColumnKey> index, IVector <ObjectSeries <TRowKey> > vector, IVectorBuilder vectorBuilder, IIndexBuilder indexBuilder) : base(index, vector, vectorBuilder, indexBuilder) { ColumnSeries <TRowKey, TColumnKey> columnSeries = this; this.vectorBuilder = vectorBuilder; this.indexBuilder = indexBuilder; }
//public GetRowKeyAt(Int64 address) => public DataFrame(IIndex <TRowKey> rowIndex, IIndex <TColumnKey> columnIndex, IVector <IVector> data, IIndexBuilder indexBuilder, IVectorBuilder vectorBuilder) { //TODO add error handling _data = data; _rowIndex = rowIndex; _columnIndex = columnIndex; _vectorBuilder = vectorBuilder; _indexBuilder = indexBuilder; }
public vbs(b[] values, b s, IEnumerator <b> @enum, int pc, IVectorBuilder current) { this.values = values; this.s = s; this.@enum = @enum; this.pc = pc; this.current = current; this.ctor(); }
internal ObjectSeries(IIndex <K> index, IVector <object> vector, IVectorBuilder vectorBuilder, IIndexBuilder indexBuilder) : base(index, vector, vectorBuilder, indexBuilder) { ObjectSeries <K> objectSeries = this; this.index = index; this.vector = vector; this.vectorBuilder = vectorBuilder; this.indexBuilder = indexBuilder; }
public static Series <K, V> FromValueLoader <K, V>(K min, K max, FSharpFunc <Tuple <K, BoundaryBehavior>, FSharpFunc <Tuple <K, BoundaryBehavior>, FSharpAsync <IEnumerable <KeyValuePair <K, V> > > > > loader) { IVectorBuilder instance1 = FVectorBuilderimplementation.VectorBuilder.Instance; IIndexBuilder instance2 = FIndexBuilderimplementation.IndexBuilder.Instance; Ranges.Ranges <K> ranges = Ranges.Ranges <K> .NewRange(new Tuple <Tuple <K, BoundaryBehavior>, Tuple <K, BoundaryBehavior> >(new Tuple <K, BoundaryBehavior>(min, BoundaryBehavior.get_Inclusive()), new Tuple <K, BoundaryBehavior>(max, BoundaryBehavior.get_Inclusive()))); DelayedSource <K, V> source = new DelayedSource <K, V>(Addressing.LinearAddressingScheme.Instance, min, max, ranges, instance2, instance1, (FSharpFunc <Tuple <Tuple <K, BoundaryBehavior>, Tuple <K, BoundaryBehavior> >[], FSharpAsync <Tuple <IIndex <K>, IVector <V> > >[]>) new DelayedSeries.source <K, V>(loader, instance1, instance2)); return(new Series <K, V>((IIndex <K>) new DelayedIndex <K, V>(source), (IVector <V>) new DelayedVector <K, V>(source), instance1, (IIndexBuilder) new DelayedIndexBuilder())); }
public virtual void Close() { Exception exception = (Exception)null; while (true) { switch (this.pc) { case 3: goto label_8; default: Unit unit; try { switch (this.pc) { case 0: case 3: this.pc = 3; this.current = (IVectorBuilder)null; unit = (Unit)null; break; case 1: this.pc = 3; LanguagePrimitives.IntrinsicFunctions.Dispose <IEnumerator <b> >((M0)this.@enum); goto case 0; default: goto case 1; } } catch (object ex) { exception = (Exception)ex; unit = (Unit)null; } continue; } } label_8: if (exception != null) { throw exception; } }
public static IVector <T> CreateRowVector <T>(IVectorBuilder vectorBuilder, long rowKeyCount, long colKeyCount, Func <object, T> mapper, IVector <IVector> data) { var boxedData = data.Select(v => BoxVector(v, vectorBuilder)).Data.Values.ToArray(); var vectorsConstr = new List <IVecConstructionCmd>(); for (long i = 0; i < colKeyCount; i++) { vectorsConstr.Add(new Return(i)); } var cmd = new Combine(rowKeyCount, vectorsConstr); var boxedVec = vectorBuilder.Build(cmd, boxedData); var resVec = boxedVec.Select(v => mapper.Invoke(v)); return(resVec); }
public static Series <K, int> Diff <K>(this Series <K, int> series, int offset) { Series <K, int> series1 = series; int num = offset; Series <K, int> series2 = series1; IVectorBuilder instance = FVectorBuilderimplementation.VectorBuilder.Instance; Tuple <IIndex <K>, VectorConstruction> tuple = series2.Index.Builder.Shift <K>(new Tuple <IIndex <K>, VectorConstruction>(series2.Index, VectorConstruction.NewReturn(0)), num); VectorConstruction vectorConstruction1 = tuple.Item2; IIndex <K> index = tuple.Item1; VectorConstruction vectorConstruction2 = series2.Index.Builder.Shift <K>(new Tuple <IIndex <K>, VectorConstruction>(series2.Index, VectorConstruction.NewReturn(0)), -num).Item2; VectorConstruction vectorConstruction3 = VectorConstruction.NewCombine((Lazy <long>)LazyExtensions.Create <long>((FSharpFunc <Unit, M0>) new SeriesExtensions.Diff2 <K>(index)), FSharpList <VectorConstruction> .Cons(vectorConstruction2, FSharpList <VectorConstruction> .Cons(vectorConstruction1, FSharpList <VectorConstruction> .get_Empty())), VectorListTransform.NewBinary((IBinaryTransform) new SeriesExtensions.Diff5((FSharpFunc <OptionalValue <int>, FSharpFunc <OptionalValue <int>, OptionalValue <int> > >) new SeriesExtensions.Diff4((FSharpFunc <int, FSharpFunc <int, int> >) new SeriesExtensions.Diff3())))); IVector <int> vector = instance.Build <int>(index.AddressingScheme, vectorConstruction3, new IVector <int>[1] { series2.Vector }); return(new Series <K, int>(index, vector, instance, series2.Index.Builder)); }
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 static Series <K, V> FromIndexVectorLoader <K, V>(Addressing.IAddressingScheme scheme, IVectorBuilder vectorBuilder, IIndexBuilder indexBuilder, K min, K max, Func <K, BoundaryBehavior, K, BoundaryBehavior, Task <Tuple <IIndex <K>, IVector <V> > > > loader) { return(DelayedSeries.FromIndexVectorLoader <K, V>(scheme, vectorBuilder, indexBuilder, min, max, (FSharpFunc <Tuple <K, BoundaryBehavior>, FSharpFunc <Tuple <K, BoundaryBehavior>, FSharpAsync <Tuple <IIndex <K>, IVector <V> > > > >) new DelayedSeries.FromIndexVectorLoader <K, V>(loader))); }
public static Series <K, V> FromIndexVectorLoader <K, V>(Addressing.IAddressingScheme scheme, IVectorBuilder vectorBuilder, IIndexBuilder indexBuilder, K min, K max, FSharpFunc <Tuple <K, BoundaryBehavior>, FSharpFunc <Tuple <K, BoundaryBehavior>, FSharpAsync <Tuple <IIndex <K>, IVector <V> > > > > loader) { Ranges.Ranges <K> ranges = Ranges.Ranges <K> .NewRange(new Tuple <Tuple <K, BoundaryBehavior>, Tuple <K, BoundaryBehavior> >(new Tuple <K, BoundaryBehavior>(min, BoundaryBehavior.get_Inclusive()), new Tuple <K, BoundaryBehavior>(max, BoundaryBehavior.get_Inclusive()))); DelayedSource <K, V> source = new DelayedSource <K, V>(scheme, min, max, ranges, indexBuilder, vectorBuilder, (FSharpFunc <Tuple <Tuple <K, BoundaryBehavior>, Tuple <K, BoundaryBehavior> >[], FSharpAsync <Tuple <IIndex <K>, IVector <V> > >[]>) new DelayedSeries.source <K, V>(loader)); return(new Series <K, V>((IIndex <K>) new DelayedIndex <K, V>(source), (IVector <V>) new DelayedVector <K, V>(source), vectorBuilder, (IIndexBuilder) new DelayedIndexBuilder())); }
public RowSequence(IIndex <TRowKey> index, IVector <ObjectSequence <TColumnKey> > vector, IVectorBuilder vectorBuilder, IIndexBuilder indexBuilder) : base(index, vector, vectorBuilder, indexBuilder) { }
public LinearIndexBuilder(IVectorBuilder vectorBuilder) { LinearIndexBuilder linearIndexBuilder = this; this.vectorBuilder = vectorBuilder; }
Tuple <IIndex <TNewKey>, IVector <R> > IIndexBuilder.Aggregate <K, TNewKey, R>(IIndex <K> index, Aggregation <K> aggregation, VectorConstruction vector, Func <Tuple <DataSegmentKind, Tuple <IIndex <K>, VectorConstruction> >, Tuple <TNewKey, R> > selector) { if (!index.IsOrdered) { throw new InvalidOperationException("Floating window aggregation and chunking is only supported on ordered indices. Consider sorting the series before calling the operation."); } IIndexBuilder indexBuilder1 = (IIndexBuilder)this; Aggregation <K> aggregation1 = aggregation; IEnumerable <Tuple <DataSegmentKind, long, long> > tuples1; switch (aggregation1.get_Tag()) { case 0: Aggregation <K> .WindowSize windowSize = (Aggregation <K> .WindowSize)aggregation1; tuples1 = Seq.windowRangesWithBounds((long)windowSize.item1, windowSize.item2, index.KeyCount); break; case 2: tuples1 = (IEnumerable <Tuple <DataSegmentKind, long, long> >)SeqModule.Map <Tuple <long, long>, Tuple <DataSegmentKind, long, long> >((Func <M0, M1>) new LinearIndex.locations(), (IEnumerable <M0>)Seq.windowRangesWhile <K>(((Aggregation <K> .WindowWhile)aggregation1).item, (IEnumerable <K>)index.Keys)); break; case 3: tuples1 = (IEnumerable <Tuple <DataSegmentKind, long, long> >)SeqModule.Map <Tuple <long, long>, Tuple <DataSegmentKind, long, long> >((Func <M0, M1>) new LinearIndex.locations(), (IEnumerable <M0>)Seq.chunkRangesWhile <K>(((Aggregation <K> .ChunkWhile)aggregation1).item, (IEnumerable <K>)index.Keys)); break; default: Aggregation <K> .ChunkSize chunkSize = (Aggregation <K> .ChunkSize)aggregation1; tuples1 = Seq.chunkRangesWithBounds((long)chunkSize.item1, chunkSize.item2, index.KeyCount); break; } IEnumerable <Tuple <DataSegmentKind, long, long> > tuples2 = tuples1; IEnumerable <Tuple <DataSegmentKind, Tuple <IIndex <K>, VectorConstruction> > > tuples3 = (IEnumerable <Tuple <DataSegmentKind, Tuple <IIndex <K>, VectorConstruction> > >)SeqModule.Map <Tuple <DataSegmentKind, long, long>, Tuple <DataSegmentKind, Tuple <IIndex <K>, VectorConstruction> > >((Func <M0, M1>) new LinearIndex.vectorConstructions <K>(index, vector), (IEnumerable <M0>)tuples2); Tuple <TNewKey, R>[] tupleArray1 = (Tuple <TNewKey, R>[])ArrayModule.OfSeq <Tuple <TNewKey, R> >((IEnumerable <M0>)SeqModule.Map <Tuple <DataSegmentKind, Tuple <IIndex <K>, VectorConstruction> >, Tuple <TNewKey, R> >((Func <M0, M1>)selector, (IEnumerable <M0>)tuples3)); IIndexBuilder indexBuilder2 = indexBuilder1; Func <Tuple <TNewKey, R>, TNewKey> Func1 = (Func <Tuple <TNewKey, R>, TNewKey>) new LinearIndex.newIndex <TNewKey, R>(); Tuple <TNewKey, R>[] tupleArray2 = tupleArray1; if ((object)tupleArray2 == null) { throw new ArgumentNullException("array"); } TNewKey[] array = new TNewKey[tupleArray2.Length]; IIndexBuilder indexBuilder3 = indexBuilder2; for (int index1 = 0; index1 < array.Length; ++index1) { array[index1] = Func1.Invoke(tupleArray2[index1]); } IIndex <TNewKey> index2 = indexBuilder3.Create <TNewKey>(System.Array.AsReadOnly <TNewKey>(array), (FSharpOption <bool>)null); IVectorBuilder vectorBuilder1 = this.vectorBuilder; Func <Tuple <TNewKey, R>, R> Func2 = (Func <Tuple <TNewKey, R>, R>) new LinearIndex.vect <TNewKey, R>(); Tuple <TNewKey, R>[] tupleArray3 = tupleArray1; if ((object)tupleArray3 == null) { throw new ArgumentNullException("array"); } R[] optionalValueArray = new R[tupleArray3.Length]; IVectorBuilder vectorBuilder2 = vectorBuilder1; for (int index1 = 0; index1 < optionalValueArray.Length; ++index1) { optionalValueArray[index1] = Func2.Invoke(tupleArray3[index1]); } IVector <R> missing = vectorBuilder2.CreateMissing <R>(optionalValueArray); return(new Tuple <IIndex <TNewKey>, IVector <R> >(index2, missing)); }
public ObjectSequence(IIndex <KeyT> index, IVector <object> vector, IVectorBuilder vectorBuilder, IIndexBuilder indexBuilder) : base(index, vector, vectorBuilder, indexBuilder) { }