RunMat
  • Pricing
RunMat
GitHub
GitHub
Sign inTry in browser
DesktopRuntimePhysicsCADAdministrationAgent

Get RunMat updates

New releases, guides and examples.

Product+
  • Runtime
  • GPU
  • Parallel
  • Compile
  • Interop and MEX
  • Simulation
  • MCAD
  • ECAD
  • Enterprise
  • AI integrations
  • Pricing
  • Download
Math+
  • Signal processing
  • Linear algebra
  • Statistics
  • Curve fitting
  • Differential equations
  • Control systems
  • Optimization
  • Finance
  • Data and tables
  • Plotting
Physics+
  • Simulation overview
  • Structural
  • Thermal
  • Electromagnetic
  • Joule heating
  • Thermal stress
  • Acoustics
  • Fluid flow
  • Conjugate heat transfer
  • Fluid–structure
  • What is FEA
Industries+
  • Aerospace
  • Automotive and transportation
  • Defense
  • Electronics and semiconductors
  • Energy
  • Industrial machinery
  • Life sciences
  • Quantitative finance
Learn+
  • Guides
  • Docs
  • Function reference
  • Language reference
  • Migration guide
  • Changelog
  • MATLAB Online
  • MATLAB AI agent
  • For students
Compare+
  • RunMat vs MATLAB
  • RunMat vs Ansys
  • RunMat vs SOLIDWORKS
  • RunMat vs Altium
  • RunMat vs Cadence
  • RunMat vs COMSOL
  • RunMat vs Python
  • RunMat vs Julia
  • RunMat vs Physics AI
  • RunMat vs Octave
  • Benchmarks
  • MATLAB alternatives
  • All comparisons
Company+
  • About
  • Blog
  • Contact
  • Source code↗
  • License
  • Privacy
  • Terms

Product

  • Runtime
  • GPU
  • Parallel
  • Compile
  • Interop and MEX
  • Simulation
  • MCAD
  • ECAD
  • Enterprise
  • AI integrations
  • Pricing
  • Download

Math

  • Signal processing
  • Linear algebra
  • Statistics
  • Curve fitting
  • Differential equations
  • Control systems
  • Optimization
  • Finance
  • Data and tables
  • Plotting

Physics

  • Simulation overview
  • Structural
  • Thermal
  • Electromagnetic
  • Joule heating
  • Thermal stress
  • Acoustics
  • Fluid flow
  • Conjugate heat transfer
  • Fluid–structure
  • What is FEA

Industries

  • Aerospace
  • Automotive and transportation
  • Defense
  • Electronics and semiconductors
  • Energy
  • Industrial machinery
  • Life sciences
  • Quantitative finance

Learn

  • Guides
  • Docs
  • Function reference
  • Language reference
  • Migration guide
  • Changelog
  • MATLAB Online
  • MATLAB AI agent
  • For students

Compare

  • RunMat vs MATLAB
  • RunMat vs Ansys
  • RunMat vs SOLIDWORKS
  • RunMat vs Altium
  • RunMat vs Cadence
  • RunMat vs COMSOL
  • RunMat vs Python
  • RunMat vs Julia
  • RunMat vs Physics AI
  • RunMat vs Octave
  • Benchmarks
  • MATLAB alternatives
  • All comparisons

Company

  • About
  • Blog
  • Contact
  • Source code↗
  • License
  • Privacy
  • Terms
GitHubXLinkedIn

© Dystr, Inc. · RunMat v0.7.1, Nov 17, 2026

RunMat® is a registered trademark of Dystr, Inc. MATLAB® is a registered trademark of The MathWorks, Inc. RunMat is not affiliated with, endorsed by, or sponsored by The MathWorks, Inc.

/
    • Solves and studies
    • Parallel and distributed execution
    • Evidence and artifacts
    • Results and trust
    • Simulation usage accounting
    • How each operation is counted
Docs>Physics>Run and results

How each operation is counted

This reference gives the exact operation counts behind simulation usage accounting, accounting version rsua-1: the primitive costs, the reference arithmetic for each solver and recovery kernel, and where each counted batch begins and ends. Auditors and anyone reproducing a usage receipt use these schedules; the user page covers what is charged and how.

Measurement uses defined algorithmic operation counts, not physical instruction counters or a conversion from elapsed time. Counters retain exact integer operation totals; displayed decimal GFLOP are a presentation of those totals, not rounded values used to settle usage.

OCCT CAD preparation and tessellation are excluded from rsua-1. They consume computing resources but do not consume the simulation allowance. Numerical meshing, assembly and solver work outside that OCCT boundary follows the counting rules below.

Basic counting convention

OperationMeasured operations
Real floating-point addition, subtraction, multiplication or division1 each
Fused multiply-add2
Real square root or transcendental-function evaluation1 per scalar evaluation
Complex arithmeticThe constituent real operations in the specified algorithm
Vector, SIMD or GPU arithmeticThe defined operations for each active numerical element

Single and double precision use the same convention. Parallel execution and instruction fusion do not add charges. Different algorithms or different numbers of iterations can perform different amounts of numerical work on the same model.

The square-root and transcendental rule counts one evaluation in the reference algorithm, not the arithmetic instructions inside a library implementation. It applies to real square root, exponential, logarithmic, power, trigonometric, inverse trigonometric, hyperbolic and inverse hyperbolic functions. For example, each real sqrt(x), exp(x), log(x), pow(x,y) or atan2(y,x) evaluation counts once. A complex function follows its specified real decomposition; it is not counted again on top of those constituent operations. Integer powers implemented by a reference multiplication sequence count that sequence instead of an additional power call. Real absolute values, sign changes and comparisons contribute zero. Backend approximations, range reduction and instruction lowering do not change these reference counts.

Real hypot(x,y) also counts one reference evaluation. Complex multiplication uses four real multiplications and two additions (6). General complex division uses a three-operation denominator, two three-operation numerators and two real divisions (11). Complex reciprocal uses that denominator and two divisions (5). A complex multiply followed by complex subtraction counts 8. A magnitude uses one hypot evaluation when the imaginary component is nonzero; the real-only absolute-value path contributes zero.

The reference three-dimensional orientation determinant uses nine coordinate differences, six cross-product multiplications, three cross-product subtractions, three final multiplications and two accumulation additions: 23 operations per evaluation. Adaptive-precision predicates implement this logical determinant with additional precision when needed; their expansion arithmetic is backend machinery, not additional reference work. Coordinate normalization and other numerical work surrounding the determinant have their own counts. Predicate admission precedes the evaluation, and failed geometry paths retain the completed reference prefix.

For a real dot product of positive length n, the direct product-and-sum algorithm performs n multiplications and n - 1 additions: 2n - 1 operations. A backend's instruction sequence does not change that reference count. An empty dot product has zero arithmetic operations under this convention.

A direct complex dot product of length n > 0 counts six real operations per complex product and two per subsequent complex addition: 8n − 2. Sparse matrix-vector multiplication sums these row-dot counts over stored entries. An empty row contributes zero; an explicitly stored zero still participates in the row's reference arithmetic. Counts are the same for Single and Double. The metered CSR operator quotes its immutable row pattern once and reserves the count before each application. A refused reservation leaves the output unchanged.

Integer arithmetic, comparisons, memory movement, communication and waiting are not floating-point operations and are unmetered. This deliberately leaves some meshing work uncharged; no arbitrary conversion weight is assigned to it.

Numerical-operation schedule

RunMat applies reference counting at these numerical boundaries:

  • Meshing: numerical geometry operations, including their special-function rules.
  • Assembly: element formulation, integration work and matrix/vector accumulation.
  • Direct solvers: actual symbolic structure/fill and the reference factorization and triangular-solve arithmetic; a generic dense n-cubed estimate is insufficient.
  • Iterative solvers: executed matrix/vector operations, preconditioning, reductions and completed iterations.
  • Nonlinear and transient analyses: constituent numerical work across iterations and time steps, without charging it again at enclosing study levels.
  • External libraries: documented reference counts with the same precision and fusion conventions, or an explicit exclusion such as OCCT preparation and tessellation in rsua-1.

The primitive costs above apply within these stages. The following sections describe the measured batches and explicit exclusions in rsua-1.

Before synchronous topology preparation, RunMat requests capacity from a checked upper bound derived from the mesh and the same reference schedule as the kernels. The kernels record the work they complete. Unused preparation capacity does not consume the simulation allowance.

Sparse LLT and LDLT reference arithmetic

For a column of an LLT factor with p stored entries below its diagonal, the right-looking reference divides those p entries by the diagonal and updates the lower triangle of their outer product. Its basic real arithmetic count is p² + 2p. For Hermitian complex factors the count is 4p² + 2p: division by the real diagonal costs 2p, diagonal updates cost 4p and off-diagonal updates cost 4p(p − 1). Each column also invokes one real square root, adding one operation to either column total. The total factorization count is p² + 2p + 1 per real column or 4p² + 2p + 1 per Hermitian complex column.

Forward and backward substitution together cost 4p + 2 real operations per column and right-hand side, or 16p + 4 for a Hermitian complex factor. Reusing a factor for k right-hand sides counts k substitutions without repeating its factorization. Column sizes come from the stored symbolic fill, including the lower-triangular blocks and trailing patterns of supernodes. Counts use checked integers rather than the solver's floating-point performance estimate.

The LDLT reference retains the pre-division column when applying each trailing update. Its factorization has the same basic arithmetic as LLT and no square roots: p² + 2p per real column or 4p² + 2p per Hermitian complex column. Its unit-diagonal triangular substitutions and separate real-diagonal solve cost 4p + 1 operations per real column and right-hand side, or 16p + 2 for Hermitian complex values. Pivoting block factorizations require their own reference schedules; these formulas do not describe Bunch–Kaufman or LU.

For rsua-1 in RunMat 0.7.0, faer's sparse LU and sparse Bunch–Kaufman numeric factorization, refactorization and substitution kernels are explicitly excluded from the simulation operation count. Pivot choices and their resulting work do not have an approved exact reference schedule. The solver classifies these two kernels by factor kind before admitting a numerical batch; an unsupported or future kind cannot silently become measured zero. Their solutions remain available in a measured FEA run. Residual construction, norms, correction updates, assembly and other independently measured work in the same run still consume allowance. The hand-written small dense LU kernel has its own reference batches and is not part of this sparse-library exclusion.

Modal and buckling eigen kernels are also excluded from rsua-1 in 0.7.0: faer's dense symmetric eigen-decomposition and the outer Lanczos/LOBPCG, shift-selection, Ritz, inertia and eigenpair postprocessing algorithms do not have complete approved reference schedules. This exclusion applies to those eigen kernels, not to separately metered sparse matrix applications, vector operations, preconditioners or LLT/LDLT direct solves they invoke. The excluded kernels consume computing resources without consuming simulation allowance.

An LLT or LDLT numeric factorization, refactorization or substitution is one reference batch. The solver reserves its count before numeric allocation or changes to the right-hand side, then records it when that batch succeeds. A refused batch leaves the factor and right-hand side unchanged. A factorization that fails before producing a factor does not complete that batch; earlier completed batches retain their counts. Cancellation observed after a batch completes does not erase its work. These boundaries apply to admitted simulation work; ordinary math execution without a simulation ledger needs no spending grant.

Iterative solver reference arithmetic

PCG, GMRES, MINRES and BiCGStab charge the batches they execute. An early convergence or rejected proposal does not charge later iterations. Matrix applications and preconditioner applications retain their own owners; the recurrence does not add their counts again.

For vectors of positive length n, the common reference batches are:

BatchReal operationsComplex operations
Dot product2n − 18n − 2
Euclidean norm, including square root2n4n
Multiply by a real scalarn2n
Add a real-scaled vector2n4n
Add a scalar-scaled vector2n8n
Form rhs − productn2n
Divide by a positive real normn2n
Update solution and residual with a real step4n8n
Gram–Schmidt projection against k retained vectorsk(4n − 1)k(16n − 2)

Empty vectors and empty projection sets contribute zero. Scalar recurrence work is counted separately when its branch executes. A zero-denominator Anderson proposal, for example, completes its residual difference and two dots but performs no coefficient division or proposed-image update. Its real reference totals are 5n − 2 before division, 5n − 1 after division, and 8n − 1 when the image update completes.

Preconditioner setup and application are separate work: reusing a Jacobi, ILU or AMG setup does not charge that setup again. A V-cycle counts the operations in its retained hierarchy and selected sweeps; unused maximum iteration counts are neither reserved nor charged as completed work.

Structural result recovery

Result recovery counts new numerical work even when it uses an existing solution. Copying the solution into a field or reading a completed field does not consume operations. Diagnostic summaries reuse the completed strain field; they do not repeat element recovery.

The reference recovery kernels use these schedules:

KernelReference operations
Tet4 strain projectionSix length-12 dot products: 138
Tet4 integration-point volume scaling1
Symmetric stress tensor from strain and retained Lamé parameters17 per tensor
Three-dimensional von Mises stress17 per tensor
Strain-energy density from a strain/stress pair12 per tensor
Tet10 extrapolation from four integration points to ten nodes217 per element
Volume-weighted tensor accumulation13 per contributing element node
Region tensor normalization6 per node-region pair
Comparing two recovered region tensors by von Mises stress34 per comparison

Geometry, material parameters and quadrature have their own primitive batches; the recovery schedules do not charge those primitives again. Curved Tet10 geometry uses its selected adaptive validation stages before the fixed recovery points. Thermal energy integration counts each selected quadrature rule, including additional rules used for convergence. It does not reserve or charge an unused maximum-order rule.

These are numerical-kernel schedules. Input and constitutive invariant checks, field-shape checks, attribution and diagnostic formatting are outside these reference batches. Their implementation details do not change the charge.

Structural transient integration

Average-acceleration Newmark integration counts each predictor, completed state and correction when it executes. For n displacement degrees of freedom:

BatchReal operations
Displacement and velocity predictor, including time-step coefficients6n + 5
Complete displacement and velocity from the solved acceleration4n + 3
Apply an acceleration correction to displacement, velocity and acceleration5n + 3
Form initial acceleration RHS load − damping − elastic2n
Form an equilibrium residual from load and three force vectors3n
Form a displacement incrementn
Average two load, velocity or reaction vectors2n

Mass, damping and stiffness applications use the CSR row-dot schedule above. Effective-operator construction counts its executed coefficient scaling and accumulation. Linear factorization, substitutions and iterative corrections keep their solver counts; integration does not charge those operations again.

Dynamic-balance histories count the matrix applications, dot products, norms, energy calculations and work increments needed to produce each snapshot. A recovered history counts numerical reconstruction it performs. Reading an already computed snapshot consumes no additional operations.

Constraint projection counts two real operations per retained recovery coefficient. Expansion counts the reference coefficient products and sums plus the affine offsets that it applies. Fixed-DOF selection and vector copies have no floating-point arithmetic charge. Input validation remains outside these numerical batches.

On this page
  • Basic counting convention
  • Numerical-operation schedule
  • Sparse LLT and LDLT reference arithmetic
  • Iterative solver reference arithmetic
  • Structural result recovery
  • Structural transient integration