public WaveTexture(String color1, String color2, float scale = .1f, Signal<float> rscale = null, bool reactive = false)
{
this.scale = rscale ?? new Lift0f(scale);
this.color1 = color1;
this.color2 = color2;
this.reactive = reactive;
}
public JuliaFractal(String algebra, String function, int precision, int iterations,
Point3 location = null, float x = -0.162f, float y = 0.163f, float z = 0.560f, float k = -0.599f,
Signal<float> rx = null, Signal<float> ry = null, Signal<float> rz = null, Signal<float> rk = null,
Point3 rotation = null, PovTexture texture = null, String finish = null, bool reactive = false)
{
this.reactive = reactive;
this.loc = location ?? new Point3(0, 0, 0, reactive: reactive);
this.rot = rotation ?? new Point3(0, 0, 0, reactive: reactive);
this.tex = texture ?? new POVColor("Red");
this.finish = finish ?? "finish {phong .9 reflection .5}";
this.x = rx ?? new Lift0f(x);
this.y = ry ?? new Lift0f(y);
this.z = rz ?? new Lift0f(z);
this.k = rk ?? new Lift0f(k);
if (algebra.Equals("quaternion"))
{
this.algebra = algebra;
}
else if (algebra.Equals(" hypercomplex"))
{
this.algebra = algebra;
}
else this.algebra = "quaternion";
this.precision = precision;
this.iterations = iterations;
this.function = function;
}
public Particle(Signal signal)
{
this.done = false;
// Init the seek and flee
seek = new Seek();
seek.endingRadius = 0;
// Initialize the origin and target
origin.position = new Vector3(signal.origin.point.X, signal.origin.point.Y, 0);
target.position = new Vector3(signal.location.X, signal.location.Y, 0);
// Now move the origin a little
int alpha = GameMode.random.Next(10, 50);
int beta = GameMode.random.Next(10, 50);
float x = (float)GameMode.random.NextDouble() * 2 * alpha - alpha;
float y = (float)GameMode.random.NextDouble() * 2 * beta - beta;
origin.position += new Vector3(x, y, 0);
// And now the target
alpha = GameMode.random.Next(0, 100);
beta = GameMode.random.Next(0, 100);
x = (float)GameMode.random.NextDouble() * 2 * alpha - alpha;
y = (float)GameMode.random.NextDouble() * 2 * beta - beta;
target.position += new Vector3(x, y, 0);
}
public void DescriptionTest()
{
var s = new Signal();
s.Description = null;
var validDescription = string.Empty;
var random = new Random(1);
for (int i = 0; i < Signal.MaxDescriptionLength; i++)
{
validDescription +=(char) random.Next(1, 255);
}
try
{
s.Description = validDescription;
}
catch (Exception)
{
Assert.Fail("Exception should not have been thrown.");
}
var invalidDescription = validDescription + (char)random.Next(1,255);
try
{
s.Description = invalidDescription;
Assert.Fail("ArgumentException should have been thrown.");
}
catch (ArgumentException)
{
}
Wfdb.Quit();
}
public static bool IsMonomial(Signal signal, Signal[] generalizedVariables)
{
if(signal.IsDrivenByPortEntity("Multiply", "Std"))
return signal.DrivenByPort.InputSignals.TrueForAll(delegate(Signal s) { return IsMonomialFactor(s, generalizedVariables); });
else
return IsMonomialFactor(signal, generalizedVariables);
}
public override bool EnterPort(Port port, Signal parent, bool again, bool root)
{
if(again)
return false;
_ports.Add(port);
return true;
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
degreesSignal.Stop();
degreesSignal.Dispose();
degreesSignal = null;
radiansSignal.Dispose();
radiansSignal = null;
sineSignal.Dispose();
sineSignal = null;
cosineSignal.Dispose();
cosineSignal = null;
signalTickCount.Dispose();
signalTickCount = null;
intervalChanged.Dispose();
intervalChanged = null;
runningEvent.Dispose();
runningEvent = null;
intervalBehavior.Dispose();
intervalBehavior = null;
runningBehavior.Dispose();
runningBehavior = null;
}
public override void HandleSignal(Signal signal)
{
var cytokine = signal as Cytokine;
if (cytokine != null &&
(cytokine.Type == CytokineType.IL2 || cytokine.Type == CytokineType.IL4))
{
var sender = Agents.FirstOrDefault(a => a.Address == signal.Sender);
if (sender == null)
{
throw new Exception("Sender of the signal is not one of my child cells!");
}
if (sender is HelperTCell)
{
var helper = (HelperTCell)sender;
foreach (var activator in helper.Activators)
{
//var apc = (APC)Agents.FirstOrDefault(a => a.Address == activator);
//Log("Attack detected in node " + apc.ActivatedIn +
//" with costimulation " + cytokine.Concentration, LogLevel.Major);
/*// report the detection results to the parent
// TODO: the signal dispatch delay is dummy
Scheduler.Schedule(Parent.HandleSignal, 0.0001, new Signal(apc.ActivatedIn,
SignalType.Cytokine, signal.Concentration, null));*/
}
}
}
base.HandleSignal(signal); // to forward the signal even if it is a cytokine in order to stimulate proliferation and differentiation
}
/// <summary>
/// Removes a signal.
/// </summary>
/// <param name="signal">The signal.</param>
public static void RemoveSignal(Signal signal)
{
if (Signals.Contains(signal))
{
Signals.Remove(signal);
}
}
/// <summary>
/// Generates a signal.
/// </summary>
///
public Signal Generate(int samples)
{
Signal signal = new Signal(Channels, samples, SamplingRate, Format);
if (Format == SampleFormat.Format32BitIeeeFloat)
{
unsafe
{
float* dst = (float*)signal.Data.ToPointer();
float p = (float)(Frequency / SamplingRate);
float a = 2f * (float)Amplitude;
for (int i = 0; i < signal.Length; i++)
{
float q = i * p;
float t = a * (q - (float)Math.Round(q));
for (int c = 0; c < signal.Channels; c++, dst++)
*dst = t;
}
}
}
return signal;
}
private static void UsingPInvoke()
{
Console.WriteLine("exgetvec Using PInvoke");
int i, j, nsig;
Sample[] v;
Signal[] s;
nsig = PInvoke.isigopen("data/100s", null, 0);
if (nsig < 1)
return;
s = new Signal[nsig];
if (PInvoke.isigopen("data/100s", s, nsig) != nsig)
return;
v = new Sample[nsig];
for (i = 0; i < 10; i++)
{
if (PInvoke.getvec(v) < 0)
break;
for (j = 0; j < nsig; j++)
Console.Write("{0} \t", v[j]);
Console.WriteLine();
}
PInvoke.wfdbquit();
}
/// <summary>
/// Generates a signal.
/// </summary>
///
public Signal Generate(int samples)
{
Signal signal = new Signal(Channels, samples, SamplingRate, Format);
unsafe
{
if (Format == SampleFormat.Format32BitIeeeFloat)
{
var dst = (float*)signal.Data.ToPointer();
for (int i = 0; i < signal.Samples; i++)
for (int c = 0; c < signal.Channels; c++, dst++)
*dst = (float)(Function(i));
}
else if (Format == SampleFormat.Format64BitIeeeFloat)
{
var dst = (double*)signal.Data.ToPointer();
for (int i = 0; i < signal.Samples; i++)
for (int c = 0; c < signal.Channels; c++, dst++)
*dst = (double)(Function(i));
}
else
{
throw new UnsupportedSampleFormatException("Sample format is not supported by the filter.");
}
}
return signal;
}
/**
* create an event containing a signal, which modifies properties of the parent
* event during rendering. Modifier types to be chosen from SignalSoundEvent.Modifier
*/
public SignalSoundEvent(SignalSoundEvent.Modifier modifierType , Signal sig)
: base()
{
_sig = sig;
_modif = modifierType;
UpdateDuration(_sig.Duration);
}
public bool RaiseSignal(Signal signal, long? id)
{
switch (signal)
{
case Signal.SOMEONE_WON:
foreach (var trigger in m_winTriggers)
if (trigger.IsTrue || trigger.RaiseSignal(signal, id))
{ //Won!
trigger.DisplayMessage(true);
Won = true;
return true;
}
foreach (var trigger in m_loseTriggers)
if (trigger.IsTrue || trigger.RaiseSignal(signal, id))
{//Lost
trigger.DisplayMessage(false);
Lost = true;
return true;
}
return false;
break;
default:
Debug.Assert(false,"Wrong signal received");
return false;
break;
}
}
public Signal Import(FileInfo file)
{
string textFromFile;
using (StreamReader sr = file.OpenText())
{
textFromFile = sr.ReadToEnd();
}
textFromFile = textFromFile.Replace('.', ',');
textFromFile = textFromFile.Trim('\n', ' ');
string[] txtValues = textFromFile.Split(' ', '\n', '\t');
double[] values = new double[txtValues.Length];
for (int i = 0; i < txtValues.Length; ++i)
values[i] = double.Parse(txtValues[i]);
if (values.Length < 2)
{
throw new Exception("Should be at least 2 values in file!");
}
try
{
var s = new Signal(values, file.Name.Remove(file.Name.Length - 4));
return s;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Adds a signal.
/// </summary>
/// <param name="signal">The signal.</param>
public static void AddSignal(Signal signal)
{
if (!Signals.Contains(signal))
{
Signals.Add(signal);
}
}
public override bool EnterSignal(Signal signal, Port parent, bool again, bool root)
{
if(again)
return false;
_signals.Add(signal);
return true;
}
/// <summary>
/// Applies the filter to a windowed signal.
/// </summary>
public Signal[] Apply(params Signal[] signal)
{
Signal[] s = new Signal[signal.Length];
for (int i = 0; i < signal.Length; i++)
s[i] = Apply(signal[i]);
return s;
}
public static void RegisterTheorems(ILibrary library)
{
Analysis.DerivativeTransformation.Provider.Add(
new Analysis.DerivativeTransformation(_entityId,
delegate(Port port, SignalSet manipulatedInputs, Signal variable, bool hasManipulatedInputs)
{
Signal[] outputs = new Signal[manipulatedInputs.Count];
ReadOnlySignalSet cotangents = StdBuilder.Cotangent(port.InputSignals);
for(int i = 0; i < outputs.Length; i++)
outputs[i] = Std.Multiply(port.OutputSignals[i], cotangents[i], manipulatedInputs[i]);
return StdBuilder.Negate(outputs);
}));
MathIdentifier typeId = new MathIdentifier("TrigonometricSubstitute", "Std");
ITheoremProvider basicProvider;
if(!library.TryLookupTheoremType(typeId, out basicProvider))
{
basicProvider = Binder.GetInstance<ITransformationTheoremProvider, MathIdentifier>(typeId);
library.AddTheoremType(basicProvider);
}
((ITransformationTheoremProvider)basicProvider).Add(
new BasicTransformation(_entityId.DerivePostfix("TrigonometricSubstitute"), typeId,
delegate() { return new Pattern(new EntityCondition(_entityId)); },
delegate(Port port) { return ManipulationPlan.DoAlter; },
delegate(Port port, SignalSet transformedInputs, bool hasTransformedInputs)
{
return StdBuilder.Invert(StdBuilder.Sine(transformedInputs));
//Signal[] ret = new Signal[transformedInputs.Count];
//for(int i = 0; i < ret.Length; i++)
// ret[i] = Std.Invert(Std.Sine(transformedInputs[i]));
//return ret;
}));
}
protected override void DoTraverse(Signal rootSignal, IScanVisitor visitor, bool ignoreHold)
{
List<Guid> signals = new List<Guid>();
List<Guid> ports = new List<Guid>();
List<Guid> buses = new List<Guid>();
TraverseSignal(signals, ports, buses, rootSignal, null, ignoreHold, visitor);
}
public override void HandleSignal(Signal signal)
{
if (signal is Stimulation)
{
var stimulation = signal as Stimulation;
var affinity = Pattern.Affinity(stimulation.Peptide, AffinityType.Euclidean);
if (affinity >= Globals.HelperAffinityThreashold)
{
peptideAffinitySum += affinity;
costimulationSum += stimulation.Concentration;
Activators.Add(stimulation.Sender);
if (!Activated && peptideAffinitySum + costimulationSum > Globals.HelperActivationThreshold)
{
Activated = true;
//Secrete(new Cytokine(Address, CytokineType.IL2, costimulationSum)); // TODO: X64 stimulates growth and differentiation of T cell response
//Secrete(new Cytokine(Address, CytokineType.IL4, costimulationSum)); // TODO: X64 stimulates proliferation and differentiation
string nodes = "";
foreach (var activator in Activators)
{
nodes += activator + ",";
}
Log("ALARM: Attack detected in node " + nodes.TrimEnd(new char[] { ',' }), LogLevel.Major);
// die after activation
Apoptosis();
}
}
}
base.HandleSignal(signal);
}
protected GenericFunctionProcess(bool[] inInput, bool[] inInternal, bool[] outOutput, bool[] outInternal)
{
if(inInput == null)
throw new ArgumentNullException("inInput");
if(inInternal == null)
throw new ArgumentNullException("inInternal");
if(outOutput == null)
throw new ArgumentNullException("outOutput");
if(outInternal == null)
throw new ArgumentNullException("outInternal");
this.inInput = inInput;
this.inInternal = inInternal;
this.outOutput = outOutput;
this.outInternal = outInternal;
//count mapped signals
for(int i = 0; i < inInput.Length; i++)
if(inInput[i]) inCount++;
for(int i = 0; i < inInternal.Length; i++)
if(inInternal[i]) inCount++;
for(int i = 0; i < outOutput.Length; i++)
if(outOutput[i]) outCount++;
for(int i = 0; i < outInternal.Length; i++)
if(outInternal[i]) outCount++;
inputs = new Signal[inCount];
outputs = new Signal[outCount];
}
public static IValueStructure MonomialDegree(Signal signal, Signal[] generalizedVariables)
{
if(Std.IsConstantAdditiveIdentity(signal))
return NegativeInfinitySymbol.Instance;
if(Array.Exists<Signal>(generalizedVariables, signal.Equals))
return IntegerValue.One;
if(!Array.Exists<Signal>(generalizedVariables, signal.DependsOn))
return IntegerValue.Zero;
ISignalSet factors;
long deg = 0;
if(signal.IsDrivenByPortEntity("Multiply", "Std"))
factors = signal.DrivenByPort.InputSignals;
else
factors = new SignalSet(signal);
for(int i = 0; i < factors.Count; i++)
{
if(Array.Exists<Signal>(generalizedVariables, factors[i].Equals))
deg++;
else if(factors[i].IsDrivenByPortEntity("Power", "Std"))
{
Signal b = signal.DrivenByPort.InputSignals[0];
Signal e = signal.DrivenByPort.InputSignals[1];
IntegerValue v;
if(Array.Exists<Signal>(generalizedVariables, b.Equals) && (v = e.Value as IntegerValue) != null && v.Value > 0)
deg += v.Value;
}
}
return new IntegerValue(deg);
}
private static void UsingPInvoke(int frequency)
{
try
{
Frequency f = frequency;
Sample[] v = new Sample[2];
Signal[] s = new Signal[2];
Time t = 0, t0 = 0, t1 = 0;
if (f <= 0)
f = PInvoke.sampfreq("data/100s");
if (PInvoke.isigopen("data/100s", s, 2) < 1)
return;
PInvoke.setifreq(f);
t0 = PInvoke.strtim("1");
PInvoke.isigsettime(t);
t1 = PInvoke.strtim("2");
for (t = t0; t <= t1; t++)
{
if (PInvoke.getvec(v) < 0)
break;
Console.WriteLine("{0}\t{1}", v[0], v[1]);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public LogArgs( string str, LogType p, Signal s )
{
Message = str;
Type = p;
sig = s;
timestamp = DateTime.Now;
}
/// <summary>
/// Applies the filter to a signal.
/// </summary>
protected unsafe override void ProcessFilter(Signal sourceData, Signal destinationData)
{
SampleFormat format = sourceData.SampleFormat;
int samples = sourceData.Samples;
if (format == SampleFormat.Format32BitIeeeFloat)
{
float* src = (float*)sourceData.Data.ToPointer();
float* dst = (float*)destinationData.Data.ToPointer();
for (int i = 0; i < samples; i++, dst++, src++)
*dst = System.Math.Abs(*src);
}
else if (format == SampleFormat.Format128BitComplex)
{
Complex* src = (Complex*)sourceData.Data.ToPointer();
Complex* dst = (Complex*)destinationData.Data.ToPointer();
Complex c = new Complex();
for (int i = 0; i < samples; i++, dst++, src++)
{
c.Re = (*src).Magnitude;
*dst = c;
}
}
}
public override bool FulfillsCondition(Signal output, Port port)
{
foreach(Condition c in _conditions)
if(!c.FulfillsCondition(output, port))
return false;
return true;
}
public override bool FulfillsCondition(Signal output, Port port)
{
if(port == null)
return false;
return port.HasArchitectureLink && _match(port.CurrentArchitecture);
}
/**
* create an event containing a signal, which modifies a parameter property of a DSP
* event during rendering. Modifier type must be SignalSoundEvent.Modifier.PARAM !
*/
public SignalSoundEvent(SignalSoundEvent.Modifier modifierType, Signal sig, int paramNumber)
: base()
{
_sig = sig;
_modif = modifierType;
_paramNumber = paramNumber;
UpdateDuration(_sig.Duration);
}
public void Traverse(Signal rootSignal, IScanVisitor visitor, bool ignoreHold)
{
//lock(??) {
ScanStrategy strat = ProvideExecutableInstance();
strat._activeScans++; //}
try { strat.DoTraverse(rootSignal, visitor, ignoreHold); }
finally { strat._activeScans--; }
}
public static Signal AutoSimplify(Signal signal)
{
return(_transformer.Transform(signal, AutoSimplifyTransformation.TransformationTypeIdentifier, false));
}
public static void ConstrainAlwaysNegative(Signal signal)
{
signal.EnableFlag(StdAspect.NegativeWithoutZeroConstraingFlag);
}
/// <summary>
/// Whether the signal is restricted to be an integer, that is one of ...,-3,-2,-1,0,1,2,3,...
/// </summary>
public static bool IsAlwaysInteger(Signal signal)
{
return(signal.IsFlagEnabled(StdAspect.IntegerConstraintFlag) ||
IsConstantInteger(signal));
}
public static void ConstrainAlwaysInteger(Signal signal)
{
signal.EnableFlag(StdAspect.IntegerConstraintFlag);
}
public static bool IsConstantReal(Signal signal)
{
return(IsConstant(signal) && RealValue.CanConvertLosslessFrom(signal.Value));
}
public static void ConstrainAlwaysReal(Signal signal)
{
signal.EnableFlag(StdAspect.RealConstraintFlag);
}
public static bool IsConstantComplex(Signal signal)
{
return(IsConstant(signal) && ComplexValue.CanConvertLosslessFrom(signal.Value));
}
partial void OnBeforeDelete(Signal signal);
partial void OnAfterDelete(Signal signal);
protected void ConnectEvent(string name, Native.D.signal_onevent handler) => Disposables.Add(Signal.Connect <Native.D.signal_onevent>(GtkWidget, name, handler));
void Connect <T>(string name, T handler) => Disposables.Add(Signal.Connect(GtkWidget, name, handler));
public bool LeaveSignal(Signal signal, Port parent, bool again, bool root)
{
return(_leaveSignal(signal, parent, again, root));
}
public bool EnterSignal(Signal signal, Port parent, bool again, bool root)
{
return(_enterSignal(signal, parent, again, root));
}
public static SignalSet Manipulate(IEnumerable <Signal> rootSignals, IManipulationVisitor visitor, bool ignoreHold)
{
Dictionary <Guid, ManipulationPlan> plans = new Dictionary <Guid, ManipulationPlan>();
Dictionary <Guid, Signal> signalReplacements = new Dictionary <Guid, Signal>();
Dictionary <Guid, Signal> sentinels = new Dictionary <Guid, Signal>();
// ## ESTIMATE MANIPULATION PLAN
Scanner.ForEachPort(rootSignals, delegate(Port p)
{
if (!plans.ContainsKey(p.InstanceId))
{
plans.Add(p.InstanceId, visitor.EstimatePlan(p));
}
return(true);
}, ignoreHold);
// ## OPTIMIZE MANIPULATION PLAN (cycle analysis)
ManipulatorPlanReducer reducer = new ManipulatorPlanReducer(plans, ignoreHold);
AllPathsStrategy.Instance.Traverse(rootSignals, reducer, ignoreHold);
// ## EXECUTE MANIPULATION
ManipulatorPlanExecutor executor = new ManipulatorPlanExecutor(plans, signalReplacements, sentinels, visitor);
AllPathsStrategy.Instance.Traverse(rootSignals, executor, ignoreHold);
// ## SELECT NEW SYSTEM
SignalSet ret = new SignalSet();
foreach (Signal root in rootSignals)
{
Signal r;
if (!signalReplacements.TryGetValue(root.InstanceId, out r))
{
r = root;
}
ret.Add(r);
}
// ## FIX SENTINELS ON SELECTED NEW SYSTEM
Scanner.ForEachPort(ret, delegate(Port p)
{
// look for sentinels on all input signals
ReadOnlySignalSet inputs = p.InputSignals;
for (int i = 0; i < inputs.Count; i++)
{
Signal input = inputs[i];
if (FixSentinel(ref input, sentinels, signalReplacements))
{
p.ReplaceInputSignalBinding(i, input);
}
}
return(true);
}, ignoreHold);
for (int i = 0; i < ret.Count; i++)
{
Signal r = ret[i];
if (FixSentinel(ref r, sentinels, signalReplacements))
{
ret[i] = r;
}
}
// ## RETURN SELECTED NEW SYSTEM AS RESULT
return(ret);
}
public static void ConstrainAlwaysComplex(Signal signal)
{
signal.EnableFlag(StdAspect.ComplexConstraintFlag);
}
partial void OnAfterPut(Signal signal);
/// <summary>
/// Whether the signal is restricted to be a complex (of real parts).
/// </summary>
public static bool IsAlwaysComplex(Signal signal)
{
return(signal.IsFlagEnabled(StdAspect.ComplexConstraintFlag) ||
IsConstantComplex(signal));
}
partial void OnBeforePut(Signal signal);
partial void OnAfterGetById(Signal Signals, Guid signalId);
public SignalEventArgs(ObjectWrapper wrapper, Signal signal) : base(wrapper)
{
this.signal = signal;
}
/// <summary>
/// Whether the signal is restricted to be a real.
/// </summary>
public static bool IsAlwaysReal(Signal signal)
{
return(signal.IsFlagEnabled(StdAspect.RealConstraintFlag) ||
IsConstantReal(signal));
}
public virtual void Notify_SignalReceived(Signal signal)
{
}
public static bool IsConstantInteger(Signal signal)
{
return(IsConstant(signal) && IntegerValue.CanConvertLosslessFrom(signal.Value));
}
public static void ConstrainAlwaysNonpositiveInteger(Signal signal)
{
ConstrainAlwaysInteger(signal);
ConstrainAlwaysNonpositive(signal);
}
public static void ConstrainAlwaysNonpositive(Signal signal)
{
signal.EnableFlag(StdAspect.NegativeOrZeroConstraintFlag);
}
public static bool IsConstantNonpositiveInteger(Signal signal)
{
return(IsConstantInteger(signal) && IsAlwaysNonpositive(signal));
}
/// <summary>Evaluates whether the signal is always one (1).</summary>
public static bool IsConstantMultiplicativeIdentity(Signal signal)
{
return(IsConstant(signal) && IsMultiplicativeIdentity(signal));
}
/// <summary>
/// Whether the signal is restricted to be an integer >= 0, that is one of 0,1,2,3,...
/// </summary>
public static bool IsAlwaysNonnegativeInteger(Signal signal)
{
return(IsAlwaysInteger(signal) && IsAlwaysNonnegative(signal));
}
public void open_short_position_with_market_order_protect_it_with_stop_and_limit_and_close_with_stop_multiple_trades()
{
// Настройки для торгуемой стратегии
Symbol symbol = new Symbol("RTS-9.13_FT", 1, 8, 10, BrokerDateTime.Make(DateTime.Now));
this.tradingData.Get <ICollection <Symbol> >().Add(symbol);
StrategyHeader strategyHeader = new StrategyHeader(1, "strategyHeader", "BP12345-RF-01", "RTS-9.13_FT", 10);
this.tradingData.Get <ICollection <StrategyHeader> >().Add(strategyHeader);
StopPointsSettings slSettings = new StopPointsSettings(strategyHeader, 300, false);
this.tradingData.Get <ICollection <StopPointsSettings> >().Add(slSettings);
ProfitPointsSettings tpSettings = new ProfitPointsSettings(strategyHeader, 500, false);
this.tradingData.Get <ICollection <ProfitPointsSettings> >().Add(tpSettings);
StopLossOrderSettings slOrderSettings = new StopLossOrderSettings(strategyHeader, 3600);
this.tradingData.Get <ICollection <StopLossOrderSettings> >().Add(slOrderSettings);
TakeProfitOrderSettings tpOrderSettings = new TakeProfitOrderSettings(strategyHeader, 3600);
this.tradingData.Get <ICollection <TakeProfitOrderSettings> >().Add(tpOrderSettings);
StrategyStopLossByPointsOnTick stopLossHandler =
new StrategyStopLossByPointsOnTick(strategyHeader, this.tradingData, this.signalQueue, new NullLogger(), true);
StrategyTakeProfitByPointsOnTick takeProfitHandler =
new StrategyTakeProfitByPointsOnTick(strategyHeader, this.tradingData, this.signalQueue, new NullLogger(), true);
PlaceStrategyStopLossByPointsOnTrade placeStopOnTradeHandler =
new PlaceStrategyStopLossByPointsOnTrade(strategyHeader, this.tradingData, this.signalQueue, new NullLogger(), true);
PlaceStrategyTakeProfitByPointsOnTrade placeTakeProfitOnTradeHandler =
new PlaceStrategyTakeProfitByPointsOnTrade(strategyHeader, this.tradingData, this.signalQueue, new NullLogger(), true);
// Сигнал на открытие позиции
Signal inputSignal = new Signal(strategyHeader, BrokerDateTime.Make(DateTime.Now), TradeAction.Sell, OrderType.Market, 150000, 0, 0);
this.signalQueue.Enqueue(inputSignal);
// Сигнал успешно обработан и заявка отправлена брокеру
Assert.AreEqual(1, this.tradingData.Get <IEnumerable <Signal> >().Count());
Assert.AreEqual(1, this.tradingData.Get <IEnumerable <Order> >().Count());
// Копия отправленной брокеру заявки на открытие позиции
Order inputOrder = this.tradingData.Get <IEnumerable <Order> >().Last();
// Брокер подтвердил получение заявки
this.tradingData.Get <ObservableHashSet <OrderDeliveryConfirmation> >().Add(new OrderDeliveryConfirmation(inputOrder, BrokerDateTime.Make(DateTime.Now)));
Assert.IsTrue(inputOrder.IsDelivered);
// Брокер исполнил заявку несколькими сделками
Trade inputTrade = new Trade(inputOrder, inputOrder.Portfolio, inputOrder.Symbol, 149900, -7, BrokerDateTime.Make(DateTime.Now));
this.tradingData.Get <ObservableHashSet <Trade> >().Add(inputTrade);
// Часть заявки исполнена, позиция открыта ровно на исполненный сделкой объем
Assert.IsFalse(inputOrder.IsFilled);
Assert.IsTrue(inputOrder.IsFilledPartially);
Assert.AreEqual(1, this.tradingData.Get <IEnumerable <Position> >().Count());
Position position = this.tradingData.Get <IEnumerable <Position> >().Last();
Assert.AreEqual(-7, position.Amount);
// Заявки на приказы stop loss и take profit не генерируются, поскольку рыночная заявка не исполнена
Assert.AreEqual(1, this.tradingData.Get <IEnumerable <Signal> >().Count());
Assert.AreEqual(1, this.tradingData.Get <IEnumerable <Order> >().Count());
// Следующая сделка
Trade t2 = new Trade(inputOrder, inputOrder.Portfolio, inputOrder.Symbol, 149920, -1, BrokerDateTime.Make(DateTime.Now));
this.tradingData.Get <ObservableHashSet <Trade> >().Add(t2);
// Часть заявки исполнена, позиция увеличилась ровно на исполненный сделкой объем
Assert.IsFalse(inputOrder.IsFilled);
Assert.IsTrue(inputOrder.IsFilledPartially);
Assert.AreEqual(-8, position.Amount);
// Заявки на приказы stop loss и take profit не генерируются, поскольку рыночная заявка не исполнена
Assert.AreEqual(1, this.tradingData.Get <IEnumerable <Signal> >().Count());
Assert.AreEqual(1, this.tradingData.Get <IEnumerable <Order> >().Count());
// Следующая сделка
Trade t3 = new Trade(inputOrder, inputOrder.Portfolio, inputOrder.Symbol, 149950, -2, BrokerDateTime.Make(DateTime.Now));
this.tradingData.Get <ObservableHashSet <Trade> >().Add(t3);
// Заявка полностью исполнена, позиция увеличилась ровно на исполненный сделкой объем
Assert.IsTrue(inputOrder.IsFilled);
Assert.IsFalse(inputOrder.IsFilledPartially);
Assert.AreEqual(-10, position.Amount);
// Для позиции созданы и отправлены брокеру защитные стоп и тейк профит приказы
Assert.AreEqual(3, this.tradingData.Get <IEnumerable <Signal> >().Count());
Assert.AreEqual(3, this.tradingData.Get <IEnumerable <Order> >().Count());
Order slOrder = this.tradingData.Get <IEnumerable <Order> >().Single(o => o.OrderType == OrderType.Stop);
Order tpOrder = this.tradingData.Get <IEnumerable <Order> >().Single(o => o.OrderType == OrderType.Limit);
// Цена защитных приказов установлена соответственно настройкам
Assert.AreEqual(150300, slOrder.Stop);
Assert.AreEqual(149500, tpOrder.Price);
// Брокер подтверждает получение защитных приказов
this.tradingData.Get <ObservableHashSet <OrderDeliveryConfirmation> >().Add(new OrderDeliveryConfirmation(slOrder, BrokerDateTime.Make(DateTime.Now)));
this.tradingData.Get <ObservableHashSet <OrderDeliveryConfirmation> >().Add(new OrderDeliveryConfirmation(tpOrder, BrokerDateTime.Make(DateTime.Now)));
Assert.IsTrue(slOrder.IsDelivered);
Assert.IsTrue(tpOrder.IsDelivered);
// Через некоторое время цена на рынке вырастает, срабатывает защитный стоп приказ и исполняется первая сделка
Trade outputTrade = new Trade(slOrder, slOrder.Portfolio, slOrder.Symbol, 150310, 3, BrokerDateTime.Make(DateTime.Now));
tradingData.Get <ObservableHashSet <Trade> >().Add(outputTrade);
// Стоп приказ исполнен лишь частично. Позиция не закрыта. Take profit приказ не отменен
Assert.IsFalse(slOrder.IsFilled);
Assert.IsTrue(slOrder.IsFilledPartially);
Assert.AreEqual(-7, position.Amount);
Assert.IsFalse(tpOrder.IsCanceled);
// Исполняется вторая сделка
Trade ot2 = new Trade(slOrder, slOrder.Portfolio, slOrder.Symbol, 150320, 4, BrokerDateTime.Make(DateTime.Now));
tradingData.Get <ObservableHashSet <Trade> >().Add(ot2);
// Стоп приказ исполнен лишь частично. Позиция не закрыта. Take profit приказ не отменен
Assert.IsFalse(slOrder.IsFilled);
Assert.IsTrue(slOrder.IsFilledPartially);
Assert.AreEqual(-3, position.Amount);
Assert.IsFalse(tpOrder.IsCanceled);
// Исполняется третья сделка
Trade ot3 = new Trade(slOrder, slOrder.Portfolio, slOrder.Symbol, 150330, 3, BrokerDateTime.Make(DateTime.Now));
tradingData.Get <ObservableHashSet <Trade> >().Add(ot3);
// Стоп приказ исполнен
Assert.IsTrue(slOrder.IsFilled);
Assert.IsFalse(tpOrder.IsFilled);
Assert.IsFalse(tpOrder.IsCanceled);
// Позиция закрыта
Assert.AreEqual(0, position.Amount);
// Брокеру отправлен запрос на отмену приказа take profit
Assert.AreEqual(1, this.tradingData.Get <ObservableHashSet <OrderCancellationRequest> >().Count);
// Брокер подтверждает получение заявки на отмену приказа
this.tradingData.Get <ObservableHashSet <OrderCancellationConfirmation> >().Add(new OrderCancellationConfirmation(tpOrder, BrokerDateTime.Make(DateTime.Now), "Заявка снята"));
Assert.IsTrue(tpOrder.IsCanceled);
}
private static extern int sigaction(Signal sig, IntPtr act, IntPtr oact);
