PrivateMarkets.Metrics 0.4.0

PrivateMarkets.Metrics

Performance metrics for private equity and private markets funds in .NET: TVPI, DPI, RVPI, PIC, MOIC, XIRR, PME (Long-Nickels, PME+, Kaplan-Schoar, mPME), Direct Alpha, vintage-year aggregation and J-curves.

• Zero dependencies, decimal everywhere except inside the IRR solver (double, converted back).
• Targets .NET 8 and .NET 10, trimming and Native AOT compatible.
• Checked against the Python reference implementations (privateassets, pypme, xirr) to 1e-6.
• Ships with an MCP server so AI agents can call the calculations.

dotnet add package PrivateMarkets.Metrics

(Until the package is on NuGet, see installing from source.)

Documentation

Quick start

using PrivateMarkets.Metrics;
using PrivateMarkets.Metrics.Pme;

var fund = new Fund("Fonds III", commitment: 50_000_000m, currency: "EUR")
    .Call(new DateOnly(2021, 3, 15), 10_000_000m)
    .Call(new DateOnly(2022, 1, 10), 15_000_000m)
    .Distribute(new DateOnly(2024, 6, 30), 8_000_000m)
    .Nav(new DateOnly(2026, 9, 30), 31_500_000m);

var m = fund.Metrics(asOf: new DateOnly(2026, 9, 30));
Console.WriteLine($"TVPI {m.Tvpi:F2}x  DPI {m.Dpi:F2}x  IRR {m.Irr:P1}");
// TVPI 1.58x  DPI 0.32x  IRR 10.5%

var index = IndexSeries.FromCsv("msci-world-tr.csv");   // date,level
var pme = fund.Pme(index);
Console.WriteLine($"KS-PME {pme.KaplanSchoar:F2}  Direct Alpha {pme.DirectAlpha:P2}");

Fund is immutable: every fluent call returns a new instance. A runnable version lives in samples/PrivateMarkets.Metrics.Sample.

Portfolio, vintages, J-curve, export

using PrivateMarkets.Metrics.Aggregation;
using PrivateMarkets.Metrics.Export;

var portfolio = new Portfolio("Programme", [fundIII, fundIV]);   // one currency per portfolio
FundMetrics pooled = portfolio.Metrics(asOf);                     // pooled IRR on combined cash flows
IReadOnlyList<VintageSummary> vintages = portfolio.ByVintage(asOf);
int quartile = vintages[0].Tvpi!.QuartileOf(fundIII.Metrics(asOf).Tvpi!.Value); // 1 = top quartile

IReadOnlyList<FundMetrics> jCurve = fundIII.JCurve(ReportingFrequency.Quarterly);
File.WriteAllText("j-curve.csv", CsvExport.ToCsv(jCurve));
File.WriteAllText("vintages.json", JsonExport.ToJson(vintages));

Data model and conventions

• Paid-in = calls + fees. Invested = calls only. Distributions include recallable ones.
• Residual value at a date = last reported NAV, rolled forward with later calls (+) and distributions (−); fees do not increase the NAV. Without any NAV the roll-forward starts at zero (cost). Disable with RollForwardNav = false. The value is floored at zero.
• Unfunded = commitment − paid-in + recallable distributions.
• Ratios with a zero denominator, and IRRs without a root, are null.

Formulas

Notation: $C_t$ contributions and $D_t$ distributions at date $t$, $NAV_T$ residual value at the valuation date $T$, $I_t$ index level, $\tau_t$ year fraction from the first cash flow under the day count convention.

Multiples

$$ \text{TVPI} = \frac{\sum D_t + NAV_T}{\sum C_t} \qquad \text{DPI} = \frac{\sum D_t}{\sum C_t} \qquad \text{RVPI} = \frac{NAV_T}{\sum C_t} \qquad \text{PIC} = \frac{\sum C_t}{\text{Commitment}} \qquad \text{MOIC} = \frac{\sum D_t + NAV_T}{\sum \text{Calls}_t} $$

IRR (XIRR)

$r$ solves $\sum_t (D_t - C_t)(1+r)^{-\tau_t} + NAV_T (1+r)^{-\tau_T} = 0$ with $\tau_t = \frac{\text{days}(t_0, t)}{B}$, $B \in {365, 360, 365.25}$. Newton-Raphson from the guess, then bisection over a scanned bracket when Newton does not converge. PeriodIrr(start, end) uses $-NAV_{start}$ as the opening flow and $NAV_{end}$ as the closing one.

Public market equivalents

Each flow is compounded to $T$ with the index: $FV(x_t) = x_t , I_T / I_t$.

PmeResult also exposes the spreads (fund IRR − benchmark IRR) for LN, PME+ and mPME.

Aggregation

• Pooled: amounts summed across funds; pooled IRR on the combined cash flows (capital-weighted).
• Quartiles: linear interpolation (Excel QUARTILE.INC, NumPy default). QuartileOf follows the private equity convention: quartile 1 is the top quartile.

Parity with Python

tests/parity/generate_parity.py builds seeded synthetic funds and index paths, runs the Python libraries, and stores inputs and expected values as JSON. The xUnit suite reloads them and compares at 1e-6:

One deliberate difference: privateassets brackets Direct Alpha on [−50 %, 500 %] and returns NaN outside; this library solves it anywhere above −100 % (the dataset includes a −65 % case, checked against SciPy).

Regenerate the data:

python -m venv .venv && .venv/Scripts/pip install -r tests/parity/requirements.txt
.venv/Scripts/python -I tests/parity/generate_parity.py

MCP server

PrivateMarkets.Metrics.Mcp exposes compute_fund_metrics, compute_pme, vintage_summary and compute_j_curve over stdio, for prompts such as "compute the DPI of Fund III and compare it to its vintage median".

dotnet pack src/PrivateMarkets.Metrics.Mcp -c Release -o ./artifacts
dotnet tool install --global PrivateMarkets.Metrics.Mcp --add-source ./artifacts
claude mcp add private-markets -- privatemarkets-mcp

Setup for Claude Desktop, VS Code and other clients, tool parameters and troubleshooting: docs/mcp-server.md.

Build and test

dotnet build
dotnet test
dotnet run --project samples/PrivateMarkets.Metrics.Sample

Out of scope (v1)

NAV de-smoothing, GPME, performance attribution, distribution waterfalls and index data sourcing.

References

• Kaplan, S. and Schoar, A. (2005). Private Equity Performance: Returns, Persistence, and Capital Flows. Journal of Finance, 60(4).
• Gredil, O., Griffiths, B. and Stucke, R. (2014). Benchmarking Private Equity: The Direct Alpha Method. directalphamethod.info
• Long, A. and Nickels, C. (1996). A Private Investment Benchmark. AIMR Conference on Venture Capital Investing.
• Rouvinez, C. (2003). Private Equity Benchmarking with PME+. Venture Capital Journal.
• Cambridge Associates (2013). Private Equity and Venture Capital Benchmarks: An Introduction for Readers of Performance Reports (mPME).
• Python implementations: privateassets, pypme, PyPME.

License

MIT