Open Source Wealth Management Software. Angular + NestJS + Prisma + Nx + TypeScript 🤍
TypeScript angularetffinancefintechghostfoliohacktoberfestinvestingnestjsosspersonal-financeportfolioprismasoftwarestocktrackertradingtypescriptwealth-managementweb
Improve calculation of overall performance percentage (#701)
gizmodusa5771f601d34
diff --git a/apps/api/src/app/portfolio/portfolio-calculator-new.ts b/apps/api/src/app/portfolio/portfolio-calculator-new.tsindex 83bbc663fc..8df16f785f 100644--- a/apps/api/src/app/portfolio/portfolio-calculator-new.ts+++ b/apps/api/src/app/portfolio/portfolio-calculator-new.ts@@ -33,6 +33,8 @@ import { TransactionPointSymbol } from './interfaces/transaction-point-symbol.inimport { TransactionPoint } from './interfaces/transaction-point.interface';export class PortfolioCalculatorNew {+ private static readonly ENABLE_LOGGING = false;+private currency: string;private currentRateService: CurrentRateService;private orders: PortfolioOrder[];@@ -228,7 +230,7 @@ export class PortfolioCalculatorNew {const initialValues: { [symbol: string]: Big } = {};const positions: TimelinePosition[] = [];- let hasErrorsInSymbolMetrics = false;+ let hasAnySymbolMetricsErrors = false;for (const item of lastTransactionPoint.items) {const marketValue = marketSymbolMap[todayString]?.[item.symbol];@@ -246,8 +248,7 @@ export class PortfolioCalculatorNew {symbol: item.symbol});- hasErrorsInSymbolMetrics = hasErrorsInSymbolMetrics || hasErrors;-+ hasAnySymbolMetricsErrors = hasAnySymbolMetricsErrors || hasErrors;initialValues[item.symbol] = initialValue;positions.push({@@ -272,12 +273,13 @@ export class PortfolioCalculatorNew {transactionCount: item.transactionCount});}+const overall = this.calculateOverallPerformance(positions, initialValues);return {...overall,positions,- hasErrors: hasErrorsInSymbolMetrics || overall.hasErrors+ hasErrors: hasAnySymbolMetricsErrors || overall.hasErrors};}@@ -395,16 +397,16 @@ export class PortfolioCalculatorNew {private calculateOverallPerformance(positions: TimelinePosition[],- initialValues: { [p: string]: Big }+ initialValues: { [symbol: string]: Big }) {- let hasErrors = false;let currentValue = new Big(0);- let totalInvestment = new Big(0);let grossPerformance = new Big(0);let grossPerformancePercentage = new Big(0);+ let hasErrors = false;let netPerformance = new Big(0);let netPerformancePercentage = new Big(0);- let completeInitialValue = new Big(0);+ let sumOfWeights = new Big(0);+ let totalInvestment = new Big(0);for (const currentPosition of positions) {if (currentPosition.marketPrice) {@@ -414,27 +416,34 @@ export class PortfolioCalculatorNew {} else {hasErrors = true;}+totalInvestment = totalInvestment.plus(currentPosition.investment);+if (currentPosition.grossPerformance) {grossPerformance = grossPerformance.plus(currentPosition.grossPerformance);+netPerformance = netPerformance.plus(currentPosition.netPerformance);} else if (!currentPosition.quantity.eq(0)) {hasErrors = true;}- if (- currentPosition.grossPerformancePercentage &&- initialValues[currentPosition.symbol]- ) {- const currentInitialValue = initialValues[currentPosition.symbol];- completeInitialValue = completeInitialValue.plus(currentInitialValue);+ if (currentPosition.grossPerformancePercentage) {+ // Use the average from the initial value and the current investment as+ // a weight+ const weight = (initialValues[currentPosition.symbol] ?? new Big(0))+ .plus(currentPosition.investment)+ .div(2);++ sumOfWeights = sumOfWeights.plus(weight);+grossPerformancePercentage = grossPerformancePercentage.plus(- currentPosition.grossPerformancePercentage.mul(currentInitialValue)+ currentPosition.grossPerformancePercentage.mul(weight));+netPerformancePercentage = netPerformancePercentage.plus(- currentPosition.netPerformancePercentage.mul(currentInitialValue)+ currentPosition.netPerformancePercentage.mul(weight));} else if (!currentPosition.quantity.eq(0)) {Logger.warn(@@ -444,11 +453,12 @@ export class PortfolioCalculatorNew {}}- if (!completeInitialValue.eq(0)) {- grossPerformancePercentage =- grossPerformancePercentage.div(completeInitialValue);- netPerformancePercentage =- netPerformancePercentage.div(completeInitialValue);+ if (sumOfWeights.gt(0)) {+ grossPerformancePercentage = grossPerformancePercentage.div(sumOfWeights);+ netPerformancePercentage = netPerformancePercentage.div(sumOfWeights);+ } else {+ grossPerformancePercentage = new Big(0);+ netPerformancePercentage = new Big(0);}return {@@ -657,6 +667,8 @@ export class PortfolioCalculatorNew {};}+ let averagePriceAtEndDate = new Big(0);+ let averagePriceAtStartDate = new Big(0);let feesAtStartDate = new Big(0);let fees = new Big(0);let grossPerformance = new Big(0);@@ -666,17 +678,13 @@ export class PortfolioCalculatorNew {let lastAveragePrice = new Big(0);let lastTransactionInvestment = new Big(0);let lastValueOfInvestmentBeforeTransaction = new Big(0);+ let maxTotalInvestment = new Big(0);let timeWeightedGrossPerformancePercentage = new Big(1);let timeWeightedNetPerformancePercentage = new Big(1);let totalInvestment = new Big(0);+ let totalInvestmentWithGrossPerformanceFromSell = new Big(0);let totalUnits = new Big(0);- const holdingPeriodPerformances: {- grossReturn: Big;- netReturn: Big;- valueOfInvestment: Big;- }[] = [];-// Add a synthetic order at the start and the end dateorders.push({symbol,@@ -688,7 +696,7 @@ export class PortfolioCalculatorNew {name: '',quantity: new Big(0),type: TypeOfOrder.BUY,- unitPrice: unitPriceAtStartDate ?? new Big(0)+ unitPrice: unitPriceAtStartDate});orders.push({@@ -701,7 +709,7 @@ export class PortfolioCalculatorNew {name: '',quantity: new Big(0),type: TypeOfOrder.BUY,- unitPrice: unitPriceAtEndDate ?? new Big(0)+ unitPrice: unitPriceAtEndDate});// Sort orders so that the start and end placeholder order are at the right@@ -724,9 +732,31 @@ export class PortfolioCalculatorNew {return order.itemType === 'start';});+ const indexOfEndOrder = orders.findIndex((order) => {+ return order.itemType === 'end';+ });+for (let i = 0; i < orders.length; i += 1) {const order = orders[i];+ if (order.itemType === 'start') {+ // Take the unit price of the order as the market price if there are no+ // orders of this symbol before the start date+ order.unitPrice =+ indexOfStartOrder === 0+ ? orders[i + 1]?.unitPrice+ : unitPriceAtStartDate;+ }++ // Calculate the average start price as soon as any units are held+ if (+ averagePriceAtStartDate.eq(0) &&+ i >= indexOfStartOrder &&+ totalUnits.gt(0)+ ) {+ averagePriceAtStartDate = totalInvestment.div(totalUnits);+ }+const valueOfInvestmentBeforeTransaction = totalUnits.mul(order.unitPrice);@@ -735,12 +765,25 @@ export class PortfolioCalculatorNew {.mul(order.unitPrice).mul(this.getFactor(order.type));- if (- !initialValue &&- order.itemType !== 'start' &&- order.itemType !== 'end'- ) {- initialValue = transactionInvestment;+ totalInvestment = totalInvestment.plus(transactionInvestment);++ if (totalInvestment.gt(maxTotalInvestment)) {+ maxTotalInvestment = totalInvestment;+ }++ if (i === indexOfEndOrder && totalUnits.gt(0)) {+ averagePriceAtEndDate = totalInvestment.div(totalUnits);+ }++ if (i >= indexOfStartOrder && !initialValue) {+ if (+ i === indexOfStartOrder &&+ !valueOfInvestmentBeforeTransaction.eq(0)+ ) {+ initialValue = valueOfInvestmentBeforeTransaction;+ } else if (transactionInvestment.gt(0)) {+ initialValue = transactionInvestment;+ }}fees = fees.plus(order.fee);@@ -760,16 +803,17 @@ export class PortfolioCalculatorNew {grossPerformanceFromSell);- totalInvestment = totalInvestment- .plus(transactionInvestment)- .plus(grossPerformanceFromSell);+ totalInvestmentWithGrossPerformanceFromSell =+ totalInvestmentWithGrossPerformanceFromSell+ .plus(transactionInvestment)+ .plus(grossPerformanceFromSell);lastAveragePrice = totalUnits.eq(0)? new Big(0)- : totalInvestment.div(totalUnits);+ : totalInvestmentWithGrossPerformanceFromSell.div(totalUnits);const newGrossPerformance = valueOfInvestment- .minus(totalInvestment)+ .minus(totalInvestmentWithGrossPerformanceFromSell).plus(grossPerformanceFromSells);if (@@ -812,14 +856,6 @@ export class PortfolioCalculatorNew {timeWeightedNetPerformancePercentage.mul(new Big(1).plus(netHoldingPeriodReturn));-- holdingPeriodPerformances.push({- grossReturn: grossHoldingPeriodReturn,- netReturn: netHoldingPeriodReturn,- valueOfInvestment: lastValueOfInvestmentBeforeTransaction.plus(- lastTransactionInvestment- )- });}grossPerformance = newGrossPerformance;@@ -849,39 +885,63 @@ export class PortfolioCalculatorNew {.minus(grossPerformanceAtStartDate).minus(fees.minus(feesAtStartDate));- let valueOfInvestmentSum = new Big(0);-- for (const holdingPeriodPerformance of holdingPeriodPerformances) {- valueOfInvestmentSum = valueOfInvestmentSum.plus(- holdingPeriodPerformance.valueOfInvestment- );- }-- let totalWeightedGrossPerformance = new Big(0);- let totalWeightedNetPerformance = new Big(0);-- // Weight the holding period returns according to their value of investment- for (const holdingPeriodPerformance of holdingPeriodPerformances) {- totalWeightedGrossPerformance = totalWeightedGrossPerformance.plus(- holdingPeriodPerformance.grossReturn- .mul(holdingPeriodPerformance.valueOfInvestment)- .div(valueOfInvestmentSum)- );-- totalWeightedNetPerformance = totalWeightedNetPerformance.plus(- holdingPeriodPerformance.netReturn- .mul(holdingPeriodPerformance.valueOfInvestment)- .div(valueOfInvestmentSum)+ const grossPerformancePercentage =+ averagePriceAtStartDate.eq(0) ||+ averagePriceAtEndDate.eq(0) ||+ orders[indexOfStartOrder].unitPrice.eq(0)+ ? totalGrossPerformance.div(maxTotalInvestment)+ : unitPriceAtEndDate+ .div(averagePriceAtEndDate)+ .div(+ orders[indexOfStartOrder].unitPrice.div(averagePriceAtStartDate)+ )+ .minus(1);++ const feesPerUnit = totalUnits.gt(0)+ ? fees.minus(feesAtStartDate).div(totalUnits)+ : new Big(0);++ const netPerformancePercentage =+ averagePriceAtStartDate.eq(0) ||+ averagePriceAtEndDate.eq(0) ||+ orders[indexOfStartOrder].unitPrice.eq(0)+ ? totalNetPerformance.div(maxTotalInvestment)+ : unitPriceAtEndDate+ .minus(feesPerUnit)+ .div(averagePriceAtEndDate)+ .div(+ orders[indexOfStartOrder].unitPrice.div(averagePriceAtStartDate)+ )+ .minus(1);++ if (PortfolioCalculatorNew.ENABLE_LOGGING) {+ console.log(+ `+ ${symbol}+ Unit price: ${orders[indexOfStartOrder].unitPrice.toFixed(+ 2+ )} -> ${unitPriceAtEndDate.toFixed(2)}+ Average price: ${averagePriceAtStartDate.toFixed(+ 2+ )} -> ${averagePriceAtEndDate.toFixed(2)}+ Max. total investment: ${maxTotalInvestment.toFixed(2)}+ Gross performance: ${totalGrossPerformance.toFixed(+ 2+ )} / ${grossPerformancePercentage.mul(100).toFixed(2)}%+ Fees per unit: ${feesPerUnit.toFixed(2)}+ Net performance: ${totalNetPerformance.toFixed(+ 2+ )} / ${netPerformancePercentage.mul(100).toFixed(2)}%`);}return {initialValue,- hasErrors: !initialValue || !unitPriceAtEndDate,+ grossPerformancePercentage,+ netPerformancePercentage,+ hasErrors: totalUnits.gt(0) && (!initialValue || !unitPriceAtEndDate),netPerformance: totalNetPerformance,- netPerformancePercentage: totalWeightedNetPerformance,- grossPerformance: totalGrossPerformance,- grossPerformancePercentage: totalWeightedGrossPerformance+ grossPerformance: totalGrossPerformance};}