protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
string signalName;
if (NavigationContext.QueryString.TryGetValue("edit", out signalName) && App.Storage.Signals.Contains(signalName))
{
var editSignal = App.Storage.Signals[signalName];
NameTextBox.Text = editSignal.Name;
var editFlashSignal = editSignal as FlashSignal;
if (editFlashSignal != null)
{
FlashRadioButton.IsChecked = true;
IntervalSlider.Value = editFlashSignal.Interval / 100;
FlashDurationSlider.Value = editFlashSignal.Duration / 100;
_editSignal = editSignal;
}
else
{
var editMorseSignal = editSignal as MorseCodeSignal;
if (editMorseSignal != null)
{
MorseCodeRadioButton.IsChecked = true;
IntervalSlider.Value = editMorseSignal.Interval / 100;
MorseCodeTextBox.Text = editMorseSignal.Message;
_editSignal = editSignal;
}
}
}
}
public SignalBase GetSignal(EPortUsage portUsage, string portName, string domainID, object initialValue)
{
switch (portUsage)
{
case EPortUsage.Clock:
return _dpb._clk;
case EPortUsage.State:
if (_stateSignal == null)
{
if (initialValue == null)
throw new InvalidOperationException("Need initial value of state signal in order to determine its type.");
string id = _dpb._psName + "_" + portName;
_stateSignal = _dpb._host.Descriptor.CreateSignalInstance(id, initialValue).Instance;
}
return _stateSignal;
default:
{
string id = _dpb._psName + "_" + portName + "_fuPin" + _dpb._nextFUPinIndex;
var result = (SignalBase)_dpb._host.Descriptor.CreateSignalInstance(id, initialValue).Instance;
++_dpb._nextFUPinIndex;
return result;
}
}
}
public void Bind(SignalBase clk, SignalBase enIn, SignalBase din, SignalBase dout)
{
Clk = (In <StdLogic>)clk;
EnIn = (In <StdLogic>)enIn;
DIn = (In <StdLogicVector>)din;
DOut = (Out <T>)dout;
}
/// <summary>
/// User, Please Describe In Short What The Signal Is Doing ...
/// This signal sends alternatly Buy/Sell orders each time its called depending on its start event.
/// </summary>
///
/// <param name="signalBase"> Passed base class of signal usercode engine. </param>
///
/// <param name="historicMarketData"> All marked data of all instrument in signals scope up to latest quotes.
/// ### Use this parameter if your Signal should process historical market data from all provided instruments. ### </param>
///
/// <param name="tradeParams"> Contains all parameters needed to trade the signal.
/// ### Use this parameter to change/override Signal Properties from "InternelGet-/SetParameter()" method. ### </param>
///
/// <param name="trigInstrData"> When start event is NewBar or NewQuote, the instruments market data triggered the event.
/// ### Use this parameter if your Signal should process the updated instument only. ### </param>
///
/// <param name="queuedTicks"> During NewQuote start event, it happens that ticks are missed during calculation.
/// This missed ticks are queued and passed in 'queuedTicks' for next start event.
/// The most recent tick from "Trigger Instrument" is added as LAST element so all recent unprocessed ticks are passed
/// within "queuedTicks" parameter.
/// ### Use this parameter if your Signal works on tick level and you don't want to miss any tick. ### </param>
///
/// <returns> Returns a list of trade signals for execution market or backtest. </returns>
public static List <TradeSignal> DetectSignals(SignalBase signalBase, Dictionary <Selection, IEnumerable <Bar> > historicMarketData,
Auxiliaries.ExecuteTradesParam tradeParams,
Dictionary <Selection, IEnumerable <Bar> > trigInstrData = null,
IEnumerable <Tick> queuedTicks = null)
{
tradeParams.EvalCount++;
var trades = new List <TradeSignal>();
Side side = Side.Sell;
foreach (var item in historicMarketData)
{
if (tradeParams.EvalCount % 2 == 0)
{
side = Side.Buy;
}
else
{
side = Side.Sell;
}
trades.Add(new TradeSignal
{
Instrument = item.Key,
Time = item.Value.Last().Date,
Price = item.Value.Last().MeanClose,
Side = side
});
}
return(trades);
}
private void syncButton_Click(object sender, EventArgs e)
{
List <SignalParams> par = signalParamsBindingSource.List.Cast <SignalParams>().ToList();
List <SignalBase> scuds = scudSignalBindingSource.List.Cast <SignalBase>().ToList();
//Добавляем в настройки отображения из списка СКУД отсутствующие параметры
foreach (var signal in scuds)
{
if (par.Count(s => signal.Name.Equals(s.Name)) == 0)
{
signalParamsBindingSource.Add(new SignalParams(signal.Name, true, float.NaN, float.NaN));
}
}
par = signalParamsBindingSource.List.Cast <SignalParams>().ToList();
//Удаляем из отображения то, чего нет в списке СКУД
for (var i = par.Count - 1; i >= 0; i--)
{
SignalBase item = par[i]; //Элемент списка настроек отображения
if (scuds.Count(s => s.Name.Equals(item.Name)) == 0 &&
!item.Name.Equals(Program.I1) &&
!item.Name.Equals(Program.I2) &&
!item.Name.Equals(Program.R1) &&
!item.Name.Equals(Program.R2)
)
{
signalParamsBindingSource.RemoveAt(i);
}
}
}
public SignalBase GetSignal(EPortUsage portUsage, string portName, string domainID, object initialValue)
{
switch (portUsage)
{
case EPortUsage.Clock:
return(_dpb._clk);
case EPortUsage.State:
if (_stateSignal == null)
{
if (initialValue == null)
{
throw new InvalidOperationException("Need initial value of state signal in order to determine its type.");
}
string id = _dpb._psName + "_" + portName;
_stateSignal = _dpb._host.Descriptor.CreateSignalInstance(id, initialValue).Instance;
}
return(_stateSignal);
default:
{
string id = _dpb._psName + "_" + portName + "_fuPin" + _dpb._nextFUPinIndex;
var result = (SignalBase)_dpb._host.Descriptor.CreateSignalInstance(id, initialValue).Instance;
++_dpb._nextFUPinIndex;
return(result);
}
}
}
public DefaultDatapathBuilder(Component host, SignalBase clk, string processName)
{
_host = host;
_clk = clk;
_psName = processName;
FUBinder = new FUBinderProxy(this, host.AutoBinder);
ICBinder = new ICRBinderProxy(this, host.AutoBinder);
}
public static Signal CreateSignal(SignalBase signalBase, string fullName) => new Signal
{
Name = fullName,
ID = signalBase.ID,
Parameters = signalBase.GetParameters(),
Selections = signalBase.Selections,
State = signalBase.State
};
public Broker(Connector connector, string username, List <PortfolioAccount> accountInfos, SignalBase signal)
{
_signal = signal;
_username = username;
_connector = connector;
_taskTimeOut = TimeSpan.FromSeconds(5);
AccountInfos = accountInfos;
GetPortfolios();
GetAccounts();
}
/// <summary>
/// Creates and adds a new signal, including its implementation-level instance.
/// </summary>
/// <param name="me">component descriptor to host the new signal</param>
/// <param name="name">name of new signal</param>
/// <param name="initialValue">initial value of new signal</param>
/// <returns>the descriptor for the newly created signal</returns>
public static SignalDescriptor CreateSignalInstance(this IComponentDescriptor me, string name, object initialValue)
{
Contract.Requires <ArgumentNullException>(me != null);
Contract.Requires <ArgumentNullException>(initialValue != null);
Contract.Requires <ArgumentNullException>(name != null);
SignalBase sinst = Signals.CreateInstance(initialValue);
SignalDescriptor result = sinst.Descriptor;
me.AddChild(result, name);
return(result);
}
SignalBase GetSignal(Type type)
{
if (signals.ContainsKey(type))
{
return(signals[type]);
}
else
{
SignalBase o = Activator.CreateInstance(type) as SignalBase;
signals[type] = o;
return(o);
}
}
/// <summary>
/// Constructs a <c>FunctionCall</c> representation of reading from a port.
/// </summary>
/// <param name="port">underlying accessed signal instance</param>
public static FunctionCall ReadPort(SignalBase port)
{
TypeDescriptor type = TypeDescriptor.GetTypeOf(port.InitialValueObject);
return(new FunctionCall()
{
Callee = MakeFun(
new IntrinsicFunction(IntrinsicFunction.EAction.ReadPort,
new PortParams(port)), type),
Arguments = new Expression[0],
ResultType = type,
SetResultTypeClass = EResultTypeClass.ObjectReference
});
}
private IActorRef CreateSignalActor(SignalBase signal)
{
IActorRef actor = ActorRefs.Nobody;
if (signal is AnalogInSignal)
{
var sg = signal as AnalogInSignal;
actor = Context.ActorOf(Props.Create(() => new AnalogInSignalActor(sg)));
sg.ActorRef = actor;
}
else if (signal is DigitTachometerSignal)
{
var sg = signal as DigitTachometerSignal;
actor = Context.ActorOf(Props.Create(() => new DigitTachometerSignalActor(sg)));
sg.ActorRef = actor;
}
else if (signal is EddyCurrentDisplacementSignal)
{
var sg = signal as EddyCurrentDisplacementSignal;
actor = Context.ActorOf(Props.Create(() => new EddyCurrentDisplacementSignalActor(sg)));
sg.ActorRef = actor;
}
else if (signal is EddyCurrentKeyPhaseSignal)
{
var sg = signal as EddyCurrentKeyPhaseSignal;
actor = Context.ActorOf(Props.Create(() => new EddyCurrentKeyPhaseSignalActor(sg)));
sg.ActorRef = actor;
}
else if (signal is EddyCurrentTachometerSignal)
{
var sg = signal as EddyCurrentTachometerSignal;
actor = Context.ActorOf(Props.Create(() => new EddyCurrentTachometerSignalActor(sg)));
sg.ActorRef = actor;
}
else if (signal is IEPESignal)
{
var sg = signal as IEPESignal;
actor = Context.ActorOf(Props.Create(() => new IEPESignalActor(sg)));
sg.ActorRef = actor;
}
else if (signal is RelaySignal)
{
var sg = signal as RelaySignal;
actor = Context.ActorOf(Props.Create(() => new RelaySignalActor(sg)));
sg.ActorRef = actor;
}
return(actor);
}
private void AdaptCalls(CodeDescriptor cd, Dictionary <object, IEnumerable <SignalArgumentDescriptor> > map)
{
List <Statement> stmts = cd.Implementation.Body.GetAtomicStatements();
IEnumerable <CallStatement> calls = stmts.Select(s => s as CallStatement).Where(s => s != null);
ComponentDescriptor owner = (ComponentDescriptor)cd.Owner;
foreach (CallStatement stmt in calls)
{
var fspec = stmt.Callee as FunctionSpec;
if (fspec == null)
{
continue;
}
object key;
/*if (fspec.SysDOMRep != null)
* key = fspec.SysDOMRep;
* else*/
if (fspec.CILRep != null)
{
key = fspec.CILRep;
}
else
{
continue;
}
IEnumerable <SignalArgumentDescriptor> addArgs;
if (!map.TryGetValue(key, out addArgs))
{
continue;
}
List <Expression> args = stmt.Arguments.ToList();
foreach (SignalArgumentDescriptor sad in addArgs)
{
SignalBase sigInst = (SignalBase)sad.Sample;
var sigRef = sigInst.Descriptor
.AsSignalRef(SignalRef.EReferencedProperty.Instance)
.RelateToComponent(owner);
if (sigRef == null)
{
throw new InvalidOperationException("Signal not found in local component");
}
args.Add(sigRef);
}
stmt.Arguments = args.ToArray();
}
}
public SignalBase StartSignalExecution(string userName, SignalInitParams p, List <PortfolioAccount> accountInfos, Dictionary <string, byte[]> files)
{
SaveSignalData(userName, p.FullName, files, out var errors);
if (!string.IsNullOrWhiteSpace(errors))
{
Logger.Error(errors);
return(null);
}
SignalBase signalBase = null;
try
{
signalBase = CreateSignalInstance(userName, p.FullName);
var res1 = signalBase.SetParameters(p.Parameters);
var res2 = signalBase.Init(new Broker(_connector, userName, accountInfos, signalBase),
_dataProvider, p.Selections, p.State, p.StrategyParameters);
if (!res1 || !res2)
{
RemoveWorkingSignal(p.FullName, userName);
}
AddWorkingSignal(signalBase, userName);
if (p.State == SignalState.Backtesting && p.BacktestSettings != null)
{
signalBase.StartBacktest(p.BacktestSettings);
Console.WriteLine($"Scripting backtest started {signalBase.ShortName}");
return(signalBase);
}
Console.WriteLine($"Scripting started {signalBase.ShortName}");
return(signalBase);
}
catch (Exception ex)
{
Logger.Error(ex.Message, ex);
if (signalBase != null)
{
RemoveWorkingSignal(p.FullName, userName);
}
return(null);
}
}
public void PrepareAllocation(long cstepCount)
{
string[] stateNames = new string[cstepCount];
for (int i = 0; i < cstepCount; i++)
{
stateNames[i] = "CStep" + i;
}
var design = _host.Descriptor.GetDesign();
string typeName = "TState" + cstepCount;
var tstate = design.GetTypes()
.Where(t => t.Name == typeName)
.FirstOrDefault();
if (tstate == null)
{
tstate = design.CreateEnum(typeName, stateNames);
}
_stateValues = tstate.CILType.GetEnumValues();
object defaultState = Activator.CreateInstance(tstate.CILType);
_stateSignal = _binder.GetSignal(EPortUsage.State, "State", null, defaultState);
}
private void AddWorkingSignal(SignalBase signal, string userName)
{
var key = userName + "|" + signal.Name;
if (_sentBacktestReports.ContainsKey(key))
{
_sentBacktestReports[key] = 0;
}
lock (_userWorkingSignals)
_userWorkingSignals.Add(signal);
lock (_startedBacktestSignals)
{
if (signal.State == SignalState.Backtesting)
{
if (!_startedBacktestSignals.Contains(key))
{
_startedBacktestSignals.Add(key);
}
}
}
}
public override void Establish(IAutoBinder binder)
{
if (_established)
{
return;
}
var boundSignal = _host.Port as SignalDescriptor;
if (boundSignal == null)
{
boundSignal = (SignalDescriptor)((IPortDescriptor)_host.Port).BoundSignal;
}
SignalBase portSignal = boundSignal.Instance;
_host.Bind(
binder.GetSignal <StdLogic>(EPortUsage.Clock, "Clk", null, '0'),
binder.GetSignal <StdLogic>(EPortUsage.Default, _host.Port.Name + "_En", null, '0'),
binder.GetSignal <StdLogicVector>(EPortUsage.Operand, _host.Port.Name + "_In", null, StdLogicVector._0s(_host.DataWidth)),
portSignal);
_established = true;
}
public void Add(SignalBase sb)
{
signalList.Add(sb);
}
/// <summary>
/// Creates a new signal reference literal.
/// </summary>
/// <param name="signal">reference signal instance</param>
/// <param name="prop">referenced property</param>
public static SignalRef Create(SignalBase signal, EReferencedProperty prop)
{
Contract.Requires(signal != null);
return Create(signal.Descriptor, prop);
}
/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="port">underlying signal instance being accessed</param>
public PortParams(SignalBase port)
{
Port = port;
}
/// <summary>
/// Constructs a <c>FunctionCall</c> representation of reading from a port.
/// </summary>
/// <param name="port">underlying accessed signal instance</param>
public static FunctionCall ReadPort(SignalBase port)
{
TypeDescriptor type = TypeDescriptor.GetTypeOf(port.InitialValueObject);
return new FunctionCall()
{
Callee = MakeFun(
new IntrinsicFunction(IntrinsicFunction.EAction.ReadPort,
new PortParams(port)), type),
Arguments = new Expression[0],
ResultType = type,
SetResultTypeClass = EResultTypeClass.ObjectReference
};
}
/// <summary>
/// Constructs a <c>FunctionCall</c> representation of writing to a port.
/// </summary>
/// <param name="port">underlying accessed signal instance</param>
public static IntrinsicFunction WritePort(SignalBase port)
{
return new IntrinsicFunction(IntrinsicFunction.EAction.WritePort,
new PortParams(port));
}
public void AddSignal(SignalBase sb)
{
signals.Add(sb);
}
/// <summary>
/// Constructs a new instance.
/// </summary>
/// <param name="port">underlying signal instance being accessed</param>
public PortParams(SignalBase port)
{
Port = port;
}
internal SignalDescriptor(SignalBase instance)
{
_instance = instance;
}
private IEnumerable <ITimedFlow> ConstructNetwork(SignalRef target, IEnumerable <ITimedFlow> flows)
{
var groupedByDelay = flows
.GroupBy(tf => tf is TimedSignalFlow ? ((TimedSignalFlow)tf).Delay : 0)
.OrderBy(grp => grp.Key);
var curTarget = target;
int remainingFanIn = flows.Count();
long generation = 0;
var pumpOut = new List <SignalFlow>();
foreach (var delayGroup in groupedByDelay)
{
foreach (var tflow in delayGroup)
{
var tsf = tflow as TimedSignalFlow;
var tvf = tflow as TimedValueFlow;
if (tsf != null)
{
long flowDelay = tsf.Delay - generation;
if (flowDelay == 0)
{
yield return(new TimedSignalFlow(tsf.Source, curTarget, tsf.Time, 0));
}
else
{
SignalBase tmpSig = Signals.CreateInstance(tsf.Source.Desc.InitialValue);
tmpSig.Descriptor.TagTemporary(_tmpIdx++);
yield return(new TimedSignalFlow(
tsf.Source,
tmpSig.ToSignalRef(SignalRef.EReferencedProperty.Next),
tsf.Time, 0));
yield return(new TimedSignalFlow(
tmpSig.ToSignalRef(SignalRef.EReferencedProperty.Cur),
curTarget,
tsf.Time + flowDelay, 0));
}
long start = tsf.Time + tsf.Delay;
foreach (var pump in pumpOut)
{
yield return(new TimedSignalFlow(pump.Source, pump.Target, start, 0));
start--;
}
}
else
{
// remark: as of now, delay is always 0
yield return(new TimedValueFlow(tvf.Value, curTarget, tvf.Time));
}
}
long delay = delayGroup.Key;
remainingFanIn -= delayGroup.Count();
#if false
if (remainingFanIn > 1)
{
var stageInSignal = _binder.GetSignal(EPortUsage.Default,
"icn_" + target.Desc.Name + "_" + generation + "_in",
null,
target.Desc.InitialValue);
var stageOutSignal = _binder.GetSignal(EPortUsage.Default,
"icn_" + target.Desc.Name + "_" + generation + "_out",
null,
target.Desc.InitialValue);
_stageInSignals.Add(stageInSignal);
_stageOutSignals.Add(stageOutSignal);
var pumpSource = new SignalRef(stageOutSignal.ToSignalRef(SignalRef.EReferencedProperty.Cur));
pumpOut.Add(new SignalFlow(pumpSource, curTarget));
curTarget = new SignalRef(stageInSignal.ToSignalRef(SignalRef.EReferencedProperty.Next));
++generation;
}
#endif
}
}
public static List <TradeSignal> BacktestPriceSegmentProcessor(SignalBase signalBase, Dictionary <Selection, IEnumerable <Bar> > marketData,
Auxiliaries.ExecuteTradesParam tradeParams,
PriceConstants btBarSegment, Func <Dictionary <Selection, IEnumerable <Bar> >, List <TradeSignal> > detectSignals,
Dictionary <Selection, IEnumerable <Bar> > trigInstrData = null,
IEnumerable <Tick> queuedTicks = null)
{
var modMarketData = marketData.ToDictionary(k => k.Key, v => v.Value.Select(b => new Bar(b)).ToList().AsEnumerable());
var origLast = marketData.Last().Value.Last();
var modLast = modMarketData.Last().Value.Last();
List <TradeSignal> trades = null;
switch (btBarSegment)
{
case PriceConstants.OPEN:
modLast.HighAsk = origLast.OpenAsk;
modLast.HighBid = origLast.OpenBid;
modLast.LowAsk = origLast.OpenAsk;
modLast.LowBid = origLast.OpenBid;
modLast.CloseAsk = origLast.OpenAsk;
modLast.CloseBid = origLast.OpenBid;
modLast.HighAsk = origLast.OpenAsk;
trigInstrData = modMarketData;
trades = detectSignals(modMarketData);
break;
case PriceConstants.HIGH:
modLast.LowAsk = origLast.HighAsk;
modLast.LowBid = origLast.HighBid;
modLast.CloseAsk = origLast.HighAsk;
modLast.CloseBid = origLast.HighBid;
trigInstrData = modMarketData;
trades = detectSignals(modMarketData);
break;
case PriceConstants.LOW:
modLast.CloseAsk = origLast.LowAsk;
modLast.CloseBid = origLast.LowBid;
trigInstrData = modMarketData;
trades = detectSignals(modMarketData);
break;
case PriceConstants.CLOSE:
trigInstrData = modMarketData;
trades = detectSignals(modMarketData);
break;
case PriceConstants.OHLC:
signalBase.Alert($"origin openAsk: {origLast.OpenAsk}");
signalBase.Alert($"origin openBid: {origLast.OpenBid}");
signalBase.Alert($"origin mean: {origLast.MeanOpen}");
signalBase.Alert($"origin highAsk: {origLast.HighAsk}");
signalBase.Alert($"origin highBid: {origLast.HighBid}");
signalBase.Alert($"origin mean: {origLast.MeanHigh}");
signalBase.Alert($"origin lowAsk: {origLast.LowAsk}");
signalBase.Alert($"origin lowBid: {origLast.LowBid}");
signalBase.Alert($"origin mean: {origLast.MeanLow}");
signalBase.Alert($"origin closeAsk: {origLast.CloseAsk}");
signalBase.Alert($"origin closeBid: {origLast.CloseBid}");
signalBase.Alert($"origin mean: {origLast.MeanClose}");
modLast.HighAsk = origLast.OpenAsk;
modLast.HighBid = origLast.OpenBid;
modLast.LowAsk = origLast.OpenAsk;
modLast.LowBid = origLast.OpenBid;
modLast.CloseAsk = origLast.OpenAsk;
modLast.CloseBid = origLast.OpenBid;
trigInstrData = modMarketData;
signalBase.Alert($"mod openAsk: {modLast.OpenAsk}");
signalBase.Alert($"mod openBid: {modLast.OpenBid}");
signalBase.Alert($"mod mean: {modLast.MeanOpen}");
signalBase.Alert($"mod highAsk: {modLast.HighAsk}");
signalBase.Alert($"mod highBid: {modLast.HighBid}");
signalBase.Alert($"mod mean: {modLast.MeanHigh}");
signalBase.Alert($"mod lowAsk: {modLast.LowAsk}");
signalBase.Alert($"mod lowBid: {modLast.LowBid}");
signalBase.Alert($"mod mean: {modLast.MeanLow}");
signalBase.Alert($"mod closeAsk: {modLast.CloseAsk}");
signalBase.Alert($"mod closeBid: {modLast.CloseBid}");
signalBase.Alert($"mod mean: {modLast.MeanClose}");
var trades1 = detectSignals(modMarketData);
trades = trades1;
//signalBase.Alert($"origin openAsk: {origLast.OpenAsk}");
//signalBase.Alert($"origin openBid: {origLast.OpenBid}");
//signalBase.Alert($"origin mean: {origLast.MeanOpen}");
//signalBase.Alert($"origin highAsk: {origLast.HighAsk}");
//signalBase.Alert($"origin highBid: {origLast.HighBid}");
//signalBase.Alert($"origin mean: {origLast.MeanHigh}");
//signalBase.Alert($"origin lowAsk: {origLast.LowAsk}");
//signalBase.Alert($"origin lowBid: {origLast.LowBid}");
//signalBase.Alert($"origin mean: {origLast.MeanLow}");
//signalBase.Alert($"origin closeAsk: {origLast.CloseAsk}");
//signalBase.Alert($"origin closeBid: {origLast.CloseBid}");
//signalBase.Alert($"origin mean: {origLast.MeanClose}");
modLast.HighAsk = origLast.HighAsk;
modLast.HighBid = origLast.HighBid;
modLast.LowAsk = origLast.HighAsk;
modLast.LowBid = origLast.HighBid;
modLast.CloseAsk = origLast.HighAsk;
modLast.CloseBid = origLast.HighBid;
trigInstrData = modMarketData;
//signalBase.Alert($"mod openAsk: {modLast.OpenAsk}");
//signalBase.Alert($"mod openBid: {modLast.OpenBid}");
//signalBase.Alert($"mod mean: {modLast.MeanOpen}");
//signalBase.Alert($"mod highAsk: {modLast.HighAsk}");
//signalBase.Alert($"mod highBid: {modLast.HighBid}");
//signalBase.Alert($"mod mean: {modLast.MeanHigh}");
//signalBase.Alert($"mod lowAsk: {modLast.LowAsk}");
//signalBase.Alert($"mod lowBid: {modLast.LowBid}");
//signalBase.Alert($"mod mean: {modLast.MeanLow}");
//signalBase.Alert($"mod closeAsk: {modLast.CloseAsk}");
//signalBase.Alert($"mod closeBid: {modLast.CloseBid}");
//signalBase.Alert($"mod mean: {modLast.MeanClose}");
var trades2 = detectSignals(modMarketData);
trades.AddRange(trades2);
//signalBase.Alert($"origin openAsk: {origLast.OpenAsk}");
//signalBase.Alert($"origin openBid: {origLast.OpenBid}");
//signalBase.Alert($"origin mean: {origLast.MeanOpen}");
//signalBase.Alert($"origin highAsk: {origLast.HighAsk}");
//signalBase.Alert($"origin highBid: {origLast.HighBid}");
//signalBase.Alert($"origin mean: {origLast.MeanHigh}");
//signalBase.Alert($"origin lowAsk: {origLast.LowAsk}");
//signalBase.Alert($"origin lowBid: {origLast.LowBid}");
//signalBase.Alert($"origin mean: {origLast.MeanLow}");
//signalBase.Alert($"origin closeAsk: {origLast.CloseAsk}");
//signalBase.Alert($"origin closeBid: {origLast.CloseBid}");
//signalBase.Alert($"origin mean: {origLast.MeanClose}");
modLast.LowAsk = origLast.LowAsk;
modLast.LowBid = origLast.LowBid;
modLast.CloseAsk = origLast.LowAsk;
modLast.CloseBid = origLast.LowBid;
trigInstrData = modMarketData;
//signalBase.Alert($"mod openAsk: {modLast.OpenAsk}");
//signalBase.Alert($"mod openBid: {modLast.OpenBid}");
//signalBase.Alert($"mod mean: {modLast.MeanOpen}");
//signalBase.Alert($"mod highAsk: {modLast.HighAsk}");
//signalBase.Alert($"mod highBid: {modLast.HighBid}");
//signalBase.Alert($"mod mean: {modLast.MeanHigh}");
//signalBase.Alert($"mod lowAsk: {modLast.LowAsk}");
//signalBase.Alert($"mod lowBid: {modLast.LowBid}");
//signalBase.Alert($"mod mean: {modLast.MeanLow}");
//signalBase.Alert($"mod closeAsk: {modLast.CloseAsk}");
//signalBase.Alert($"mod closeBid: {modLast.CloseBid}");
//signalBase.Alert($"mod mean: {modLast.MeanClose}");
var trades3 = detectSignals(modMarketData);
trades.AddRange(trades3);
modLast.CloseAsk = origLast.CloseAsk;
modLast.CloseBid = origLast.CloseBid;
modMarketData = marketData;
trigInstrData = modMarketData;
signalBase.Alert($"origin openAsk: {origLast.OpenAsk}");
signalBase.Alert($"origin openBid: {origLast.OpenBid}");
signalBase.Alert($"origin mean: {origLast.MeanOpen}");
signalBase.Alert($"origin highAsk: {origLast.HighAsk}");
signalBase.Alert($"origin highBid: {origLast.HighBid}");
signalBase.Alert($"origin mean: {origLast.MeanHigh}");
signalBase.Alert($"origin lowAsk: {origLast.LowAsk}");
signalBase.Alert($"origin lowBid: {origLast.LowBid}");
signalBase.Alert($"origin mean: {origLast.MeanLow}");
signalBase.Alert($"origin closeAsk: {origLast.CloseAsk}");
signalBase.Alert($"origin closeBid: {origLast.CloseBid}");
signalBase.Alert($"origin mean: {origLast.MeanClose}");
signalBase.Alert($"mod openAsk: {modLast.OpenAsk}");
signalBase.Alert($"mod openBid: {modLast.OpenBid}");
signalBase.Alert($"mod mean: {modLast.MeanOpen}");
signalBase.Alert($"mod highAsk: {modLast.HighAsk}");
signalBase.Alert($"mod highBid: {modLast.HighBid}");
signalBase.Alert($"mod mean: {modLast.MeanHigh}");
signalBase.Alert($"mod lowAsk: {modLast.LowAsk}");
signalBase.Alert($"mod lowBid: {modLast.LowBid}");
signalBase.Alert($"mod mean: {modLast.MeanLow}");
signalBase.Alert($"mod closeAsk: {modLast.CloseAsk}");
signalBase.Alert($"mod closeBid: {modLast.CloseBid}");
signalBase.Alert($"mod mean: {modLast.MeanClose}");
var trades4 = detectSignals(modMarketData);
trades.AddRange(trades4);
break;
case PriceConstants.OLHC:
modLast.HighAsk = origLast.OpenAsk;
modLast.HighBid = origLast.OpenBid;
modLast.LowAsk = origLast.OpenAsk;
modLast.LowBid = origLast.OpenBid;
modLast.CloseAsk = origLast.OpenAsk;
modLast.CloseBid = origLast.OpenBid;
trigInstrData = modMarketData;
trades1 = detectSignals(modMarketData);
trades = trades1;
modLast.HighAsk = origLast.LowAsk;
modLast.HighBid = origLast.LowBid;
modLast.CloseAsk = origLast.LowAsk;
modLast.CloseBid = origLast.LowBid;
trigInstrData = modMarketData;
trades3 = detectSignals(modMarketData);
trades.AddRange(trades3);
modLast.CloseAsk = origLast.HighAsk;
modLast.CloseBid = origLast.HighBid;
trigInstrData = modMarketData;
trades2 = detectSignals(modMarketData);
trades.AddRange(trades2);
trigInstrData = modMarketData;
trades4 = detectSignals(modMarketData);
trades.AddRange(trades4);
break;
}
return(trades);
}
/// <summary>
/// Constructs a <c>FunctionCall</c> representation of writing to a port.
/// </summary>
/// <param name="port">underlying accessed signal instance</param>
public static IntrinsicFunction WritePort(SignalBase port)
{
return(new IntrinsicFunction(IntrinsicFunction.EAction.WritePort,
new PortParams(port)));
}
public AddSignal(SignalBase signal)
{
Signal = signal;
}
private void SaveSignal(SignalBase signal)
{
if (_editSignal != null)
{
if (!_editSignal.Name.Equals(signal.Name, StringComparison.Ordinal))
{
_editSignal.UnpinTile();
}
App.Storage.Signals.Remove(_editSignal);
}
App.Storage.Signals.Add(signal);
}
public PlotXY(SignalBase xsignal, params SignalBase[] ysignals)
{
this.xsignal = xsignal;
this.ysignals.AddRange(ysignals);
}
/// <summary>
/// Add a signal to logger
/// </summary>
/// <param name="sig">Signal to be logged</param>
public void Add(SignalBase sig)
{
owb.Add(sig);
}
public static object DefaultEval(SignalRef signalRef, IEvaluator eval)
{
SignalDescriptor sd = signalRef.Desc as SignalDescriptor;
if (sd == null)
{
throw new BreakEvaluationException();
}
SignalBase sinst = sd.SignalInstance;
dynamic sobj = sinst;
if (signalRef.Indices != null && signalRef.Indices.Count() > 0)
{
foreach (Expression[] indices in signalRef.Indices)
{
object[] indexvs = indices.Select(x => x.Eval(eval)).ToArray();
Type[] indexts = indexvs.Select(x => x.GetType()).ToArray();
Type vtype = sobj.GetType();
PropertyInfo prop = vtype.GetProperty("Item", indexts);
if (prop == null)
{
throw new InvalidOperationException("Indexer property not found");
}
sobj = prop.GetValue(sobj, indexvs);
}
}
switch (signalRef.Prop)
{
case SignalRef.EReferencedProperty.ChangedEvent:
return(sobj.ChangedEvent);
case SignalRef.EReferencedProperty.Cur:
if (sinst.Context.State == DesignContext.ESimState.Simulation)
{
return(sobj.Cur);
}
else
{
return(sobj.InitialValue);
}
case SignalRef.EReferencedProperty.FallingEdge:
if (sinst.Context.State == DesignContext.ESimState.Simulation)
{
return(((In <StdLogic>)sobj).FallingEdge());
}
else
{
return(false);
}
case SignalRef.EReferencedProperty.RisingEdge:
if (sinst.Context.State == DesignContext.ESimState.Simulation)
{
return(((In <StdLogic>)sobj).RisingEdge());
}
else
{
return(false);
}
case SignalRef.EReferencedProperty.Instance:
return(sobj);
case SignalRef.EReferencedProperty.Next:
throw new InvalidOperationException();
case SignalRef.EReferencedProperty.Pre:
if (sinst.Context.State == DesignContext.ESimState.Simulation)
{
return(sobj.Pre);
}
else
{
return(sobj.InitialValue);
}
default:
throw new NotImplementedException();
}
}
public void PrepareAllocation(long cstepCount)
{
string[] stateNames = new string[cstepCount];
for (int i = 0; i < cstepCount; i++)
stateNames[i] = "CStep" + i;
var design = _host.Descriptor.GetDesign();
string typeName = "TState" + cstepCount;
var tstate = design.GetTypes()
.Where(t => t.Name == typeName)
.FirstOrDefault();
if (tstate == null)
tstate = design.CreateEnum(typeName, stateNames);
_stateValues = tstate.CILType.GetEnumValues();
object defaultState = Activator.CreateInstance(tstate.CILType);
_stateSignal = _binder.GetSignal(EPortUsage.State, "State", null, defaultState);
}
/// <summary>
/// Creates a new signal reference literal.
/// </summary>
/// <param name="signal">reference signal instance</param>
/// <param name="prop">referenced property</param>
public static SignalRef Create(SignalBase signal, EReferencedProperty prop)
{
Contract.Requires(signal != null);
return(Create(signal.Descriptor, prop));
}
public static void Execute(List <TradeSignal> signals, SignalBase signalBase, ExecuteTradesParam execTradeParam)
{
decimal actualPrice = 0;
decimal priceOffset = 0;
var tradeSignals = signals;
var stopLoss = execTradeParam.SL;
var takeProfit = execTradeParam.TP;
foreach (var _account in signalBase.BrokerAccounts)
{
//check if the account can trade this symbol...
if (execTradeParam.DataFeed.AvailableDataFeeds.Contains(_account.DataFeedName))
{
foreach (var item in tradeSignals)
{ // trade only if the symbol has correct trade slot and it was not the first iteration (first iteration can)
if (execTradeParam.TradeableSymbols.Contains(item.Instrument.Symbol) && execTradeParam.EvalCount > 1)
{
if (execTradeParam.OrderType == TradeType.Limit || execTradeParam.OrderType == TradeType.Stop)
{
Tick tick = null;
try
{
tick = execTradeParam.DataFeed.GetLastTick(_account.DataFeedName, item.Instrument.Symbol);
}
catch (Exception e)
{
signalBase.Alert($"Failed to retrieve tick for {item.Instrument}: {e.Message}");
}
if (tick != null)
{
if (item.Side == Side.Buy && tick.Ask > 0)
{
actualPrice = tick.Ask;
if (execTradeParam.OrderType == TradeType.Limit)
{
priceOffset = execTradeParam.BuyPriceOffset / -100000;
}
if (execTradeParam.OrderType == TradeType.Stop)
{
priceOffset = execTradeParam.BuyPriceOffset / 100000;
}
}
else if (item.Side == Side.Sell && tick.Bid > 0)
{
actualPrice = tick.Bid;
if (execTradeParam.OrderType == TradeType.Limit)
{
priceOffset = execTradeParam.SellPriceOffset / 100000;
}
if (execTradeParam.OrderType == TradeType.Stop)
{
priceOffset = execTradeParam.SellPriceOffset / -100000;
}
}
}
}
if (execTradeParam.HideSL == true)
{
stopLoss = null;
}
if (execTradeParam.HideTP == true)
{
takeProfit = null;
}
signalBase.PlaceOrder(new OrderParams(DateTime.UtcNow.Ticks.ToString(), item.Instrument.Symbol)
{
TimeInForce = execTradeParam.TIF,
SLOffset = stopLoss,
TPOffset = takeProfit,
Quantity = execTradeParam.OrderQuantity,
OrderSide = item.Side,
OrderType = execTradeParam.OrderType,
DataServerSide = execTradeParam.HideOrder,
Price = actualPrice + priceOffset,
}, _account);
signalBase.Alert($"Trade: {execTradeParam.OrderType}, {item.Instrument.Symbol}, {item.Side}, {execTradeParam.OrderQuantity}, {execTradeParam.TP}, {execTradeParam.SL}");
}
}
}
}
}
public DefaultDatapathBuilder(Component host, SignalBase clk, string processName)
{
_host = host;
_clk = clk;
_psName = processName;
FUBinder = new FUBinderProxy(this, host.AutoBinder);
ICBinder = new ICRBinderProxy(this, host.AutoBinder);
}
