Money Weighted Return Calculator
Understand your investment's true performance by accounting for the timing and size of your cash flows.
Investment Cash Flow Analysis
Enter your investment details below to calculate the Money Weighted Return (MWR).
Enter the starting value of your investment.
Enter the ending value of your investment.
Sum of all money added to the investment.
Sum of all money taken out of the investment.
Duration of the investment in years.
Calculation Results
Money Weighted Return (MWR)
–.–%
Net Cash Flow
–.–
Total Investment Gain/Loss
–.–
Average Investment Value
–.–
Formula Used: The Money Weighted Return (MWR) is essentially the Internal Rate of Return (IRR) of the investment's cash flows. It finds the discount rate that makes the present value of all cash outflows equal to the present value of all cash inflows. A simplified approximation often used for periods where cash flows are relatively evenly distributed or for educational purposes is: MWR ≈ (Total Return – Net Cash Flow) / (Average Investment Value + Net Cash Flow / 2). A more accurate method involves iterative calculations or financial functions to solve for IRR directly. For this calculator, we are finding the IRR that equates the initial investment and subsequent cash flows to the final value.
Investment Growth Over Time
Money Weighted Return Rate
Investment Value Progression
| Period | Starting Value | Cash Flow | Ending Value |
|---|
What is Money Weighted Return (MWR)?
Money Weighted Return (MWR), also known as the Internal Rate of Return (IRR), is a performance measure used in finance that accounts for the timing and size of cash flows into and out of an investment portfolio. Unlike the Time Weighted Return (TWR), which measures the performance of the underlying assets, MWR measures the performance of the investor's actual invested capital. It answers the question: "What rate of return did the investor actually earn on the money they invested?"
Who should use it: MWR is particularly useful for individual investors or portfolio managers who want to understand the return generated on their specific investment decisions, especially when they have made significant contributions or withdrawals during the investment period. It helps assess the effectiveness of the investor's own capital allocation strategy.
Common misconceptions: A frequent misconception is that MWR is always lower than TWR when there are significant positive cash flows. This is true; MWR will be lower than TWR if you invest more money when the portfolio is performing poorly or withdraw money when the portfolio is performing well. Conversely, MWR can be higher than TWR if you invest more when performance is strong or withdraw during periods of weakness. Another misconception is that MWR is simply the total return divided by the average investment value; it is a more sophisticated calculation that considers the exact timing of each cash flow.
Money Weighted Return (MWR) Formula and Mathematical Explanation
The Money Weighted Return (MWR) is formally defined as the discount rate that equates the present value of all cash inflows to the present value of all cash outflows over the life of an investment. In simpler terms, it's the interest rate at which the net present value (NPV) of all cash flows (both positive and negative) associated with an investment equals zero.
The calculation is the same as finding the Internal Rate of Return (IRR) for a series of cash flows. The equation to solve is:
0 = CF₀ + CF₁/(1+IRR)¹ + CF₂/(1+IRR)² + … + CFn/(1+IRR)ⁿ
Where:
- CF₀ is the initial investment (usually negative, as it's an outflow).
- CF₁, CF₂, …, CFn are the subsequent cash flows (positive for contributions, negative for withdrawals) at specific periods (t=1, 2, …, n).
- IRR is the Money Weighted Return (the unknown we are solving for).
- n is the number of periods.
Variable Explanations:
| Variable | Meaning | Unit | Typical Range |
|---|---|---|---|
| CF₀ | Initial Investment Outflow | Currency Unit (e.g., USD) | Positive (e.g., 10,000) |
| CF₁, CF₂, …, CFn | Subsequent Cash Flows (Contributions are positive, Withdrawals are negative) | Currency Unit (e.g., USD) | Can be positive, negative, or zero |
| n | Number of Periods (e.g., years) | Years | ≥ 1 |
| IRR | Money Weighted Return (Internal Rate of Return) | Percentage (%) | Typically ranges from -100% to very high positive percentages |
| Final Value (Implied Cash Flow) | The value of the investment at the end of the period, treated as a positive cash flow at time n. | Currency Unit (e.g., USD) | Must be greater than sum of negative cash flows to yield a positive return. |
Solving this equation for IRR typically requires iterative numerical methods or financial functions available in software like Excel (IRR function) or specialized financial calculators, as it cannot be solved algebraically for more than a few periods. Our calculator uses such methods to find the IRR.
Practical Examples (Real-World Use Cases)
Let's illustrate MWR with practical scenarios:
Example 1: Consistent Growth with Regular Contributions
Sarah invested $10,000 into a diversified equity fund. Over 5 years, she added $2,000 annually to her investment. At the end of the 5-year period, her portfolio value grew to $20,000. She made no withdrawals.
Inputs:
- Initial Investment: $10,000
- Total Contributions: $2,000/year * 5 years = $10,000
- Total Withdrawals: $0
- Final Value: $20,000
- Investment Period: 5 Years
Calculation: Using the MWR calculator with these inputs, we find the IRR.
(Simulated Output based on calculator logic)
Results:
- Money Weighted Return (MWR): Approximately 11.39%
- Net Cash Flow: $10,000 (Contributions)
- Total Investment Gain/Loss: $0 (Final Value $20,000 – Initial $10,000 – Contributions $10,000)
- Average Investment Value: Approximately $15,000 ((Initial $10,000 + Final $20,000) / 2)
Interpretation: Sarah's actual return on the capital she deployed over the 5 years was approximately 11.39%. This metric reflects her success in timing her investments and the overall growth.
Example 2: Volatility with Withdrawals
John started with $50,000. In year 2, he withdrew $10,000 for a down payment. In year 3, he contributed $5,000. After 5 years, his portfolio is worth $65,000.
Inputs:
- Initial Investment: $50,000
- Total Contributions: $5,000
- Total Withdrawals: $10,000
- Final Value: $65,000
- Investment Period: 5 Years
Calculation: Inputting these figures into the MWR calculator.
(Simulated Output based on calculator logic)
Results:
- Money Weighted Return (MWR): Approximately 5.35%
- Net Cash Flow: -$5,000 ($5,000 Contributions – $10,000 Withdrawals)
- Total Investment Gain/Loss: $20,000 (Final Value $65,000 – Initial $50,000 – Contributions $5,000 + Withdrawals $10,000)
- Average Investment Value: Approximately $57,500 ((Initial $50,000 + Final $65,000) / 2)
Interpretation: John's effective return on his invested capital was about 5.35%. The withdrawal in year 2 likely impacted the MWR negatively, assuming it occurred when the portfolio was not growing significantly, while the final value reflects the overall success.
How to Use This Money Weighted Return Calculator
Using our Money Weighted Return calculator is straightforward. Follow these steps to get an accurate assessment of your investment performance:
- Enter Initial Investment: Input the exact amount you initially invested at the beginning of your investment period.
- Enter Final Investment Value: Provide the total value of your investment at the end of the period.
- Enter Total Contributions: Sum up all the additional money you have put into the investment over the entire period. Be precise.
- Enter Total Withdrawals: Sum up all the money you have taken out of the investment over the entire period.
- Enter Investment Period: Specify the total duration of the investment in years (e.g., 5.5 years for five and a half years).
- Click 'Calculate MWR': Once all fields are populated, click this button to generate the results. The calculator will process the inputs and display the MWR.
How to read results:
- Money Weighted Return (MWR): This is the primary result, shown in percentage. It represents the annualized rate of return achieved on your specific invested capital, considering all cash flows.
- Net Cash Flow: This is the difference between your total contributions and total withdrawals. A positive number means you added more than you took out; a negative number means the opposite.
- Total Investment Gain/Loss: This is the absolute profit or loss from your investment, calculated as Final Value – Initial Investment – Total Contributions + Total Withdrawals.
- Average Investment Value: A simplified average often calculated as (Initial Investment + Final Value) / 2. This is used in some approximation formulas but is not the direct IRR driver.
Decision-making guidance: A higher MWR indicates better performance relative to your capital deployment. Compare your MWR to your investment goals, benchmarks, and the Time Weighted Return (TWR) if available. If your MWR is significantly lower than expected or lower than a comparable risk-adjusted benchmark, review your contribution and withdrawal timing. If you consistently invest during market downturns and withdraw during upturns, your MWR will naturally be penalized compared to TWR.
Key Factors That Affect Money Weighted Return Results
Several factors significantly influence the Money Weighted Return calculation, making it sensitive to investor behavior and market conditions:
- Timing of Cash Flows: This is the most critical factor. Investing large sums just before a market surge or withdrawing funds right before a market crash will boost your MWR. Conversely, investing heavily before a downturn or withdrawing before a rally will reduce your MWR.
- Size of Cash Flows: Larger contributions or withdrawals have a more pronounced effect on MWR than smaller ones. A substantial investment made at the beginning of the period, for instance, anchors the IRR calculation significantly.
- Investment Period Length: Longer periods allow for compounding effects and can smooth out the impact of individual cash flows. Short periods with many large cash flows can lead to volatile MWR figures. The accuracy of the investment period in years is crucial.
- Overall Investment Performance (Market Returns): The underlying growth rate of the assets in the portfolio is fundamental. Even with perfect cash flow timing, poor market returns will result in a low MWR.
- Fees and Expenses: Transaction costs, management fees, and other expenses reduce the net returns. Since MWR focuses on actual cash invested, these costs directly diminish the final value and thus the calculated return.
- Inflation: While MWR calculates nominal returns, comparing it to inflation (real return) is important for understanding purchasing power. High inflation can erode the real gains even if the nominal MWR appears satisfactory.
- Taxes: Capital gains taxes and income taxes on investment earnings reduce the actual cash received by the investor, impacting the final portfolio value and consequently the MWR.
Frequently Asked Questions (FAQ)
Q1: What is the difference between Money Weighted Return (MWR) and Time Weighted Return (TWR)?
A1: MWR measures the performance of the investor's actual capital, considering the timing and size of their cash flows. TWR measures the performance of the underlying investment strategy or assets, irrespective of cash flows. TWR is better for comparing investment managers, while MWR is better for evaluating an individual investor's success.
Q2: Can MWR be negative?
A2: Yes, absolutely. If the investment loses value overall, or if the investor withdraws more than the gains achieved, the MWR can be negative, indicating a loss on the capital invested.
Q3: Why is my MWR lower than the stated fund performance?
A3: This is common if you invested more money when the fund's value was lower or withdrew money when it was high. The fund's stated performance likely uses Time Weighted Return (TWR), which removes the investor's cash flow impact.
Q4: How accurate is the approximation formula for MWR?
A4: The approximation formula (Total Return – Net Cash Flow) / (Average Investment Value + Net Cash Flow / 2) can be reasonably close for simple cases, but it's not as precise as calculating the IRR directly, especially with irregular cash flows or over very long periods. Our calculator uses a more robust IRR calculation method.
Q5: Does MWR account for reinvested dividends?
A5: Yes, reinvested dividends are treated as positive cash flows (contributions) into the investment, increasing its value. The MWR calculation inherently includes their effect on the portfolio's final value.
Q6: Is MWR a good measure for evaluating a portfolio manager?
A6: Generally, no. MWR is heavily influenced by when the client deposits or withdraws funds, which is outside the manager's control. TWR is the preferred metric for evaluating a manager's skill in asset selection and market timing.
Q7: What is considered a 'good' Money Weighted Return?
A7: A 'good' MWR depends heavily on the asset class, market conditions, investment horizon, and risk tolerance. It should be compared against relevant benchmarks (like a stock market index or bond index) and your personal financial goals.
Q8: Can I calculate MWR for multiple periods?
A8: Yes, the MWR (IRR) concept applies to any investment period. For multi-year investments with cash flows in each year, you would typically calculate the IRR across all cash flows and the final value. Our calculator assumes a single period for simplicity but the underlying IRR principle holds.
Money Weighted Return (MWR)
–.–%
';
document.getElementById("netCashFlow").innerText = "–.–";
document.getElementById("totalGainLoss").innerText = "–.–";
document.getElementById("averageInvestmentValue").innerText = "–.–";
return;
}
// Intermediate Calculations
var netCashFlow = totalContributions – totalWithdrawals;
var totalGainLoss = finalValue – initialInvestment – totalContributions + totalWithdrawals;
var averageInvestmentValue = (initialInvestment + finalValue) / 2; // Simplified average for display
// MWR Calculation (IRR approximation using Newton-Raphson or similar iterative method)
// For simplicity and to avoid complex JS libraries, we'll use a common iterative approach.
// This is a simplified example; real-world IRR solvers are more robust.
var mwr = irrSolver(initialInvestment, totalContributions, totalWithdrawals, finalValue, investmentPeriod);
// Display Intermediate Results
document.getElementById("netCashFlow").innerText = formatCurrency(netCashFlow);
document.getElementById("totalGainLoss").innerText = formatCurrency(totalGainLoss);
document.getElementById("averageInvestmentValue").innerText = formatCurrency(averageInvestmentValue);
// Display Main Result
document.getElementById("result").innerHTML = 'Money Weighted Return (MWR)
' + formatPercentage(mwr) + '
';
// Update Chart and Table
updateChartAndTable(initialInvestment, totalContributions, totalWithdrawals, finalValue, investmentPeriod, mwr);
}
// Simplified IRR Solver using Newton-Raphson method
function irrSolver(initialInvestment, totalContributions, totalWithdrawals, finalValue, period) {
// We need to construct cash flows for the IRR function.
// Assuming contributions/withdrawals happen evenly throughout the period for simplicity in this basic solver.
// A more accurate approach would require specific dates for each cash flow.
// For this example, let's represent contributions and withdrawals as lump sums at the start/end of the period for a simplified IRR solver.
// This is a common simplification when precise dates aren't available.
// Actual IRR calculation is complex and usually involves iterative methods.
// Let's structure cash flows for a simplified IRR calculation:
// Time 0: -InitialInvestment
// Time Period: +FinalValue + TotalContributions – TotalWithdrawals
// Simplified cash flow setup for period T
// CF[0] = -InitialInvestment
// CF[T] = FinalValue + TotalContributions – TotalWithdrawals
// This is a very basic representation. A real IRR calculation needs cash flows at specific times.
// Let's simulate cash flows for a basic IRR solver, assuming contributions/withdrawals spread over the period.
// We'll use a common iterative approach: Newton-Raphson method for finding the root of a function.
var guess = 0.1; // Initial guess for IRR
var iterations = 100;
var tolerance = 0.00001;
var irr = guess;
// Function to calculate NPV for a given rate
// NPV(rate) = CF0 + CF1/(1+rate)^1 + CF2/(1+rate)^2 + … + CFr/(1+rate)^r
// For MWR, we need to model cash flows more realistically.
// Let's assume contributions and withdrawals occur at discrete points.
// A common simplification for MWR calculation when specific dates are unknown is to use approximate cash flows.
// However, a true IRR solver needs precise timing.
// Let's use a common simplified financial function approach for IRR as it's computationally intensive in pure JS.
// A practical JS IRR implementation involves an iterative search.
// Let's model cash flows as:
// Initial Outflow at T=0: -initialInvestment
// Net Cash Flow at T=period: netCashFlow = totalContributions – totalWithdrawals
// Final Value at T=period: finalValue
// Function to calculate NPV for a given rate 'r' and cash flows.
// For MWR, cash flows are:
// C0 = -initialInvestment
// C_period = finalValue + totalContributions – totalWithdrawals
// Note: A more accurate IRR calculation would require cash flows at EACH point in time.
// For this simplified calculator, let's assume contributions and withdrawals are lumped at the END of the period.
// This is a MAJOR simplification and deviates from true IRR's sensitivity to timing.
// Let's use a simplified cash flow representation:
// Time 0: -initialInvestment
// Time 'period': finalValue + totalContributions – totalWithdrawals
// This is NOT precise IRR, but a common approximation for basic calculators.
// A more standard approach for MWR is to find the rate 'r' such that:
// 0 = -InitialInvestment + Sum(Contributions_i / (1+r)^t_i) – Sum(Withdrawals_j / (1+r)^t_j) + FinalValue / (1+r)^Period
// Let's implement a numerical solver for the IRR equation.
// We'll define f(r) = Sum(CF_t / (1+r)^t) = 0
// CF_0 = -initialInvestment
// For simplicity, let's distribute contributions and withdrawals across the period.
// Assume contributions and withdrawals are averaged over the period for the purpose of this solver.
// This is a significant simplification.
var cashFlows = [];
cashFlows.push(-initialInvestment); // Initial Outflow
// For intermediate cash flows, we will approximate. A true IRR requires specific dates.
// Let's create a simple annual cash flow if period is integer, otherwise prorate.
if (period > 0) {
var annualContribution = totalContributions / period;
var annualWithdrawal = totalWithdrawals / period;
for (var i = 1; i < period; i++) {
cashFlows.push(annualContribution – annualWithdrawal);
}
// Final cash flow at the end of the period
cashFlows.push(finalValue + annualContribution – annualWithdrawal);
} else {
cashFlows.push(finalValue + totalContributions – totalWithdrawals); // If period is < 1, lump sum at end
}
// Newton-Raphson method for IRR
var maxIterations = 100;
var precision = 0.00001;
var rateGuess = 0.1; // 10% initial guess
for (var i = 0; i < maxIterations; i++) {
var npv = 0;
var derivative = 0;
for (var t = 0; t < cashFlows.length; t++) {
var denominator = Math.pow(1 + rateGuess, t);
npv += cashFlows[t] / denominator;
derivative += -cashFlows[t] * t / Math.pow(1 + rateGuess, t + 1);
}
if (Math.abs(derivative) < precision) {
// Derivative is too small, might be at a minimum/maximum or flat area.
// Can't improve, return current guess or indicate failure.
break;
}
var nextRate = rateGuess – npv / derivative;
if (Math.abs(nextRate – rateGuess) < precision) {
rateGuess = nextRate; // Converged
break;
}
rateGuess = nextRate;
}
// Handle cases where solver doesn't converge or results in NaN/Infinity
if (isNaN(rateGuess) || !isFinite(rateGuess)) {
// Fallback: Try a simpler approximation or return an indicator of failure
// A very basic approximation: MWR ~ (Total Return / Initial Investment) – Net Cash Flow Adjustment
// This is not accurate enough for a reliable MWR.
// Let's return a placeholder or NaN if solver fails.
return NaN; // Indicate failure
}
return rateGuess; // This is the MWR (IRR)
}
function updateChartAndTable(initial, contributions, withdrawals, final, period, mwr) {
var ctx = document.getElementById('investmentChart').getContext('2d');
if (window.myChart) {
window.myChart.destroy();
}
var chartDataPoints = [];
var investmentValueProgression = [];
var cashFlowsArray = [];
var netCashFlowPerPeriod = (contributions – withdrawals) / period;
var currentInvestmentValue = initial;
// Simulate value progression and cash flows
for (var i = 0; i <= period; i++) {
var time = i;
var cashFlowAtTime = 0;
if (i === 0) {
cashFlowAtTime = -initial;
currentInvestmentValue = initial; // Starting point
} else if (i < period) {
cashFlowAtTime = netCashFlowPerPeriod;
currentInvestmentValue += netCashFlowPerPeriod;
} else { // At the end of the period
cashFlowAtTime = final + netCashFlowPerPeriod; // Includes final value and last period's cash flow
currentInvestmentValue = final;
}
chartDataPoints.push(time);
investmentValueProgression.push(currentInvestmentValue);
cashFlowsArray.push(cashFlowAtTime);
}
// Now, let's simulate the MWR rate application
// The MWR is an annualized rate. We'll show its effect if applied constantly.
var constantGrowthProgression = [];
var currentConstantValue = initial;
for (var i = 0; i <= period; i++) {
constantGrowthProgression.push(currentConstantValue);
if (i < period) { // Apply MWR for next period's growth
currentConstantValue *= (1 + mwr);
}
}
window.myChart = new Chart(ctx, {
type: 'line',
data: {
labels: chartDataPoints,
datasets: [{
label: 'Investment Value Progression',
data: investmentValueProgression,
borderColor: '#ffc107', // Yellow for investment value
backgroundColor: 'rgba(255, 193, 7, 0.2)',
fill: false,
tension: 0.1
}, {
label: 'MWR Growth Simulation',
data: constantGrowthProgression,
borderColor: 'var(–primary-color)', // Primary color for MWR
backgroundColor: 'rgba(0, 74, 153, 0.2)',
fill: false,
tension: 0.1,
borderDash: [5, 5] // Dashed line for simulation
}]
},
options: {
responsive: true,
maintainAspectRatio: false,
scales: {
y: {
beginAtZero: false,
title: {
display: true,
text: 'Value ($)'
}
},
x: {
title: {
display: true,
text: 'Period (Years)'
}
}
},
plugins: {
tooltip: {
mode: 'index',
intersect: false,
},
legend: {
display: false // Use custom legend
}
},
hover: {
mode: 'index',
intersect: false
}
}
});
// Populate Table
var tableBody = document.getElementById('cashFlowTableBody');
tableBody.innerHTML = ''; // Clear previous rows
var annualCont = contributions / period;
var annualWdwl = withdrawals / period;
var currentValForTable = initial;
for (var i = 0; i <= period; i++) {
var row = tableBody.insertRow();
var cellPeriod = row.insertCell(0);
var cellStart = row.insertCell(1);
var cellCashFlow = row.insertCell(2);
var cellEnd = row.insertCell(3);
cellPeriod.innerText = i === 0 ? "Start" : (i === period ? "End" : "Year " + i);
cellStart.innerText = i === 0 ? formatCurrency(initial) : formatCurrency(currentValForTable);
var cashFlowThisPeriod = 0;
if (i === 0) {
cashFlowThisPeriod = -initial; // Initial outflow
} else if (i 0 && i < period) {
currentValForTable += cashFlowThisPeriod;
} else if (i === period) {
// Final value is already set as currentValForTable after adding last cash flow
}
}
}
function formatCurrency(amount) {
return "$" + amount.toFixed(2).replace(/\d(?=(\d{3})+\.)/g, '$&,');
}
function formatPercentage(rate) {
return (rate * 100).toFixed(2) + "%";
}
function resetCalculator() {
document.getElementById("initialInvestment").value = "10000";
document.getElementById("finalValue").value = "15000";
document.getElementById("totalContributions").value = "2000";
document.getElementById("totalWithdrawals").value = "500";
document.getElementById("investmentPeriod").value = "5";
document.getElementById("initialInvestmentError").innerText = "";
document.getElementById("finalValueError").innerText = "";
document.getElementById("totalContributionsError").innerText = "";
document.getElementById("totalWithdrawalsError").innerText = "";
document.getElementById("investmentPeriodError").innerText = "";
document.getElementById("result").innerHTML = 'Money Weighted Return (MWR)
–.–%
';
document.getElementById("netCashFlow").innerText = "–.–";
document.getElementById("totalGainLoss").innerText = "–.–";
document.getElementById("averageInvestmentValue").innerText = "–.–";
// Optionally clear chart and table or reset to defaults
if (window.myChart) {
window.myChart.destroy();
}
document.getElementById('cashFlowTableBody').innerHTML = ";
}
function copyResults() {
var mainResultLabel = "Money Weighted Return (MWR)";
var mainResultValue = document.querySelector('.highlighted-result .value').innerText;
var netCashFlowLabel = "Net Cash Flow";
var netCashFlowValue = document.getElementById("netCashFlow").innerText;
var totalGainLossLabel = "Total Investment Gain/Loss";
var totalGainLossValue = document.getElementById("totalGainLoss").innerText;
var avgInvValueLabel = "Average Investment Value";
var avgInvValueValue = document.getElementById("averageInvestmentValue").innerText;
var contributions = document.getElementById("totalContributions").value;
var withdrawals = document.getElementById("totalWithdrawals").value;
var period = document.getElementById("investmentPeriod").value;
var clipboardText = `— Money Weighted Return (MWR) Calculation —
${mainResultLabel}: ${mainResultValue}
Key Intermediate Values:
${netCashFlowLabel}: ${netCashFlowValue}
${totalGainLossLabel}: ${totalGainLossValue}
${avgInvValueLabel}: ${avgInvValueValue}
Key Assumptions:
Total Contributions: $${contributions}
Total Withdrawals: $${withdrawals}
Investment Period: ${period} years
`;
navigator.clipboard.writeText(clipboardText).then(function() {
// Show feedback
var copyButton = document.querySelector('.btn-copy');
var feedback = document.createElement('span');
feedback.className = 'copy-feedback';
feedback.innerText = 'Copied!';
copyButton.parentNode.insertBefore(feedback, copyButton.nextSibling);
setTimeout(function() {
feedback.style.opacity = '1';
}, 10);
setTimeout(function() {
feedback.style.opacity = '0';
setTimeout(function() {
feedback.remove();
}, 300);
}, 1500);
}).catch(function(err) {
console.error('Failed to copy text: ', err);
// Optionally provide error feedback to user
});
}
// Initial calculation on load
document.addEventListener('DOMContentLoaded', calculateMWR);