public override decimal Calculate(ITimeSeries series, ITradingRecord tradingRecord)
{
CashFlow cashFlow = new CashFlow(series, tradingRecord);
decimal MaximumDrawdown = CalculateMaximumDrawdown(series, cashFlow);
return(MaximumDrawdown);
}
public override decimal Calculate(ITimeSeries series, ITradingRecord tradingRecord)
{
int numberOfProfitable = 0;
foreach (Trade trade in tradingRecord.Trades)
{
int entryIndex = trade.GetEntry().getIndex();
int exitIndex = trade.GetExit().getIndex();
decimal result;
if (trade.GetEntry().isBuy())
{
// buy-then-sell trade
result = series.GetBar(exitIndex).ClosePrice.DividedBy(series.GetBar(entryIndex).ClosePrice);
}
else
{
// sell-then-buy trade
result = series.GetBar(entryIndex).ClosePrice.DividedBy(series.GetBar(exitIndex).ClosePrice);
}
if (result.IsGreaterThan(Decimals.ONE))
{
numberOfProfitable++;
}
}
return(((decimal)numberOfProfitable).DividedBy(tradingRecord.GetTradeCount()));
}
public override bool IsSatisfied(int index, ITradingRecord tradingRecord)
{
bool satisfied = _cross.GetValue(index);
traceIsSatisfied(index, satisfied);
return(satisfied);
}
public override bool IsSatisfied(int index, ITradingRecord tradingRecord)
{
bool satisfied = false;
// No trading history or no trade opened, no gain
if (tradingRecord != null)
{
Trade currentTrade = tradingRecord.GetCurrentTrade();
if (currentTrade.IsOpened())
{
decimal entryPrice = currentTrade.GetEntry().getPrice();
decimal currentPrice = _closePrice.GetValue(index);
decimal threshold = entryPrice.MultipliedBy(_gainRatioThreshold);
if (currentTrade.GetEntry().isBuy())
{
satisfied = currentPrice.IsGreaterThanOrEqual(threshold);
}
else
{
satisfied = currentPrice.IsLessThanOrEqual(threshold);
}
}
}
traceIsSatisfied(index, satisfied);
return(satisfied);
}
public void SetUp()
{
tradingRecord = new BaseTradingRecord();
closePrice = new ClosePriceIndicator(new MockTimeSeries(
100, 105, 110, 120, 100, 150, 110, 100
));
}
public override bool IsSatisfied(int index, ITradingRecord tradingRecord)
{
bool satisfied = _rule1.IsSatisfied(index, tradingRecord) && _rule2.IsSatisfied(index, tradingRecord);
traceIsSatisfied(index, satisfied);
return(satisfied);
}
public override decimal Calculate(ITimeSeries series, ITradingRecord tradingRecord)
{
decimal totalCosts = 0M;
decimal tradedAmount = _initialAmount;
foreach (Trade trade in tradingRecord.Trades)
{
decimal tradeCost = getTradeCost(series, trade, tradedAmount);
totalCosts += tradeCost;
// To Calculate the new traded amount:
// - Remove the cost of the *first* order
// - Multiply by the profit ratio
// - Remove the cost of the *second* order
tradedAmount = (tradedAmount - getOrderCost(trade.GetEntry(), tradedAmount));
tradedAmount *= _profit.Calculate(series, trade);
tradedAmount -= getOrderCost(trade.GetExit(), tradedAmount);
}
// Special case: if the current trade is open
Trade currentTrade = tradingRecord.GetCurrentTrade();
if (currentTrade.IsOpened())
{
totalCosts += getOrderCost(currentTrade.GetEntry(), tradedAmount);
}
return(totalCosts);
}
public override bool IsSatisfied(int index, ITradingRecord tradingRecord)
{
bool satisfied = _first.GetValue(index).Equals(_second.GetValue(index));
traceIsSatisfied(index, satisfied);
return(satisfied);
}
public override bool IsSatisfied(int index, ITradingRecord tradingRecord)
{
bool satisfied = _indicator.GetValue(index).IsLessThanOrEqual(_upper.GetValue(index)) &&
_indicator.GetValue(index).IsGreaterThanOrEqual(_lower.GetValue(index));
traceIsSatisfied(index, satisfied);
return(satisfied);
}
/**
* Calculates the cash flow for a trading record.
* @param tradingRecord the trading record
*/
private void Calculate(ITradingRecord tradingRecord)
{
foreach (Trade trade in tradingRecord.Trades)
{
// For each trade[]
Calculate(trade);
}
}
/**
* @param index the bar index
* @param tradingRecord the potentially needed trading history
* @return true to recommend to exit, false otherwise
*/
public bool ShouldExit(int index, ITradingRecord tradingRecord)
{
if (IsUnstableAt(index))
{
return(false);
}
return(ExitRule.IsSatisfied(index, tradingRecord));
}
public override decimal Calculate(ITimeSeries series, ITradingRecord tradingRecord)
{
ITradingRecord fakeRecord = new BaseTradingRecord();
fakeRecord.Enter(series.GetBeginIndex());
fakeRecord.Exit(series.GetEndIndex());
return(_criterion.Calculate(series, tradingRecord) / _criterion.Calculate(series, fakeRecord));
}
public override decimal Calculate(ITimeSeries series, ITradingRecord tradingRecord)
{
decimal bars = _numberOfBars.Calculate(series, tradingRecord);
if (bars == 0)
{
return(1);
}
return(_totalProfit.Calculate(series, tradingRecord).Pow(1M / bars));
}
public override decimal Calculate(ITimeSeries series, ITradingRecord tradingRecord)
{
decimal nBars = 0M;
foreach (Trade trade in tradingRecord.Trades)
{
nBars += Calculate(series, trade);
}
return(nBars);
}
public override decimal Calculate(ITimeSeries series, ITradingRecord tradingRecord)
{
decimal value = 1M;
foreach (Trade trade in tradingRecord.Trades)
{
value *= CalculateProfit(series, trade);
}
return(value);
}
public override bool IsSatisfied(int index, ITradingRecord tradingRecord)
{
LowestValueIndicator lowest = new LowestValueIndicator(_indicator, _timeFrame);
decimal lowestVal = lowest.GetValue(index);
decimal refVal = _indicator.GetValue(index);
bool satisfied = !refVal.IsNaN() && !lowestVal.IsNaN() && refVal.Equals(lowestVal);
traceIsSatisfied(index, satisfied);
return(satisfied);
}
internal TradingRecord(ITradingRecord tradingRecord)
{
Time = tradingRecord.Time;
Type = tradingRecord.Type;
StockCode = tradingRecord.StockCode;
Quantity = tradingRecord.Quantity;
Price = tradingRecord.Price;
Commissions = tradingRecord.Commissions;
StampDuty = tradingRecord.StampDuty;
TransferFees = tradingRecord.TransferFees;
FeesSettlement = tradingRecord.FeesSettlement;
}
public override bool IsSatisfied(int index, ITradingRecord tradingRecord)
{
DifferenceIndicator diff = new DifferenceIndicator(_indicator, _prev);
decimal val = diff.GetValue(index);
bool MinSlopeSatisfied = _minSlope.IsNaN() || val.IsGreaterThanOrEqual(_minSlope);
bool MaxSlopeSatisfied = _maxSlope.IsNaN() || val.IsLessThanOrEqual(_maxSlope);
bool isNaN = _minSlope.IsNaN() && _maxSlope.IsNaN();
bool satisfied = MinSlopeSatisfied && MaxSlopeSatisfied && !isNaN;
traceIsSatisfied(index, satisfied);
return(satisfied);
}
/**
* @param index the bar index
* @param tradingRecord the potentially needed trading history
* @return true to recommend an order, false otherwise (no recommendation)
*/
public bool ShouldOperate(int index, ITradingRecord tradingRecord)
{
Trade trade = tradingRecord.GetCurrentTrade();
if (trade.IsNew())
{
return(ShouldEnter(index, tradingRecord));
}
else if (trade.IsOpened())
{
return(ShouldExit(index, tradingRecord));
}
return(false);
}
public override bool IsSatisfied(int index, ITradingRecord tradingRecord)
{
bool satisfied = false;
for (int i = 0; i < _indexes.Length; i++)
{
if (_indexes[i] == index)
{
satisfied = true;
break;
}
}
traceIsSatisfied(index, satisfied);
return(satisfied);
}
public override bool IsSatisfied(int index, ITradingRecord tradingRecord)
{
if (satisfied)
{
return(false);
}
else if (_rule == null)
{
satisfied = true;
traceIsSatisfied(index, true);
return(true);
}
satisfied = _rule.IsSatisfied(index, tradingRecord);
return(satisfied);
}
public void SetUp()
{
emptyRecord = new BaseTradingRecord();
openedRecord = new BaseTradingRecord(
Order.buyAt(0, Decimals.NaN, Decimals.NaN),
Order.sellAt(3, Decimals.NaN, Decimals.NaN),
Order.buyAt(7, Decimals.NaN, Decimals.NaN)
);
closedRecord = new BaseTradingRecord(
Order.buyAt(0, Decimals.NaN, Decimals.NaN),
Order.sellAt(3, Decimals.NaN, Decimals.NaN),
Order.buyAt(7, Decimals.NaN, Decimals.NaN),
Order.sellAt(8, Decimals.NaN, Decimals.NaN)
);
}
public override bool IsSatisfied(int index, ITradingRecord tradingRecord)
{
bool satisfied = false;
// No trading history, no need to wait
if (tradingRecord != null)
{
Order lastOrder = tradingRecord.GetLastOrder(_orderType);
if (lastOrder != null)
{
int currentNumberOfBars = index - lastOrder.getIndex();
satisfied = currentNumberOfBars >= _numberOfBars;
}
}
traceIsSatisfied(index, satisfied);
return(satisfied);
}
public override bool IsSatisfied(int index, ITradingRecord tradingRecord)
{
if (_minStrenght >= 1)
{
_minStrenght = 0.99;
}
int count = 0;
for (int i = Math.Max(0, index - _timeFrame + 1); i <= index; i++)
{
if (_indicator.GetValue(i).IsLessThan(_indicator.GetValue(Math.Max(0, i - 1))))
{
count += 1;
}
}
double ratio = count / (double)_timeFrame;
bool satisfied = ratio >= _minStrenght;
traceIsSatisfied(index, satisfied);
return(satisfied);
}
public abstract bool IsSatisfied(int index, ITradingRecord tradingRecord);
public override decimal Calculate(ITimeSeries series, ITradingRecord tradingRecord)
{
return(_totalProfit.Calculate(series, tradingRecord).DividedBy(_maxDrawdown.Calculate(series, tradingRecord)));
}
public override bool IsSatisfied(int index, ITradingRecord tradingRecord)
{
traceIsSatisfied(index, _satisfied);
return(_satisfied);
}
/** * @param series a time series * @param tradingRecord a trading record * @return the criterion value for the trades */ public abstract decimal Calculate(ITimeSeries series, ITradingRecord tradingRecord);
/// <summary>
/// 添加交易记录
/// </summary>
/// <param name="tradingRecord"></param>
internal void Add(ITradingRecord tradingRecord)
{
if (tradingRecord.Type == TradeType.Buy)
{
this._quantity += tradingRecord.Quantity;
}
else
{
this._quantity -= tradingRecord.Quantity;
}
this._tradingRecords.Add(tradingRecord);
}
/**
* Constructor.
* @param timeSeries the time series
* @param tradingRecord the trading record
*/
public CashFlow(ITimeSeries timeSeries, ITradingRecord tradingRecord)
{
_timeSeries = timeSeries;
Calculate(tradingRecord);
FillToTheEnd();
}
/**
* Gets the readonly criterion value.
*
* @param series TimeSeries is ignored
* @param tradingRecord is ignored
*/
public override decimal Calculate(ITimeSeries series, ITradingRecord tradingRecord)
{
return(values[values.Count - 1]);
}
public override decimal Calculate(ITimeSeries series, ITradingRecord tradingRecord)
{
return(series.GetBar(series.GetEndIndex()).ClosePrice.DividedBy(series.GetBar(series.GetBeginIndex()).ClosePrice));
}
