Beneish M-Score

Reconstruct DSRI through TATA, reconcile every coefficient, and treat the M-Score as an investigation trigger rather than an allegation.

The decision this tutorial makes visible

Beneish M-Score matters because a compact score can organize a review queue, but only when its accounting definitions, original estimation population, availability clock, and interpretation boundary remain visible.

The precise question is: How do eight two-period financial-statement indices combine into Beneish's earnings-manipulation screening score?

A practitioner needs to know what the diagnostic does and does not justify. A builder needs a contract that can be reproduced from the same point-in-time inputs in Python, TypeScript, a visual, and a browser lab.

Intuition before notation

The indices compare current accounting relationships with the prior year; unusual movement can arise from manipulation or legitimate structural change.

The result depends on the declared algorithm scope, input clocks, units, equality and rounding policies, and unsupported-state treatment. Change one of those and the output represents a different decision even when its field name is unchanged.

Scope and nearby methods

Beneish 1999 eight-variable model with the -4.84 intercept and -1.78 package screening cutoff.

Variant	Definition	Best use	Main limitation
Eight-variable 1999 model	Canonical package equation	Broad financial-statement screening	Structural changes can trigger it
Five-variable model	Reduced predictor set	Limited data	Not comparable
Later re-estimation	New population and coefficients	Current research	Cannot retain old cutoff

What is sourced, selected, synthetic, and derived

Role	Material claim	Evidence	Boundary
Sourced fact	Defines the financial-statement indices and estimated screening model for detected earnings manipulators.	S1 original or explicitly limited reproduction	The screen requires investigation; it can respond to structural business changes and is not a finding of manipulation.
Implementation choice	Beneish 1999 eight-variable model with the -4.84 intercept and -1.78 package screening cutoff.	Frozen definition contract, code, fixtures, and parity tests	Nearby coefficient sets and variants remain separate.
Synthetic teaching input	All company records, periods, peer samples, scenarios, and outputs are repository-authored synthetic data.	datasets/canonical-input.json and scenario-results.json	No value is an observed issuer or provider record.
Author-derived calculation	The synthetic two-year record yields a high DSRI and M = -1.668866, above the package's -1.78 screening cutoff. That is a prompt to inspect the drivers, not a manipulation conclusion.	Formula, expected-output.json, independent checks, and Python/TypeScript parity	Arithmetic fidelity does not validate prediction or company conclusions.
Scope boundary	The output does not establish a current issuer conclusion, audit finding, rating, default forecast, investment return, or causal claim.	No empirical current-population or advisory claim is tested	Use as a documented screen or research measure only.

The authoritative sources support only the exact facts named in the claim ledger. They do not certify the synthetic numbers in this tutorial. The repository fixture is deliberately invented for auditability, and the displayed output is author-derived under the selected implementation choice.

Formula, symbols, and numerical policy

Plain text

M = -4.84 + .920 DSRI + .528 GMI + .404 AQI + .892 SGI + .115 DEPI - .172 SGAI + 4.679 TATA - .327 LVGI

Symbol	Meaning	Unit	Policy
DSRI	Days-sales-in-receivables index	index	Current relation / prior relation
AQI	Asset-quality index	index	Noncurrent non-PPE quality proxy
TATA	Total accruals / total assets	ratio	Income less CFO
M	Beneish screening score	index	Not a finding

Use full floating-point precision and round only for display.
Ratios are dimensionless unless a days or currency-scale contract is explicit.
Reject missing, nonfinite, boolean-as-number, zero-denominator, invalid-log, singular-regression, mixed-period, or unsupported records.
Keep the raw index, transformation, contribution vector, threshold policy, and diagnostic state together.

Read the formula in the same order as the algorithm. Validate identity, ordering, units, and supported state first. Apply the selected equality, cutoff, and estimation rules second. Calculate with unrounded numeric values. Round only at the declared presentation boundary, and preserve null as a diagnostic rather than coercing it to zero.

Build the algorithm

Align current and prior statements and validate denominators.
Calculate receivable, margin, asset-quality, growth, depreciation, SG&A, leverage, and accrual indices.
Apply the eight coefficients and intercept.
Compare with the frozen cutoff and retain every component.

Production-minded operational checklist

Confirm model variant and original population
Map every accounting input and clock
Reconcile score contributions
Treat the output as a review screen, not a conclusion

Stop when a required line item, filing clock, unit scale, original-population condition, or estimation sample is unavailable; do not manufacture precision from a familiar score name.

Worked synthetic example

The canonical fixture is synthetic teaching data, not an observed issuer, filing, audit case, or market outcome. Its primary author-derived output, m_score, is eight indices, nine contribution entries, M = -1.668866, and an above-cutoff screen. The complete input and output are in datasets/canonical-input.json and datasets/expected-output.json.

The synthetic two-year record yields a high DSRI and M = -1.668866, above the package's -1.78 screening cutoff. That is a prompt to inspect the drivers, not a manipulation conclusion.

Counterfactual checkpoint

One-driver stress. Move one declared accounting driver while holding the remaining synthetic record fixed. The output changes because The score is a weighted mapping of the frozen inputs, not an independent fact.

The structured result retains state and diagnostics in addition to the primary number. That makes the calculation independently reviewable and prevents an incomplete, rejected, unsupported, or retrospective result from being mistaken for an unqualified conclusion.

Boundary and counterexample workbook

The playground computes every scenario at 61 deterministic parameter states. The table uses the declared focus step and states whether that focus reproduces the canonical fixture. The full state ledger and compressed transition segments are in datasets/scenario-results.json.

Scenario	Review focus	Purpose	State	Primary output	Diagnostic	Decision segments
Canonical DSRI	Step 30 · canonical fixture	Driver: receivables. Sweep receivables to isolate the days-sales-in-receivables index. Predict: Will faster receivables growth push DSRI upward?	calculated	-1.6689	calculated · above-screening-cutoff · beneish-1999-eight-variable	1
TATA cash-versus-income	Step 30 · canonical fixture	Driver: income_from_continuing_operations. Sweep continuing income while CFO stays fixed. Predict: Will a larger income-minus-CFO accrual contribution lift M?	calculated	-1.6689	calculated · above-screening-cutoff · beneish-1999-eight-variable	1
Asset-quality index	Step 30 · canonical fixture	Driver: current_assets. Sweep current assets while noncurrent assets stay fixed. Predict: Will the asset-quality index respond to the current-asset mix?	calculated	-1.6689	calculated · above-screening-cutoff · beneish-1999-eight-variable	1
Leverage index	Step 30 · canonical fixture	Driver: long_term_debt. Sweep long-term debt against the prior leverage base. Predict: Will higher leverage change LVGI and the signed contribution?	calculated	-1.6689	calculated · above-screening-cutoff · beneish-1999-eight-variable	1
Total-asset scale	Step 30 · canonical fixture	Driver: total_assets. Sweep current total assets to expose scaling in AQI, LVGI, and TATA. Predict: Which indices are most sensitive to the common asset denominator?	calculated	-1.6689	calculated · above-screening-cutoff · beneish-1999-eight-variable	1
Cash-sales bridge	Step 30 · canonical fixture	Driver: operating_cash_flow. Sweep CFO to isolate the cash-sales/TATA pathway. Predict: Will lower CFO make the accrual component more positive?	calculated	-1.6689	calculated · above-screening-cutoff · beneish-1999-eight-variable	1
Gross-margin index	Step 30 · canonical fixture	Driver: cost_of_goods_sold. Sweep current COGS while sales remain fixed. Predict: Will a weaker gross margin raise GMI and the M-score contribution?	calculated	-1.6689	calculated · above-screening-cutoff · beneish-1999-eight-variable	1

These rows are not backtest observations. They are controlled counterexamples that expose how one driver changes the state, output, or reason code while the rest of the contract stays fixed.

Visualize the boundary

Beneish M-Score annotated teaching map

Open this SVG at full size, or use the guided playground to compare the seven topic-specific canonical, boundary, policy, and failure scenarios.

The Mermaid flow answers where the selected calculation sits in the processing sequence. The SVG keeps the formula, output, decision boundary, and invariant visible together. The lab lets the reader step through the same structured states without changing the underlying definition.

Implementation walkthrough

The Python and TypeScript references begin with the same validation contract, reject malformed and unsupported state before calculation, preserve declared ordering and rounding policies, and return structured diagnostics rather than one context-free number.

The main implementation branches are:

M > -1.78 — Label above screening cutoff, because Package cutoff crossed.
M <= -1.78 — Label below screening cutoff, because Inclusive lower side.
index denominator invalid — Reject, because No silent neutral index.

Neither reference silently fetches data, mutates caller-owned inputs outside the declared engine behavior, guesses hidden state, or substitutes a provider default. Shared JSON fixtures make value, null, state, and reason-code drift visible across languages.

Testing and validation

Definition tests compare every canonical field, reject malformed state, and exercise the material boundary. Family validation recomputes every playground state from the reference function. Independent arithmetic is recorded beside the fixture rather than inferred only from implementation output.

The audit must preserve these invariants:

M equals the intercept plus all eight displayed contributions.
All indices use one current/prior direction.
A score above -1.78 remains a screen requiring investigation.
The output retains named predictors/components, raw score, screen or residual interpretation, and method identifier.

Passing checks proves the selected equation, mapping, scenario, and language parity. It does not validate out-of-sample classification performance.

Failure modes and misuse

The model can be stale, population-specific, industry-sensitive, and affected by accounting classification or business-model changes.
A threshold crossing is a screen for further review, not bankruptcy, fraud, audit, rating, or valuation evidence by itself.
Implementation fidelity does not prove predictive accuracy, causality, market usefulness, or suitability for a current jurisdiction.

Debugging order

When a result looks surprising, inspect the state in this order:

Confirm the exact model variant and coefficients.
Confirm filing availability and accounting mapping.
Confirm units, scale, signs, periods, logs, and denominators.
Reconcile each contribution or regression residual before interpreting the aggregate.

Evidence and historical boundary

Historical decision: not useful. A named issuer is not useful for the canonical arithmetic because a defensible case would require the exact filing version available at the decision date, a line-item mapping ledger, restatement and corporate-action treatment, model-population eligibility, coefficient provenance, and independently reproducible arithmetic. Original research samples establish model history; synthetic records isolate mechanics without alleging distress or misstatement by a real company.

The primary sources are Beneish (1999), SEC financial-statement guide, IFRS Conceptual Framework. They support the source roles listed in the research ledger, not a redistributable historical observation, a current issuer conclusion, audit finding, rating, default forecast, investment return, or causal claim

Summary and next topic

You can now calculate, audit, and bound Beneish M-Score before continuing to Sloan Accrual Measure. The learning flow is: Piotroski F-Score → Beneish M-Score → Sloan Accrual Measure. Carry the result forward only with its scope, clock, state, and evidence label.

Deep visual atlas

Accounting model anatomy

Threshold and interpretation ceiling

Variant and misuse boundaries

Use the anatomy to reconstruct the score, the threshold map to preserve equality and interpretation, the clock to prevent hindsight, and the boundary map to stop variant drift.

Use the accounting studio

Read the prediction prompt and name the direction before moving the state slider.
Check the driver under test and compare the scenario base with the current state.
Reconcile the visible intermediate (eight indices and coefficient contributions) to the headline.
Apply the boundary and evidence clock: M equals the -1.78 screening cutoff.

Visual	Question it answers	Studio handoff
Model anatomy	What is the calculation order?	Start with Qualify → Map → Calculate → Reconcile.
Threshold and interpretation	What does equality mean?	Move to the boundary scenario and read the interpretation ceiling.
Evidence clock	What was knowable at the decision time?	For A12, wait for future CFO; for A13, freeze the peer sample.
Variant boundaries	Which nearby model is not interchangeable?	Compare the active driver with the claim ledger before changing the model.

Workflows

Rendered from the canonical Mermaid sources linked by this article.

Beneish M-Score calculation flow

This flow identifies the selected calculation stages and the structured output.

Rendering system map…

Takeaway: A screening result becomes auditable only when the unusual indices and their legitimate alternative explanations stay visible.

ReferencesPrimary sources and evidence notes

Expand the source trail, evidence role, and limitations behind the engineering choices.

S1 — The Detection of Earnings Manipulation

Organization or authors: Messod D. Beneish
Source type: Original peer-reviewed paper
Publication or effective date: 1999
Version: Original publication or cited edition
URL or DOI: https://doi.org/10.2469/faj.v55.n5.2296
Accessed: 2026-08-06
Jurisdiction: U.S. firms in the paper's estimation and holdout samples
Supports: Defines the financial-statement indices and estimated screening model for detected earnings manipulators.
Limitations: The screen requires investigation; it can respond to structural business changes and is not a finding of manipulation.

S2 — Beginners' Guide to Financial Statements

Organization or authors: U.S. Securities and Exchange Commission
Source type: Official regulator publication
Publication or effective date: 2007-02-05
Version: Original publication or cited edition
URL or DOI: https://www.sec.gov/about/reports-publications/investor-publications/beginners-guide-financial-statements
Accessed: 2026-08-06
Jurisdiction: United States public-company reporting
Supports: Balance sheets describe a point in time, income and cash-flow statements describe a period, and the notes are integral to interpretation.
Limitations: It does not prescribe any score, line-item mapping, coefficient, cutoff, or empirical conclusion.

S3 — Conceptual Framework for Financial Reporting

Organization or authors: International Accounting Standards Board
Source type: Official accounting framework
Publication or effective date: 2021 issued compilation
Version: Original publication or cited edition
URL or DOI: https://www.ifrs.org/content/dam/ifrs/publications/pdf-standards/english/2021/issued/part-a/conceptual-framework-for-financial-reporting.pdf
Accessed: 2026-08-06
Jurisdiction: IFRS reporting
Supports: Financial-statement elements and measurement are framework-dependent and must be interpreted with presentation and disclosure context.
Limitations: It does not endorse legacy distress or earnings-quality coefficient sets.

Evidence boundary

The original research source establishes the named historical model and research context. It does not certify this synthetic fixture, a current population calibration, or a company conclusion. SEC/IFRS sources establish statement context only.

Implementation

Full dependency-light reference implementations in both supported languages.

quality-distress.ts

/** Canonical TypeScript reference for D18-F04 Quality and Distress. */

type RecordValue = Record<string, unknown>;

function objectValue(data: RecordValue, name: string): RecordValue {
  const value = data[name];
  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${name} must be an object`);
  return value as RecordValue;
}

function numberValue(data: RecordValue, name: string): number {
  const value = data[name];
  if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`${name} must be a finite number`);
  return value;
}

function positive(data: RecordValue, name: string): number {
  const value = numberValue(data, name);
  if (value <= 0) throw new RangeError(`${name} must be positive`);
  return value;
}

function nonnegative(data: RecordValue, name: string): number {
  const value = numberValue(data, name);
  if (value < 0) throw new RangeError(`${name} must be nonnegative`);
  return value;
}

function booleanValue(data: RecordValue, name: string): boolean {
  const value = data[name];
  if (typeof value !== "boolean") throw new TypeError(`${name} must be a boolean`);
  return value;
}

function ratio(numerator: number, denominator: number, name: string): number {
  if (denominator === 0) throw new RangeError(`${name} denominator must be nonzero`);
  return numerator / denominator;
}

function logistic(index: number): number {
  if (index >= 0) { const z = Math.exp(-index); return 1 / (1 + z); }
  const z = Math.exp(index); return z / (1 + z);
}

function normalCdf(value: number): number {
  const sign = value < 0 ? -1 : 1;
  const x = Math.abs(value) / Math.sqrt(2);
  const t = 1 / (1 + 0.3275911 * x);
  const polynomial = (((((1.061405429 * t - 1.453152027) * t) + 1.421413741) * t - 0.284496736) * t + 0.254829592) * t;
  const erfValue = sign * (1 - polynomial * Math.exp(-x * x));
  return 0.5 * (1 + erfValue);
}

function sum(values: Record<string, number>): number { return Object.values(values).reduce((a, b) => a + b, 0); }

function altman(data: RecordValue): RecordValue {
  const assets = positive(data, "total_assets"), liabilities = positive(data, "total_liabilities");
  const ratios = {
    working_capital_to_assets: numberValue(data, "working_capital") / assets,
    retained_earnings_to_assets: numberValue(data, "retained_earnings") / assets,
    ebit_to_assets: numberValue(data, "ebit") / assets,
    market_equity_to_liabilities: nonnegative(data, "market_value_equity") / liabilities,
    sales_to_assets: numberValue(data, "sales") / assets,
  };
  const contributions = {
    working_capital: 1.2 * ratios.working_capital_to_assets,
    retained_earnings: 1.4 * ratios.retained_earnings_to_assets,
    ebit: 3.3 * ratios.ebit_to_assets,
    market_equity: 0.6 * ratios.market_equity_to_liabilities,
    sales: ratios.sales_to_assets,
  };
  const score = sum(contributions);
  const zone = score < 1.81 ? "distress-zone" : score > 2.99 ? "safe-zone" : "grey-zone";
  return {state:"calculated",method:"altman-1968-public-manufacturer",ratios,contributions,z_score:score,zone,threshold_policy:"distress<1.81; grey=1.81..2.99; safe>2.99"};
}

function piotroski(data: RecordValue): RecordValue {
  const beginAssets=positive(data,"beginning_total_assets"), priorBeginAssets=positive(data,"prior_beginning_total_assets");
  const currentAssets=positive(data,"current_assets"), currentLiabilities=positive(data,"current_liabilities");
  const priorCurrentAssets=positive(data,"prior_current_assets"), priorCurrentLiabilities=positive(data,"prior_current_liabilities");
  const sales=positive(data,"sales"), priorSales=positive(data,"prior_sales");
  const netIncome=numberValue(data,"net_income"), priorNetIncome=numberValue(data,"prior_net_income"), cfo=numberValue(data,"operating_cash_flow");
  const roa=netIncome/beginAssets, priorRoa=priorNetIncome/priorBeginAssets;
  const signals = {
    positive_roa: +(roa>0), positive_cfo: +(cfo>0), improving_roa: +(roa>priorRoa), cash_exceeds_income: +(cfo>netIncome),
    lower_leverage: +(numberValue(data,"long_term_debt")/beginAssets < numberValue(data,"prior_long_term_debt")/priorBeginAssets),
    higher_current_ratio: +(currentAssets/currentLiabilities > priorCurrentAssets/priorCurrentLiabilities),
    no_equity_issue: +(nonnegative(data,"equity_issued")===0),
    higher_gross_margin: +(numberValue(data,"gross_profit")/sales > numberValue(data,"prior_gross_profit")/priorSales),
    higher_asset_turnover: +(sales/beginAssets > priorSales/priorBeginAssets),
  };
  const score=sum(signals), band=score<=2?"weak-signals":score>=8?"strong-signals":"mixed-signals";
  return {state:"calculated",method:"piotroski-2000-nine-signal",signals,f_score:score,band,signal_count:9};
}

function beneish(data: RecordValue): RecordValue {
  const sales=positive(data,"sales"), priorSales=positive(data,"prior_sales");
  const receivables=nonnegative(data,"receivables"), priorReceivables=nonnegative(data,"prior_receivables");
  const grossMargin=(sales-numberValue(data,"cost_of_goods_sold"))/sales;
  const priorGrossMargin=(priorSales-numberValue(data,"prior_cost_of_goods_sold"))/priorSales;
  if (grossMargin===0 || priorGrossMargin===0) throw new RangeError("gross margins must be nonzero");
  const assets=positive(data,"total_assets"), priorAssets=positive(data,"prior_total_assets");
  const currentAssetQuality=1-(numberValue(data,"current_assets")+numberValue(data,"net_ppe")+numberValue(data,"securities"))/assets;
  const priorAssetQuality=1-(numberValue(data,"prior_current_assets")+numberValue(data,"prior_net_ppe")+numberValue(data,"prior_securities"))/priorAssets;
  if (priorAssetQuality===0) throw new RangeError("prior asset-quality denominator must be nonzero");
  const depreciationRate=ratio(numberValue(data,"depreciation"),numberValue(data,"net_ppe")+numberValue(data,"depreciation"),"depreciation rate");
  const priorDepreciationRate=ratio(numberValue(data,"prior_depreciation"),numberValue(data,"prior_net_ppe")+numberValue(data,"prior_depreciation"),"prior depreciation rate");
  const indices={
    dsri:ratio(receivables/sales,priorReceivables/priorSales,"DSRI"), gmi:priorGrossMargin/grossMargin,
    aqi:currentAssetQuality/priorAssetQuality, sgi:sales/priorSales, depi:priorDepreciationRate/depreciationRate,
    sgai:ratio(numberValue(data,"sga_expense")/sales,numberValue(data,"prior_sga_expense")/priorSales,"SGAI"),
    lvgi:ratio((numberValue(data,"current_liabilities")+numberValue(data,"long_term_debt"))/assets,(numberValue(data,"prior_current_liabilities")+numberValue(data,"prior_long_term_debt"))/priorAssets,"LVGI"),
    tata:(numberValue(data,"income_from_continuing_operations")-numberValue(data,"operating_cash_flow"))/assets,
  };
  const contributions={intercept:-4.84,dsri:.92*indices.dsri,gmi:.528*indices.gmi,aqi:.404*indices.aqi,sgi:.892*indices.sgi,depi:.115*indices.depi,sgai:-.172*indices.sgai,tata:4.679*indices.tata,lvgi:-.327*indices.lvgi};
  const score=sum(contributions);
  return {state:"calculated",method:"beneish-1999-eight-variable",indices,contributions,m_score:score,screen:score>-1.78?"above-screening-cutoff":"below-screening-cutoff",cutoff:-1.78};
}

function sloan(data: RecordValue): RecordValue {
  const avgAssets=positive(data,"average_total_assets");
  const deltaCa=numberValue(data,"current_assets")-numberValue(data,"prior_current_assets");
  const deltaCash=numberValue(data,"cash")-numberValue(data,"prior_cash");
  const deltaCl=numberValue(data,"current_liabilities")-numberValue(data,"prior_current_liabilities");
  const deltaStd=numberValue(data,"short_term_debt")-numberValue(data,"prior_short_term_debt");
  const deltaTax=numberValue(data,"taxes_payable")-numberValue(data,"prior_taxes_payable");
  const depreciation=nonnegative(data,"depreciation_and_amortization");
  const accrualAmount=(deltaCa-deltaCash)-(deltaCl-deltaStd-deltaTax)-depreciation, measure=accrualAmount/avgAssets;
  return {state:"calculated",method:"sloan-1996-balance-sheet-accrual",delta_current_assets:deltaCa,delta_cash:deltaCash,delta_current_liabilities:deltaCl,delta_short_term_debt:deltaStd,delta_taxes_payable:deltaTax,depreciation_and_amortization:depreciation,accrual_amount:accrualAmount,accrual_measure:measure,absolute_accrual_measure:Math.abs(measure),interpretation:measure<0?"income-decreasing-accrual":measure>0?"income-increasing-accrual":"zero-net-accrual"};
}

function ohlson(data: RecordValue): RecordValue {
  const assets=positive(data,"total_assets"), priceIndex=positive(data,"price_level_index"), liabilities=positive(data,"total_liabilities");
  const currentAssets=positive(data,"current_assets"), currentLiabilities=nonnegative(data,"current_liabilities");
  const netIncome=numberValue(data,"net_income"), priorIncome=numberValue(data,"prior_net_income"), chinDenominator=Math.abs(netIncome)+Math.abs(priorIncome);
  if (chinDenominator===0) throw new RangeError("current and prior net income cannot both be zero");
  const variables={size:Math.log(assets/priceIndex),tlta:liabilities/assets,wcta:numberValue(data,"working_capital")/assets,clca:currentLiabilities/currentAssets,oeneg:+(liabilities>assets),nita:netIncome/assets,futl:numberValue(data,"funds_from_operations")/liabilities,intwo:+(netIncome<0&&priorIncome<0),chin:(netIncome-priorIncome)/chinDenominator};
  const score=-1.32-.407*variables.size+6.03*variables.tlta-1.43*variables.wcta+.0757*variables.clca-1.72*variables.oeneg-2.37*variables.nita-1.83*variables.futl+.285*variables.intwo-.521*variables.chin;
  const probability=logistic(score);
  return {state:"calculated",method:"ohlson-1980-model-1",variables,o_score:score,logistic_probability:probability,screen:probability>.038?"above-original-cutoff":"below-original-cutoff",cutoff_probability:.038};
}

function zmijewski(data: RecordValue): RecordValue {
  const assets=positive(data,"total_assets"), liabilities=nonnegative(data,"total_liabilities"), currentLiabilities=positive(data,"current_liabilities");
  const variables={roa:numberValue(data,"net_income")/assets,leverage:liabilities/assets,current_ratio:numberValue(data,"current_assets")/currentLiabilities};
  const score=-4.336-4.513*variables.roa+5.679*variables.leverage+.004*variables.current_ratio, probability=normalCdf(score);
  return {state:"calculated",method:"zmijewski-1984-probit",variables,x_score:score,probit_probability:probability,screen:score>0?"distress-side":"non-distress-side",index_cutoff:0};
}

function springate(data: RecordValue): RecordValue {
  const assets=positive(data,"total_assets"), currentLiabilities=positive(data,"current_liabilities");
  const ratios={working_capital_to_assets:numberValue(data,"working_capital")/assets,ebit_to_assets:numberValue(data,"ebit")/assets,ebt_to_current_liabilities:numberValue(data,"ebt")/currentLiabilities,sales_to_assets:numberValue(data,"sales")/assets};
  const score=1.03*ratios.working_capital_to_assets+3.07*ratios.ebit_to_assets+.66*ratios.ebt_to_current_liabilities+.4*ratios.sales_to_assets;
  return {state:"calculated",method:"springate-1978-four-ratio",ratios,s_score:score,screen:score<.862?"distress-side":"non-distress-side",cutoff:.862};
}

function taffler(data: RecordValue): RecordValue {
  const currentLiabilities=positive(data,"current_liabilities"), liabilities=positive(data,"total_liabilities"), assets=positive(data,"total_assets"), dailyExpenses=positive(data,"daily_operating_expenses");
  const ratios={pbt_to_current_liabilities:numberValue(data,"profit_before_tax")/currentLiabilities,current_assets_to_total_liabilities:numberValue(data,"current_assets")/liabilities,current_liabilities_to_total_assets:currentLiabilities/assets,no_credit_interval_days:(numberValue(data,"quick_assets")-currentLiabilities)/dailyExpenses};
  const score=3.2+12.18*ratios.pbt_to_current_liabilities+2.5*ratios.current_assets_to_total_liabilities-10.68*ratios.current_liabilities_to_total_assets+.0289*ratios.no_credit_interval_days;
  return {state:"calculated",method:"taffler-1983-uk-industrial-transformed",ratios,z_score:score,screen:score<0?"distress-side":"non-distress-side",index_cutoff:0};
}

function fulmer(data: RecordValue): RecordValue {
  const assets=positive(data,"total_assets"), debt=positive(data,"total_debt"), equity=positive(data,"equity"), interest=positive(data,"interest_expense"), tangible=positive(data,"tangible_assets_usd_thousands"), ebit=numberValue(data,"ebit");
  if (ebit/interest<=0) throw new RangeError("EBIT/interest must be positive for the logarithm");
  const variables={retained_earnings_to_assets:numberValue(data,"retained_earnings")/assets,sales_to_assets:numberValue(data,"sales")/assets,ebt_to_equity:numberValue(data,"ebt")/equity,operating_cash_flow_to_debt:numberValue(data,"operating_cash_flow")/debt,debt_to_assets:debt/assets,current_liabilities_to_assets:numberValue(data,"current_liabilities")/assets,log10_tangible_assets_usd_thousands:Math.log10(tangible),working_capital_to_debt:numberValue(data,"working_capital")/debt,log10_ebit_interest:Math.log10(ebit/interest)};
  const score=5.528*variables.retained_earnings_to_assets+.212*variables.sales_to_assets+.073*variables.ebt_to_equity+1.270*variables.operating_cash_flow_to_debt-.120*variables.debt_to_assets+2.335*variables.current_liabilities_to_assets+.575*variables.log10_tangible_assets_usd_thousands+1.083*variables.working_capital_to_debt+.894*variables.log10_ebit_interest-6.075;
  return {state:"calculated",method:"fulmer-1984-small-firm-nine-factor",variables,h_score:score,screen:score<0?"distress-side":"non-distress-side",index_cutoff:0,scale_policy:"tangible assets expressed in USD thousands before log10"};
}

function grover(data: RecordValue): RecordValue {
  const assets=positive(data,"total_assets");
  const variables={working_capital_to_assets:numberValue(data,"working_capital")/assets,ebit_to_assets:numberValue(data,"ebit")/assets,roa:numberValue(data,"net_income")/assets};
  const score=1.650*variables.working_capital_to_assets+3.404*variables.ebit_to_assets-.016*variables.roa+.057;
  const zone=score<=-.02?"distress-zone":score>=.01?"non-distress-zone":"grey-zone";
  return {state:"calculated",method:"grover-2001-reported-reestimation",variables,g_score:score,zone,threshold_policy:"distress<=-0.02; grey=(-0.02,0.01); non-distress>=0.01"};
}

function noa(row: RecordValue): number {
  return numberValue(row,"total_assets")-numberValue(row,"cash")-numberValue(row,"investments_and_advances")+numberValue(row,"investments_at_equity")-numberValue(row,"total_liabilities")-numberValue(row,"preferred_stock");
}

function dechowF(data: RecordValue): RecordValue {
  const current=objectValue(data,"current"), prior=objectValue(data,"prior"), prior2=objectValue(data,"prior2");
  const avgAssets=(positive(current,"total_assets")+positive(prior,"total_assets"))/2;
  const priorAvgAssets=(positive(prior,"total_assets")+positive(prior2,"total_assets"))/2;
  const currentCashSales=numberValue(current,"sales")-(numberValue(current,"receivables")-numberValue(prior,"receivables"));
  const priorCashSales=numberValue(prior,"sales")-(numberValue(prior,"receivables")-numberValue(prior2,"receivables"));
  if (priorCashSales===0) throw new RangeError("prior cash sales must be nonzero");
  const variables={
    rsst_accruals:(noa(current)-noa(prior))/avgAssets,
    change_receivables:(numberValue(current,"receivables")-numberValue(prior,"receivables"))/avgAssets,
    change_inventory:(numberValue(current,"inventory")-numberValue(prior,"inventory"))/avgAssets,
    soft_assets:(numberValue(current,"total_assets")-numberValue(current,"net_ppe")-numberValue(current,"cash"))/numberValue(current,"total_assets"),
    change_cash_sales:currentCashSales/priorCashSales-1,
    change_roa:numberValue(current,"net_income")/avgAssets-numberValue(prior,"net_income")/priorAvgAssets,
    actual_issuance:+booleanValue(data,"issued_equity_or_long_term_debt"),
  };
  const logit=-7.893+.790*variables.rsst_accruals+2.518*variables.change_receivables+1.191*variables.change_inventory+1.979*variables.soft_assets+.171*variables.change_cash_sales-.932*variables.change_roa+1.029*variables.actual_issuance;
  const probability=logistic(logit), score=probability/.0037;
  const band=score<=1?"at-or-below-baseline":score<1.85?"above-baseline":score<2.45?"substantial":"high-screen";
  return {state:"calculated",method:"dechow-et-al-2011-model-1",variables,logit,misstatement_probability:probability,f_score:score,band,unconditional_probability:.0037};
}

function solve(matrix: number[][], vector: number[]): number[] {
  const n=vector.length, augmented=matrix.map((row,index)=>[...row,vector[index]]);
  for(let col=0;col<n;col++){
    let pivot=col;
    for(let row=col+1;row<n;row++) if(Math.abs(augmented[row][col])>Math.abs(augmented[pivot][col])) pivot=row;
    if(Math.abs(augmented[pivot][col])<1e-12) throw new RangeError("regression design matrix is singular");
    [augmented[col],augmented[pivot]]=[augmented[pivot],augmented[col]];
    const scale=augmented[col][col]; augmented[col]=augmented[col].map(value=>value/scale);
    for(let row=0;row<n;row++) if(row!==col){
      const factor=augmented[row][col];
      augmented[row]=augmented[row].map((left,index)=>left-factor*augmented[col][index]);
    }
  }
  return augmented.map(row=>row[row.length-1]);
}

function ols(x: number[][], y: number[]): [number[],number[]] {
  if(!x.length||x.length!==y.length) throw new RangeError("regression requires aligned observations");
  const width=x[0].length;
  if(x.length<=width||x.some(row=>row.length!==width)) throw new RangeError("regression requires more aligned observations than predictors");
  const xtx=Array.from({length:width},(_,i)=>Array.from({length:width},(_,j)=>x.reduce((total,row)=>total+row[i]*row[j],0)));
  const xty=Array.from({length:width},(_,i)=>x.reduce((total,row,index)=>total+row[i]*y[index],0));
  const beta=solve(xtx,xty);
  const residuals=y.map((target,index)=>target-beta.reduce((total,coefficient,j)=>total+coefficient*x[index][j],0));
  return [beta,residuals];
}

function dechowDichev(data: RecordValue): RecordValue {
  const raw=data.observations;
  if(!Array.isArray(raw)||raw.length<7||raw.some(row=>!row||typeof row!=="object"||Array.isArray(row))) throw new RangeError("observations must contain at least seven period records");
  const rows=raw as RecordValue[], cfo=rows.map(row=>numberValue(row,"cfo_scaled")), accruals=rows.map(row=>numberValue(row,"working_capital_accrual_scaled")), periods=rows.map(row=>String(row.period??""));
  if(periods.some(period=>!period)||new Set(periods).size!==periods.length) throw new RangeError("period labels must be unique and nonempty");
  const x=rows.slice(1,-1).map((_,offset)=>{const index=offset+1;return [1,cfo[index-1],cfo[index],cfo[index+1]];});
  const y=accruals.slice(1,-1), [beta,residuals]=ols(x,y), df=residuals.length-beta.length;
  const residualStd=Math.sqrt(residuals.reduce((total,value)=>total+value*value,0)/df), fitted=y.map((target,index)=>target-residuals[index]);
  return {state:"calculated",method:"dechow-dichev-2002-firm-specific",coefficients:{intercept:beta[0],cfo_t_minus_1:beta[1],cfo_t:beta[2],cfo_t_plus_1:beta[3]},estimation_periods:periods.slice(1,-1),fitted_accruals:fitted,residuals,accrual_quality:residualStd,interpretation:"higher residual dispersion means lower accrual quality",available_after_period:periods[periods.length-1]};
}

function modifiedJones(data: RecordValue): RecordValue {
  const raw=data.industry_year_sample, targetId=data.target_id;
  if(!Array.isArray(raw)||raw.length<5||raw.some(row=>!row||typeof row!=="object"||Array.isArray(row))) throw new RangeError("industry_year_sample must contain at least five records");
  if(typeof targetId!=="string"||!targetId) throw new TypeError("target_id must be a nonempty string");
  const rows=raw as RecordValue[], ids=rows.map(row=>row.entity_id);
  if(new Set(ids).size!==ids.length||!ids.includes(targetId)) throw new RangeError("entity IDs must be unique and include target_id");
  const design=(row:RecordValue):number[]=>{const priorAssets=positive(row,"prior_total_assets");return [1/priorAssets,(numberValue(row,"revenue_change")-numberValue(row,"receivables_change"))/priorAssets,numberValue(row,"net_ppe")/priorAssets];};
  const peers=rows.filter(row=>row.entity_id!==targetId), x=peers.map(design), y=peers.map(row=>numberValue(row,"total_accruals")/positive(row,"prior_total_assets"));
  const [beta,residuals]=ols(x,y), target=rows.find(row=>row.entity_id===targetId) as RecordValue, targetX=design(target);
  const scaledTotal=numberValue(target,"total_accruals")/positive(target,"prior_total_assets"), nondiscretionary=beta.reduce((total,coefficient,index)=>total+coefficient*targetX[index],0), discretionary=scaledTotal-nondiscretionary;
  return {state:"calculated",method:"modified-jones-1995-peer-estimation",target_id:targetId,estimation_count:peers.length,coefficients:{inverse_assets:beta[0],revenue_less_receivables:beta[1],net_ppe:beta[2]},peer_residuals:residuals,scaled_total_accruals:scaledTotal,nondiscretionary_accruals:nondiscretionary,discretionary_accruals:discretionary,absolute_discretionary_accruals:Math.abs(discretionary),interpretation:"signed residual; no universal manipulation cutoff"};
}

const calculators: Record<string,(data:RecordValue)=>RecordValue> = {
  "D18-F04-A01":altman,"D18-F04-A02":piotroski,"D18-F04-A03":beneish,"D18-F04-A04":sloan,
  "D18-F04-A05":ohlson,"D18-F04-A06":zmijewski,"D18-F04-A07":springate,"D18-F04-A08":taffler,
  "D18-F04-A09":fulmer,"D18-F04-A10":grover,"D18-F04-A11":dechowF,"D18-F04-A12":dechowDichev,"D18-F04-A13":modifiedJones,
};

export function calculate(topicId: string, data: RecordValue): RecordValue {
  if(!data||typeof data!=="object"||Array.isArray(data)) throw new TypeError("data must be an object");
  const calculator=calculators[topicId];
  if(!calculator) throw new RangeError(`unsupported topic_id: ${topicId}`);
  return calculator(data);
}

Playground

The embedded lab now expands to its full document height, keeping the article as the only scroll surface.

Full-height labplaygroundOpen full screen