public static ResultsPair <LocalCoins.Portfolio> UpdatePortfolio(int portfolioId, string portfolioName, Types.PortfolioDisplayType displayType, bool isDefault)
{
try
{
using (PegasunDBContext db = new PegasunDBContext())
{
Portfolios portfolio = db.Portfolios.FirstOrDefault(x => x.PortfolioId == portfolioId);
if (portfolio != null)
{
portfolio.Name = portfolioName.Clean(new[] { Types.CleanInputType.AZ09CommonCharsSM });
portfolio.DisplayType = (short)displayType;
portfolio.IsDefault = isDefault;
db.Update(portfolio);
db.SaveChanges();
}
return(ResultsPair.Create(ResultsItem.Success("Successfully updated portfolio name."), portfolio.Adapt <LocalCoins.Portfolio>()));
}
}
catch (Exception ex)
{
Utilities.LogException(new[] { "UpdatePortfolio", $"portfolioId:{portfolioId},portfolioName:{portfolioName}" }, ex);
return(ResultsPair.CreateError <LocalCoins.Portfolio>($"Unable to update portfolio. {ex.Message}"));
}
}
public override void CopyFrom(BinaryMetaInfo src)
{
base.CopyFrom(src);
var posInfo = (PositionMetaInfo)src;
BeginValue = Clone(posInfo.BeginValue);
CurrentValue = Clone(posInfo.CurrentValue);
BlockedValue = Clone(posInfo.BlockedValue);
CurrentPrice = Clone(posInfo.CurrentPrice);
AveragePrice = Clone(posInfo.AveragePrice);
UnrealizedPnL = Clone(posInfo.UnrealizedPnL);
RealizedPnL = Clone(posInfo.RealizedPnL);
VariationMargin = Clone(posInfo.VariationMargin);
Leverage = Clone(posInfo.Leverage);
Commission = Clone(posInfo.Commission);
CurrentValueInLots = Clone(posInfo.CurrentValueInLots);
Portfolios.Clear();
Portfolios.AddRange(posInfo.Portfolios);
ClientCodes.Clear();
ClientCodes.AddRange(posInfo.ClientCodes);
DepoNames.Clear();
DepoNames.AddRange(posInfo.DepoNames);
SettlementPrice = Clone(posInfo.SettlementPrice);
}
public Portfolio CreatePortfolio(User user, string portfolioname, bool isSimulated, Tuple <string, AssetClass>[] tuples)
{
Portfolio portfolio = new Portfolio()
{
Name = portfolioname,
AssetAllocations = new List <AssetAllocation>(),
UserId = user.Id,
};
Portfolios.Add(portfolio);
SaveChanges();
foreach (var tuple in tuples)
{
AssetBase assetBase = GetAssetyBy(tuple.Item2, tuple.Item1);
if (assetBase == null)
{
assetBase = CreateAsset(tuple.Item2, tuple.Item1);
}
AssetAllocation assetAllocation = new AssetAllocation()
{
Asset = assetBase,
PortfolioId = portfolio.Id,
};
AssetAllocations.Add(assetAllocation);
portfolio.AssetAllocations.Add(assetAllocation);
}
portfolio.UserId = user.Id;
portfolio.IsSimulated = true;
Update(portfolio);
return(portfolio);
}
public override void CopyFrom(TransactionSerializerMetaInfo src)
{
base.CopyFrom(src);
FirstOrderId = src.FirstOrderId;
LastOrderId = src.LastOrderId;
FirstTradeId = src.FirstTradeId;
LastTradeId = src.LastTradeId;
FirstTransactionId = src.FirstTransactionId;
LastTransactionId = src.LastTransactionId;
FirstOriginalTransactionId = src.FirstOriginalTransactionId;
LastOriginalTransactionId = src.LastOriginalTransactionId;
FirstPrice = src.FirstPrice;
LastPrice = src.LastPrice;
FirstCommission = src.FirstCommission;
LastCommission = src.LastCommission;
Portfolios.Clear();
Portfolios.AddRange(src.Portfolios);
StrategyIds.Clear();
StrategyIds.AddRange(src.StrategyIds);
Comments.Clear();
Comments.AddRange(src.Comments);
Errors.Clear();
Errors.AddRange(src.Errors);
}
public override void CopyFrom(PositionMetaInfo src)
{
base.CopyFrom(src);
BeginValue = Clone(src.BeginValue);
CurrentValue = Clone(src.CurrentValue);
BlockedValue = Clone(src.BlockedValue);
CurrentPrice = Clone(src.CurrentPrice);
AveragePrice = Clone(src.AveragePrice);
UnrealizedPnL = Clone(src.UnrealizedPnL);
RealizedPnL = Clone(src.RealizedPnL);
VariationMargin = Clone(src.VariationMargin);
Leverage = Clone(src.Leverage);
Commission = Clone(src.Commission);
CurrentValueInLots = Clone(src.CurrentValueInLots);
Portfolios.Clear();
Portfolios.AddRange(src.Portfolios);
ClientCodes.Clear();
ClientCodes.AddRange(src.ClientCodes);
DepoNames.Clear();
DepoNames.AddRange(src.DepoNames);
}
/// <summary>
/// Загрузить настройки.
/// </summary>
/// <param name="storage">Хранилище настроек.</param>
public override void Load(SettingsStorage storage)
{
InnerSessions.Clear();
Portfolios.Clear();
storage
.GetValue <IEnumerable <SettingsStorage> >("InnerSessions")
.ForEach(s =>
{
var sessionHolder = s.GetValue <Type>("type").CreateInstanceArgs <IMessageSessionHolder>(new object[] { TransactionIdGenerator });
sessionHolder.Load(s.GetValue <SettingsStorage>("settings"));
InnerSessions.Add(sessionHolder, s.GetValue <int>("Priority"));
var portfolios = s.GetValue <IEnumerable <string> >("Portfolios");
if (portfolios != null)
{
foreach (var portfolio in portfolios)
{
Portfolios[portfolio] = sessionHolder;
}
}
});
base.Load(storage);
}
public static void UpdatePosition(QuikConnectionManager.Position obj)
{
if (Positions.Any(k => k.AccountName == obj.AccountName && k.Instrument.Code == obj.SecurityCode))
{
Entities.Position p = Positions.First(k => k.AccountName == obj.AccountName && k.Instrument.Code == obj.SecurityCode);
p.Update(obj.TotalNet, obj.BuyQty, obj.SellQty, obj.VarMargin);
//p.TotalNet = obj.TotalNet;
//p.BuyQty = obj.BuyQty;
//p.SellQty = obj.SellQty;
//p.VM = obj.VarMargin;
}
else
{
log.Warn("Update on unknown position {0} {1}", obj.AccountName, obj.SecurityCode);
}
// update portfolio
try
{
Entities.Instrument i = Instruments.First(k => k.Code == obj.SecurityCode);
string basec = i.Type == Entities.InstrumentType.Futures? i.Code:i.BaseContract;
Entities.Portfolio p = Portfolios.First(k => k.Account == obj.AccountName && k.BaseCode == basec);
Entities.Position pos = p.Positions.First(k => k.AccountName == obj.AccountName && k.Instrument.Code == obj.SecurityCode);
pos.Update(obj.TotalNet, obj.BuyQty, obj.SellQty, obj.VarMargin);
//pos.TotalNet=obj.TotalNet;
//pos.VM = obj.VarMargin;
//pos.BuyQty = obj.BuyQty;
//pos.SellQty = obj.SellQty;
}
catch { log.Warn("Can`t find portfolio for position update!"); }
}
private IQueryable <PortfolioMeter> GetPortfolioMeters(string portfolioId)
{
return(from p in Portfolios.AsQueryable().Include(p => p.PortfolioMeters)
where p.Id == portfolioId
from pm in p.PortfolioMeters
select pm);
}
public static async Task <ResultsPair <LocalCoins.Portfolio> > InsertNewPortfolio(int userId, string portfolioName, Types.PortfolioDisplayType displayType, bool isDefault)
{
try
{
using (PegasunDBContext db = new PegasunDBContext())
{
Portfolios portfolio = new Portfolios
{
UserId = userId,
Name = portfolioName.Clean(new[] { Types.CleanInputType.AZ09CommonCharsSM }),
DisplayType = (short)displayType,
IsDefault = isDefault
};
db.Portfolios.Add(portfolio);
await db.SaveChangesAsync();
return(ResultsPair.Create(ResultsItem.Success("Successfully created a new portfolio."), portfolio.Adapt <LocalCoins.Portfolio>()));
}
}
catch (Exception ex)
{
return(ResultsPair.CreateError <LocalCoins.Portfolio>($"Unable to create a new portfolio. {ex.Message}"));
}
}
private void OnHolding(int tableId, object[] values)
{
var table = HoldingTable;
var account = table.GetValue <string>(values, AlorHoldingColumns.Account);
var security = GetSecurityBySecCode(table.GetValue <string>(values, AlorHoldingColumns.SecurityCode));
var portfolio = account.Trim() != ""
? GetPortfolio(table.GetValue <string>(values, AlorHoldingColumns.Account))
: Portfolios.ToList()[0];
UpdatePosition(portfolio, security,
position =>
{
using (position.BeginUpdate())
{
position.BeginValue = table.GetValue <int>(values, AlorHoldingColumns.BeginValue);
position.CurrentValue = table.GetValue <int>(values, AlorHoldingColumns.CurrentValue);
position.BlockedValue =
table.GetValue <int>(values, AlorHoldingColumns.CurrentBidsVolume) +
table.GetValue <int>(values, AlorHoldingColumns.CurrentAsksVolume);
table.FillNonMandatoryInfo(position, values);
}
return(true);
});
}
public void Clear()
{
foreach (var p in Portfolios)
{
this.framework.EventServer.OnPortfolioRemoved(p);
}
Portfolios.Clear();
this.counter = 0;
}
public static void AddPosition(QuikConnectionManager.Position obj)
{
if (!Positions.Any(k => k.AccountName == obj.AccountName && k.Instrument.Code == obj.SecurityCode))
{
Entities.Instrument instr;
if (obj.AccountName == "FOUXK_001")
{
Console.Write("fnfyng");
}
try
{
instr = Instruments.First(k => k.Code == obj.SecurityCode);
var pos = new Entities.Position(obj.AccountName, instr, obj.TotalNet, obj.BuyQty, obj.SellQty, obj.VarMargin);
Positions.Add(pos);
log.Info("New position added. SecCode={0} Account={1}", obj.SecurityCode, obj.AccountName);
if (pos.Instrument.Type == Entities.InstrumentType.Futures)
{
if (Portfolios.Any(k => k.BaseCode == pos.Instrument.Code && k.Account == pos.AccountName))
{
Portfolios.First(k => k.BaseCode == pos.Instrument.Code && k.Account == pos.AccountName).Positions.Add(pos);
log.Info("Futures Position added to existing portfolio.");
}
else
{ // create new portfolio
Entities.Portfolio port = new Entities.Portfolio(pos.Instrument.Code, pos.AccountName);
port.Positions.Add(pos);
Portfolios.Add(port);
log.Info("New portfolio created. Name={0} Base={1} Account={2}", port.Name, port.BaseCode, port.Account);
}
}
else if (pos.Instrument.Type == Entities.InstrumentType.Option)
{
if (Portfolios.Any(k => k.BaseCode == pos.Instrument.BaseContract && k.Account == pos.AccountName))
{
Portfolios.First(k => k.BaseCode == pos.Instrument.BaseContract && k.Account == pos.AccountName).Positions.Add(pos);
log.Info("Option Position added to existing portfolio.");
}
else
{ // create new portfolio
Entities.Portfolio port = new Entities.Portfolio(pos.Instrument.BaseContract, pos.AccountName);
port.Positions.Add(pos);
Portfolios.Add(port);
log.Info("New portfolio created. Name={0} Base={1} Account={2}", port.Name, port.BaseCode, port.Account);
}
}
}
catch (SystemException exep)
{
log.Error("Try to add position for unknown instrument {0} {1} {2}", obj.SecurityCode, obj.AccountName, obj.TotalNet);
log.Error(exep.Message);
}
}
else
{
log.Warn("Try to add existing position. {0} {1}", obj.AccountName, obj.SecurityCode);
}
}
public Portfolio AddPortfolio(string portfolioName)
{
var newPortfolio = new Portfolio()
{
PortfolioId = Portfolios.Count() + 1,
PortfolioName = portfolioName
};
Portfolios.Add(newPortfolio);
return newPortfolio;
}
public void MarketOrder(SignalInfo signal, IExpert adv)
{
try
{
if (adv == null)
{
return;
}
// decimal priceInOrder = Math.Round(tool.LastPrice + tool.Step * 5, tool.PriceAccuracy);
// decimal priceInOrder = 0;// Math.Round(tool.LastPrice, tool.PriceAccuracy);
int qty = (int)adv.Volume();
var portfolio = Portfolios.Where(x => x.Name == adv.AccountName()).FirstOrDefault();
if (!Trader.RegisteredPortfolios.Contains(portfolio))
{
Trader.RegisterPortfolio(portfolio);
}
Order order = new Order();
order.Type = OrderTypes.Market;
var securities = Securities.Where(x => x.Code == adv.Symbol());
if (securities != null && securities.Count() > 0)
{
order.Security = securities.FirstOrDefault();
}
else
{
order.Security = new Security();
order.Security.Code = adv.Symbol();
order.Security.Id = adv.Symbol() + "@FORTS";
}
order.Comment = adv.Comment();
order.Portfolio = portfolio;
if (!Trader.RegisteredSecurities.Contains(order.Security))
{
Trader.RegisterSecurity(order.Security);
Trader.RegisterTrades(order.Security);
}
order.Volume = qty;
order.Direction = signal.Value == 0 ? Sides.Buy : Sides.Sell;
Log(
$"Expert <{adv.AccountName()}> On {adv.Symbol()} {order.Direction.ToString()} Register order: lots=" +
qty);
Trader.RegisterOrder(order);
}
catch (Exception e)
{
Log($"Expert <{adv.AccountName()}> Error registering order: " + e);
}
}
/// <summary>
/// Сохранить настройки.
/// </summary>
/// <param name="storage">Хранилище настроек.</param>
public override void Save(SettingsStorage storage)
{
storage.SetValue("InnerSessions", InnerSessions.Select(s =>
{
var settings = s.SaveEntire(true);
settings.SetValue("Priority", InnerSessions[s]);
settings.SetValue("Portfolios", Portfolios.Where(p => p.Value == s).Select(p => p.Key).ToArray());
return(settings);
}).ToArray());
base.Save(storage);
}
private void ProcessPortfolioLookupResultMessage(PortfolioLookupResultMessage message)
{
if (message.Error != null)
RaiseError(message.Error);
var criteria = _portfolioLookups.TryGetValue(message.OriginalTransactionId);
if (criteria == null)
return;
RaiseLookupPortfoliosResult(message.Error, Portfolios.Where(pf => pf.Name.CompareIgnoreCase(criteria.PortfolioName)));
}
public Portfolio GetPortfoliosByUserNameAndPortfolioName(string userName, string portfolioname)
{
User user = GetUser(userName);
if (user == null)
{
return(null);
}
else
{
return(Portfolios.Include(p => p.Transactions).Include(p => p.AssetAllocations).Include(p => p.Balances).Where(p => p.UserId == user.Id && p.Name == portfolioname).SingleOrDefault());
}
}
public override void CopyFrom(BinaryMetaInfo src)
{
base.CopyFrom(src);
var tsInfo = (TransactionSerializerMetaInfo)src;
FirstOrderId = tsInfo.FirstOrderId;
LastOrderId = tsInfo.LastOrderId;
FirstTradeId = tsInfo.FirstTradeId;
LastTradeId = tsInfo.LastTradeId;
FirstTransactionId = tsInfo.FirstTransactionId;
LastTransactionId = tsInfo.LastTransactionId;
FirstOriginalTransactionId = tsInfo.FirstOriginalTransactionId;
LastOriginalTransactionId = tsInfo.LastOriginalTransactionId;
FirstCommission = tsInfo.FirstCommission;
LastCommission = tsInfo.LastCommission;
FirstPnL = tsInfo.FirstPnL;
LastPnL = tsInfo.LastPnL;
FirstPosition = tsInfo.FirstPosition;
LastPosition = tsInfo.LastPosition;
FirstSlippage = tsInfo.FirstSlippage;
LastSlippage = tsInfo.LastSlippage;
Portfolios.Clear();
Portfolios.AddRange(tsInfo.Portfolios);
ClientCodes.Clear();
ClientCodes.AddRange(tsInfo.ClientCodes);
BrokerCodes.Clear();
BrokerCodes.AddRange(tsInfo.BrokerCodes);
DepoNames.Clear();
DepoNames.AddRange(tsInfo.DepoNames);
UserOrderIds.Clear();
UserOrderIds.AddRange(tsInfo.UserOrderIds);
Comments.Clear();
Comments.AddRange(tsInfo.Comments);
SystemComments.Clear();
SystemComments.AddRange(tsInfo.SystemComments);
Errors.Clear();
Errors.AddRange(tsInfo.Errors);
StrategyIds.Clear();
StrategyIds.AddRange(tsInfo.StrategyIds);
}
private void Test()
{
var secs = FileReaders.ReadSecurities(@"C:\A\Experiments\Exp\securities.csv");
var covs = FileReaders.ReadCorrelations(@"C:\A\Experiments\Exp\correlations.csv", secs);
var matrix = Portfolios.ComputeCovariances(covs);
using (new ReportTime())
{
Dictionary <Security, double> weights;
var variance = Portfolios.ComputePortfolioMinimumVariance(matrix, 9d, out weights, true);
Console.WriteLine(weights.Aggregate("Weights:" + Environment.NewLine,
(str, pair) => str + (Environment.NewLine + pair.Key.Symbol + "," + pair.Value)));
Console.WriteLine("Variance: " + variance);
}
}
public Portfolio CreatePortfolio(User user, string portfolioname)
{
Portfolio portfolio = new Portfolio()
{
UserId = user.Id,
Name = portfolioname,
};
Portfolios.Add(portfolio);
//https://docs.microsoft.com/en-us/ef/core/saving/related-data
//TODO: falta resolver el cascade insert, es decir: si existe obtnerlo y si no crearlo
SaveChanges();
return(portfolio);
}
public double Calculate()
{
// fetch portfolios by using the provider
Portfolios = PortfolioProvider.Portfolios;
// call market data provider and gathering product parameters
ProductParameters = ProductParametersProvider.ProductsParameters;
// look over all portfolios and getting the positions
IEnumerable <KeyValuePair <Product, long> > allTransactions =
Portfolios.SelectMany(x => x.Transactions)
.GroupBy(y => y.Product)
.Select(z => new KeyValuePair <Product, long>(z.Key, z.Sum(x => x.Position)));
Positions = allTransactions.ToDictionary(t => t.Key, t => t.Value);
// foreach product do the montecarlo simulation with the target product parameter
// and multiply it by the position value and calculate the lost value
var lostsValuesByProduct = new Dictionary <string, IEnumerable <double> >();
foreach (var pos in Positions)
{
long position = pos.Value;
ProductParameters parameters = ProductParameters.First(x => x.Product.Equals(pos.Key));
var normalDistribution = new NormalEnumerable();
var input = new MonteCarloInput
{
Parameters = parameters,
Position = position,
};
IEnumerable <double> results = normalDistribution.Take(TotalSimulations)
.Select(alea => StatisticsUtilities.CalculateLoss(input, alea))
.ToList();
lostsValuesByProduct.Add(pos.Key.Name, results);
}
// aggregate the lost value for all products
IList <double> totals = new List <double>();
Func <IList <double>, string, IList <double> > sumList =
(current, key) => Helpers.SumList(current, lostsValuesByProduct[key].ToList());
totals = lostsValuesByProduct.Keys.Aggregate(totals, sumList);
// put prices and positions at the portfolio level
// choose the var at 99% for 1 day
return(StatisticsUtilities.CalculateVar(totals, 0.99));
}
public override void CopyFrom(TransactionSerializerMetaInfo src)
{
base.CopyFrom(src);
FirstOrderId = src.FirstOrderId;
LastOrderId = src.LastOrderId;
FirstTradeId = src.FirstTradeId;
LastTradeId = src.LastTradeId;
FirstTransactionId = src.FirstTransactionId;
LastTransactionId = src.LastTransactionId;
FirstOriginalTransactionId = src.FirstOriginalTransactionId;
LastOriginalTransactionId = src.LastOriginalTransactionId;
FirstPrice = src.FirstPrice;
LastPrice = src.LastPrice;
FirstCommission = src.FirstCommission;
LastCommission = src.LastCommission;
FirstPnL = src.FirstPnL;
LastPnL = src.LastPnL;
FirstPosition = src.FirstPosition;
LastPosition = src.LastPosition;
FirstSlippage = src.FirstSlippage;
LastSlippage = src.LastSlippage;
Portfolios.Clear();
Portfolios.AddRange(src.Portfolios);
ClientCodes.Clear();
ClientCodes.AddRange(src.ClientCodes);
BrokerCodes.Clear();
BrokerCodes.AddRange(src.BrokerCodes);
DepoNames.Clear();
DepoNames.AddRange(src.DepoNames);
UserOrderIds.Clear();
UserOrderIds.AddRange(src.UserOrderIds);
Comments.Clear();
Comments.AddRange(src.Comments);
SystemComments.Clear();
SystemComments.AddRange(src.SystemComments);
Errors.Clear();
Errors.AddRange(src.Errors);
}
public static Portfolios Process(DataTable table, string source, DateTime valueDate)
{
var stopWatch = new Stopwatch();
stopWatch.Start();
var portfolios = new Portfolios {
Source = source
};
var tenorCol = table.Columns["tenor"];
var portfolioidCol = table.Columns["portfolioid"];
var valueCol = table.Columns["value"];
var sql = "tenor is not null AND portfolioid <> 0";
//remove any null rows. Its assumed all other data is valid that has been saved to file.
var rows = table.Select(sql);
//todo: AsParallel() this read.
foreach (DataRow tableRow in rows)
{
var tenor = tableRow[tenorCol].ToString();
var portfolioid = Utils.SafeCastToIntParse(tableRow[portfolioidCol].ToString());
var value = Utils.SafeCastToDoubleParse(tableRow[valueCol].ToString());
var pr = new PortfolioRisk()
{
Tenor = tenor,
PortfolioId = portfolioid,
Value = value,
ValueDate = valueDate,
Source = source,
LastUpdated = ConfigDataHandler.SystemName,
UpdateDate = DateTime.UtcNow
};
portfolios.Add(pr);
}
stopWatch.Stop();
portfolios.LoadTime = stopWatch.Elapsed;
return(portfolios);
}
private void AddNewPortfolio(object parameter)
{
Portfolio NewPortfolio = new Portfolio();
NewPortfolioViewModel NPVM = new NewPortfolioViewModel();
NewPortfolioWindow NPW = new NewPortfolioWindow();
NPW.DataContext = NPVM;
NPW.ShowDialog();
if (NPW.DialogResult.HasValue && NPW.DialogResult.Value)
{
NewPortfolio.PortfolioName = NPW.PortfolioNameTextBox.Text;
}
NewPortfolio.BenchmarkInstrument = NPW.BenchmarkInstrumentTextBox.Text;
NewPortfolio.InceptionDate = DateTime.Today;
Portfolios.Add(NewPortfolio);
RepositoryWriter.WritePortfolio(NewPortfolio.PortfolioName, NewPortfolio.BenchmarkInstrument, NewPortfolio.InceptionDate);
}
public override void Read(Stream stream)
{
base.Read(stream);
BeginValue = ReadInfo(stream);
CurrentValue = ReadInfo(stream);
BlockedValue = ReadInfo(stream);
CurrentPrice = ReadInfo(stream);
AveragePrice = ReadInfo(stream);
UnrealizedPnL = ReadInfo(stream);
RealizedPnL = ReadInfo(stream);
VariationMargin = ReadInfo(stream);
Leverage = ReadInfo(stream);
Commission = ReadInfo(stream);
CurrentValueInLots = ReadInfo(stream);
var pfCount = stream.Read <int>();
for (var i = 0; i < pfCount; i++)
{
Portfolios.Add(stream.Read <string>());
}
var ccCount = stream.Read <int>();
for (var i = 0; i < ccCount; i++)
{
ClientCodes.Add(stream.Read <string>());
}
var dnCount = stream.Read <int>();
for (var i = 0; i < dnCount; i++)
{
DepoNames.Add(stream.Read <string>());
}
if (Version < MarketDataVersions.Version33)
{
return;
}
SettlementPrice = ReadInfo(stream);
}
public void TestVarianceMatrix()
{
var secs = FileReaders.ReadSecurities(@"securities.csv");
var covs = FileReaders.ReadCorrelations(@"correlations.csv", secs);
using (ReportTime.Start())
{
Dictionary <Security, double> weights;
var expectedReturn = 9d;
var matrix = Portfolios.ComputeCovariances(covs);
var variance = Portfolios.ComputePortfolioMinimumVariance(matrix, expectedReturn, out weights);
Console.WriteLine(weights.Aggregate("Weights:" + Environment.NewLine,
(str, pair) => str + (Environment.NewLine + pair.Key.Symbol + "," + pair.Value)));
Console.WriteLine("ExpectedReturn: " + expectedReturn);
Console.WriteLine("Variance: " + variance);
Console.WriteLine("Sharpe: " + expectedReturn / Math.Sqrt(variance));
}
}
private void CreateCommonData()
{
var securityIds = Securities.GetSecurityIds().ToHashSet();
var securities = new List <Security>();
securities.AddRange(CreateSecurities("RI", securityIds));
securities.AddRange(CreateSecurities("SR", securityIds));
if (!securityIds.Contains("SBER@TQBR"))
{
securities.Add(new Security
{
Id = "SBER@TQBR",
Code = "SBER",
Board = ExchangeBoard.MicexTqbr,
Type = SecurityTypes.Stock,
ExtensionInfo = new Dictionary <object, object>()
});
}
if (securities.Count > 0)
{
securities.ForEach(s => Securities.Add(s));
Securities.DelayAction.WaitFlush();
}
const string pfName = "Simulator";
if (Portfolios.ReadById(pfName) == null)
{
Portfolios.Save(new Portfolio
{
Name = pfName,
BeginValue = 1000000,
Board = ExchangeBoard.Test,
ExtensionInfo = new Dictionary <object, object>()
});
Portfolios.DelayAction.WaitFlush();
}
}
public IEnumerable <Portfolio> GetPortfoliosByUserName(string username)
{
User user = GetUser(username);
if (user == null)
{
return(new List <Portfolio>());
}
else
{
var portfolios = Portfolios
.Include(p => p.AssetAllocations)
.ThenInclude(a => a.Asset)
.Include(p => p.Balances)
.Include(p => p.Transactions)
.ThenInclude(t => t.Asset)
.Where(p => p.UserId == user.Id).ToList();
return(portfolios);
}
}
public static async Task <ResultsItem> DeletePortfolio(int portfolioId)
{
try
{
using (PegasunDBContext db = new PegasunDBContext())
{
Portfolios portfolio = db.Portfolios.FirstOrDefault(x => x.PortfolioId == portfolioId);
if (portfolio != null)
{
db.Portfolios.Remove(portfolio);
await db.SaveChangesAsync();
}
}
return(ResultsItem.Success("Successfully deleted portfolio."));
}
catch (Exception ex)
{
return(ResultsItem.Error($"Unable to delete portfolio. {ex.Message}"));
}
}
private void ProcessPortfolioMessage(string portfolioName, Message message)
{
var adapter = portfolioName.IsEmpty() ? null : Portfolios.TryGetValue(portfolioName);
if (adapter == null)
{
var adapters = _messageTypeAdapters.TryGetValue(message.Type)?.Cache;
if (adapters == null || adapters.Length != 1)
{
throw new InvalidOperationException(LocalizedStrings.Str623Params.Put(portfolioName));
}
adapter = adapters.First();
}
else
{
adapter = _hearbeatAdapters[adapter];
}
adapter.SendInMessage(message);
}
