Ast Playground 1. visualization

Src/AST/Myc.Ast.Nodes.pas

@@ -201,14 +201,14 @@ uses
     System.Classes;
 
 type
-    // Private interface to encapsulate a string value for reference counting.
-    IAstTextValue = interface(IInterface)
+    // Private interface to encapsulate a non scalar value for reference counting.
+    IAstValue<T> = interface
         function GetValue: string;
         property Value: string read GetValue;
     end;
 
     // Implementation of the text value interface.
-    TAstTextValue = class(TInterfacedObject, IAstTextValue)
+    TAstValue<T> = class(TInterfacedObject, IAstValue<T>)
     private
         FValue: string;
         function GetValue: string;
@@ -216,15 +216,15 @@ type
         constructor Create(const AValue: string);
     end;
 
-{ TAstTextValue }
+{ TAstValue }
 
-constructor TAstTextValue.Create(const AValue: string);
+constructor TAstValue<T>.Create(const AValue: string);
 begin
     inherited Create;
     FValue := AValue;
 end;
 
-function TAstTextValue.GetValue: string;
+function TAstValue<T>.GetValue: string;
 begin
     Result := FValue;
 end;
@@ -255,7 +255,7 @@ function TAstValue.AsText: String;
 begin
     if (FKind <> avkText) then
         raise EInvalidCast.Create('Cannot read value as Text.');
-    Result := IAstTextValue(FInterface).Value;
+    Result := IAstValue<String>(FInterface).Value;
 end;
 
 class function TAstValue.FromClosure(const AValue: IEvaluatorClosure): TAstValue;
@@ -275,7 +275,7 @@ end;
 class function TAstValue.FromText(const AValue: String): TAstValue;
 begin
     Result.FKind := avkText;
-    Result.FInterface := TAstTextValue.Create(AValue);
+    Result.FInterface := TAstValue<String>.Create(AValue);
     Result.FScalar := Default(TScalar);
 end;
 

Src/Data/Myc.Data.POD.pas

@@ -8,7 +8,7 @@ uses
     Myc.Data.Series;
 
 type
-    // POD: Plain old data (...that fits into 128 bits)
+    // POD: Plain old data (...that fits into 64 bits)
 
     TScalarKind = (
         skInteger,
@@ -26,9 +26,9 @@ type
         skDecimal
     );
 
-    TScalarBytes = array[0..15] of Byte;
-    TScalarPChar = array[0..7] of Char;
-    TScalarString = String[15];
+    TScalarBytes = array[0..7] of Byte;
+    TScalarPChar = array[0..3] of Char;
+    TScalarString = String[7];
 
     TScalarValue = record
     public
@@ -49,54 +49,29 @@ type
         class function FromBytes(const AValue: TScalarBytes): TScalarValue; static; inline;
         class function FromDecimal(AValue: TDecimal): TScalarValue; static; inline;
 
-        function GetAsInteger: Integer; inline;
-        function GetAsInt64: Int64; inline;
-        function GetAsUInt64: UInt64; inline;
-        function GetAsSingle: Single; inline;
-        function GetAsDouble: Double; inline;
-        function GetAsDateTime: TDateTime; inline;
-        function GetAsTimestamp: TTimestamp; inline;
-        function GetAsBoolean: Boolean; inline;
-        function GetAsChar: Char; inline;
-        function GetAsPChar: PChar; inline;
-        function GetAsString: ShortString; inline;
-        function GetAsBytes: TScalarBytes; inline;
-        function GetAsDecimal: TDecimal; inline;
-
-        property AsInteger: Integer read GetAsInteger;
-        property AsInt64: Int64 read GetAsInt64;
-        property AsUInt64: UInt64 read GetAsUInt64;
-        property AsSingle: Single read GetAsSingle;
-        property AsDouble: Double read GetAsDouble;
-        property AsDateTime: TDateTime read GetAsDateTime;
-        property AsTimestamp: TTimestamp read GetAsTimestamp;
-        property AsBoolean: Boolean read GetAsBoolean;
-        property AsChar: Char read GetAsChar;
-        property AsPChar: PChar read GetAsPChar;
-        property AsString: ShortString read GetAsString;
-        property AsBytes: TScalarBytes read GetAsBytes;
-        property AsDecimal: TDecimal read GetAsDecimal;
-
-    strict private
+    // Direct field access for performance.
     case TScalarKind of
-        skInteger: (FInteger: Integer);
-        skInt64: (FInt64: Int64);
-        skUInt64: (FUInt64: UInt64);
-        skSingle: (FSingle: Single);
-        skDouble: (FDouble: Double);
-        skDateTime: (FDateTime: TDateTime);
-        skTimestamp: (FTimestamp: TTimestamp);
-        skBoolean: (FBoolean: Boolean);
-        skChar: (FChar: Char);
-        skPChar: (FPChar: TScalarPChar);
-        skString: (FString: String[15]);
-        skBytes: (FBytes: TScalarBytes);
-        skDecimal: (FDecimal: TDecimal);
+        skInteger: (AsInteger: Integer);
+        skInt64: (AsInt64: Int64);
+        skUInt64: (AsUInt64: UInt64);
+        skSingle: (AsSingle: Single);
+        skDouble: (AsDouble: Double);
+        skDateTime: (AsDateTime: TDateTime);
+        skTimestamp: (AsTimestamp: TTimestamp);
+        skBoolean: (AsBoolean: Boolean);
+        skChar: (AsChar: Char);
+        skPChar: (AsPChar: TScalarPChar);
+        skString: (AsString: String[7]);
+        skBytes: (AsBytes: TScalarBytes);
+        skDecimal: (AsDecimal: TDecimal);
     end;
 
     // A scalar value with a type identifier.
     TScalar = record
     public
+        Kind: TScalarKind;
+        Value: TScalarValue;
+
         // Creates a new scalar from a kind and a value.
         constructor Create(AKind: TScalarKind; const AValue: TScalarValue);
 
@@ -113,19 +88,9 @@ type
         class function FromPChar(const AValue: TScalarPChar): TScalar; static; inline;
         class function FromString(const AValue: String): TScalar; static; inline;
         class function FromBytes(const AValue: TScalarBytes): TScalar; static; inline;
-        class function FromDecimal(AValue: TDecimal): TScalar; static; inline;
-
-        function GetKind: TScalarKind; inline;
-        function GetValue: TScalarValue; inline;
+        class function FromDecimal(const AValue: TDecimal): TScalar; static; inline;
 
         function ToString: String;
-
-        property Kind: TScalarKind read GetKind;
-        property Value: TScalarValue read GetValue;
-
-    strict private
-        FKind: TScalarKind;
-        FValue: TScalarValue;
     end;
 
     // Basic data structures using the scalar type (these are not POD of course)
@@ -133,51 +98,23 @@ type
     // An array of scalar values of the same kind.
     TScalarArray = record
     public
+        Kind: TScalarKind;
+        Items: TArray<TScalarValue>;
+
         // Creates a new scalar array.
         constructor Create(AKind: TScalarKind; const AItems: TArray<TScalarValue>);
-
-        function GetKind: TScalarKind; inline;
-        function GetItems: TArray<TScalarValue>; inline;
-
-        property Kind: TScalarKind read GetKind;
-        property Items: TArray<TScalarValue> read GetItems;
-
-    strict private
-        FKind: TScalarKind;
-        FItems: TArray<TScalarValue>;
     end;
 
     TScalarTuple = TArray<TScalar>;
 
     // A field definition for a scalar record.
     TScalarRecordField = record
-    public
-        // Creates a new record field definition.
+        Name: String;
+        Kind: TScalarKind;
         constructor Create(const AName: String; AKind: TScalarKind);
-
-        function GetName: String; inline;
-        function GetKind: TScalarKind; inline;
-
-        property Name: String read GetName;
-        property Kind: TScalarKind read GetKind;
-
-    strict private
-        FName: String;
-        FKind: TScalarKind;
     end;
 
-    // A collection of field definitions that describe a scalar record.
-    TScalarRecordDefinition = record
-    public
-        // Creates a new record definition.
-        constructor Create(const AFields: TArray<TScalarRecordField>);
-
-        function GetFields: TArray<TScalarRecordField>; inline;
-        property Fields: TArray<TScalarRecordField> read GetFields;
-
-    strict private
-        FFields: TArray<TScalarRecordField>;
-    end;
+    TScalarRecordDefinition = TArray<TScalarRecordField>;
 
     // A record of scalar values, based on a definition.
     TScalarRecord = record
@@ -215,272 +152,213 @@ type
         FItems: TSeries<TScalarValue>;
     end;
 
+    // A time series of scalar records, optimized for memory and access speed.
+    TScalarRecordSeries = record
+    private
+        FDef: TScalarRecordDefinition;
+        FArray: TChunkArray<TScalarValue>;
+        FTotalCount: Int64;
+        function GetDef: TScalarRecordDefinition; inline;
+        function GetItems(Idx: Integer): TScalarRecord;
+    public
+        constructor Create(const ADef: TScalarRecordDefinition);
+        procedure Add(const Item: TScalarRecord; Lookback: Int64 = -1);
+        property Def: TScalarRecordDefinition read GetDef;
+        property Items[Idx: Integer]: TScalarRecord read GetItems; default;
+        property TotalCount: Int64 read FTotalCount;
+    end;
+
 implementation
 
 { TScalarValue }
 
 class function TScalarValue.FromBoolean(AValue: Boolean): TScalarValue;
 begin
-    Result.FBoolean := AValue;
+    Result.AsBoolean := AValue;
 end;
 
 class function TScalarValue.FromBytes(const AValue: TScalarBytes): TScalarValue;
 begin
-    Result.FBytes := AValue;
+    Result.AsBytes := AValue;
 end;
 
 class function TScalarValue.FromChar(AValue: Char): TScalarValue;
 begin
-    Result.FChar := AValue;
+    Result.AsChar := AValue;
 end;
 
 class function TScalarValue.FromDateTime(AValue: TDateTime): TScalarValue;
 begin
-    Result.FDateTime := AValue;
+    Result.AsDateTime := AValue;
 end;
 
 class function TScalarValue.FromDecimal(AValue: TDecimal): TScalarValue;
 begin
-    Result.FDecimal := AValue;
+    Result.AsDecimal := AValue;
 end;
 
 class function TScalarValue.FromDouble(AValue: Double): TScalarValue;
 begin
-    Result.FDouble := AValue;
+    Result.AsDouble := AValue;
 end;
 
 class function TScalarValue.FromInt64(AValue: Int64): TScalarValue;
 begin
-    Result.FInt64 := AValue;
+    Result.AsInt64 := AValue;
 end;
 
 class function TScalarValue.FromInteger(AValue: Integer): TScalarValue;
 begin
-    Result.FInteger := AValue;
+    Result.AsInteger := AValue;
 end;
 
 class function TScalarValue.FromPChar(const AValue: String): TScalarValue;
 var
     len, i: Integer;
 begin
-    FillChar(Result.FPChar, SizeOf(Result.FPChar), #0);
+    FillChar(Result.AsPChar, SizeOf(Result.AsPChar), #0);
     len := Length(AValue);
     if (len > 0) then
     begin
-        if (len > Length(Result.FPChar)) then
-            len := Length(Result.FPChar);
+        if (len > Length(Result.AsPChar)) then
+            len := Length(Result.AsPChar);
         for i := 0 to len - 1 do
-            Result.FPChar[i] := AValue[i + 1];
+            Result.AsPChar[i] := AValue[i + 1];
     end;
 end;
 
 class function TScalarValue.FromPChar(const AValue: TScalarPChar): TScalarValue;
 begin
-    Result.FPChar := AValue;
+    Result.AsPChar := AValue;
 end;
 
 class function TScalarValue.FromSingle(AValue: Single): TScalarValue;
 begin
-    Result.FSingle := AValue;
+    Result.AsSingle := AValue;
 end;
 
 class function TScalarValue.FromString(const AValue: String): TScalarValue;
 begin
-    Result.FString := ShortString(AValue);
+    Result.AsString := ShortString(AValue);
 end;
 
 class function TScalarValue.FromString(const AValue: TScalarString): TScalarValue;
 begin
-    Result.FString := AValue;
+    Result.AsString := AValue;
 end;
 
 class function TScalarValue.FromTimestamp(AValue: TTimestamp): TScalarValue;
 begin
-    Result.FTimestamp := AValue;
+    Result.AsTimestamp := AValue;
 end;
 
 class function TScalarValue.FromUInt64(AValue: UInt64): TScalarValue;
 begin
-    Result.FUInt64 := AValue;
-end;
-
-function TScalarValue.GetAsBoolean: Boolean;
-begin
-    Result := FBoolean;
-end;
-
-function TScalarValue.GetAsBytes: TScalarBytes;
-begin
-    Result := FBytes;
-end;
-
-function TScalarValue.GetAsChar: Char;
-begin
-    Result := FChar;
-end;
-
-function TScalarValue.GetAsDateTime: TDateTime;
-begin
-    Result := FDateTime;
-end;
-
-function TScalarValue.GetAsDecimal: TDecimal;
-begin
-    Result := FDecimal;
-end;
-
-function TScalarValue.GetAsDouble: Double;
-begin
-    Result := FDouble;
-end;
-
-function TScalarValue.GetAsInt64: Int64;
-begin
-    Result := FInt64;
-end;
-
-function TScalarValue.GetAsInteger: Integer;
-begin
-    Result := FInteger;
-end;
-
-function TScalarValue.GetAsPChar: PChar;
-begin
-    Result := @FPChar;
-end;
-
-function TScalarValue.GetAsSingle: Single;
-begin
-    Result := FSingle;
-end;
-
-function TScalarValue.GetAsString: ShortString;
-begin
-    Result := FString;
-end;
-
-function TScalarValue.GetAsTimestamp: TTimestamp;
-begin
-    Result := FTimestamp;
-end;
-
-function TScalarValue.GetAsUInt64: UInt64;
-begin
-    Result := FUInt64;
+    Result.AsUInt64 := AValue;
 end;
 
 { TScalar }
 
 constructor TScalar.Create(AKind: TScalarKind; const AValue: TScalarValue);
 begin
-    FKind := AKind;
-    FValue := AValue;
+    Kind := AKind;
+    Value := AValue;
 end;
 
 class function TScalar.FromBoolean(AValue: Boolean): TScalar;
 begin
-    Result.FKind := skBoolean;
-    Result.FValue := TScalarValue.FromBoolean(AValue);
+    Result.Kind := skBoolean;
+    Result.Value := TScalarValue.FromBoolean(AValue);
 end;
 
 class function TScalar.FromBytes(const AValue: TScalarBytes): TScalar;
 begin
-    Result.FKind := skBytes;
-    Result.FValue := TScalarValue.FromBytes(AValue);
+    Result.Kind := skBytes;
+    Result.Value := TScalarValue.FromBytes(AValue);
 end;
 
 class function TScalar.FromChar(AValue: Char): TScalar;
 begin
-    Result.FKind := skChar;
-    Result.FValue := TScalarValue.FromChar(AValue);
+    Result.Kind := skChar;
+    Result.Value := TScalarValue.FromChar(AValue);
 end;
 
 class function TScalar.FromDateTime(AValue: TDateTime): TScalar;
 begin
-    Result.FKind := skDateTime;
-    Result.FValue := TScalarValue.FromDateTime(AValue);
+    Result.Kind := skDateTime;
+    Result.Value := TScalarValue.FromDateTime(AValue);
 end;
 
-class function TScalar.FromDecimal(AValue: TDecimal): TScalar;
+class function TScalar.FromDecimal(const AValue: TDecimal): TScalar;
 begin
-    Result.FKind := skDecimal;
-    Result.FValue := TScalarValue.FromDecimal(AValue);
+    Result.Kind := skDecimal;
+    Result.Value := TScalarValue.FromDecimal(AValue);
 end;
 
 class function TScalar.FromDouble(AValue: Double): TScalar;
 begin
-    Result.FKind := skDouble;
-    Result.FValue := TScalarValue.FromDouble(AValue);
+    Result.Kind := skDouble;
+    Result.Value := TScalarValue.FromDouble(AValue);
 end;
 
 class function TScalar.FromInt64(AValue: Int64): TScalar;
 begin
-    Result.FKind := skInt64;
-    Result.FValue := TScalarValue.FromInt64(AValue);
+    Result.Kind := skInt64;
+    Result.Value := TScalarValue.FromInt64(AValue);
 end;
 
 class function TScalar.FromInteger(AValue: Integer): TScalar;
 begin
-    Result.FKind := skInteger;
-    Result.FValue := TScalarValue.FromInteger(AValue);
+    Result.Kind := skInteger;
+    Result.Value := TScalarValue.FromInteger(AValue);
 end;
 
 class function TScalar.FromPChar(const AValue: TScalarPChar): TScalar;
 begin
-    Result.FKind := skPChar;
-    Result.FValue := TScalarValue.FromPChar(AValue);
+    Result.Kind := skPChar;
+    Result.Value := TScalarValue.FromPChar(AValue);
 end;
 
 class function TScalar.FromSingle(AValue: Single): TScalar;
 begin
-    Result.FKind := skSingle;
-    Result.FValue := TScalarValue.FromSingle(AValue);
+    Result.Kind := skSingle;
+    Result.Value := TScalarValue.FromSingle(AValue);
 end;
 
 class function TScalar.FromString(const AValue: String): TScalar;
 begin
-    Result.FKind := skString;
-    Result.FValue := TScalarValue.FromString(AValue);
+    Result.Kind := skString;
+    Result.Value := TScalarValue.FromString(AValue);
 end;
 
 class function TScalar.FromTimestamp(AValue: TTimestamp): TScalar;
 begin
-    Result.FKind := skTimestamp;
-    Result.FValue := TScalarValue.FromTimestamp(AValue);
+    Result.Kind := skTimestamp;
+    Result.Value := TScalarValue.FromTimestamp(AValue);
 end;
 
 class function TScalar.FromUInt64(AValue: UInt64): TScalar;
 begin
-    Result.FKind := skUInt64;
-    Result.FValue := TScalarValue.FromUInt64(AValue);
-end;
-
-function TScalar.GetKind: TScalarKind;
-begin
-    Result := FKind;
-end;
-
-function TScalar.GetValue: TScalarValue;
-begin
-    Result := FValue;
+    Result.Kind := skUInt64;
+    Result.Value := TScalarValue.FromUInt64(AValue);
 end;
 
 function TScalar.ToString: String;
 begin
-    case FKind of
-        skInteger: Result := IntToStr(FValue.AsInteger);
-        skInt64: Result := IntToStr(FValue.AsInt64);
-        skUInt64: Result := UIntToStr(FValue.AsUInt64);
-        skSingle: Result := FloatToStr(FValue.AsSingle);
-        skDouble: Result := FloatToStr(FValue.AsDouble);
-        skDateTime: Result := DateTimeToStr(FValue.AsDateTime);
-        skTimestamp: Result := FormatDateTime('yyyy-mm-dd hh:nn:ss.zzz', TimeStampToDateTime(FValue.AsTimestamp));
-        skBoolean: Result := BoolToStr(FValue.AsBoolean, True);
-        skChar: Result := '''' + FValue.AsChar + '''';
-        skPChar: Result := FValue.AsPChar; // Already null-terminated
-        skString: Result := '''' + string(FValue.AsString) + '''';
+    case Kind of
+        skInteger: Result := IntToStr(Value.AsInteger);
+        skInt64: Result := IntToStr(Value.AsInt64);
+        skUInt64: Result := UIntToStr(Value.AsUInt64);
+        skSingle: Result := FloatToStr(Value.AsSingle);
+        skDouble: Result := FloatToStr(Value.AsDouble);
+        skDateTime: Result := DateTimeToStr(Value.AsDateTime);
+        skTimestamp: Result := FormatDateTime('yyyy-mm-dd hh:nn:ss.zzz', TimeStampToDateTime(Value.AsTimestamp));
+        skBoolean: Result := BoolToStr(Value.AsBoolean, True);
+        skChar: Result := '''' + Value.AsChar + '''';
+        skPChar: Result := PChar(@Value.AsPChar); // Needs explicit cast/pointer
+        skString: Result := '''' + string(Value.AsString) + '''';
         skBytes: Result := '(Bytes)';
-        skDecimal: Result := FloatToStr(Double(FValue.AsDecimal));
+        skDecimal: Result := FloatToStr(Double(Value.AsDecimal));
     else
         Result := '[Unknown Scalar]';
     end;
@@ -490,55 +368,23 @@ end;
 
 constructor TScalarArray.Create(AKind: TScalarKind; const AItems: TArray<TScalarValue>);
 begin
-    FKind := AKind;
-    FItems := AItems;
-end;
-
-function TScalarArray.GetKind: TScalarKind;
-begin
-    Result := FKind;
-end;
-
-function TScalarArray.GetItems: TArray<TScalarValue>;
-begin
-    Result := FItems;
+    Kind := AKind;
+    Items := AItems;
 end;
 
 { TScalarRecordField }
 
 constructor TScalarRecordField.Create(const AName: String; AKind: TScalarKind);
 begin
-    FName := AName;
-    FKind := AKind;
-end;
-
-function TScalarRecordField.GetName: String;
-begin
-    Result := FName;
-end;
-
-function TScalarRecordField.GetKind: TScalarKind;
-begin
-    Result := FKind;
-end;
-
-{ TScalarRecordDefinition }
-
-constructor TScalarRecordDefinition.Create(const AFields: TArray<TScalarRecordField>);
-begin
-    FFields := AFields;
-end;
-
-function TScalarRecordDefinition.GetFields: TArray<TScalarRecordField>;
-begin
-    Result := FFields;
+    Name := AName;
+    Kind := AKind;
 end;
 
 { TScalarRecord }
 
 constructor TScalarRecord.Create(const ADef: TScalarRecordDefinition; const AFields: TArray<TScalarValue>);
 begin
-    Assert(Length(ADef.Fields) = Length(AFields), 'Field definition and value count must match.');
+    Assert(Length(ADef) = Length(AFields), 'Field definition and value count must match.');
     FDef := ADef;
     FFields := AFields;
 end;
@@ -559,9 +405,9 @@ var
     fieldDef: TScalarRecordField;
 begin
     // Find the index of the field by name (case-insensitive)
-    for i := 0 to Length(FDef.Fields) - 1 do
+    for i := 0 to Length(FDef) - 1 do
     begin
-        fieldDef := FDef.Fields[i];
+        fieldDef := FDef[i];
         if (CompareText(fieldDef.Name, Name) = 0) then
         begin
             // Found it. Construct the TScalar result from the kind and value.
@@ -592,7 +438,42 @@ begin
     Result := FItems;
 end;
 
+{ TScalarRecordSeries }
+
+// Implements a time series of scalar records using a chunk array for efficient storage.
+// Each record's fields are stored sequentially in the TChunkArray.
+
+constructor TScalarRecordSeries.Create(const ADef: TScalarRecordDefinition);
+begin
+    Assert(Length(ADef) > 0);
+    FDef := ADef;
+    FArray := Default(TChunkArray<TScalarValue>);
+    FTotalCount := 0;
+end;
+
+procedure TScalarRecordSeries.Add(const Item: TScalarRecord; Lookback: Int64 = -1);
+begin
+    FArray.Add(Item.Fields, Length(FDef) * Lookback);
+    inc(FTotalCount);
+end;
+
+function TScalarRecordSeries.GetDef: TScalarRecordDefinition;
+begin
+    Result := FDef;
+end;
+
+function TScalarRecordSeries.GetItems(Idx: Integer): TScalarRecord;
+var
+    values: TArray<TScalarValue>;
+    fieldCount: Integer;
+begin
+    fieldCount := Length(FDef);
+    SetLength(values, fieldCount);
+    Move(FArray.ItemRef[(FArray.Count - fieldCount) - (Idx * fieldCount)]^, values[0], sizeof(TScalarValue) * fieldCount);
+    Result.Create(FDef, values);
+end;
+
 initialization
-    Assert(sizeof(TScalarValue) = 16);
+    Assert(sizeof(TScalarValue) = 8);
 
 end.

Src/Myc.Data.Series.pas

@@ -4,16 +4,19 @@ interface
 
 type
     TChunkArray<T> = record
+        type
+            PT = ^T;
     private
         const
             ChunkSize = 1024;
         type
-            TChunk = TArray<T>;
+            TChunk = array of T;
     private
         FChunks: TArray<TChunk>;
         FOffset: Integer;
         FCount: Integer;
         function GetItems(Idx: Integer): T; inline;
+        function GetItemRef(Idx: Integer): PT; inline;
 
     public
         constructor Create(const AChunks: TArray<TChunk>; ACount: Integer; AOffset: Integer);
@@ -32,6 +35,7 @@ type
 
         property Count: Integer read FCount;
         property Items[Idx: Integer]: T read GetItems; default;
+        property ItemRef[Idx: Integer]: PT read GetItemRef;
     end;
 
     // A series where the last added item has index 0.
@@ -274,9 +278,7 @@ end;
 
 function TChunkArray<T>.GetItems(Idx: Integer): T;
 begin
-    // Convert logical index to physical index inside chunks
-    var physicalIdx := Idx + FOffset;
-    Result := FChunks[physicalIdx div ChunkSize][physicalIdx mod ChunkSize];
+    Result := GetItemRef(Idx)^;
 end;
 
 function TChunkArray<T>.Copy(MaxCount: Integer): TChunkArray<T>;
@@ -341,6 +343,13 @@ begin
     Result.FCount := effectiveCount;
 end;
 
+function TChunkArray<T>.GetItemRef(Idx: Integer): PT;
+begin
+    Assert((Idx >= 0) and (Idx < FCount));
+    var physicalIdx := Idx + FOffset;
+    Result := @FChunks[physicalIdx div ChunkSize][physicalIdx mod ChunkSize];
+end;
+
 class operator TChunkArray<T>.Initialize(out Dest: TChunkArray<T>);
 begin
     Dest.FOffset := 0;
@@ -349,6 +358,12 @@ end;
 
 { TSeries<T> }
 
+constructor TSeries<T>.Create(const AArray: TChunkArray<T>; ATotalCount: Int64);
+begin
+    FArray := AArray;
+    FTotalCount := ATotalCount;
+end;
+
 procedure TSeries<T>.Add(const Data: T; Lookback: Int64);
 begin
     FArray.Add(Data, Lookback);
@@ -361,12 +376,6 @@ begin
     inc(FTotalCount, Length(Data));
 end;
 
-constructor TSeries<T>.Create(const AArray: TChunkArray<T>; ATotalCount: Int64);
-begin
-    FArray := AArray;
-    FTotalCount := ATotalCount;
-end;
-
 function TSeries<T>.Copy(Lookback: Integer): TSeries<T>;
 begin
     // Create a copy of the underlying chunk array, optionally truncating it.

Src/Myc.Trade.Indicators_v2.pas

@@ -1,4 +1,4 @@
-unit Myc.Trade.Indicators_V2;
+unit Myc.Trade.Indicators_V2 deprecated;
 
 interface
 
@@ -377,7 +377,7 @@ begin
     begin
         shortName := rttiType.Name;
     end;
-
+    {
     // Create the main factory procedure. This is a double-nested anonymous method
     // that wraps the template's specific factory and worker functions.
     factoryProc :=
@@ -419,7 +419,7 @@ begin
                     Result := DataValueFromTValue(resultAsTValue);
                 end;
         end;
-
+}
     // Create the final factory instance with all type handles and extracted metadata.
     Result := TGenericIndicatorFactory.Create(factoryProc, shortName, name, hint, paramsDataType, argsDataType, resultDataType);
 end;
@@ -452,7 +452,7 @@ begin
     var paramsAsTValue := TValue.From<TParams>(Params);
     var paramsAsDataValue := DataValueFromTValue(paramsAsTValue);
     var cIndicator := FFactoryProc(paramsAsDataValue);
-
+    {
     Result :=
         function(const Args: TArgs): TResult
         begin
@@ -461,7 +461,7 @@ begin
             var resultAsDataValue := cIndicator(argsAsDataValue);
             var resultAsTValue := resultAsDataValue.AsTValue;
             Result := resultAsTValue.AsType<TResult>;
-        end;
+        end;}
 end;
 
 { TIndicatorRegistry.TItem }
@@ -481,7 +481,7 @@ begin
     var paramsAsTValue := TValue.From<TParams>(Params);
     var paramsAsDataValue := DataValueFromTValue(paramsAsTValue);
     var cIndicator := FFactory.CreateIndicator(paramsAsDataValue);
-
+    {
     // Return a wrapper that handles the conversion for args and result.
     Result :=
         function(const Args: TArgs): TResult
@@ -491,7 +491,7 @@ begin
             var resultAsDataValue := cIndicator(argsAsDataValue);
             var resultAsTValue := resultAsDataValue.AsTValue;
             Result := resultAsTValue.AsType<TResult>;
-        end;
+        end;}
 end;
 
 { TIndicatorRegistry }