public Tuple <double[], bool> Compute(IMarketModelIndicator market_model)
{
double[] result = new double[SubIndicatorCount];
bool is_valid = ComputeRBA(market_model, result);
return(new Tuple <double[], bool>(result, is_valid));
}
public override bool ComputeRBA(IMarketModelIndicator market_model, double[] target)
{
Tuple <double[], bool> tuple = indicator.Compute(market_model);
if (!tuple.Item2)
{
return(false);
}
target[0] = model.GetLabel(tuple.Item1);
return(true);
}
public override bool ComputeRBA(IMarketModelIndicator market_model, double[] result)
{
bool is_valid = HistorySize <= market_model.Second1.HistoryCount;
if (is_valid)
{
double average = market_model.CurrentBid;
for (int index = 0; index < HistorySize; index++)
{
average += market_model.Second1.GetHistory(index).OpenBid;
}
result[0] = average / (HistorySize + 1);
}
return(is_valid);
}
public virtual Tuple <double[, ], bool[]> ComputeAll(IMarketModelIndicator market_model, int price_count)
{
double[,] values = new double[price_count, SubIndicatorCount];
bool[] is_valid = new bool[price_count];
double[] result_temp = new double[SubIndicatorCount];
for (int price_index = 0; price_index < price_count - 1; price_index++)
{
is_valid[price_index] = ComputeRBA(market_model, result_temp);
values.Set1DIndex0(price_index, result_temp);
market_model.StepSecond();
}
is_valid[price_count - 1] = ComputeRBA(market_model, result_temp);
values.Set1DIndex0(price_count - 1, result_temp);
return(new Tuple <double[, ], bool[]>(values, is_valid));
}
public override bool ComputeRBA(IMarketModelIndicator market_model, double[] target)
{
bool all_valid = true;
for (int indicator_index = 0; indicator_index < indicators.Count; indicator_index++)
{
IIndicator inidicator = indicators[indicator_index];
Tuple <double[], bool> tuple = inidicator.Compute(market_model);
ToolsCollection.CopyRBA(tuple.Item1, 0, target, indicator_offsets[indicator_index], inidicator.SubIndicatorCount);
if (!tuple.Item2)
{
all_valid = false;
}
}
return(all_valid);
}
public override bool ComputeRBA(IMarketModelIndicator market_model, double[] result)
{
if (previous_1 == 0)
{
previous_1 = market_model.CurrentBid;
previous_2 = market_model.CurrentBid;
}
double momentum = previous_1 - previous_2;
double error_now = market_model.CurrentBid - (previous_1 + (momentum_weight * momentum));
error_now_array_sqr_sum = (error_now_array_sqr_sum + ToolsMath.Sqr(error_now) - ToolsMath.Sqr(this.error_now_array[index_error_now % this.error_now_array.Length])) / this.error_now_array.Length;
error_now_array_sum = error_now_array_sum + error_now - this.error_now_array[index_error_now % this.error_now_array.Length];
this.error_now_array[index_error_now % this.error_now_array.Length] = error_now;
index_error_now++;
double error_now_sdev = Math.Sqrt(error_now_array_sqr_sum);
if (error_now_sdev == 0)
{
error_now_sdev = double.Epsilon;
}
double error_now_z = error_now / error_now_sdev;
double error_now_weight = max_error_weight * (1 - Math.Exp(-ToolsMath.Sqr(error_now_z) / expected_error_z));
result[0] = previous_1 + (momentum * momentum_weight) + (error_now * error_now_weight);
result[1] = result[0] + (error_now_sdev * 2);
result[2] = result[0] - (error_now_sdev * 2);
result[3] = error_now;
result[4] = error_now_sdev;
result[5] = error_now_array_sum;
result[6] = error_now_z;
result[7] = error_now_weight;
result[8] = momentum;
previous_2 = previous_1;
previous_1 = result[0];
return(this.error_now_array.Length < market_model.Second1.HistoryCount);
}
public override bool ComputeRBA(IMarketModelIndicator market_model, double[] result)
{
if (market_model.Prices.FutureCount < future)
{
return(false);
}
double long_profit = market_model.CurrentBid - market_model.CurrentAsk;
double short_profit = market_model.CurrentBid - market_model.CurrentAsk;
for (int index = 0; index < future; index++)
{
long_profit = Math.Max(long_profit, market_model.Prices.GetFuture(index).Bid - market_model.CurrentAsk);
short_profit = Math.Max(short_profit, market_model.CurrentBid - market_model.Prices.GetFuture(index).Ask);
}
result[0] = long_profit;
result[1] = short_profit;
return(true);
}
public override bool ComputeRBA(IMarketModelIndicator market_model, double[] result)
{
if (previous_1 == 0)
{
previous_1 = market_model.CurrentBid;
previous_2 = market_model.CurrentBid;
}
double momentum = previous_1 - previous_2;
double error_now = market_model.CurrentBid - (previous_1 + (momentum_weight * momentum));
indicator_error_now[index_indicator_error_now % indicator_error_now.Length] = error_now;
index_indicator_error_now++;
double error_now_s = ToolsMathStatistics.StandardDeviation(indicator_error_now);
if (error_now_s == 0)
{
error_now_s = double.Epsilon;
}
double error_now_z = error_now / error_now_s;
double error_now_weight = max_error_weight * (1 - Math.Exp(-ToolsMath.Sqr(error_now_z) / expected_error_z));
result[0] = previous_1 + (momentum * momentum_weight) + (error_now * error_now_weight);
result[1] = result[0] + (error_now_s * 2);
result[2] = result[0] - (error_now_s * 2);
result[3] = error_now;
result[4] = error_now_s;
result[5] = error_now_z;
result[6] = error_now_weight;
result[7] = momentum;
previous_2 = previous_1;
previous_1 = result[0];
return(indicator_error_now.Length < market_model.Second1.HistoryCount);
}
public abstract bool ComputeRBA(IMarketModelIndicator market_model, double[] result);
public void CheckSwap(IMarketModelIndicator market_model)
{
}
public override bool ComputeRBA(IMarketModelIndicator market_model, double[] result)
{
return(true);
}
