Brummel/MycLib
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Aura types

Browse Source
This commit is contained in:
Michael Schimmel
2025-08-25 20:18:38 +02:00
parent b4a5e30b45
commit e4681e2bf7
2 changed files with 590 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Src/Data/Myc.Data.Types.Method.pas
-3
View File
@@ -9,7 +9,6 @@ uses
type
// Implements the IDataMethodType interface.
// This class is now instantiated for each unique method signature.
TDataMethodType = class(TInterfacedObject, IDataMethodType)
private
FArgType: IDataType;
@@ -20,7 +19,6 @@ type
function GetResultType: IDataType;
function CreateValue(const AValue: TMethodProc): IDataMethodValue;
public
// The constructor now takes the signature types.
constructor Create(const AArgType, AResultType: IDataType);
end;
@@ -57,7 +55,6 @@ begin
if not Assigned(AValue) then
raise EArgumentException.Create('AValue');
// Pass Self to the value's constructor, so it knows its exact type
Result := TDataMethodValue.Create(Self, AValue);
end;
Src/Myc.Trade.Indicators.Common.pas
+590
View File
@@ -9,6 +9,7 @@ uses
Myc.Data.Records,
Myc.Data.Pipeline,
Myc.Data.Series,
Myc.Data.Types,
Myc.Trade.Types,
Myc.Trade.Indicators;
@@ -18,6 +19,10 @@ type
[IndicatorName('SMA', 'Simple Moving Average')]
[IndicatorHint('Calculates the average of a selected range of prices.')]
TSMA = class
strict private
class var
FFactory: IDataMethodValue;
class constructor CreateClass;
public
type
TParams = record
@@ -32,11 +37,18 @@ type
[IndicatorFactory]
class function CreateFactory: TIndicatorFactoryProc<TParams, TArgs, TResult>; static;
class function CreateSMA(Period: Integer): TConvertFunc<Double, Double>; static;
// Provides the factory method for this indicator as a data value.
class property Factory: IDataMethodValue read FFactory;
end;
[IndicatorName('EMA', 'Exponential Moving Average')]
[IndicatorHint('A moving average that places greater weight on the most recent data points.')]
TEMA = class
strict private
class var
FFactory: IDataMethodValue;
class constructor CreateClass;
public
type
TParams = record
@@ -51,11 +63,17 @@ type
[IndicatorFactory]
class function CreateFactory: TIndicatorFactoryProc<TParams, TArgs, TResult>; static;
class function CreateEMA(Period: Integer): TConvertFunc<Double, Double>; static;
// Provides the factory method for this indicator as a data value.
class property Factory: IDataMethodValue read FFactory;
end;
[IndicatorName('WMA', 'Weighted Moving Average')]
[IndicatorHint('A moving average that places greater weight on more recent data points.')]
TWMA = class
strict private
class var
FFactory: IDataMethodValue;
class constructor CreateClass;
public
type
TParams = record
@@ -70,11 +88,17 @@ type
[IndicatorFactory]
class function CreateFactory: TIndicatorFactoryProc<TParams, TArgs, TResult>; static;
class function CreateWMA(Period: Integer): TConvertFunc<Double, Double>; static;
// Provides the factory method for this indicator as a data value.
class property Factory: IDataMethodValue read FFactory;
end;
[IndicatorName('HMA', 'Hull Moving Average')]
[IndicatorHint('A fast, smooth moving average that minimizes lag.')]
THMA = class
strict private
class var
FFactory: IDataMethodValue;
class constructor CreateClass;
public
type
TParams = record
@@ -89,11 +113,17 @@ type
[IndicatorFactory]
class function CreateFactory: TIndicatorFactoryProc<TParams, TArgs, TResult>; static;
class function CreateHMA(Period: Integer): TConvertFunc<Double, Double>; static;
// Provides the factory method for this indicator as a data value.
class property Factory: IDataMethodValue read FFactory;
end;
[IndicatorName('RSI', 'Relative Strength Index')]
[IndicatorHint('A momentum indicator measuring the magnitude of recent price changes.')]
TRSI = class
strict private
class var
FFactory: IDataMethodValue;
class constructor CreateClass;
public
type
TParams = record
@@ -108,11 +138,17 @@ type
[IndicatorFactory]
class function CreateFactory: TIndicatorFactoryProc<TParams, TArgs, TResult>; static;
class function CreateRSI(Period: Integer): TConvertFunc<Double, Double>; static;
// Provides the factory method for this indicator as a data value.
class property Factory: IDataMethodValue read FFactory;
end;
[IndicatorName('MACD', 'Moving Average Convergence Divergence')]
[IndicatorHint('A trend-following momentum indicator showing the relationship between two EMAs.')]
TMACD = class
strict private
class var
FFactory: IDataMethodValue;
class constructor CreateClass;
public
type
TParams = record
@@ -136,11 +172,17 @@ type
EmaSlow,
EmaSignal: TConvertFunc<Double, Double>
): TConvertFunc<Double, TMACD.TResult>; overload; static;
// Provides the factory method for this indicator as a data value.
class property Factory: IDataMethodValue read FFactory;
end;
[IndicatorName('Stoch', 'Stochastic Oscillator')]
[IndicatorHint('A momentum indicator comparing a closing price to a range of its prices.')]
TStochastic = class
strict private
class var
FFactory: IDataMethodValue;
class constructor CreateClass;
public
type
TParams = record
@@ -162,11 +204,17 @@ type
KPeriod: Integer;
const SmaD: TConvertFunc<Double, Double>
): TConvertFunc<TOhlcItem, TStochastic.TResult>; overload; static;
// Provides the factory method for this indicator as a data value.
class property Factory: IDataMethodValue read FFactory;
end;
[IndicatorName('StdDev', 'Standard Deviation')]
[IndicatorHint('Measures the amount of variation or dispersion of a set of values.')]
TStdDev = class
strict private
class var
FFactory: IDataMethodValue;
class constructor CreateClass;
public
type
TParams = record
@@ -181,11 +229,17 @@ type
[IndicatorFactory]
class function CreateFactory: TIndicatorFactoryProc<TParams, TArgs, TResult>; static;
class function CreateStdDev(Period: Integer): TConvertFunc<Double, Double>; static;
// Provides the factory method for this indicator as a data value.
class property Factory: IDataMethodValue read FFactory;
end;
[IndicatorName('BB', 'Bollinger Bands')]
[IndicatorHint('Characterizes prices and volatility over time using standard deviation bands.')]
TBollingerBands = class
strict private
class var
FFactory: IDataMethodValue;
class constructor CreateClass;
public
type
TParams = record
@@ -203,11 +257,17 @@ type
[IndicatorFactory]
class function CreateFactory: TIndicatorFactoryProc<TParams, TArgs, TResult>; static;
class function CreateBollingerBands(Period: Integer; Multiplier: Double): TConvertFunc<Double, TResult>; static;
// Provides the factory method for this indicator as a data value.
class property Factory: IDataMethodValue read FFactory;
end;
[IndicatorName('ATR', 'Average True Range')]
[IndicatorHint('Measures market volatility by decomposing the entire range of an asset price.')]
TATR = class
strict private
class var
FFactory: IDataMethodValue;
class constructor CreateClass;
public
type
TParams = record
@@ -223,11 +283,17 @@ type
class function CreateFactory: TIndicatorFactoryProc<TParams, TArgs, TResult>; static;
class function CreateATR(Period: Integer): TConvertFunc<TOhlcItem, Double>; overload; static;
class function CreateATR(const MovAvgTR: TConvertFunc<Double, Double>): TConvertFunc<TOhlcItem, Double>; overload; static;
// Provides the factory method for this indicator as a data value.
class property Factory: IDataMethodValue read FFactory;
end;
[IndicatorName('KC', 'Keltner Channels')]
[IndicatorHint('A volatility-based indicator composed of an EMA and two ATR-based outer lines.')]
TKeltnerChannels = class
strict private
class var
FFactory: IDataMethodValue;
class constructor CreateClass;
public
type
TParams = record
@@ -250,11 +316,17 @@ type
const AtrFunc: TConvertFunc<TOhlcItem, Double>;
Multiplier: Double
): TConvertFunc<TOhlcItem, TKeltnerChannels.TResult>; overload; static;
// Provides the factory method for this indicator as a data value.
class property Factory: IDataMethodValue read FFactory;
end;
[IndicatorName('Mean', 'Mean Value')]
[IndicatorHint('Calculates the arithmetic mean of an array of values.')]
TMean = class
strict private
class var
FFactory: IDataMethodValue;
class constructor CreateClass;
public
type
TParams = record
@@ -268,12 +340,73 @@ type
[IndicatorFactory]
class function CreateFactory: TIndicatorFactoryProc<TParams, TArgs, TResult>; static;
class function CreateMean: TConvertFunc<TArray<Double>, Double>; static;
// Provides the factory method for this indicator as a data value.
class property Factory: IDataMethodValue read FFactory;
end;
implementation
{ TSMA }
class constructor TSMA.CreateClass;
begin
{ var params := TDataType.RecordOf( [TRecordField.Create( 'Period', TDataType.Ordinal )] );
var args := TDataType.RecordOf( [TRecordField.Create( 'Value', TDataType.Float )] );
var results := TDataType.RecordOf( [TRecordField.Create( 'SMA', TDataType.Float )] );
var indicatorMethod := TDataType.MethodOf( args, results );
var factoryMethod := TDataType.MethodOf( params, indicatorMethod );
FFactory := factoryMethod.CreateValue(
function( const Params: IDataValue ): IDataValue
begin
var period := TDataValue(TDataValue(Params).AsRecord.Items[0]).AsOrdinal.Value;
var SMA := CreateSMA( period );
Result := indicatorMethod.CreateValue(
function( const Args: IDataValue ): IDataValue
begin
var value := TDataValue(TDataValue(Args).AsRecord.Items[0]).AsFloat.Value;
var res := SMA( value );
Result := results.CreateValue( [TDataValue.FromFloat(res)] );
end );
end );
}
// ....or....
var params := TDataType.Ordinal;
var args := TDataType.Float;
var results := TDataType.Float;
var indicatorMethod := TDataType.MethodOf(args, results);
var factoryMethod := TDataType.MethodOf(params, indicatorMethod);
FFactory :=
factoryMethod.CreateValue(
function(const Params: IDataValue): IDataValue
begin
var period := TDataValue(Params).AsOrdinal.Value;
var SMA := CreateSMA(period);
Result :=
indicatorMethod.CreateValue(
function(const Args: IDataValue): IDataValue
begin
var value := TDataValue(Args).AsFloat.Value;
var res := SMA(value);
Result := results.CreateValue(res);
end
);
end
);
end;
class function TSMA.CreateFactory: TIndicatorFactoryProc<TSMA.TParams, TSMA.TArgs, TSMA.TResult>;
begin
Result :=
@@ -348,6 +481,36 @@ end;
{ TEMA }
class constructor TEMA.CreateClass;
begin
var params := TDataType.RecordOf([TRecordField.Create('Period', TDataType.Ordinal)]);
var args := TDataType.RecordOf([TRecordField.Create('Value', TDataType.Float)]);
var results := TDataType.RecordOf([TRecordField.Create('EMA', TDataType.Float)]);
var indicatorMethod := TDataType.MethodOf(args, results);
var factoryMethod := TDataType.MethodOf(params, indicatorMethod);
FFactory :=
factoryMethod.CreateValue(
function(const Params: IDataValue): IDataValue
begin
var period := TDataValue(TDataValue(Params).AsRecord.Items[0]).AsOrdinal.Value;
var EMA := CreateEMA(period);
Result :=
indicatorMethod.CreateValue(
function(const Args: IDataValue): IDataValue
begin
var value := TDataValue(TDataValue(Args).AsRecord.Items[0]).AsFloat.Value;
var res := EMA(value);
Result := results.CreateValue([TDataValue.FromFloat(res)]);
end
);
end
);
end;
class function TEMA.CreateFactory: TIndicatorFactoryProc<TEMA.TParams, TEMA.TArgs, TEMA.TResult>;
begin
Result :=
@@ -406,6 +569,34 @@ end;
{ TWMA }
class constructor TWMA.CreateClass;
begin
var params := TDataType.RecordOf([TRecordField.Create('Period', TDataType.Ordinal)]);
var args := TDataType.RecordOf([TRecordField.Create('Value', TDataType.Float)]);
var results := TDataType.RecordOf([TRecordField.Create('WMA', TDataType.Float)]);
var indicatorMethod := TDataType.MethodOf(args, results);
var factoryMethod := TDataType.MethodOf(params, indicatorMethod);
FFactory :=
factoryMethod.CreateValue(
function(const Params: IDataValue): IDataValue
begin
var period := TDataValue(TDataValue(Params).AsRecord.Items[0]).AsOrdinal.Value;
var WMA := CreateWMA(period);
Result :=
indicatorMethod.CreateValue(
function(const Args: IDataValue): IDataValue
begin
var value := TDataValue(TDataValue(Args).AsRecord.Items[0]).AsFloat.Value;
var res := WMA(value);
Result := results.CreateValue([TDataValue.FromFloat(res)]);
end
);
end
);
end;
class function TWMA.CreateFactory: TIndicatorFactoryProc<TWMA.TParams, TWMA.TArgs, TWMA.TResult>;
begin
Result :=
@@ -476,6 +667,34 @@ end;
{ THMA }
class constructor THMA.CreateClass;
begin
var params := TDataType.RecordOf([TRecordField.Create('Period', TDataType.Ordinal)]);
var args := TDataType.RecordOf([TRecordField.Create('Value', TDataType.Float)]);
var results := TDataType.RecordOf([TRecordField.Create('HMA', TDataType.Float)]);
var indicatorMethod := TDataType.MethodOf(args, results);
var factoryMethod := TDataType.MethodOf(params, indicatorMethod);
FFactory :=
factoryMethod.CreateValue(
function(const Params: IDataValue): IDataValue
begin
var period := TDataValue(TDataValue(Params).AsRecord.Items[0]).AsOrdinal.Value;
var HMA := CreateHMA(period);
Result :=
indicatorMethod.CreateValue(
function(const Args: IDataValue): IDataValue
begin
var value := TDataValue(TDataValue(Args).AsRecord.Items[0]).AsFloat.Value;
var res := HMA(value);
Result := results.CreateValue([TDataValue.FromFloat(res)]);
end
);
end
);
end;
class function THMA.CreateFactory: TIndicatorFactoryProc<THMA.TParams, THMA.TArgs, THMA.TResult>;
begin
Result :=
@@ -519,6 +738,34 @@ end;
{ TRSI }
class constructor TRSI.CreateClass;
begin
var params := TDataType.RecordOf([TRecordField.Create('Period', TDataType.Ordinal)]);
var args := TDataType.RecordOf([TRecordField.Create('Value', TDataType.Float)]);
var results := TDataType.RecordOf([TRecordField.Create('RSI', TDataType.Float)]);
var indicatorMethod := TDataType.MethodOf(args, results);
var factoryMethod := TDataType.MethodOf(params, indicatorMethod);
FFactory :=
factoryMethod.CreateValue(
function(const Params: IDataValue): IDataValue
begin
var period := TDataValue(TDataValue(Params).AsRecord.Items[0]).AsOrdinal.Value;
var RSI := CreateRSI(period);
Result :=
indicatorMethod.CreateValue(
function(const Args: IDataValue): IDataValue
begin
var value := TDataValue(TDataValue(Args).AsRecord.Items[0]).AsFloat.Value;
var res := RSI(value);
Result := results.CreateValue([TDataValue.FromFloat(res)]);
end
);
end
);
end;
class function TRSI.CreateFactory: TIndicatorFactoryProc<TRSI.TParams, TRSI.TArgs, TRSI.TResult>;
begin
Result :=
@@ -592,6 +839,61 @@ end;
{ TMACD }
class constructor TMACD.CreateClass;
begin
var params :=
TDataType.RecordOf(
[
TRecordField.Create('FastPeriod', TDataType.Ordinal),
TRecordField.Create('SlowPeriod', TDataType.Ordinal),
TRecordField.Create('SignalPeriod', TDataType.Ordinal)
]
);
var args := TDataType.RecordOf([TRecordField.Create('Value', TDataType.Float)]);
var results :=
TDataType.RecordOf(
[
TRecordField.Create('MacdLine', TDataType.Float),
TRecordField.Create('SignalLine', TDataType.Float),
TRecordField.Create('Histogram', TDataType.Float)
]
);
var indicatorMethod := TDataType.MethodOf(args, results);
var factoryMethod := TDataType.MethodOf(params, indicatorMethod);
FFactory :=
factoryMethod.CreateValue(
function(const Params: IDataValue): IDataValue
var
paramsRec: IDataRecordValue;
begin
paramsRec := TDataValue(Params).AsRecord;
var fastPeriod := TDataValue(paramsRec.Items[0]).AsOrdinal.Value;
var slowPeriod := TDataValue(paramsRec.Items[1]).AsOrdinal.Value;
var signalPeriod := TDataValue(paramsRec.Items[2]).AsOrdinal.Value;
var MACD := CreateMACD(fastPeriod, slowPeriod, signalPeriod);
Result :=
indicatorMethod.CreateValue(
function(const Args: IDataValue): IDataValue
begin
var value := TDataValue(TDataValue(Args).AsRecord.Items[0]).AsFloat.Value;
var res := MACD(value);
Result :=
results.CreateValue(
[
TDataValue.FromFloat(res.MacdLine),
TDataValue.FromFloat(res.SignalLine),
TDataValue.FromFloat(res.Histogram)
]
);
end
);
end
);
end;
class function TMACD.CreateFactory: TIndicatorFactoryProc<TMACD.TParams, TMACD.TArgs, TMACD.TResult>;
begin
Result :=
@@ -703,6 +1005,64 @@ begin
Result := FItems[FHead];
end;
class constructor TStochastic.CreateClass;
begin
var params :=
TDataType.RecordOf([TRecordField.Create('KPeriod', TDataType.Ordinal), TRecordField.Create('DPeriod', TDataType.Ordinal)]);
var ohlcType :=
TDataType.RecordOf(
[
TRecordField.Create('Open', TDataType.Float),
TRecordField.Create('High', TDataType.Float),
TRecordField.Create('Low', TDataType.Float),
TRecordField.Create('Close', TDataType.Float),
TRecordField.Create('Volume', TDataType.Float)
]
);
var args := TDataType.RecordOf([TRecordField.Create('Value', ohlcType)]);
var results := TDataType.RecordOf([TRecordField.Create('K', TDataType.Float), TRecordField.Create('D', TDataType.Float)]);
var indicatorMethod := TDataType.MethodOf(args, results);
var factoryMethod := TDataType.MethodOf(params, indicatorMethod);
FFactory :=
factoryMethod.CreateValue(
function(const Params: IDataValue): IDataValue
var
paramsRec: IDataRecordValue;
begin
paramsRec := TDataValue(Params).AsRecord;
var kPeriod := TDataValue(paramsRec.Items[0]).AsOrdinal.Value;
var dPeriod := TDataValue(paramsRec.Items[1]).AsOrdinal.Value;
var Stochastic := CreateStochastic(kPeriod, dPeriod);
Result :=
indicatorMethod.CreateValue(
function(const Args: IDataValue): IDataValue
var
argRec, ohlcRec: IDataRecordValue;
ohlcVal: TOhlcItem;
begin
argRec := TDataValue(Args).AsRecord;
ohlcRec := TDataValue(argRec.Items[0]).AsRecord;
ohlcVal.Open := TDataValue(ohlcRec.Items[0]).AsFloat.Value;
ohlcVal.High := TDataValue(ohlcRec.Items[1]).AsFloat.Value;
ohlcVal.Low := TDataValue(ohlcRec.Items[2]).AsFloat.Value;
ohlcVal.Close := TDataValue(ohlcRec.Items[3]).AsFloat.Value;
ohlcVal.Volume := TDataValue(ohlcRec.Items[4]).AsFloat.Value;
var res := Stochastic(ohlcVal);
Result := results.CreateValue([TDataValue.FromFloat(res.K), TDataValue.FromFloat(res.D)]);
end
);
end
);
end;
class function TStochastic.CreateFactory: TIndicatorFactoryProc<TStochastic.TParams, TStochastic.TArgs, TStochastic.TResult>;
begin
Result :=
@@ -810,6 +1170,34 @@ end;
{ TStdDev }
class constructor TStdDev.CreateClass;
begin
var params := TDataType.RecordOf([TRecordField.Create('Period', TDataType.Ordinal)]);
var args := TDataType.RecordOf([TRecordField.Create('Value', TDataType.Float)]);
var results := TDataType.RecordOf([TRecordField.Create('StdDev', TDataType.Float)]);
var indicatorMethod := TDataType.MethodOf(args, results);
var factoryMethod := TDataType.MethodOf(params, indicatorMethod);
FFactory :=
factoryMethod.CreateValue(
function(const Params: IDataValue): IDataValue
begin
var period := TDataValue(TDataValue(Params).AsRecord.Items[0]).AsOrdinal.Value;
var StdDev := CreateStdDev(period);
Result :=
indicatorMethod.CreateValue(
function(const Args: IDataValue): IDataValue
begin
var value := TDataValue(TDataValue(Args).AsRecord.Items[0]).AsFloat.Value;
var res := StdDev(value);
Result := results.CreateValue([TDataValue.FromFloat(res)]);
end
);
end
);
end;
class function TStdDev.CreateFactory: TIndicatorFactoryProc<TStdDev.TParams, TStdDev.TArgs, TStdDev.TResult>;
begin
Result :=
@@ -875,6 +1263,54 @@ end;
{ TBollingerBands }
class constructor TBollingerBands.CreateClass;
begin
var params :=
TDataType.RecordOf([TRecordField.Create('Period', TDataType.Ordinal), TRecordField.Create('Multiplier', TDataType.Float)]);
var args := TDataType.RecordOf([TRecordField.Create('Value', TDataType.Float)]);
var results :=
TDataType.RecordOf(
[
TRecordField.Create('UpperBand', TDataType.Float),
TRecordField.Create('MiddleBand', TDataType.Float),
TRecordField.Create('LowerBand', TDataType.Float)
]
);
var indicatorMethod := TDataType.MethodOf(args, results);
var factoryMethod := TDataType.MethodOf(params, indicatorMethod);
FFactory :=
factoryMethod.CreateValue(
function(const Params: IDataValue): IDataValue
var
paramsRec: IDataRecordValue;
begin
paramsRec := TDataValue(Params).AsRecord;
var period := TDataValue(paramsRec.Items[0]).AsOrdinal.Value;
var multiplier := TDataValue(paramsRec.Items[1]).AsFloat.Value;
var BollingerBands := CreateBollingerBands(period, multiplier);
Result :=
indicatorMethod.CreateValue(
function(const Args: IDataValue): IDataValue
begin
var value := TDataValue(TDataValue(Args).AsRecord.Items[0]).AsFloat.Value;
var res := BollingerBands(value);
Result :=
results.CreateValue(
[
TDataValue.FromFloat(res.UpperBand),
TDataValue.FromFloat(res.MiddleBand),
TDataValue.FromFloat(res.LowerBand)
]
);
end
);
end
);
end;
class function TBollingerBands.CreateFactory:
TIndicatorFactoryProc<TBollingerBands.TParams, TBollingerBands.TArgs, TBollingerBands.TResult>;
begin
@@ -921,6 +1357,55 @@ end;
{ TATR }
class constructor TATR.CreateClass;
begin
var params := TDataType.RecordOf([TRecordField.Create('Period', TDataType.Ordinal)]);
var ohlcType :=
TDataType.RecordOf(
[
TRecordField.Create('Open', TDataType.Float),
TRecordField.Create('High', TDataType.Float),
TRecordField.Create('Low', TDataType.Float),
TRecordField.Create('Close', TDataType.Float),
TRecordField.Create('Volume', TDataType.Float)
]
);
var args := TDataType.RecordOf([TRecordField.Create('Value', ohlcType)]);
var results := TDataType.RecordOf([TRecordField.Create('ATR', TDataType.Float)]);
var indicatorMethod := TDataType.MethodOf(args, results);
var factoryMethod := TDataType.MethodOf(params, indicatorMethod);
FFactory :=
factoryMethod.CreateValue(
function(const Params: IDataValue): IDataValue
begin
var period := TDataValue(TDataValue(Params).AsRecord.Items[0]).AsOrdinal.Value;
var ATR := CreateATR(period);
Result :=
indicatorMethod.CreateValue(
function(const Args: IDataValue): IDataValue
var
argRec, ohlcRec: IDataRecordValue;
ohlcVal: TOhlcItem;
begin
argRec := TDataValue(Args).AsRecord;
ohlcRec := TDataValue(argRec.Items[0]).AsRecord;
ohlcVal.Open := TDataValue(ohlcRec.Items[0]).AsFloat.Value;
ohlcVal.High := TDataValue(ohlcRec.Items[1]).AsFloat.Value;
ohlcVal.Low := TDataValue(ohlcRec.Items[2]).AsFloat.Value;
ohlcVal.Close := TDataValue(ohlcRec.Items[3]).AsFloat.Value;
ohlcVal.Volume := TDataValue(ohlcRec.Items[4]).AsFloat.Value;
var res := ATR(ohlcVal);
Result := results.CreateValue([TDataValue.FromFloat(res)]);
end
);
end
);
end;
class function TATR.CreateFactory: TIndicatorFactoryProc<TATR.TParams, TATR.TArgs, TATR.TResult>;
begin
Result :=
@@ -968,6 +1453,74 @@ end;
{ TKeltnerChannels }
class constructor TKeltnerChannels.CreateClass;
begin
var params :=
TDataType.RecordOf([TRecordField.Create('Period', TDataType.Ordinal), TRecordField.Create('Multiplier', TDataType.Float)]);
var ohlcType :=
TDataType.RecordOf(
[
TRecordField.Create('Open', TDataType.Float),
TRecordField.Create('High', TDataType.Float),
TRecordField.Create('Low', TDataType.Float),
TRecordField.Create('Close', TDataType.Float),
TRecordField.Create('Volume', TDataType.Float)
]
);
var args := TDataType.RecordOf([TRecordField.Create('Value', ohlcType)]);
var results :=
TDataType.RecordOf(
[
TRecordField.Create('UpperBand', TDataType.Float),
TRecordField.Create('MiddleBand', TDataType.Float),
TRecordField.Create('LowerBand', TDataType.Float)
]
);
var indicatorMethod := TDataType.MethodOf(args, results);
var factoryMethod := TDataType.MethodOf(params, indicatorMethod);
FFactory :=
factoryMethod.CreateValue(
function(const Params: IDataValue): IDataValue
var
paramsRec: IDataRecordValue;
begin
paramsRec := TDataValue(Params).AsRecord;
var period := TDataValue(paramsRec.Items[0]).AsOrdinal.Value;
var multiplier := TDataValue(paramsRec.Items[1]).AsFloat.Value;
var KeltnerChannels := CreateKeltnerChannels(period, multiplier);
Result :=
indicatorMethod.CreateValue(
function(const Args: IDataValue): IDataValue
var
argRec, ohlcRec: IDataRecordValue;
ohlcVal: TOhlcItem;
begin
argRec := TDataValue(Args).AsRecord;
ohlcRec := TDataValue(argRec.Items[0]).AsRecord;
ohlcVal.Open := TDataValue(ohlcRec.Items[0]).AsFloat.Value;
ohlcVal.High := TDataValue(ohlcRec.Items[1]).AsFloat.Value;
ohlcVal.Low := TDataValue(ohlcRec.Items[2]).AsFloat.Value;
ohlcVal.Close := TDataValue(ohlcRec.Items[3]).AsFloat.Value;
ohlcVal.Volume := TDataValue(ohlcRec.Items[4]).AsFloat.Value;
var res := KeltnerChannels(ohlcVal);
Result :=
results.CreateValue(
[
TDataValue.FromFloat(res.UpperBand),
TDataValue.FromFloat(res.MiddleBand),
TDataValue.FromFloat(res.LowerBand)
]
);
end
);
end
);
end;
class function TKeltnerChannels.CreateFactory:
TIndicatorFactoryProc<TKeltnerChannels.TParams, TKeltnerChannels.TArgs, TKeltnerChannels.TResult>;
begin
@@ -1021,6 +1574,43 @@ end;
{ TMean }
class constructor TMean.CreateClass;
begin
var params := TDataType.RecordOf([]);
var args := TDataType.RecordOf([TRecordField.Create('Values', TDataType.ArrayOf(TDataType.Float))]);
var results := TDataType.RecordOf([TRecordField.Create('Mean', TDataType.Float)]);
var indicatorMethod := TDataType.MethodOf(args, results);
var factoryMethod := TDataType.MethodOf(params, indicatorMethod);
FFactory :=
factoryMethod.CreateValue(
function(const Params: IDataValue): IDataValue
begin
var Mean := CreateMean();
Result :=
indicatorMethod.CreateValue(
function(const Args: IDataValue): IDataValue
var
i: Integer;
argsRec: IDataRecordValue;
valuesArray: IDataArrayValue;
values: TArray<Double>;
begin
argsRec := TDataValue(Args).AsRecord;
valuesArray := TDataValue(argsRec.Items[0]).AsArray;
SetLength(values, valuesArray.ElementCount);
for i := 0 to valuesArray.ElementCount - 1 do
values[i] := TDataValue(valuesArray.Items[i]).AsFloat.Value;
var res := Mean(values);
Result := results.CreateValue([TDataValue.FromFloat(res)]);
end
);
end
);
end;
class function TMean.CreateFactory: TIndicatorFactoryProc<TMean.TParams, TMean.TArgs, TMean.TResult>;
begin
Result :=