}//runEfficientFrontierModule
private void setOptimalPortsCollection(ISecurities cSecsCol, List <double> colRisks, List <double> colRates)
{ // Finalizes the optimal portfolios values (based on results from math engine)
Boolean isFindTP = true;
// ANNUALIZE & NORMALIZE
double dRiskVal = 0D, dReturn = 0D;
double dMaxRatio = 0D;
m_colOptimalPorts.Clear();
for (int iPorts = 0; iPorts < colRisks.Count; iPorts++)
{ // Goes through optimal portfolios
dReturn = colRates[iPorts] * 52; // RETURN
dRiskVal = colRisks[iPorts] * Math.Sqrt(52);
dRiskVal = Math.Abs(cClientStaticMethods.NormalRisk(dRiskVal)); // RISK
if (isFindTP)
{ // Whether we still search for the TP portfolio
if ((dReturn / dRiskVal) > dMaxRatio)
{
dMaxRatio = (dReturn / dRiskVal);
}
else
{
m_iTangencyPortInd = iPorts - 1; isFindTP = false;
}
}
m_colOptimalPorts.Add(new cOptimalPort(m_dWeightsMatrix, iPorts, dRiskVal, dReturn, cSecsCol, m_objErrorHandler,
m_objPortfolio.Details.Equity, m_AdjCoeff, m_objPortfolio.Details.CalcCurrency));
}
}//setOptimalPortsCollection
}//setCollectionsDataForRiskLevel
public void setSecuritiesWeightsCollection(ISecurities cSecsCol, int iRiskInd)
{ // Sets collection of securities weight items based on the weights matrix
for (int iSecs = 0; iSecs < cSecsCol.Count; iSecs++)
{
cSecsCol[iSecs].Weight = m_dWeightsMatrix[iRiskInd, iSecs];
}
}//setSecuritiesWeightsCollection
}//runMainCalculation
//private void prepareSecurityStatistics(ISecurities cSecsCol)
//{ // Prepares statistics calculations (st-Dev / avg) for each security
// cProperties.QaPos = 0; // Restart Qa position
// for (int iSecs = 0; iSecs < cSecsCol.Count; iSecs++)
// cSecsCol[iSecs].CovarClass.setCalculationStatistics();
//}//prepareSecurityStatistics
private void calculateNewCovarianceMatrix(ISecurities cSecsCol, Boolean isBacktesting)
{ // Calculates the covariance matrix
try
{
List <PriceReturn> colRatesI = new List <PriceReturn>();
List <PriceReturn> colRatesJ = new List <PriceReturn>();
m_dCovarMatrix = new double[cSecsCol.Count, cSecsCol.Count]; // Empty matrix
for (int i = 0; i < cSecsCol.Count; i++)
{
for (int j = 0; j < cSecsCol.Count; j++)
{ // Fills covariance matrix
if (i <= j)
{
colRatesI = (isBacktesting) ? cSecsCol[i].RatesClass.BacktestingReturns : cSecsCol[i].RatesClass.PriceReturns;
colRatesJ = (isBacktesting) ? cSecsCol[j].RatesClass.BacktestingReturns : cSecsCol[j].RatesClass.PriceReturns;
m_dCovarMatrix[i, j] = cBasicStaticCalcs.getNewCovarianceValue(colRatesI, cSecsCol[i].CovarClass.Average, colRatesJ,
cSecsCol[j].CovarClass.Average);
if (i != j)
{
m_dCovarMatrix[j, i] = m_dCovarMatrix[i, j];
}
}
}//main for
}
} catch (Exception ex) {
m_objErrorHandler.LogInfo(ex);
}
}//calculateCovarianceMatrix
}//updtIndividualSecsValRange
#endregion Inequality
#region Individual
private void setIndividualSecsConsts(ISecurities cSecsCol)
{ // Sets the collection of constraints on individual securities
// Empty lower / upper bounds
m_arrEmptySecsLowerBound = new double[cSecsCol.Count];
m_arrEmptySecsUpperBound = new double[cSecsCol.Count];
for (int iSecs = 0; iSecs < cSecsCol.Count; iSecs++)
{
m_arrEmptySecsUpperBound[iSecs] = 1D;
}
// Full lower / upper bounds
for (int iConsts = 0; iConsts < m_colSingleSecs.Count; iConsts++)
{
for (int iSecs = 0; iSecs < cSecsCol.Count; iSecs++)
{
if (m_colSingleSecs[iConsts].ItemIds[0] == cSecsCol[iSecs].Properties.PortSecurityId)
{ // Searches Security that matches SecurityID given in constraint
if (m_colSingleSecs[iConsts].Maximum != double.MaxValue) // Upper bound
{
m_arrSecsUpperBound[iSecs] = m_colSingleSecs[iConsts].Maximum;
}
if (m_colSingleSecs[iConsts].Minimum != double.MinValue) // Lower bound
{
m_arrSecsLowerBound[iSecs] = m_colSingleSecs[iConsts].Minimum;
}
break;
}//of for loops
}
}
}//setIndividualSecsConsts
}//setQaDataTable
public static void writeQaDataToCsv(ISecurities cSecsCol)
{ // Writes all QA data to Csv file
if (cProperties.DataForQa.Rows.Count == 0)
{
return; // No Data collected
}
StringBuilder sb = new StringBuilder();
sb.AppendLine("Security ID, Symbol, Date, Close Price, Adjusted Price, FAC, FAC Accumulated, Return, R - AVG(R), (R - AVG(R))2");
ISecurity cCurrSec;
String strCurrId = cProperties.DataForQa.Rows[0]["idSecurity"].ToString(), strNextId = "";
for (int iRows = 0; iRows < cProperties.DataForQa.Rows.Count; iRows++)
{
strNextId = cProperties.DataForQa.Rows[iRows]["idSecurity"].ToString();
if (strCurrId != strNextId)
{ // New security
cCurrSec = cSecsCol.getSecurityById(strCurrId);
if (cCurrSec != null)
{
writeSecuritySummary(sb, cCurrSec);
}
strCurrId = strNextId;
}
IEnumerable <string> fields = cProperties.DataForQa.Rows[iRows].ItemArray.Select(field => field.ToString());
sb.AppendLine(string.Join(",", fields));
}
File.WriteAllText(cProperties.DataFolder + "\\" + cGeneralFunctions.getDateFormatStr(DateTime.Today, "_") + "_Rate_Risk_Calcs.csv", sb.ToString());
}//writeQaDataToCsv
}//clearSecsCalculatedData
private void setSubCollections()
{ // Sets the smaller collections (of active secs and benchmarks)
setListOfSecuritiesByRisk();
m_colSecurities.sortSecurities();
m_colFullCollection.sortSecurities();
m_colActiveSecurities = m_colFullCollection.getListOfActiveSecs(); // Creates active securities list
}//setSubCollectionsNoCategories
}//setOptimalPortsCollection
private double[] getRatesArrForScilab(ISecurities cSecsCol)
{ // Returns series of rates from the Scilab working matrix
double[] ratesArr = new double[cSecsCol.Count];
for (int iSecs = 0; iSecs < cSecsCol.Count; iSecs++)
{
ratesArr[iSecs] = double.IsNaN(cSecsCol[iSecs].RatesClass.WeeklyReturn) ? 0 : cSecsCol[iSecs].RatesClass.WeeklyReturn;
}
return(ratesArr);
}//getRatesArrFromScilab
}//setSeperatedConstraintCols
private void initSecBounds(ISecurities cSecsCol)
{ // Sets initial formation of securities' lower and upper bounds
m_arrSecsUpperBound = new double[cSecsCol.Count];
m_arrSecsLowerBound = new double[cSecsCol.Count];
for (int iSecs = 0; iSecs < cSecsCol.Count; iSecs++)
{
m_arrSecsUpperBound[iSecs] = 1;
}
}//initSecBounds
public SingleSecurityManager(ISecurities securities, string secCode)
{
SecCode = secCode;
Security = securities[secCode];
_worker = new Worker<NewQuoteEventArgs>("[" + SecCode + " worker]");
_worker.NewEvent += WorkerNewEvent;
_worker.Start();
securities.UpdatedEvent += SecuritiesUpdated;
}
}//constructor
#endregion Consturctors, Initialization & Destructor
#region Methods
#region General methods
public void setBacktestingSecuritiesCollection(ISecurities secsCol, cDateRange cDrRange)
{ // Sets the collection of backtesting securities, based on a given securities collection
m_colSecurities = secsCol;
m_colBackSecurities.Clear();
for (int iSecs = 0; iSecs < secsCol.Count; iSecs++)
{
m_colBackSecurities.Add(new cBacktestingSecurity(m_objPortfolio, secsCol[iSecs], cDrRange));
}
}//setBacktestingSecuritiesCollection
public OrdersManager(IOrders orders, ITrades trades, ISecurities securities)
{
if (orders == null)
throw new ArgumentNullException("orders");
if (trades == null)
throw new ArgumentNullException("trades");
_orders = orders;
_orders.Updated += OrdersUpdated;
_trades = trades;
_trades.Updated += TradesUpdated;
}
}//setSecuritiesPriceReturns
private List <string> getSecIDsString(ISecurities cSecsCol)
{// Get list of securities IDs from given securities collection
List <string> lstFinal = new List <string>();
for (int i = 0; i < cSecsCol.Count; i++)
{
lstFinal.Add(cSecsCol[i].Properties.PortSecurityId);
}
return(lstFinal);
}//GetSecIDsString
}//Double_addEqualityConstsFromCollection
private void addDefaultEqualitySumTo100(ISecurities cSecsCol)
{ // Adds the equality constraint of all weights summing up to 100%
List <String> lstAllSecs = new List <String>();
for (int iSecs = 0; iSecs < cSecsCol.Count; iSecs++)
{
lstAllSecs.Add(cSecsCol[iSecs].Properties.PortSecurityId);
}
cConstraint cNewConst = new cConstraint(lstAllSecs, "", enumConstraintType.Security, 1D);
m_colDefaultEquality.Add(cNewConst);
}//addDefaultEqualitySumTo100
public void removeInactiveSecurities(ISecurities cDisabled)
{ // Removes the inactive securities after the calculation (after they have been filtered)
for (int iSecs = 0; iSecs < cDisabled.Count; iSecs++)
{ // Removes disabled secs from collection
//iSecPos = m_colSecurities.Select
//if (iSecPos >= 0) { this[iSecPos].setSecurityActivity(false); this.RemoveAt(iSecPos); }
var sec = m_colSecurities.Where(x => x.Properties.PortSecurityId == cDisabled[iSecs].Properties.PortSecurityId).FirstOrDefault();
if (sec != null)
{
sec.setSecurityActivity(false); m_colSecurities.Remove(sec);
} //LR
}
}//removeInactiveSecurities
public async Task <ActionResult <IReadOnlyList <SecuritiesModel> > > GetSecuritiesBodyParameters(
[FromServices] ISecurities _securities, [FromBody] SecuritiesModel inputModel)
{
var response = await _securities.GetSecuritiesBodyParameters(inputModel);
var List = new List <SecuritiesModel>();
foreach (var item in response)
{
List.Add(item);
}
return(List);
}
}//setSecuritiesDatatable
// Modified to use outside collection
private void fillSecuritiesTableData(ISecurities cSecsCol)
{ // Fills the Datatable with info of participating securities
try
{
// setting date for calculations, if from backtesting take 'From Date' - !!!NOT USED IN BACKTESTING!!!
DateTime calcDate = DateTime.Today.AddDays(-1);
int cnt = 0;
double dSecValue = 0D, dPrice = 0D, dQuantity = 0D, dCash = 0D;
for (int iSecs = 0; iSecs < m_dWeightsMatrix.GetLength(1); iSecs++)
{
if (m_dWeightsMatrix[m_iPortPos, iSecs] > 0D)
{
cSecsCol[iSecs].Weight = m_dWeightsMatrix[m_iPortPos, iSecs];
cnt += 1;
// Calculate Security Value, Price and Quantity
dSecValue = cSecsCol[iSecs].Weight * m_objPortfolio.Details.CurrEquity; //m_objPortfolio.Details.Equity;
dPrice = getSecurityPrice(cSecsCol[iSecs], calcDate);
dQuantity = dSecValue / dPrice * m_AdjCoeff; // double division is multiplication
cSecsCol[iSecs].Quantity = dQuantity;
if (cProperties.IsWithCash)
{
dSecValue = Math.Floor(dQuantity) * dPrice / m_AdjCoeff;
dCash += (dQuantity - Math.Floor(dQuantity)) * dPrice / m_AdjCoeff;
// add cents/agorot of security value to cash
dCash += dSecValue - Math.Floor(dSecValue);
dSecValue = Math.Floor(dSecValue); //whole value, without cents/agorot
}
if (dQuantity > 0D)
{
m_dtSecsData.Rows.Add(cnt, cSecsCol[iSecs].Properties.PortSecurityId, cSecsCol[iSecs].Properties.SecuritySymbol, cSecsCol[iSecs].Properties.SecurityDisplay,
cSecsCol[iSecs].CovarClass.StandardDeviation, cSecsCol[iSecs].RatesClass.FinalRate, cSecsCol[iSecs].Weight, dSecValue, dPrice, dQuantity,
cSecsCol[iSecs].Properties.Market.ID.ToString(), cSecsCol[iSecs].Properties.Sector.ID.ToString(), cSecsCol[iSecs].Properties.SecurityType.ID.ToString(),
cSecsCol[iSecs].Properties.Market.ItemName.ToString(), cSecsCol[iSecs].Properties.Sector.ItemName.ToString(),
cSecsCol[iSecs].Properties.SecurityType.ItemName.ToString());
}
}
}
if (cProperties.IsWithCash)
{
// Add 1 line for CASH
m_dtSecsData.Rows.Add(cnt + 1, "", "", "CASH", -1, 0, 0, dCash, 0, 0, "", "", "", "", "", "");
}
m_objPortfolio.Details.Cash = dCash;
} catch (Exception ex) {
m_objErrorHandler.LogInfo(ex);
}
}//fillSecuritiesTableData
}//setSecuritiesQuantities
private List <double> getLastPricesCol(ISecurities cSecsCol, DateTime dtEndDate)
{ // Creates a collection containing the last prices of securities
double dPriceVal = 0D;
//Boolean isFound = false;
List <Price> drCurrRow;
List <double> lstFinal = new List <double>();
//ISecurities cSecsCol = m_objPortfolio.Classes.Optimizer.SecuritiesCol;
for (int iSecs = 0; iSecs < cSecsCol.Count; iSecs++)
{
if (cSecsCol[iSecs].PriceTable.Count > 0)
{ // Only if data exists
//isFound = false;
var nearestDiff = cSecsCol[iSecs].PriceTable.Min(x => Math.Abs((x.dDate.Date - DateTime.Today.AddDays(-1)).Ticks));
drCurrRow = cSecsCol[iSecs].PriceTable.Where(x => Math.Abs((x.dDate.Date - DateTime.Today.AddDays(-1)).Ticks) == nearestDiff).ToList(); // should find 1 row on that day
if (drCurrRow.Count == 0) // Not found
{
lstFinal.Add(0D); continue;
}
dPriceVal = (m_objPortfolio.Details.CalcCurrency == "9999") ? ((double)drCurrRow[0].fNISClose) : ((double)drCurrRow[0].fClose);
lstFinal.Add(dPriceVal);
//for (int iRows = 0; iRows < cSecsCol[iSecs].PriceTable.Count; iRows++)
// if (Convert.ToDateTime(cSecsCol[iSecs].PriceTable[iRows].dDate) <= dtEndDate)
// { // Adds found price to collection
// // WE HAVE TO TAKE FOUND PRICE not the last price, which is actualy first price because table is in descending order
// //dPriceVal = (m_objPortfolio.Details.CalcCurrency == "9999") ? Convert.ToDouble(cSecsCol[iSecs].PriceTable[cSecsCol[iSecs].PriceTable.Count - 1].fNISClose) : Convert.ToDouble(cSecsCol[iSecs].PriceTable[cSecsCol[iSecs].PriceTable.Count - 1].fClose);
// dPriceVal = (m_objPortfolio.Details.CalcCurrency == "9999") ? Convert.ToDouble(cSecsCol[iSecs].PriceTable[iRows].fNISClose) : Convert.ToDouble(cSecsCol[iSecs].PriceTable[iRows].fClose);
// lstFinal.Add(dPriceVal); isFound = true; break;
// }
//if (!isFound) lstFinal.Add(0D);
}
else
{
lstFinal.Add(0D);
}
}
return(lstFinal);
}//fillPreviousLastPrices
}//getDoubleOfConstraintSecs
private int[] getArrOfConstraintSecs(cConstraint cConst, ISecurities cSecsCol)
{ // Returns array of participating securities in given constraint
int[] iFinalArr = new int[cSecsCol.Count];
for (int iItems = 0; iItems < cConst.ItemIds.Count; iItems++)
{ // Goes through constraint items
iFinalArr = updtArrOfIndexes(iFinalArr, enumConstraintType.Security, cConst.ItemIds[iItems], iItems, cSecsCol);
if (iFinalArr == null)
{
return(iFinalArr);
}
}
return(iFinalArr);
}//getArrOfConstraintSecs
}//filterSecuritiesForNewPortfolio
#endregion Filter Methods
#region General
public void setDisabledSecsToActive()
{ // Sets disabled securities back to active state
// Loop through list of disabled securities and setting them to active state
for (int iSecs = 0; iSecs < m_colDisabledSecurities.Count; iSecs++)
{
m_colDisabledSecurities[iSecs].setSecurityActivity(true);
}
// Clear DisabledSecs collection
m_colDisabledSecurities.Clear();
// Clear DisabledSecs collection
m_colActiveSecurities = m_colFullCollection.getListOfActiveSecs(); // Creates active securities list
}//setDisabledSecsToActive
}//addDefaultEqualitySumTo100
#endregion Equality
#region Inequality
private void Double_setCollectionOfRangeConsts(ISecurities cSecsCol)
{ // Sets the collection of range constraints suitable for scilab format
m_colDefaultRange.Clear();
m_emptyDoubleRangeSecs = new List <List <double> >();
m_emptyDoubleRangeVals = new List <double>();
m_doubleRangeSecs = new List <List <double> >();
m_doubleRangeVals = new List <double>();
//if (m_is100OrLess) addDefaultRange100OrLess();
Double_addRangeConstsFromCollection(m_colDefaultRange, cSecsCol);
Double_addRangeConstsFromCollection(m_colRange, cSecsCol);
}//Double_setCollectionOfRangeConsts
}//Double_setCollectionOfRangeConsts
private void Double_addRangeConstsFromCollection(cConstraints cConstCol, ISecurities cSecsCol)
{ // Adds the format of constraints from collection to final variables
for (int iConst = 0; iConst < cConstCol.Count; iConst++)
{ // Inserts equality constraint
if (cConstCol[iConst].Maximum != double.MaxValue) // Maximal value
{
Double_addSingleInequalityConstraint(cConstCol[iConst], false, true, cSecsCol);
}
if (cConstCol[iConst].Minimum != double.MinValue) // Minimal value
{
Double_addSingleInequalityConstraint(cConstCol[iConst], true, false, cSecsCol);
}
} //of main for
} //Double_addRangeConstsFromCollection
}//constructor
#endregion Constructor
#region Methods
#region Initializing Collection
public void setProperSecuritiesCollections(ISecurities cSecCol)
{ // Sets children (securities) for each collection item
try
{
ICategoryItem cCurrItem;
clearSecuritiesItems();
for (int iSecs = 0; iSecs < cSecCol.Count; iSecs++)
{ // Goes through collection of securities
cCurrItem = cSecCol[iSecs].Properties.getCurrentCategoryValue(m_enCategoryType); // gets item
cCurrItem.Securities.Add(cSecCol[iSecs]);
}
} catch (Exception ex) {
m_objErrorHandler.LogInfo(ex);
}
}//setProperSecuritiesCollections
}//calculateCovarianceMatrix
private DataTable getCovarMatTableStruct(ISecurities cSecsCol)
{ // Creates structure for covariance matrix table
DataTable dtFinal = new DataTable();
dtFinal.Columns.Add(new DataColumn("strName", typeof(String)));
for (int iSecs = 0; iSecs < cSecsCol.Count; iSecs++)
{
if (cSecsCol[iSecs].Weight > 0)
{
dtFinal.Columns.Add(new DataColumn(cSecsCol[iSecs].Properties.PortSecurityId, typeof(String)));
}
}
return(dtFinal);
}//getCovarMatTableStruct
}//IsTotalLessThan100
#endregion Add / Remove Methods
#region Exportation of constraints
#region Public method
public void setConstraintValues(ISecurities cSecsCol)
{ // Creates all constraint string collections (matrices)
try
{
refreshClassPointers();
initSecBounds(cSecsCol);
Double_setCollectionOfEqualityConsts(cSecsCol);
Double_setCollectionOfRangeConsts(cSecsCol);
setIndividualSecsConsts(cSecsCol);
} catch (Exception ex) {
m_objErrorHandler.LogInfo(ex);
}
}//setConstraintValues
private bool isBacktestingPort = false; // not backtesting portfolio
#endregion Data Members
#region Consturctors, Initialization & Destructor
public cManagePortfolios(IPortfolioBL cPort, IRepository rep)
{
m_objPortfolio = cPort;
m_objErrorHandler = m_objPortfolio.cErrorLog;
repository = rep;
//m_objDbConnection = m_objPortfolio.OleDBConn;
securitiesBL = new cSecurities(cPort);
try
{
//setPortfolioTable();
}
catch (Exception ex)
{
m_objErrorHandler.LogInfo(ex);
}
}//constructor
private ISecurities m_colSecurities; // Securities belonging to current
#endregion Data Members
#region Constructors, Initialization & Destructors
public cCategoryItem(enumCatType eType, String strName, int iId, IErrorHandler cErrors, IPortfolioBL cPort)
{
m_enumItemType = eType;
m_strName = strName;
m_iItemId = iId;
m_objErrorHandler = cErrors;
m_objPortfolio = cPort;
m_colSecurities = new cSecurities(m_objPortfolio);
try
{
m_objColor = Color.FromArgb(cProperties.RndGenerator.Next(0, 255), cProperties.RndGenerator.Next(0, 255), cProperties.RndGenerator.Next(0, 255));
} catch (Exception ex) {
m_objErrorHandler.LogInfo(ex);
}
}//constructor
}//reportCovarianceMatrix
private DataTable getCovarianceMatTable(ISecurities cSecsCol, Boolean isBacktesting)
{ // Returns a datatble containing a shortened covariance matrix
DataTable dtCovarForReport = getCovarMatTableStruct(cSecsCol);
DataRow drCurrLine;
int iColPos = 0;
List <PriceReturn> colRatesI = new List <PriceReturn>();
List <PriceReturn> colRatesJ = new List <PriceReturn>();
for (int i = 0; i < cSecsCol.Count; i++)
{
iColPos = 1;
drCurrLine = dtCovarForReport.NewRow();
for (int j = 0; j < cSecsCol.Count; j++)
{ // Fills covariance matrix
if ((cSecsCol[i].Weight > 0) && (cSecsCol[j].Weight > 0))
{ // Minimized covariance matrix for report
if ((cSecsCol[i].Properties.SecuritySymbol == "NOVT") && (cSecsCol[j].Properties.SecuritySymbol == "NVDA"))
{
Console.Write("");
}
if ((cSecsCol[i].Properties.SecuritySymbol == "NVDA") && (cSecsCol[j].Properties.SecuritySymbol == "NOVT"))
{
Console.Write("");
}
if ((cSecsCol[i].Properties.SecuritySymbol == "AAOI") && (cSecsCol[j].Properties.SecuritySymbol == "AAOI"))
{
Console.Write("");
}
colRatesI = (isBacktesting) ? cSecsCol[i].RatesClass.BacktestingReturns : cSecsCol[i].RatesClass.PriceReturns;
colRatesJ = (isBacktesting) ? cSecsCol[j].RatesClass.BacktestingReturns : cSecsCol[j].RatesClass.PriceReturns;
drCurrLine[iColPos] = cBasicStaticCalcs.getNewCovarianceValue(colRatesI, cSecsCol[i].CovarClass.Average, colRatesJ,
cSecsCol[j].CovarClass.Average);
iColPos++;
}
}//main for
if (iColPos > 1)
{ // Writes line to report table
drCurrLine[0] = cSecsCol[i].Properties.SecuritySymbol;
dtCovarForReport.Rows.Add(drCurrLine);
}
}
return(dtCovarForReport);
}//getCovarianceMatTable
}//fillPreviousLastPrices
#endregion Calculation methods
#region DataTable Methods
public void setSecuritiesDatatable(ISecurities cSecsCol)
{ // Sets the data to be display on the gridgrpSecsDoughnut
try
{
if (m_dtSecsData != null)
{
m_dtSecsData.Clear();
}
else
{
m_dtSecsData = getSecsDataStruct();
}
fillSecuritiesTableData(cSecsCol);
} catch (Exception ex) {
m_objErrorHandler.LogInfo(ex);
}
}//setSecuritiesDatatable
}//calculateNewEfficientFrontier
private void runEfficientFrontierModule(ISecurities cSecsCol)
{ // Runs the efficient frontier calculation
try
{
// Initialize variables
double[,] weightsMat;
cOptimalStaticCalcs calcs = new cOptimalStaticCalcs();
// Constraints
m_objConstraints.refreshConstList();
m_objConstraints.setConstraintValues(cSecsCol);
// Parameters
m_arrRatesVector = getRatesArrForScilab(cSecsCol); // Create rates array
if ((m_arrRatesVector.Length == 0) || (m_arrCovarData == null))
{
m_strEngineErrors = "Missing data"; m_objErrorHandler.LogInfo(m_strEngineErrors); return;
}
// Calculation
List <double> colRisks = new List <double>(), colRates = new List <double>();
m_strEngineErrors = calcs.runOptimizationProcess(out colRisks, out colRates, out weightsMat, m_arrCovarData, m_arrRatesVector,
m_objConstraints.DoubleUpperBound, m_objConstraints.DoubleLowerBound, m_objConstraints.DoubleEqualitySecs, m_objConstraints.DoubleEqualityValues, m_objConstraints.IntEqualityNum,
m_objConstraints.Double_NonEqualitySecs, m_objConstraints.Double_NonEqualityValues, 0, cProperties.OptimalPorts);
if ((m_strEngineErrors != "") || (colRisks.Count == 0) || (colRates.Count == 0))
{
m_isSuccessfulCalc = false; return;
} // Error in calculation
// Set final variables
m_dWeightsMatrix = weightsMat;
setOptimalPortsCollection(cSecsCol, colRisks, colRates);
setMainWeightsMatrix(weightsMat);
if (m_colOptimalPorts.Count == 0)
{
m_isSuccessfulCalc = false; m_strEngineErrors = "Failed to calculate EF"; return;
}
} catch (Exception ex) {
m_objErrorHandler.LogInfo(ex);
}
}//runEfficientFrontierModule
}//Dispose
//public void clearCalcData()
//{ // Clears relevant calculation data
// if (m_dtSecurityRatesData != null) m_dtSecurityRatesData.Clear();
// //m_objRateData.clearCalcData();
//}//clearCalcData
#endregion Construcors, Initialization & Destructor
#region Methods
//public void calcSecurityRates(ISecurities cSecsCol, cDateRange drPeriod, Boolean isRemoveDisabled)
//{ // Calculation of the security rates (based on calculation method selected)
// try
// {
// //cQaMethods.setQaDataTable(); // Sets Datatable for work start
// //StringBuilder sbSecIds = new StringBuilder();
// //sbSecIds.AppendLine("SecurityId, Symbol, Final Rate");
// for (int iSecs = 0; iSecs < cSecsCol.Count; iSecs++) // Goes through securities in collection
// {
// cSecsCol[iSecs].RatesClass.setUpdatedRateData(drPeriod); // Only re-calculates if necessary
// //if (cProperties.isQARequested) sbSecIds.AppendLine(cSecsCol[iSecs].Properties.PortSecurityId.ToString() + ", " + cSecsCol[iSecs].Properties.SecuritySymbol + ", " +
// // cSecsCol[iSecs].RatesClass.FinalRate.ToString());
// }
// if (isRemoveDisabled)
// cSecsCol.removeInactiveSecurities(m_objColHandler.DisabledSecs);
// cRiskFreeRates.isMarketChanged = false;
// } catch (Exception ex) {
// m_objErrorHandler.LogInfo(ex);
// }
//}//calcSecurityRates
public List <PriceReturn> setSecuritiesPriceReturns(ISecurities cSecsCol, DateTime fromDT, DateTime toDT, string calcCurrency)
{ // Retrieves collection of pre-calculated price-returns for a given collection of securities and date-range
// CALL PRICES FROM SP
List <string> secIDs = getSecIDsString(cSecsCol);
List <PriceReturn> res = new List <PriceReturn>();
Dictionary <string, Tuple <object, NHibernate.Type.IType> > param = new Dictionary <string, Tuple <object, NHibernate.Type.IType> >();
param.Add("security_id_list", new Tuple <object, NHibernate.Type.IType>(string.Join(",", secIDs), NHibernate.NHibernateUtil.StringClob));
param.Add("date_start", new Tuple <object, NHibernate.Type.IType>(fromDT, NHibernate.NHibernateUtil.DateTime));
param.Add("date_end", new Tuple <object, NHibernate.Type.IType>(toDT, NHibernate.NHibernateUtil.DateTime));
param.Add("calc_currency", new Tuple <object, NHibernate.Type.IType>(calcCurrency, NHibernate.NHibernateUtil.String));
IRepository repository = Resolver.Resolve <IRepository>();
var priceReturns = repository.ExecuteSp <Entities.dbo.PriceReturn>("getPriceReturnsInDateRange", param);
// Split prices to securities
List <PriceReturn> finalReturns = new List <PriceReturn>();
for (int i = 0; i < cSecsCol.Count; i++)
{ // Split main Table of PriceReturns amongst Securities in Securities -> RateData -> RatesBacktesting (cSecsCol[i].RatesClass.RatesBacktesting)
var securityQry = priceReturns.Where(x => x.idSecurity == cSecsCol[i].Properties.PortSecurityId);
var secPriceReturns = securityQry.Select(x => new Cherries.Models.App.PriceReturn
{
idSecurity = x.idSecurity,
idCurrency = x.idCurrency,
dtDate = x.dtDate,
dReturn = x.dReturn,
fAdjClose = x.fAdjClose,
fAdjClosePrevWeek = x.fAdjClosePrevWeek
}).ToList();
// Reverse prices
//cSecsCol[i].RatesClass.RatesBacktesting = new List<PriceReturn>();
//for (int iRows = ratesBackt.Count - 1; iRows >= 0; iRows--)
// cSecsCol[i].RatesClass.RatesBacktesting.Add(ratesBackt[iRows]);
cSecsCol[i].RatesClass.PriceReturns = secPriceReturns;
cSecsCol[i].RatesClass.setFinalReturn(cSecsCol[i].AvgYield);
}
finalReturns = AutoMapper.Mapper.Map <List <PriceReturn> >(priceReturns);
return(finalReturns);
}//setSecuritiesPriceReturns
public cCollectionsHandler(IPortfolioBL cPort, string currency, List <int> exchangesPackagees)
{
m_objPortfolio = cPort;
m_objCatHandler = m_objPortfolio.Classes.CategoryHandler;
m_objErrorHandler = m_objPortfolio.cErrorLog;
m_colFullCollection = new cSecurities(m_objPortfolio);
m_colSecurities = new cSecurities(m_objPortfolio);
m_colSecuritiesByRisk = new cSecurities(m_objPortfolio);
m_colActiveSecurities = new cSecurities(m_objPortfolio);
m_colDisabledSecurities = new cSecurities(m_objPortfolio);
m_colBenchmarks = new cSecurities(m_objPortfolio);
this.currency = currency;
this.exchanges = exchangesPackagees;
//LR:TODO
////if (exchanges == null)
//// exchanges = new List<int>(new int[]{ 1, 3, 4, 5 });
securityRepository = Resolver.Resolve <IRepository>();
}//constructor
}//Double_setCollectionOfEqualityConsts
private void Double_addEqualityConstsFromCollection(cConstraints cConstCol, ISecurities cSecsCol, Boolean isEmpty)
{ // Adds the format of constraints from collection to final variables
List <List <double> > colEqualitySecs = isEmpty ? m_emptyDoubleEqualitySecs : m_doubleEqualitySecs;
List <double> colEqualityVals = isEmpty ? m_emptyDoubleEqualityVals : m_doubleEqualityVals;
for (int iConst = 0; iConst < cConstCol.Count; iConst++)
{ // Inserts equality constraint
List <double> row = getDoubleOfConstraintSecs(cConstCol[iConst], false, cSecsCol); //c1
if (row != null)
{
colEqualitySecs.Add(row);
}
else
{
continue; // Skips constraint (in event failed to find corresponding securities
}
colEqualityVals.Add(cConstCol[iConst].Equality); //b1
}
}//Double_addEqualityConstsFromCollection
public HomeController(ISecurities Securities)
{
_Securities = Securities;
}
