682 lines
27 KiB
C#
682 lines
27 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Telerik.Windows.Data;
|
|
using MarketData.Utils;
|
|
using MarketData.MarketDataModel;
|
|
using TradeBlotter.Model;
|
|
using TradeBlotter.ViewModels;
|
|
using System.Text;
|
|
using MarketData.DividendRiskParity;
|
|
using MarketData.MarketDataModel.GainLoss;
|
|
|
|
namespace TradeBlotter.UIUtils
|
|
{
|
|
// **********************************************************************************************************************************
|
|
// ********************************************************* G A I N L O S S V I E W *****************************************
|
|
// **********************************************************************************************************************************
|
|
public class GainLossViewSumFunctionSymbol : AggregateFunction<GainLossSummaryItem, String>
|
|
{
|
|
public GainLossViewSumFunctionSymbol()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<GainLossSummaryItem> source)
|
|
{
|
|
int itemCount=0;
|
|
if(null!=source)itemCount=source.Count();
|
|
return String.Format("{0} rows",itemCount);
|
|
}
|
|
}
|
|
|
|
// **********************************************************************************************************************************
|
|
// ********************************************************* D I V I D E N D P A R I T Y *****************************************
|
|
// **********************************************************************************************************************************
|
|
public class DividendRiskParitySumFunctionGainLossPercent : AggregateFunction<DividendRiskParityPosition, String>
|
|
{
|
|
public DividendRiskParitySumFunctionGainLossPercent()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<DividendRiskParityPosition> source)
|
|
{
|
|
double totalMV=source.Sum(x=>x.CurrentPrice*x.Shares);
|
|
double totalExposure = source.Sum(x => x.Exposure);
|
|
return Utility.FormatPercent((totalMV-totalExposure)/totalExposure);
|
|
}
|
|
}
|
|
public class DividendRiskParitySumFunctionPrice : AggregateFunction<DividendRiskParityPosition, String>
|
|
{
|
|
public DividendRiskParitySumFunctionPrice()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<DividendRiskParityPosition> source)
|
|
{
|
|
double totalExposure = source.Sum(x => x.Exposure);
|
|
double totalShares = source.Sum(x => x.Shares);
|
|
return Utility.FormatCurrency(totalExposure/totalShares, 2);
|
|
}
|
|
}
|
|
public class DividendRiskParitySumFunctionShares : AggregateFunction<DividendRiskParityPosition, String>
|
|
{
|
|
public DividendRiskParitySumFunctionShares()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<DividendRiskParityPosition> source)
|
|
{
|
|
double totalShares = source.Sum(x => x.Shares);
|
|
return Utility.FormatNumber(totalShares, 3,true);
|
|
}
|
|
}
|
|
public class DividendRiskParitySumFunctionExposure : AggregateFunction<DividendRiskParityPosition, String>
|
|
{
|
|
public DividendRiskParitySumFunctionExposure()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<DividendRiskParityPosition> source)
|
|
{
|
|
double totalExposure = source.Sum(x => x.Exposure);
|
|
return Utility.FormatCurrency(totalExposure, 2);
|
|
}
|
|
}
|
|
public class DividendRiskParitySumFunctionWeightedDividend : AggregateFunction<DividendRiskParityPosition, String>
|
|
{
|
|
public DividendRiskParitySumFunctionWeightedDividend()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<DividendRiskParityPosition> source)
|
|
{
|
|
double totalWeightedDividendPercent = source.Sum(x => x.WeightedDividendPercent);
|
|
return Utility.FormatNumber(totalWeightedDividendPercent,2,true);
|
|
}
|
|
}
|
|
public class DividendRiskParitySumFunctionDividendPayment : AggregateFunction<DividendRiskParityPosition, String>
|
|
{
|
|
public DividendRiskParitySumFunctionDividendPayment()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<DividendRiskParityPosition> source)
|
|
{
|
|
double totalDividendPayment = source.Sum(x => x.DividendPayment);
|
|
return Utility.FormatCurrency(totalDividendPayment,2);
|
|
}
|
|
}
|
|
public class DividendRiskParitySumFunctionWeight : AggregateFunction<DividendRiskParityPosition, String>
|
|
{
|
|
public DividendRiskParitySumFunctionWeight()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<DividendRiskParityPosition> source)
|
|
{
|
|
double totalWeight = source.Sum(x => x.Weight);
|
|
return Utility.FormatPercent(totalWeight);
|
|
}
|
|
}
|
|
public class DividendRiskParitySumFunctionGainLoss : AggregateFunction<DividendRiskParityPosition, String>
|
|
{
|
|
public DividendRiskParitySumFunctionGainLoss()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<DividendRiskParityPosition> source)
|
|
{
|
|
double totalGainLoss = source.Sum(x => x.GainLoss);
|
|
return Utility.FormatCurrency(totalGainLoss, 2);
|
|
}
|
|
}
|
|
|
|
// **********************************************************************************************************************************
|
|
// ********************************************************* Q U A N T U M M O M E N T U M ******************************************************
|
|
// **********************************************************************************************************************************
|
|
public class MomentumPositionSumFunctionShares : AggregateFunction<MGPositionModel,String>
|
|
{
|
|
public MomentumPositionSumFunctionShares()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<MGPositionModel> source)
|
|
{
|
|
double sum=(from MGPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.Shares).Sum();
|
|
return Utility.FormatNumber(sum,3,false);
|
|
}
|
|
}
|
|
public class MomentumPositionSumFunctionExposure : AggregateFunction<MGPositionModel,String>
|
|
{
|
|
public MomentumPositionSumFunctionExposure()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<MGPositionModel> source)
|
|
{
|
|
double exposure=(from MGPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.Exposure).Sum();
|
|
return Utility.FormatCurrency(exposure);
|
|
}
|
|
}
|
|
public class MomentumPositionSumFunctionMarketValue : AggregateFunction<MGPositionModel,String>
|
|
{
|
|
public MomentumPositionSumFunctionMarketValue()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<MGPositionModel> source)
|
|
{
|
|
double marketValue=(from MGPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.MarketValue).Sum();
|
|
return Utility.FormatCurrency(marketValue);
|
|
}
|
|
}
|
|
public class MomentumPositionSumFunctionGainLoss : AggregateFunction<MGPositionModel,String>
|
|
{
|
|
public MomentumPositionSumFunctionGainLoss()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<MGPositionModel> source)
|
|
{
|
|
StringBuilder sb=new StringBuilder();
|
|
double sum=(from MGPositionModel positionModel in source select positionModel.GainLoss).Sum();
|
|
sb.Append("Total:").Append(Utility.FormatCurrency(sum)).Append("\n");
|
|
sum=(from MGPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.GainLoss).Sum();
|
|
sb.Append("Active:").Append(Utility.FormatCurrency(sum));
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
public class MomentumPositionSumFunctionGainLossPcnt : AggregateFunction<MGPositionModel,String>
|
|
{
|
|
public MomentumPositionSumFunctionGainLossPcnt()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<MGPositionModel> source)
|
|
{
|
|
StringBuilder sb=new StringBuilder();
|
|
double marketValue=0.00;
|
|
double exposure=0.00;
|
|
double gainLossPcnt=0.00;
|
|
|
|
double cumulativeReturn=ModelPerformanceAggregator.CalculateCumulativeReturn(source);
|
|
sb.Append("Total:").Append(Utility.FormatPercent(cumulativeReturn,2)).Append("\n");
|
|
|
|
marketValue=(from MGPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.MarketValue).Sum();
|
|
exposure=(from MGPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.Exposure).Sum();
|
|
if(0.00!=exposure)gainLossPcnt=(marketValue-exposure)/exposure;
|
|
sb.Append("Active:").Append(Utility.FormatPercent(gainLossPcnt,2));
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
// **********************************************************************************************************************************
|
|
// ********************************************************* C M M O M E N T U M ******************************************************
|
|
// **********************************************************************************************************************************
|
|
public class CMMomentumPositionSumFunctionShares : AggregateFunction<CMPositionModel, String>
|
|
{
|
|
public CMMomentumPositionSumFunctionShares()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMPositionModel> source)
|
|
{
|
|
double sum = (from CMPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.Shares).Sum();
|
|
return Utility.FormatNumber(sum, 3, false);
|
|
}
|
|
}
|
|
public class CMMomentumPositionSumFunctionExposure : AggregateFunction<CMPositionModel, String>
|
|
{
|
|
public CMMomentumPositionSumFunctionExposure()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMPositionModel> source)
|
|
{
|
|
double exposure = (from CMPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.Exposure).Sum();
|
|
return Utility.FormatCurrency(exposure);
|
|
}
|
|
}
|
|
public class CMMomentumPositionSumFunctionMarketValue : AggregateFunction<CMPositionModel, String>
|
|
{
|
|
public CMMomentumPositionSumFunctionMarketValue()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMPositionModel> source)
|
|
{
|
|
double marketValue = (from CMPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.MarketValue).Sum();
|
|
return Utility.FormatCurrency(marketValue);
|
|
}
|
|
}
|
|
public class CMMomentumPositionSumFunctionGainLoss : AggregateFunction<CMPositionModel, String>
|
|
{
|
|
public CMMomentumPositionSumFunctionGainLoss()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMPositionModel> source)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
double sum = (from CMPositionModel positionModel in source select positionModel.GainLoss).Sum();
|
|
sb.Append("Total:").Append(Utility.FormatCurrency(sum)).Append("\n");
|
|
sum = (from CMPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.GainLoss).Sum();
|
|
sb.Append("Active:").Append(Utility.FormatCurrency(sum));
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
public class CMMomentumPositionSumFunctionGainLossPcnt : AggregateFunction<CMPositionModel, String>
|
|
{
|
|
public CMMomentumPositionSumFunctionGainLossPcnt()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMPositionModel> source)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
double marketValue=0.00;
|
|
double exposure=0.00;
|
|
double gainLossPcnt=0.00;
|
|
|
|
double cumulativeReturn=ModelPerformanceAggregator.CalculateCumulativeReturn(source);
|
|
sb.Append("Total:").Append(Utility.FormatPercent(cumulativeReturn,2)).Append("\n");
|
|
|
|
marketValue = (from CMPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.MarketValue).Sum();
|
|
exposure = (from CMPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.Exposure).Sum();
|
|
if (0.00 != exposure) gainLossPcnt = (marketValue - exposure) / exposure;
|
|
sb.Append("Active:").Append(Utility.FormatPercent(gainLossPcnt,2));
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
public class CMMomentumPositionSumFunctionSharpeRatio : AggregateFunction<CMPositionModel, String>
|
|
{
|
|
public CMMomentumPositionSumFunctionSharpeRatio()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMPositionModel> source)
|
|
{
|
|
try
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
List<double> weights = new List<double>();
|
|
List<CMPositionModel> items = new List<CMPositionModel>(source.ToList());
|
|
int itemCount = items.Count();
|
|
|
|
double totalExposure = (from CMPositionModel positionModel in items select positionModel.Exposure).Sum();
|
|
double totalSharpeRatio = 0.00;
|
|
foreach (CMPositionModel cmPositionModel in items) weights.Add(cmPositionModel.Exposure / totalExposure);
|
|
|
|
for (int index = 0; index < itemCount; index++)
|
|
{
|
|
CMPositionModel cmPositionModel = items[index];
|
|
double weight = weights[index];
|
|
totalSharpeRatio += cmPositionModel.SharpeRatio * weight;
|
|
}
|
|
return Utility.FormatNumber(totalSharpeRatio, 4);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return Constants.CONST_DASHES;
|
|
}
|
|
}
|
|
}
|
|
public class CMMomentumPositionSumFunctionBeta : AggregateFunction<CMPositionModel, String>
|
|
{
|
|
public CMMomentumPositionSumFunctionBeta()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMPositionModel> source)
|
|
{
|
|
try
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
List<double> weights = new List<double>();
|
|
List<CMPositionModel> items = new List<CMPositionModel>(source.ToList());
|
|
int itemCount = items.Count();
|
|
|
|
double totalExposure = (from CMPositionModel positionModel in items select positionModel.Exposure).Sum();
|
|
double totalBeta = 0.00;
|
|
foreach (CMPositionModel cmPositionModel in items) weights.Add(cmPositionModel.Exposure / totalExposure);
|
|
|
|
for (int index = 0; index < itemCount; index++)
|
|
{
|
|
CMPositionModel cmPositionModel = items[index];
|
|
double weight = weights[index];
|
|
totalBeta += cmPositionModel.Beta * weight;
|
|
}
|
|
return Utility.FormatNumber(totalBeta, 4);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return Constants.CONST_DASHES;
|
|
}
|
|
}
|
|
}
|
|
// **********************************************************************************************************************************
|
|
// ********************************* C M T T R E N D (M A R C M I N E R V I N I / V A N T H A R P E *******************************
|
|
// **********************************************************************************************************************************
|
|
public class CMTTrendPositionSumFunctionShares:AggregateFunction<CMTPositionModel,String>
|
|
{
|
|
public CMTTrendPositionSumFunctionShares()
|
|
{
|
|
this.AggregationExpression=items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMTPositionModel> source)
|
|
{
|
|
double sum=(from CMTPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.Shares).Sum();
|
|
return Utility.FormatNumber(sum,3,false);
|
|
}
|
|
}
|
|
public class CMTTrendPositionSumFunctionExposure:AggregateFunction<CMTPositionModel,String>
|
|
{
|
|
public CMTTrendPositionSumFunctionExposure()
|
|
{
|
|
this.AggregationExpression=items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMTPositionModel> source)
|
|
{
|
|
double exposure=(from CMTPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.Exposure).Sum();
|
|
return Utility.FormatCurrency(exposure);
|
|
}
|
|
}
|
|
|
|
public class CMTTrendPositionSumFunctionEdgeRatio:AggregateFunction<CMTPositionModel,String>
|
|
{
|
|
public CMTTrendPositionSumFunctionEdgeRatio()
|
|
{
|
|
this.AggregationExpression=items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMTPositionModel> source)
|
|
{
|
|
double sumERatio=0.00;
|
|
|
|
List<CMTPositionModel> openItems=(from CMTPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel).ToList();
|
|
if(null==openItems || 0==openItems.Count)return Utility.FormatNumber(sumERatio,2);
|
|
double totalExposure=(from CMTPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.Exposure).Sum();
|
|
double[] weightedRatios=new double[openItems.Count];
|
|
for(int index=0;index<weightedRatios.Length;index++)
|
|
{
|
|
CMTPositionModel positionModel=openItems[index];
|
|
weightedRatios[index]=positionModel.EdgeRatio*(positionModel.Exposure/totalExposure);
|
|
}
|
|
sumERatio=weightedRatios.Sum();
|
|
return Utility.FormatNumber(sumERatio,2);
|
|
}
|
|
}
|
|
|
|
public class CMTTrendPositionSumFunctionMarketValue:AggregateFunction<CMTPositionModel,String>
|
|
{
|
|
public CMTTrendPositionSumFunctionMarketValue()
|
|
{
|
|
this.AggregationExpression=items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMTPositionModel> source)
|
|
{
|
|
double marketValue=(from CMTPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.MarketValue).Sum();
|
|
return Utility.FormatCurrency(marketValue);
|
|
}
|
|
}
|
|
public class CMTTrendPositionSumFunctionGainLoss:AggregateFunction<CMTPositionModel,String>
|
|
{
|
|
public CMTTrendPositionSumFunctionGainLoss()
|
|
{
|
|
this.AggregationExpression=items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMTPositionModel> source)
|
|
{
|
|
StringBuilder sb=new StringBuilder();
|
|
double sum=(from CMTPositionModel positionModel in source select positionModel.GainLoss).Sum();
|
|
sb.Append("Total:").Append(Utility.FormatCurrency(sum)).Append("\n");
|
|
|
|
sum=(from CMTPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.GainLoss).Sum();
|
|
sb.Append("Active:").Append(Utility.FormatCurrency(sum));
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
public class CMTTrendPositionSumFunctionGainLossPcnt:AggregateFunction<CMTPositionModel,String>
|
|
{
|
|
public CMTTrendPositionSumFunctionGainLossPcnt()
|
|
{
|
|
this.AggregationExpression=items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMTPositionModel> source)
|
|
{
|
|
StringBuilder sb=new StringBuilder();
|
|
double marketValue=0.00;
|
|
double exposure=0.00;
|
|
double gainLossPcnt=0.00;
|
|
|
|
double cumulativeReturn=ModelPerformanceAggregator.CalculateCumulativeReturn(source);
|
|
sb.Append("Total:").Append(Utility.FormatPercent(cumulativeReturn,2)).Append("\n");
|
|
|
|
|
|
marketValue=(from CMTPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.MarketValue).Sum();
|
|
exposure=(from CMTPositionModel positionModel in source where Utility.IsEpoch(positionModel.SellDate) select positionModel.Exposure).Sum();
|
|
if(0.00!=exposure) gainLossPcnt=(marketValue-exposure)/exposure;
|
|
sb.Append("Active:").Append(Utility.FormatPercent(gainLossPcnt));
|
|
return sb.ToString();
|
|
}
|
|
}
|
|
public class CMTTrendPositionSumFunctionRisk:AggregateFunction<CMTPositionModel,String>
|
|
{
|
|
public CMTTrendPositionSumFunctionRisk()
|
|
{
|
|
this.AggregationExpression=items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<CMTPositionModel> source)
|
|
{
|
|
StringBuilder sb=new StringBuilder();
|
|
List<CMTPositionModel> activePositions=source.Where(x => x.IsActivePosition).ToList();
|
|
double sum=activePositions.Sum(x => x.TotalRiskExposure);
|
|
return Utility.FormatCurrency(sum);
|
|
}
|
|
}
|
|
// **********************************************************************************************************************************
|
|
// ******************************************************** V A L U E A T R I S K ************************************************
|
|
// **********************************************************************************************************************************
|
|
public class ValueAtRiskModelMarketValueFunction : AggregateFunction<PortfolioHoldingViewModel,String>
|
|
{
|
|
public ValueAtRiskModelMarketValueFunction()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<PortfolioHoldingViewModel> source)
|
|
{
|
|
return Utility.FormatCurrency((from portfolioHoldingViewModel in source select portfolioHoldingViewModel.MarketValue).Sum());
|
|
}
|
|
}
|
|
public class ValueAtRiskModelWeightFunction : AggregateFunction<PortfolioHoldingViewModel, String>
|
|
{
|
|
public ValueAtRiskModelWeightFunction()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<PortfolioHoldingViewModel> source)
|
|
{
|
|
return Utility.FormatPercent((from portfolioHoldingViewModel in source select portfolioHoldingViewModel.Weight).Sum());
|
|
}
|
|
}
|
|
public class ValueAtRiskModelWeightExpFunction : AggregateFunction<PortfolioHoldingViewModel, String>
|
|
{
|
|
public ValueAtRiskModelWeightExpFunction()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<PortfolioHoldingViewModel> source)
|
|
{
|
|
return Utility.FormatPercent((from portfolioHoldingViewModel in source select portfolioHoldingViewModel.WeightExp).Sum());
|
|
}
|
|
}
|
|
public class ValueAtRiskModelVaRContributionFunction : AggregateFunction<PortfolioHoldingViewModel, String>
|
|
{
|
|
public ValueAtRiskModelVaRContributionFunction()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<PortfolioHoldingViewModel> source)
|
|
{
|
|
return Utility.FormatPercent((from portfolioHoldingViewModel in source select portfolioHoldingViewModel.Contribution).Sum());
|
|
}
|
|
}
|
|
public class ValueAtRiskModelExposureFunction : AggregateFunction<PortfolioHoldingViewModel, String>
|
|
{
|
|
public ValueAtRiskModelExposureFunction()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<PortfolioHoldingViewModel> source)
|
|
{
|
|
return Utility.FormatCurrency((from portfolioHoldingViewModel in source select portfolioHoldingViewModel.Exposure).Sum());
|
|
}
|
|
}
|
|
// ****************************************************************
|
|
public class SumFunctionWeight : AggregateFunction<TradeViewModel, String>
|
|
{
|
|
public SumFunctionWeight()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<TradeViewModel> source)
|
|
{
|
|
double totalWeight = 0.00;
|
|
foreach (TradeViewModel model in source)
|
|
{
|
|
if (!model.IsOpen) continue;
|
|
totalWeight += Utility.ParsePercent(model.Weight);
|
|
}
|
|
return Utility.FormatPercent(totalWeight);
|
|
}
|
|
}
|
|
// ******************************
|
|
public class SumFunctionTodaysChange : AggregateFunction<TradeViewModel, String>
|
|
{
|
|
public SumFunctionTodaysChange()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<TradeViewModel> source)
|
|
{
|
|
double totalTodaysChange = 0.00;
|
|
foreach (TradeViewModel model in source)
|
|
{
|
|
if (!model.IsOpen || model.TodaysChange.Equals(Constants.CONST_DASHES)) continue;
|
|
totalTodaysChange += Utility.ParseCurrency(model.TodaysChange);
|
|
}
|
|
return Utility.FormatCurrency(totalTodaysChange);
|
|
}
|
|
}
|
|
// ******************************
|
|
|
|
public class SumFunctionShares : AggregateFunction<TradeViewModel, String>
|
|
{
|
|
public SumFunctionShares()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<TradeViewModel> source)
|
|
{
|
|
double totalShares = 0.00;
|
|
foreach (TradeViewModel model in source)
|
|
{
|
|
if (!model.IsOpen) continue;
|
|
totalShares += model.Shares;
|
|
}
|
|
return Utility.FormatNumber(totalShares);
|
|
}
|
|
}
|
|
// ******************************
|
|
public class SumFunctionMarketValue : AggregateFunction<TradeViewModel, String>
|
|
{
|
|
public SumFunctionMarketValue()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<TradeViewModel> source)
|
|
{
|
|
double totalMarketValue = 0.00;
|
|
foreach (TradeViewModel model in source)
|
|
{
|
|
if (model.MarketValue.Equals(Constants.CONST_DASHES) || model.MarketValue.Equals("N.A.")) continue;
|
|
totalMarketValue += Utility.ParseCurrency(model.MarketValue);
|
|
}
|
|
return Utility.FormatCurrency(totalMarketValue);
|
|
}
|
|
}
|
|
// ******************************
|
|
public class SumFunctionExposure : AggregateFunction<TradeViewModel, String>
|
|
{
|
|
public SumFunctionExposure()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<TradeViewModel> source)
|
|
{
|
|
double totalExposure = 0.00;
|
|
foreach (TradeViewModel model in source)
|
|
{
|
|
if (!model.IsOpen) continue;
|
|
totalExposure += Utility.ParseCurrency(model.Exposure);
|
|
}
|
|
return Utility.FormatCurrency(totalExposure);
|
|
}
|
|
}
|
|
// ******************************
|
|
public class SumFunctionGainLoss : AggregateFunction<TradeViewModel, String>
|
|
{
|
|
public SumFunctionGainLoss()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<TradeViewModel> source)
|
|
{
|
|
double totalGainLoss = 0.00;
|
|
foreach (TradeViewModel model in source)
|
|
{
|
|
if(model.IsOpen)totalGainLoss += Utility.ParseCurrency(model.GainLoss);
|
|
}
|
|
return Utility.FormatCurrency(totalGainLoss);
|
|
}
|
|
}
|
|
// ******************************
|
|
public class TotalReturnFunction : AggregateFunction<TradeViewModel, String>
|
|
{
|
|
public TotalReturnFunction()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<TradeViewModel> source)
|
|
{
|
|
double totalExposure = 0.00;
|
|
double totalMarketValue = 0.00;
|
|
foreach (TradeViewModel model in source)
|
|
{
|
|
if (model.IsOpen)
|
|
{
|
|
totalExposure += Utility.ParseCurrency(model.Exposure);
|
|
totalMarketValue += Utility.ParseCurrency(model.MarketValue);
|
|
}
|
|
}
|
|
String totalReturn = Utility.FormatPercent(((totalMarketValue - totalExposure) / totalExposure));
|
|
return totalReturn;
|
|
}
|
|
}
|
|
// ****************************************************************
|
|
public class ETFHoldingsSumFunctionPercentOfAssets : AggregateFunction<ETFHoldingModel, String>
|
|
{
|
|
public ETFHoldingsSumFunctionPercentOfAssets()
|
|
{
|
|
this.AggregationExpression = items => Sum(items);
|
|
}
|
|
private String Sum(IEnumerable<ETFHoldingModel> source)
|
|
{
|
|
double totalWeight = 0.00;
|
|
foreach (ETFHoldingModel model in source)
|
|
{
|
|
totalWeight += model.PercentOfAssets;
|
|
}
|
|
return Utility.FormatNumber(totalWeight,2);
|
|
}
|
|
}
|
|
}
|