Sean/ARM64
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Initial Commit

Browse Source
This commit is contained in:
Sean
2025-03-25 21:42:32 -04:00
parent c266eecfeb
commit 30c33d3cfd
247 changed files with 60107 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

91
MarketData/MarketDataLib/Generator/GainLoss/ActiveGainLossGenerator.cs Executable file
View File

@@ -0,0 +1,91 @@
using System;
using System.Linq;
using System.Collections.Generic;
using MarketData;
using MarketData.MarketDataModel;
using MarketData.MarketDataModel.GainLoss;
using MarketData.Utils;
using MarketData.DataAccess;
using MarketData.Cache;
namespace MarketData.Generator.GainLoss
{
// ***************************************************************** G A I N L O S S G E N E R A T O R **********************************************************
public class ActiveGainLossGenerator : IActiveGainLossGenerator
{
public ActiveGainLossGenerator()
{
}
//public void RefreshPriceCache()
//{
// LocalPriceCache.GetInstance().Refresh();
//}
// *****************************************************************************************************************************************************************
// ************************************************ G E N E R A T E A C T I V E G A I N L O S S / G A I N L O S S P E R C E N T *****************************
// *****************************************************************************************************************************************************************
public GainLossCollection GenerateGainLoss(PortfolioTrades portfolioTrades,DateTime? maxDateRef=null)
{
if (null == portfolioTrades || 0 == portfolioTrades.Count) return null;
LocalPriceCache.GetInstance().Add(portfolioTrades);
DateTime minTradeDate = portfolioTrades.GetMinTradeDate();
DateTime maxDate = PricingDA.GetLatestDate();
if(null!=maxDateRef)maxDate=maxDateRef.Value;
Dictionary<DateTime,GainLossItem> gainLoss = new Dictionary<DateTime, GainLossItem>();
DateGenerator dateGenerator = new DateGenerator();
List<DateTime> holdingDates = dateGenerator.GenerateHistoricalDates(maxDate, minTradeDate);
for (int index = holdingDates.Count - 1; index >= 0; index--)
{
DateTime holdingDate = holdingDates[index];
double? gainLossHoldings = null;
double totalExposure = 0.00;
double totalCostBasis=0.00;
double totalMarketValue=0.00;
PortfolioTrades openTrades = portfolioTrades.GetOpenTradesOn(holdingDate);
if (null == openTrades || 0 == openTrades.Count)
{
gainLoss.Add(holdingDate, new GainLossItem(holdingDate, 0,0,false));
continue;
}
if(!LocalPriceCache.GetInstance().ContainsPrice(openTrades.Symbols,holdingDate))
{
if(holdingDate.Date.Equals(maxDate))
{
LocalPriceCache.GetInstance().Add(openTrades.Symbols,holdingDate);
}else continue;
}
foreach (PortfolioTrade portfolioTrade in openTrades)
{
double? gainLossItem = null;
double? exposure = null;
double? costBasis=null;
double? marketValue=null;
costBasis=GainLossHelper.GetCostBasis(holdingDate,portfolioTrade);
gainLossItem=GainLossHelper.GetGainLoss(holdingDate, portfolioTrade);
marketValue=GainLossHelper.GetMarketValue(holdingDate,portfolioTrade);
if (null == gainLossItem) continue;
if (null == gainLossHoldings) gainLossHoldings = gainLossItem;
else gainLossHoldings += gainLossItem;
exposure = GainLossHelper.GetExposure(holdingDate,portfolioTrade);
if (null != exposure) totalExposure += exposure.Value;
if(null!=costBasis)totalCostBasis+=costBasis.Value;
if(null!=marketValue)totalMarketValue+=marketValue.Value;
}
GainLossItem gainLossElement = null;
double totalGainLossPercent=0;
if(0!=totalCostBasis)totalGainLossPercent=((totalMarketValue-totalCostBasis)/totalCostBasis)*100.00;
if(null==gainLossHoldings)
{
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("ActiveGainLossGenerator:GenerateGainLoss 'GainLossHoldings' is null for on {0}",Utility.DateTimeToStringMMHDDHYYYY(holdingDate)));
continue;
}
if (null == gainLossHoldings)gainLossElement = new GainLossItem(holdingDate,gainLossHoldings.Value,totalGainLossPercent,totalExposure,false);
else gainLossElement = new GainLossItem(holdingDate, gainLossHoldings.Value,totalGainLossPercent,totalExposure,false);
gainLoss.Add(holdingDate, gainLossElement);
}
GainLossCollection gainLossList = new GainLossCollection(gainLoss.Values);
gainLossList.Sort();
return gainLossList;
}
}
}

127
MarketData/MarketDataLib/Generator/GainLoss/GainLossGenerator.cs Executable file
View File

@@ -0,0 +1,127 @@
using System;
using System.Linq;
using System.Collections.Generic;
using MarketData;
using MarketData.MarketDataModel;
using MarketData.MarketDataModel.GainLoss;
using MarketData.Utils;
using MarketData.DataAccess;
using MarketData.Cache;
namespace MarketData.Generator.GainLoss
{
// ***************************************************************** G A I N L O S S G E N E R A T O R **********************************************************
public class GainLossGenerator : ITotalGainLossGenerator
{
public GainLossGenerator()
{
}
// *****************************************************************************************************************************************************************
// ************************************************ G E N E R A T E T O T A L G A I N L O S S / T O T A L G A I N L O S S P E R C E N T *******************
// *****************************************************************************************************************************************************************
public TotalGainLossCollection GenerateTotalGainLoss(PortfolioTrades portfolioTrades,DateTime? maxDateRef=null)
{
if (null == portfolioTrades || 0 == portfolioTrades.Count) return null;
LocalPriceCache.GetInstance().Add(portfolioTrades);
DateTime minTradeDate = portfolioTrades.GetMinTradeDate();
DateTime maxDate = PricingDA.GetLatestDate();
if(null!=maxDateRef)maxDate=maxDateRef.Value;
Dictionary<DateTime,TotalGainLossItem> gainLossCollection = new Dictionary<DateTime, TotalGainLossItem>();
DateGenerator dateGenerator = new DateGenerator();
List<DateTime> holdingDates = dateGenerator.GenerateHistoricalDates(maxDate, minTradeDate);
for (int index = holdingDates.Count - 1; index >= 0; index--)
{
DateTime holdingDate = holdingDates[index];
double totalGainLoss = 0.00;;
double totalExposure = 0.00;
double totalCostBasis=0.00;
double totalMarketValue=0.00;
PortfolioTrades tradesOnOrBefore = portfolioTrades.GetTradesOnOrBefore(holdingDate);
if (null == tradesOnOrBefore || 0 == tradesOnOrBefore.Count)
{
gainLossCollection.Add(holdingDate, new TotalGainLossItem(holdingDate, 0,0,0,0));
continue;
}
foreach (PortfolioTrade portfolioTrade in tradesOnOrBefore)
{
double? gainLoss = null;
double? exposure = null;
double? costBasis=null;
double? marketValue=null;
gainLoss=GainLossHelper.GetTotalGainLoss(holdingDate,portfolioTrade);
costBasis=GainLossHelper.GetTotalCostBasis(holdingDate,portfolioTrade);
marketValue=GainLossHelper.GetTotalMarketValue(holdingDate,portfolioTrade);
exposure=GainLossHelper.GetTotalExposure(holdingDate,portfolioTrade);
if (null == gainLoss || null==costBasis || null==marketValue) continue;
if(null!=gainLoss) totalGainLoss += gainLoss.Value;
if (null != exposure) totalExposure += exposure.Value;
if(null!=costBasis)totalCostBasis+=costBasis.Value;
if(null!=marketValue)totalMarketValue+=marketValue.Value;
}
TotalGainLossItem gainLossElement = null;
double totalGainLossPercent=0;
if(0!=totalCostBasis)totalGainLossPercent=((totalMarketValue-totalCostBasis)/totalCostBasis)*100.00;
gainLossElement=new TotalGainLossItem(holdingDate,totalGainLoss,totalGainLossPercent,totalExposure,totalMarketValue);
gainLossCollection.Add(holdingDate, gainLossElement);
}
TotalGainLossCollection gainLossList = new TotalGainLossCollection(gainLossCollection.Values);
gainLossList.Sort();
return gainLossList;
}
// *****************************************************************************************************************************************************************
// ************************************************ G E N E R A T E T O T A L G A I N L O S S W I T H D I V I D E N D S / T O T A L G A I N L O S S P E R C E N T *******************
// *****************************************************************************************************************************************************************
public TotalGainLossCollection GenerateTotalGainLossWithDividends(PortfolioTrades portfolioTrades,DividendPayments dividendPayments,DateTime? maxDateRef=null)
{
if (null == portfolioTrades || 0 == portfolioTrades.Count) return null;
LocalPriceCache.GetInstance().Add(portfolioTrades);
DateTime minTradeDate = portfolioTrades.GetMinTradeDate();
DateTime maxDate = PricingDA.GetLatestDate();
if(null!=maxDateRef)maxDate=maxDateRef.Value;
Dictionary<DateTime,TotalGainLossItem> gainLossCollection = new Dictionary<DateTime, TotalGainLossItem>();
DateGenerator dateGenerator = new DateGenerator();
List<DateTime> holdingDates = dateGenerator.GenerateHistoricalDates(maxDate, minTradeDate);
for (int index = holdingDates.Count - 1; index >= 0; index--)
{
DateTime holdingDate = holdingDates[index];
double totalGainLoss = 0.00;;
double totalExposure = 0.00;
double totalCostBasis=0.00;
double totalMarketValue=0.00;
PortfolioTrades tradesOnOrBefore = portfolioTrades.GetTradesOnOrBefore(holdingDate);
if (null == tradesOnOrBefore || 0 == tradesOnOrBefore.Count)
{
gainLossCollection.Add(holdingDate, new TotalGainLossItem(holdingDate, 0,0,0,0));
continue;
}
foreach (PortfolioTrade portfolioTrade in tradesOnOrBefore)
{
double? gainLoss = null;
double? exposure = null;
double? costBasis=null;
double? marketValue=null;
gainLoss=GainLossHelper.GetTotalGainLoss(holdingDate,portfolioTrade);
costBasis=GainLossHelper.GetTotalCostBasis(holdingDate,portfolioTrade);
marketValue=GainLossHelper.GetTotalMarketValue(holdingDate,portfolioTrade);
exposure=GainLossHelper.GetTotalExposure(holdingDate,portfolioTrade);
if (null == gainLoss || null==costBasis || null==marketValue) continue;
if(null!=gainLoss) totalGainLoss += gainLoss.Value;
if (null != exposure) totalExposure += exposure.Value;
if(null!=costBasis)totalCostBasis+=costBasis.Value;
if(null!=marketValue)totalMarketValue+=marketValue.Value;
}
TotalGainLossItem gainLossElement = null;
double totalGainLossPercent=0;
double dividendPaymentsToDate=dividendPayments.GetDividendPaymentsToDate(holdingDate);
totalMarketValue+=dividendPaymentsToDate;
totalGainLoss+=dividendPaymentsToDate;
if(0!=totalCostBasis)totalGainLossPercent=((totalMarketValue-totalCostBasis)/totalCostBasis)*100.00;
gainLossElement=new TotalGainLossItem(holdingDate,totalGainLoss,totalGainLossPercent,totalExposure,totalMarketValue,dividendPaymentsToDate);
gainLossCollection.Add(holdingDate, gainLossElement);
}
TotalGainLossCollection gainLossList = new TotalGainLossCollection(gainLossCollection.Values);
gainLossList.Sort();
return gainLossList;
}
}
}

193
MarketData/MarketDataLib/Generator/GainLoss/GainLossGeneratorCum.cs Executable file
View File

@@ -0,0 +1,193 @@
using System;
using System.Linq;
using System.Collections.Generic;
using MarketData;
using MarketData.MarketDataModel;
using MarketData.MarketDataModel.GainLoss;
using MarketData.Utils;
using MarketData.DataAccess;
using MarketData.Cache;
namespace MarketData.Generator.GainLoss
{
public class GainLossGeneratorCum : ITotalGainLossGenerator
{
private DateGenerator dateGenerator=new DateGenerator();
public TotalGainLossCollection GenerateTotalGainLoss(PortfolioTrades portfolioTrades,DateTime? maxDateRef=null)
{
DateGenerator dateGenerator=new DateGenerator();
ModelPerformanceSeries performanceSeries=new ModelPerformanceSeries();
List<TotalGainLossItem> gainLossList=new List<TotalGainLossItem>();
LocalPriceCache.GetInstance().Add(portfolioTrades);
try
{
if(!ValidatePortfolioTrades(portfolioTrades))return null;
DateTime minDate=portfolioTrades.GetMinTradeDate();
DateTime maxDate=PricingDA.GetLatestDate();
if(null!=maxDateRef) maxDate=maxDateRef.Value;
double prevGainLoss=double.NaN;
List<DateTime> historicalDates=dateGenerator.GenerateHistoricalDates(minDate,maxDate);
foreach(DateTime currentDate in historicalDates)
{
PortfolioTrades openPositions=portfolioTrades.GetOpenTradesOn(currentDate);
PortfolioTrades closedPositions=portfolioTrades.GetClosedTradesOn(currentDate);
if(0==openPositions.Count&&0==closedPositions.Count) continue;
double gainLoss=0.00;
double gainLossClosedPositions=0.00;
double exposure=0.00;
double marketValue=0.00;
if(!dateGenerator.IsMarketOpen(currentDate)) continue;
ModelPerformanceItem performanceItem=new ModelPerformanceItem();
foreach(PortfolioTrade openPosition in openPositions)
{
exposure+=openPosition.Shares*openPosition.Price;
Price price=LocalPriceCache.GetInstance().GetPrice(openPosition.Symbol,currentDate);
if(null==price)
{
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("No price for {0} on {1}",openPosition.Symbol,currentDate.ToShortDateString()));
continue;
}
gainLoss+=((price.Close*openPosition.Shares)-(openPosition.Price*openPosition.Shares));
marketValue+=(price.Close*openPosition.Shares);
}
foreach(PortfolioTrade closedPosition in closedPositions)
{
double gainLossPosition=(closedPosition.SellPrice*closedPosition.Shares)-(closedPosition.Price*closedPosition.Shares);
gainLossClosedPositions+=gainLossPosition;
}
performanceItem.Date=currentDate;
performanceItem.Exposure=exposure;
performanceItem.MarketValue=marketValue;
performanceItem.GainLossDOD=double.IsNaN(prevGainLoss)?gainLoss:(gainLoss-prevGainLoss)+gainLossClosedPositions;
performanceItem.GainLoss=gainLoss+gainLossClosedPositions;
performanceItem.ClosedPositions=closedPositions.Count>0?true:false;
performanceSeries.Add(performanceItem);
prevGainLoss=gainLoss;
}
performanceSeries.CalculatePerformance();
double totalGainLoss=double.NaN;
foreach(ModelPerformanceItem performanceItem in performanceSeries)
{
if(double.IsNaN(totalGainLoss))totalGainLoss=performanceItem.GainLossDOD;
else totalGainLoss+=performanceItem.GainLossDOD;
TotalGainLossItem totalGainLossItem=new TotalGainLossItem(
performanceItem.Date,
totalGainLoss,
performanceItem.CumProdMinusOne*100.00,
performanceItem.Exposure,
performanceItem.MarketValue);
gainLossList.Add(totalGainLossItem);
}
TotalGainLossCollection totalGainLossCollection= new TotalGainLossCollection(gainLossList);
totalGainLossCollection.Sort();
return totalGainLossCollection;
}
catch(Exception exception)
{
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Exception: {0}",exception.ToString()));
return new TotalGainLossCollection(new List<TotalGainLossItem>());
}
}
public TotalGainLossCollection GenerateTotalGainLossWithDividends(PortfolioTrades portfolioTrades,DividendPayments dividendPayments,DateTime? maxDateRef=null)
{
DateGenerator dateGenerator=new DateGenerator();
ModelPerformanceSeries performanceSeries=new ModelPerformanceSeries();
List<TotalGainLossItem> gainLossList=new List<TotalGainLossItem>();
LocalPriceCache.GetInstance().Add(portfolioTrades);
try
{
if(!ValidatePortfolioTrades(portfolioTrades)) return null;
DateTime minDate=portfolioTrades.Min(x => x.TradeDate);
DateTime maxDate=PricingDA.GetLatestDate();
double prevGainLoss=double.NaN;
// LocalPriceCache.GetInstance().RemoveDate(maxDate);
List<DateTime> historicalDates=dateGenerator.GenerateHistoricalDates(minDate,maxDate);
foreach(DateTime currentDate in historicalDates)
{
PortfolioTrades openPositions=portfolioTrades.GetOpenTradesOn(currentDate);
PortfolioTrades closedPositions=portfolioTrades.GetClosedTradesOn(currentDate);
if(0==openPositions.Count&&0==closedPositions.Count) continue;
double gainLoss=0.00;
double gainLossClosedPositions=0.00;
double exposure=0.00;
double marketValue=0.00;
if(!dateGenerator.IsMarketOpen(currentDate)) continue;
ModelPerformanceItem performanceItem=new ModelPerformanceItem();
foreach(PortfolioTrade openPosition in openPositions)
{
exposure+=openPosition.Shares*openPosition.Price;
//if(!LocalPriceCache.GetInstance().ContainsPrice(openPosition.Symbol,currentDate))
//{
// Prices prices=PricingDA.GetPricesForward(openPosition.Symbol,currentDate,90);
// LocalPriceCache.GetInstance().Add(prices);
//}
Price price=LocalPriceCache.GetInstance().GetPrice(openPosition.Symbol,currentDate);
if(null==price)
{
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("No price for {0} on {1}",openPosition.Symbol,currentDate.ToShortDateString()));
}
gainLoss+=((price.Close*openPosition.Shares)-(openPosition.Price*openPosition.Shares));
marketValue+=(price.Close*openPosition.Shares);
}
foreach(PortfolioTrade closedPosition in closedPositions)
{
double gainLossPosition=(closedPosition.SellPrice*closedPosition.Shares)-(closedPosition.Price*closedPosition.Shares);
gainLossClosedPositions+=gainLossPosition;
}
double dividendPaymentsToDate=dividendPayments.GetDividendPaymentsToDate(currentDate);
marketValue+=dividendPaymentsToDate;
gainLoss+=dividendPaymentsToDate;
performanceItem.Date=currentDate;
performanceItem.Exposure=exposure;
performanceItem.MarketValue=marketValue;
performanceItem.GainLossDOD=double.IsNaN(prevGainLoss)?gainLoss:(gainLoss-prevGainLoss)+gainLossClosedPositions;
performanceItem.GainLoss=gainLoss+gainLossClosedPositions;
performanceItem.ClosedPositions=closedPositions.Count>0?true:false;
performanceSeries.Add(performanceItem);
prevGainLoss=gainLoss;
}
performanceSeries.CalculatePerformance();
double totalGainLoss=double.NaN;
foreach(ModelPerformanceItem performanceItem in performanceSeries)
{
double dividendPaymentsToDate=dividendPayments.GetDividendPaymentsToDate(performanceItem.Date);
if(double.IsNaN(totalGainLoss))totalGainLoss=performanceItem.GainLossDOD;
else totalGainLoss+=performanceItem.GainLossDOD;
TotalGainLossItem totalGainLossItem=new TotalGainLossItem(
performanceItem.Date,
totalGainLoss,
performanceItem.CumProdMinusOne*100.00,
performanceItem.Exposure,
performanceItem.MarketValue,
dividendPaymentsToDate);
gainLossList.Add(totalGainLossItem);
}
TotalGainLossCollection totalGainLossCollection= new TotalGainLossCollection(gainLossList);
totalGainLossCollection.Sort();
return totalGainLossCollection;
}
catch(Exception exception)
{
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("Exception: {0}",exception.ToString()));
return new TotalGainLossCollection(new List<TotalGainLossItem>());
}
}
public bool ValidatePortfolioTrades(PortfolioTrades portfolioTrades)
{
foreach(PortfolioTrade portfolioTrade in portfolioTrades)
{
if(!dateGenerator.IsMarketOpen(portfolioTrade.TradeDate))return false;
if(!dateGenerator.IsMarketOpen(portfolioTrade.SellDate)) return false;
}
return true;
}
}
}

111
MarketData/MarketDataLib/Generator/GainLoss/GainLossHelper.cs Executable file
View File

@@ -0,0 +1,111 @@
using System;
using System.Linq;
using System.Collections.Generic;
using MarketData;
using MarketData.MarketDataModel;
using MarketData.MarketDataModel.GainLoss;
using MarketData.Utils;
using MarketData.DataAccess;
using MarketData.Cache;
namespace MarketData.Generator.GainLoss
{
public class GainLossHelper
{
private GainLossHelper()
{
}
public static double? GetTotalGainLoss(DateTime holdingDate,PortfolioTrade portfolioTrade)
{
if(holdingDate<portfolioTrade.TradeDate) return null;
if(portfolioTrade.IsOpen||(portfolioTrade.IsClosed&&portfolioTrade.SellDate>holdingDate))
{
Price price=LocalPriceCache.GetInstance().GetPrice(portfolioTrade.Symbol,holdingDate);
if(null==price)
{
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("No price for {0} on {1}",portfolioTrade.Symbol,Utility.DateTimeToStringMMHDDHYYYY(holdingDate)));
return null;
}
return (price.Close*portfolioTrade.Shares)-(portfolioTrade.Shares*portfolioTrade.Price);
}
return (portfolioTrade.SellPrice*portfolioTrade.Shares)-(portfolioTrade.Price*portfolioTrade.Shares);
}
public static double? GetTotalMarketValue(DateTime holdingDate,PortfolioTrade portfolioTrade)
{
if(holdingDate<portfolioTrade.TradeDate) return null;
if(portfolioTrade.IsOpen||(portfolioTrade.IsClosed&&portfolioTrade.SellDate>holdingDate))
{
Price price=LocalPriceCache.GetInstance().GetPrice(portfolioTrade.Symbol,holdingDate);
if(null==price)
{
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("No price for {0} on {1}",portfolioTrade.Symbol,Utility.DateTimeToStringMMHDDHYYYY(holdingDate)));
return null;
}
return (price.Close*portfolioTrade.Shares);
}
return (portfolioTrade.SellPrice*portfolioTrade.Shares);
}
public static double? GetTotalExposure(DateTime holdingDate,PortfolioTrade portfolioTrade)
{
if(holdingDate<portfolioTrade.TradeDate) return null;
return portfolioTrade.Shares*portfolioTrade.Price;
}
public static double? GetTotalCostBasis(DateTime holdingDate,PortfolioTrade portfolioTrade)
{
if(holdingDate<portfolioTrade.TradeDate) return null;
return portfolioTrade.Price*portfolioTrade.Shares;
}
public static double? GetGainLoss(DateTime holdingDate,PortfolioTrade portfolioTrade)
{
if(holdingDate<portfolioTrade.TradeDate) return null;
if(!portfolioTrade.SellDate.Equals(Utility.Epoch)&&holdingDate>portfolioTrade.SellDate) return null;
// check to see if we sold this on holdingDate
if(!portfolioTrade.SellDate.Equals(Utility.Epoch)&&holdingDate.Equals(portfolioTrade.SellDate))
{
return (portfolioTrade.SellPrice*portfolioTrade.Shares)-(portfolioTrade.Price*portfolioTrade.Shares);
}
// check to see if we bought and sold on the same date.
if(portfolioTrade.SellDate.Equals(portfolioTrade.TradeDate))
{
return (portfolioTrade.SellPrice*portfolioTrade.Shares)-(portfolioTrade.Price*portfolioTrade.Shares);
}
Price price=LocalPriceCache.GetInstance().GetPrice(portfolioTrade.Symbol,holdingDate);
if(null==price)
{
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("No price for {0} on {1}",portfolioTrade.Symbol,Utility.DateTimeToStringMMHDDHYYYY(holdingDate)));
return null;
}
return (price.Close*portfolioTrade.Shares)-(portfolioTrade.Shares*portfolioTrade.Price);
}
public static double? GetMarketValue(DateTime holdingDate,PortfolioTrade portfolioTrade)
{
if(holdingDate<portfolioTrade.TradeDate) return null;
if(!portfolioTrade.SellDate.Equals(Utility.Epoch)&&holdingDate>portfolioTrade.SellDate) return null;
// check to see if we bought and sold on the same date.
if(portfolioTrade.SellDate.Equals(portfolioTrade.TradeDate)) return (portfolioTrade.SellPrice*portfolioTrade.Shares);
Price price=LocalPriceCache.GetInstance().GetPrice(portfolioTrade.Symbol,holdingDate);
if(null==price)
{
MDTrace.WriteLine(LogLevel.DEBUG,String.Format("No price for {0} on {1}",portfolioTrade.Symbol,Utility.DateTimeToStringMMHDDHYYYY(holdingDate)));
return null;
}
return portfolioTrade.Shares*price.Close;
}
public static double? GetCostBasis(DateTime holdingDate,PortfolioTrade portfolioTrade)
{
if(holdingDate<portfolioTrade.TradeDate) return null;
if(!portfolioTrade.SellDate.Equals(Utility.Epoch)&&holdingDate>portfolioTrade.SellDate) return null;
return portfolioTrade.Price*portfolioTrade.Shares;
}
public static double? GetExposure(DateTime holdingDate,PortfolioTrade portfolioTrade)
{
if(holdingDate<portfolioTrade.TradeDate) return null;
if(!portfolioTrade.SellDate.Equals(Utility.Epoch)&&holdingDate>portfolioTrade.SellDate) return null;
return portfolioTrade.Shares*portfolioTrade.Price;
}
}
}

12
MarketData/MarketDataLib/Generator/GainLoss/IActiveGainLossGenerator.cs Executable file
View File

@@ -0,0 +1,12 @@
using System;
using MarketData.MarketDataModel;
using MarketData.MarketDataModel.GainLoss;
namespace MarketData.Generator.GainLoss
{
public interface IActiveGainLossGenerator
{
GainLossCollection GenerateGainLoss(PortfolioTrades portfolioTrades,DateTime? maxDateRef=null);
}
}

12
MarketData/MarketDataLib/Generator/GainLoss/ITotalGainLossGenerator.cs Executable file
View File

@@ -0,0 +1,12 @@
using System;
using MarketData.MarketDataModel;
using MarketData.MarketDataModel.GainLoss;
namespace MarketData.Generator.GainLoss
{
public interface ITotalGainLossGenerator
{
TotalGainLossCollection GenerateTotalGainLoss(PortfolioTrades portfolioTrades,DateTime? maxDateRef=null);
TotalGainLossCollection GenerateTotalGainLossWithDividends(PortfolioTrades portfolioTrades,DividendPayments dividendPayments,DateTime? maxDateRef=null);
}
}