public IStrategy[] GetStrategies()
{
var subStrategies = new[]
{
_strategyFactory.Create(new RelativeStrengthParameters()),
_strategyFactory.Create(new DeltaParameters()),
_strategyFactory.Create(new GradientParameters()),
_strategyFactory.Create(new LinearRegressionParameters()),
_strategyFactory.Create(new VolumeParameters()),
_strategyFactory.Create(new HolidayEffectParameters()),
_strategyFactory.Create(new MovingAverageParameters()),
_strategyFactory.Create(new OptimalStoppingParameters()),
_strategyFactory.Create(new ProbabilityParameters()),
//_strategyFactory.Create(new EntropyParameters()),
_strategyFactory.Create(new ClusteringParameters())
//_strategyFactory.Create(new WeightedParameters())
};
//var strategies = subStrategies.Concat(new[]
//{
// _strategyFactory.Create(new WeightedParameters {Weights = subStrategies.ToDictionary(x => x, v => 0d)})
//});
var strategies = subStrategies;
Log.Information($"Evaluating against strategies: {string.Join<IStrategy>(", ", strategies)}");
return(strategies.ToArray());
}
public void Process()
{
var source = new DataService(_code);
var target = new LogService(_code);
var method = StrategyFactory.Create("Unilateral", source);
for (DateTime day = _start; day <= _end; day = day.AddDays(1))
{
var data = source.DailyData(day);
if (data == null)
{
continue;
}
foreach (var item in data)
{
var signals = method.Update(item);
foreach (var signal in signals)
{
if (signal.actInfo != Actions.Null)
{
target.Execute(signal);
method.Feedback(target.Query());
}
}
}
}
}
public IParameters Maximum(
IEnumerable <IParameters> parameters,
DateTime fromDate,
DateTime endDate)
{
var potentials = parameters.Select((param, index) =>
{
var strategy = _strategyFactory.Create(param);
var investor = _investorProvider.Current;
var simulator = new TrainingSimulator(_dataCache, _simulationCache);
var result = simulator.Evaluate(strategy, investor, endDate).Last();
return(result.Worth, result.BuyCount, strategy, index);
})
.AsParallel()
.OrderByDescending(x => x.Worth)
.ThenBy(x => x.index) // This is used as a tie breaker due to parallelism
.Select(x => x.strategy)
.ToArray();
var optimal = potentials.First();
var toRemove = potentials.Except(new[] { optimal }.AsParallel());
_simulationCache.Remove(fromDate, endDate, toRemove);
return(optimal.Parameters);
}
static void Main()
{
var factory = new StrategyFactory <IRPSStrategy>();
Console.Write("Player One Name? ");
string p1Name = Console.ReadLine();
Console.Write($"Player One Strategy [{factory.Options}]? ");
string p1Strategy = Console.ReadLine();
Console.Write("Player Two Name? ");
string p2Name = Console.ReadLine();
Console.Write($"Player Two Strategy [{factory.Options}]? ");
string p2Strategy = Console.ReadLine();
Console.WriteLine();
Console.Write("How many throws? ");
int count = int.Parse(Console.ReadLine());
Console.WriteLine();
Game game = new Game(new Player(p1Name, factory.Create(p1Strategy)), new Player(p2Name, factory.Create(p2Strategy)));
for (int i = 0; i < count; ++i)
{
game.Iterate();
}
}
public WorkItem(string code)
{
_code = code;
_source = new DataService(code);
_target = new LogService(code);
_method = StrategyFactory.Create("Inertance", _source);
_source.Start(this.handler);
}
public Player(PlayerConfiguration conf, BufferBlock <Message> queue, ISocketClient <Message,
Message> client, ILogger log)
{
this.conf = conf;
this.strategy = StrategyFactory.Create((StrategyEnum)conf.Strategy, this, log);
this.queue = queue;
this.client = client;
this.logger = log.ForContext <Player>();
this.Team = conf.TeamID;
this.Position = (-1, -1);
}
void init(string code, Painter painter, DateTime day)
{
_code = code;
_painter = painter;
_source = new DataService(_code);
_target = new LogService(_code);
_method = StrategyFactory.Create("Inertance", _source);
_painter.Init(_source.GetPreClose(day), _source.GetRecentAvgVol(day));
}
public void ItCreates_HardStrategy()
{
// Prepare :
var factory = new StrategyFactory();
// Act:
var strategy = factory.Create(Strategies.HardStrategy);
// Assert:
Assert.NotNull(strategy);
Assert.IsType<HardStrategy>(strategy);
}
public TimeScheduleWorkflowManager()
{
try
{
ConfigurationSetting.Initialize();
strategryFactory = new StrategyFactory();
timeSchedule = new TimeSchedule(strategryFactory.Create());
timeSchedule.LoadRequests(ConfigurationSetting.InputFile);
}
catch (Exception ex)
{
Console.WriteLine(UNEXPECTEDFAILURE);
Console.WriteLine(ex);
}
}
public void Run()
{
do
{
_userInputManager.RequestConfigurationData();
_simulator.InitRouletteGame(_userInputManager.MinimumBid, _userInputManager.MaximumBid);
_statisticsManager.Clear();
do
{
var strategy = StrategyFactory.Create(_userInputManager.Strategy, _userInputManager.Cycles, new Player(_userInputManager.Name, _userInputManager.Budget));
var result = _simulator.ExecuteStrategy(strategy, _userInputManager.StartBet);
_statisticsManager.Process(result);
_visualizer.ShowStatistics(_statisticsManager.GetStatistics());
} while (_userInputManager.ShowModal("Run strategy again? (y or n):", "y", "n"));
} while (_userInputManager.ShowModal("Continue or quit? (Enter or q):", "Enter", "q"));
}
//public void Init(Team team, IStrategy strategy, Guid id)
//{
// var newPlayer = new GomokuPlayer(strategy, team, id);
// if (team == Team.Red)
// PlayerRed = newPlayer;
// else
// if (team == Team.Blue)
// PlayerBlue = newPlayer;
// if (PlayerRed != null && PlayerBlue != null)
// OnPlayersConnected?.Invoke();
//}
public void Init(Team team, Type strategy, Guid id)
{
var newPlayer = new GomokuPlayer(StrategyFactory.Create(strategy, Game, team), team, id);
if (team == Team.Red)
{
PlayerRed = newPlayer;
}
else
if (team == Team.Blue)
{
PlayerBlue = newPlayer;
}
if (PlayerRed != null && PlayerBlue != null)
{
OnPlayersConnected?.Invoke();
}
}
/// <inheritdoc />
public void Parse(string basePath, OutputOptions options, out EndValueNamespaceNavigationNode endValueNode)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
var root = RootNamespaceNavigation.GetInstance();
var strategy = StrategyFactory.Create(basePath, options);
Console.WriteLine(strategy.Path);
endValueNode = new EndValueNamespaceNavigationNode(strategy);
if (IsDefault(options))
{
root.SetDefaultNavValue(endValueNode);
return;
}
if (IncludeStar(options))
{
root.SetAllNavValue(endValueNode);
return;
}
var validNamespaceList = GetValidNamespaceList(options);
foreach (var @namespace in validNamespaceList)
{
if (@namespace.IndexOf(".", StringComparison.Ordinal) < 0)
{
root.SetFirstLevelNavValue(@namespace, endValueNode);
}
else
{
root.SetFluentLinkedNavValue(@namespace, endValueNode);
}
}
}