Broadcasting element-wise engine for cv::Mat (+ cv::texpr) (#29426)

* experimental new arithmetics; work-in-progress

* continue working on new-gen arithmetic expressions

* * improved performance of the new add on small arrays
* added sub
* extended tests

* fixed potential bug when adding multi-channel array and a single-channel scalar

* improved const handling

* * added copyMask
* added mul/dev (without scale so far)

* * accelerated mul
* addedd scale to mul and div

* * done substantial refactoring; however a few more rounds of refactoring are ahead.
* added min, max, absdiff, addweighted.

* improved performance of the new arithmetic functions, but some of them are still slow, e.g. operations with mask have some bugs (that affect speed, not accuracy).

* * further (significantly) accelerated several functions, especially on small arrays: mul, binary ops with mask

* further polished the new arithmetic engine

* started integration of the new element-wise arithmetic engine into core

* big step forward. We now use the new engine inside cv::add, subtract, multiply, divide, absdiff, min and max.

* big progress:
* added bitwise operations
* fixed and accelerated compare
* ported regression tests to test new broadcasting behaviour of arithmetic functions

* lot's of improvements in compare, divide, addWeighted!

* lot's of small and big performance improvements in the new arithmetics

* * some more optimizations; parsing texpr-expressions is now faster as well

* port new_arithm to Linux/x86: dispatch guards, scalar-Mat compat fallback, dnn shape-contract fixes

Core:
- arithm.simd.hpp: CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY guards (the file is included
  once per dispatched mode on x86), vx_load_expand instead of the 128-bit v_load_expand,
  VTraits::vlanes() instead of ::nlanes
- arithm.cpp/precomp.hpp: compat fallback for scalar-like Mat operands (1x1, 1xcn/cnx1,
  4x1 CV_64F - java/python tuples, operator-(Mat, Matx)): treated as a per-channel scalar
  ONLY when the shapes are not broadcast-compatible, so every valid numpy-style broadcast
  keeps its meaning and calls that would otherwise throw get the 4.x semantics

DNN (fallout of the stricter shape semantics, found by the new engine):
- dict.hpp: DictValue relied on fresh AutoBuffer having size()==fixed_size; allocate explicitly
- batch_norm: weights_/bias_ are 1-D [n] now; 0/1-D forward runs on exact-shape 1-D views
- net_impl2: extend the post-forward sanity check to non-temp outputs - a layer that
  reallocates its preallocated output tensor now fails loudly instead of silently
  detaching the result from the graph
- LSTM/LSTM2 batchwise (layout=1): getMemoryShapes now matches what forward() writes
  (ONNX: Y=(batch,seq,dirs,hid), Yh/Yc=(batch,dirs,hid)); forward assembles seq-major
  results in a local buffer and transposes INTO the preallocated outputs in place

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* u8/s8 multiply: exact integer SIMD path on non-FP16 builds (3-10x vs 5.x)

The unit-scale branch of vecBinaryKernel already supported a separate work-vector
type Wvec1 (used by the ARM f16 build and by u16/s16 everywhere), but on x86 the
u8/s8 same-type multiply still went through the f32 hub. Route it through
v_uint16/v_int16: products of 8-bit values fit exactly (255^2 < 2^16), the
saturating pack on store gives bit-exact results at half the vector traffic.

Also fix a latent kernel bug this exposed: the unit-scale branch stepped by
Wvec's lane count while loading/storing Wvec1 vectors. All previous Wvec1
instantiations had equal lane counts, but u8's v_uint16 has 2x the lanes of
v_float32 - the pairs overlapped (50% redundant work) and the tail backoff
could write VECSZ bytes past the row end. The branch now derives its step,
offsets and tail condition from Wvec1 itself.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* vecBinaryKernel: constexpr Op::useScalar instead of a runtime-only scale check

Every binary op functor now declares whether it consumes the scale scalar
(params[0]): true only for mul and the two div variants. Ops that ignore it
(add/sub/min/max/absdiff) take the fast 2-arg branch unconditionally - the
'scalar == 1' check used to fail for them (their params[0] is 0), sending them
through the preproc branch, and the condition now folds at compile time.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* restore cv::hal::mul8u as a wrapper over the element-wise engine

The symbol is still declared in core/hal/hal.hpp and called directly by external
code (the G-API fluid backend in opencv_contrib), but its implementation went
away with the old arithm kernels. Forward it to getMulFunc(CV_8U, CV_8U) - with
scale==1 it lands on the new exact integer SIMD path.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* silence every new-arithm warning reported by CI (ARM64/Mac) and gcc 15

- arithm.cpp: bitwise_op_ocl and the actualScalarDepth/coerceTypes helpers are
  consumed only by the OpenCL paths - guard them with HAVE_OPENCL; haveScalar in
  cv::compare is read only inside CV_OCL_RUN - CV_UNUSED for OpenCL-less builds
- arithm_expr.hpp: declare getBitwiseFunc/getNotFunc/getAddWeightedFunc next to
  the other per-op entry points (-Wmissing-prototypes in arithm.dispatch.cpp)
- arithm.simd.hpp: define CV_SIMD_16F to 0 when FP16 SIMD is absent (-Wundef);
  {}-init the expandScalar staging buffers (-Wmaybe-uninitialized: they are
  fully written before use, but the compiler cannot prove it with runtime
  vector widths); rename the compare kernel's lambda parameter (-Wshadow)
- arithm_expr.cpp: rename the exec tile-lambda's hot-field locals that shadowed
  TExpr members and outer locals (-Wshadow)
- test_new_arithm_extensive.cpp: rename the name-generator lambdas' parameter
  shadowing the INSTANTIATE macro's own (-Wshadow), drop an unused variable

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* restore 4.x scalar semantics for the bindings' 4x1 CV_64F Scalar columns

The python/java bindings materialize numbers and tuples as a 2-D 4x1 CV_64F
Mat - or UMat, when the call carries UMat arguments. Three CI-reported python
failures came from those pseudo-scalars reaching the engine as arrays:

- absdiff(int_arr, 0): the (4,1) column is broadcast-COMPATIBLE with a 1-D
  array, so numpy semantics silently won - an outer-product f64 result instead
  of the int per-channel-scalar one;
- subtract(u8 4x8x4, (40,)): same, by the rows==4 coincidence;
- multiply(UMat, 2., dst=UMat): the scalar arrives as a UMAT, which the
  scalar detection did not recognize at all.

isScalarArg now treats the exact bindings shape - 2-D 4x1 CV_64F single-channel
Mat/UMat against a <=4-channel array - as a scalar UNCONDITIONALLY (a 1-D [4]
array has dims==1 and still broadcasts). One exception, decided in arithm_op:
when the partner is itself a tiny scalar-shaped array, both are honest data and
ride the broadcast (compare(Mat 4x1, Mat 1x1) - issue #8999 - stays elementwise).

Small-array discipline, this all runs per engine call: the probes read Mat/UMat
fields directly (rows == 4 alone rejects almost everything, no _InputArray
getter dispatch), and a UMAT scalar's 32 bytes are copied into a caller-stack
buffer - no heap, no getMat mapping. Measured: no latency change on 4x4/16x16
element-wise calls.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* cv::texpr: std::string_view -> const std::string& in the public API

string_view in an exported signature breaks some CUDA toolchain builds, and for
short expression strings the difference is immaterial (SSO, parsed once). The
parser internals keep string_view - the argument converts implicitly. Also drop
the now-unused <string_view> include from cvstd.hpp, so the header does not
reach every nvcc TU.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* compare boundary-rewrite: fixed 4-slot kind/bound arrays instead of AutoBuffers

A CONST operand is capped at 4 channels (addConst), so the per-channel
kind/bound staging needs no dynamic buffers - plain int[4]/double[4], with a
CV_Assert on the contract. This is also what gcc's -Wmaybe-uninitialized was
flagging (it could not see the AutoBuffer's inline storage get filled).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* element-wise engine: unary math kernels (sqrt/exp/log/sin/cos/tanh/erf/relu) + select

New dispatched pair math.simd.hpp / math.dispatch.cpp - the unary/ternary sibling
of arithm.simd.hpp:

- vecUnaryKernel: T -> T over f16/bf16/f32/f64 on top of the intrin_math
  primitives (v_exp/v_log/v_sin/v_cos/v_sqrt/v_erf/v_max). f32/f64 compute
  natively, f16/bf16 ride the f32 hub inside the kernel (vx_load_pair_as /
  v_store_pair_as) - no materialized casts. Continuity collapse + the halide
  right-edge backoff, suppressed in-place (it would re-apply Op to
  already-written values). tanh = (e^2x-1)/(e^2x+1) with the input clamped to
  +/-10 (f32) / +/-20 (f64) - unclamped saturation hits inf/inf = NaN. erf has
  no f64 SIMD primitive: std::erf per lane.
- selectKernel(mask, x, y): 1-byte mask expanded to lane width and tested
  against zero in the INTEGER domain (immune to DAZ/FTZ), branches of any
  depth by element size, broadcast branches supported.
- emitUnary: math over a float input is T -> T now (f16 in -> f16 out, native
  kernel when input and result depths match); integer inputs still compute in
  the float domain and land in f32.
- emitTernary/select: literal branches are typed via typedConstFrom (an
  OP_CAST of a depth-less flex const crashed); a non-1-byte mask is normalized
  by an explicit "mask != 0" compare, never a value cast.

texpr already parsed the function names - they now execute. Tests: per-depth
accuracy of all 8 ops against the double std:: reference, integer input,
in-place, select over 4 depths / const branch / float mask.

Perf vs the classic kernels (1920x1080 f32, 16 threads, AVX2): exp 3.7x,
log 2.6x, sqrt 5.7x faster; polarToCart expressed as (r*cos(a), r*sin(a)) 4.0x.
Accuracy improves too (max rel err vs f64 reference): exp 8.1e-8 vs 2.1e-7,
log 8.0e-8 vs 1.5e-7.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* engine: OP_COPY_MASK folded into OP_SELECT; selectKernel moved to arithm.simd.hpp

copyMask(dst, mask, src) is select(mask, src, dst) - one masking primitive
instead of two. The compiler emits the masked-op tail as
addInsn(OP_SELECT, mask, r, out, out): the output slot rides as both arg2 and
the result, so unmasked elements are preserved by reading them back through
the b-branch. OP_COPY_MASK, copyMaskKernel and getCopyMaskFunc are gone.

selectKernel (moved from math.simd.hpp to arithm.simd.hpp) inherits every
copyMaskKernel optimization:
- the interleaved multichannel fast path (2..4 channels under a per-pixel
  mask: expand the mask once per VECSZ rows, v_store_interleave across lanes);
- the per-row scalar path with the row-skip when the selected source row IS
  dst (the "leave the output untouched" half of copyMask);
- plus the select-specific ones: branch broadcasts (stepx == 0) and the
  right-edge tail backoff under dst-aliases-a-branch - safe because re-running
  select over already-blended elements is idempotent; only dst == mask keeps
  the backoff off (the store would rewrite mask bytes before the re-read).

Masked-add perf is on par with the old copyMask (1280x720, 1 thread: 8UC3
204 -> 198 us, 32FC3 1395 -> 1344, 8UC1/32FC1 within noise). Full core suite
24117 green.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* engine: dedicated vectorized pow kernel (moved from arithm to math.simd.hpp)

pow was the last scalar-only binary op (scalarBinaryKernel + std::pow, f32/f64
only). The new powKernel keeps exact std::pow semantics and is T x T -> T over
all four float depths (f16/bf16 via the f32 hub):

- scalar exponent (the dominant call shape - texpr literals ride as 0-dim
  broadcast consts) is dispatched PER ROW to the special cases:
  y==2 -> x*x, y==3 -> x*x*x, y==0.5 -> v_sqrt, y==1 -> copy, y==0 -> fill 1;
- everything else - including a per-element exponent array - runs the general
  vectorized exp(y * log(x)) path, valid for x > 0; a vector pair containing
  any x <= 0 lane falls back to scalar std::pow for that pair (v_check_any),
  which preserves every std::pow subtlety: signed results for integer y on
  negative bases, NaN for fractional y, the x == 0 family;
- no right-edge tail backoff: pow is not idempotent, in-place calls finish
  rows in the scalar tail.

Perf vs the classic cv::pow (1920x1080 f32, 16 threads, AVX2): p=2 1.4x
(classic special-cases it too), p=3 6.1x, p=0.5 6.3x, fractional p 4.5x with
slightly better accuracy (6.1e-7 vs 7.4e-7 max rel err). Tests: exponent
sweep 2/3/0.5/1/0/2.5/-1.5 vs the double std::pow reference on f32/f64,
negative bases (exact signed cubes, NaN for fractional), array exponent.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* powKernel: halide right-edge tail backoff in every SIMD loop

Same shape as vecBinaryKernel: the final partial vector re-processes
[width - VECSZ*2, width) instead of finishing scalar, suppressed when dst
aliases an input (pow is not idempotent - the overlap region must be
recomputed from an untouched source, which the no-alias case guarantees).

Modest measured win (~2% on ROI rows for the special-cased exponents; the
general path tail was already cheap - modern libm powf is fast), no
regressions; mainly aligns the kernel with the house style, where every
SIMD loop ends vector-wide.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix MSVC 2019 C2975: function-local constexpr as a template argument inside a lambda

MSVC 2019 loses the constexpr-ness of function-local constants (LOCAL_OPS,
MAX_DIMS, ...) when they are used as template arguments inside a lambda body
(AutoBuffer<Slice, LOCAL_OPS> / std::array<int, MAX_DIMS> in the parallel
bodies of BroadcastOp::run and TExpr::exec). Hoist them to namespace scope -
no behavior change.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ocl_arithm_op: route 16U multiply to the CPU engine on Apple OpenCL

The Apple OpenCL driver miscompiles the 16U multiply kernel: products near
the top of the u16 range come back wrapped instead of saturated (CPU vs GPU
NORM_INF up to 65535 in OCL_Arithm/Mul.Mat CV_16U cases). The same arithm.cl
kernel is correct on Intel NEO and NVIDIA drivers - verified not to reproduce
on Linux/Intel iGPU - so gate the decline to __APPLE__ only; the CPU engine
computes 16u multiply exactly (integer SIMD path).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* engine: neg/abs as compositions, clamp kernel, ** and ?: operators, abs(a-b) peephole

- OP_NEG and OP_ABS need no kernels: neg = sub(0, a), abs = absdiff(a, 0) -
  including the engine absdiff auto-type rule (signed |a| lands in the
  UNSIGNED type of the same width: |SHRT_MIN| fits u16 exactly instead of
  saturating; NB the public cv::absdiff auto depth keeps the source type for
  4.x compatibility - values agree, the depth rule is the engine own).
- peephole: abs(x - y) rewrites to absdiff(x, y) ALWAYS. On integers the
  literal semantics differ (the subtract saturates first: u8 gives
  max(x-y, 0)), but whoever writes abs(a - b) means absdiff - we deliberately
  hand out the useful semantics instead of the saturation artifact. The just-
  emitted OP_SUB is retired via the moveToOutput manoeuvre, so the program
  shrinks to the single absdiff instruction. abs(x), abs(x - 0) and
  absdiff(x, 0) all give one result.
- OP_CLAMP kernel (arithm.simd.hpp): v_min(v_max(x, lo), hi) over
  u8/s8/u16/s16/u32/s32/f32 (+f64 with 64-bit SIMD), scalar f16/bf16/64-bit
  ints; lo/hi may broadcast (the common clamp(img, a, b) shape) or be full
  arrays; the tail backoff stays on under dst-aliases-x (clamp is idempotent).
  emitTernary types literal bounds via typedConstFrom (same flex-const crash
  select had) and keeps the auto result type pinned to x.
- parser: "a ** b" == pow(a, b), precedence above * /, RIGHT-associative
  (a ** 2 ** 3 == a ** 8); "cond ? a : b" == select(cond, a, b), precedence
  below everything, right-associative chains (f1 ? a : f2 ? b : c) work
  without parentheses. parseTernary() is the expression entry point now.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* cv::exp/log/sqrt on the engine via math_op; hal functions wrapped as engine kernels

math_op is the master function of the unary math family (the arithm_op
analogue): same-shape same-type output over f16/bf16/f32/f64 (classic
exp/log accepted f32/f64 only - the half floats are new), two tiers:
- small (<= 100000 elements) and continuous: call the kernel DIRECTLY over
  the flattened data - no TExpr, no broadcastOp, no parallel_for setup;
- everything else: the usual single-instruction program via compile()/exec()
  (parallelism for large arrays, real steps for ROIs).

getMathFunc routes OP_EXP/OP_LOG at f32/f64 through the full cv::hal stack -
an external vendor HAL (CALL_HAL), IPP, or the built-in table kernels,
whichever is installed - by wrapping hal::exp32f/exp64f/log32f/log64f as
engine kernels with the function pointer in TKernel::userdata, the same
mechanism castKernel uses for core BinaryFuncs. The engine adds tiling and
parallelism on top, so every tier gets the best available scalar-span
implementation. v_exp/v_log remain for f16/bf16 (the f32 hub) and the ops
hal has no entry points for.

v_log_default_32f: the degree-8 polynomial is evaluated by Estrin pairing
(4 dependent levels) instead of an 8-FMA Horner chain (~5% on the f16 hub
path). An exp64 Taylor-without-division rewrite was tried and benched SLOWER
than the Cephes Pade scheme (the evaluation is FMA-throughput-bound, and
vdivpd pipelines well enough) - reverted; a table-based reduction is the only
way further there.

cv::exp f32 (16 threads, AVX2+IPP build), old -> new: 640 elements
0.16 -> 0.15 us, 16k 2.79 -> 2.49, 640x480 47 -> 20, 1920x1080 452 -> 60 us
(the old CPU loops were single-threaded); f64 exp 1080p 1295 -> 161 us.
No size regresses; small arrays now run at installed-HAL speed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* getMathFunc: IPP tier + raw-HAL probing; the exp/log table kernels are deleted

The raw cv_hal_* entry points return int for a reason: without an installed
HAL they are stubs returning CV_HAL_ERROR_NOT_IMPLEMENTED. getMathFunc now
selects the exp/log implementation in three tiers:
 1. HAVE_IPP && ipp::useIPP(): ippsExp/ippsLn through thin int adapters (IPP
    is not routed through the cv_hal_ hooks, so it needs its own tier);
 2. the raw cv_hal_exp32f/... hook, PROBED once with a 1-element call on the
    safe input 1.0 (cached in magic statics): implemented -> wrapped as an
    engine kernel with the function pointer in TKernel::userdata;
 3. the engine own v_exp/v_log kernels.
Whichever wins, the engine adds tiling and parallelism on top.

The EXPTAB/LOGTAB table kernels and their tables (~790 lines in
mathfuncs_core.simd.hpp + mathfuncs.cpp) are DELETED: they benched within
~15% of v_exp/v_log, not worth a second implementation. The public
cv::hal::exp32f/exp64f/log32f/log64f keep their contract - CALL_HAL, then
IPP, then the built-in implementation - but the built-in is now the engine
vector kernel via ew::mathSpanEngine (one contiguous span, exported from
math.dispatch.cpp).

All unary math kernels (vec/scalar/hal wrappers, pow) also handle the
vertical-broadcast tile (s0y == 0, a row expanded into a matrix): the first
row is computed, the rest are memcpy of it - transcendentals cost far more
than a row copy.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* texpr: hypot(x, y) binary op (alias: mag)

hypot = sqrt(x^2 + y^2), NAIVE like cv::magnitude (not the overflow-safe
std::hypot), computed in the float work type; kernels for the four float
depths only (T x T -> T; integer inputs ride the usual f32-compute + cast).
A 10-line EwHypot functor on top of vecBinaryKernel in arithm.simd.hpp -
broadcast branches, continuity collapse and the tail backoff come for free.
Registered in the parser as both "hypot" (the C/numpy name) and "mag" (the
cv::magnitude-flavored alias). A building block for the future cartToPolar.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* texpr: atan2(y, x) binary op - radians, standard C range

v_atan2 (arithm.simd.hpp, generic over the universal-intrinsic float vector):
the fastAtan2 minimax polynomial from mathfuncs_core v_atan_f32 reworked to
plain radians - the 180/pi factor dropped from the coefficients and the C
quadrant logic instead of the [0, 360) wrap, so the result matches std::atan2
over (-pi, pi]. Measured absolute accuracy ~1.6e-4 rad. (v_atan_f32 itself is
untouched - cv::phase/fastAtan2 keep their degree semantics.)

EwAtan2 rides vecBinaryKernel: f16/bf16/f32 through v_atan2 (the f32 hub),
f64 through exact scalar std::atan2. arg0 = y, arg1 = x, like std::atan2;
float depths only, same emitBinary policy as pow/hypot. Parser name "atan2".
Together with hypot this completes the cartToPolar building blocks.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix the RISC-V RVV build and two ARM64 warnings

The new f64 kernel registrations (hypot, pow, the unary math family) gate on
CV_SIMD_64F || CV_SIMD_SCALABLE_64F, but the vx_setall_as(const double*,
v_float64&) helper family in arithm.simd.hpp was still CV_SIMD_64F-only -
scalable platforms (RVV) have v_float64 with CV_SIMD_64F == 0, so
vecBinaryKernel<double, ...> failed to instantiate there. Widen the helper
gate to match (verified with a riscv64 rv64gcv cross-build of opencv_core -
the engine f64 paths now vectorize on RVV instead of not compiling).

cv::exp/cv::log: the depth local is consumed by CV_OCL_RUN only - CV_UNUSED
for OpenCL-less builds (ARM64 -Wunused-variable).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* silence the remaining ARM64 gcc warnings

- compare boundary-rewrite: {}-init the fixed kind/bound arrays (filled for
  every channel used below, but gcc cannot prove it across the cn <= 4 loop);
- cv::exp/log: [[maybe_unused]] on the depth local (consumed by CV_OCL_RUN
  only), instead of the CV_UNUSED idiom;
- AutoBuffer::reserve: a targeted -Wmaybe-uninitialized suppression around
  the live-element copy loop - only [0, sz) is read, all written before, but
  gcc inlining a grow-from-inline-storage chain cannot see that. An
  annotation for the analyzer, no behavior change.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* saturating 32-bit add/sub kernels; cv::texpr python binding; two CI warnings

- v_add_sat/v_sub_sat for v_int32/v_uint32, local to arithm.simd.hpp for now
  (the plan is to grow them into proper universal intrinsics later): NEON
  single-instruction vqadd/vqsub, elsewhere the Hacker Delight bit tricks
  over universal intrinsics (u32 add is 2 ops: or with the wrapped-compare
  mask). EwAdd/EwSub overload vec() for the 32-bit lanes and getAddSubFunc
  routes 32S/32U T->T through vecBinaryKernel instead of the former pure
  scalar kernel. Semantics unchanged - the scalar int64 tail already
  saturated; directed boundary tests added (both rails, 0 - INT_MIN, u32
  cases, a full-range random block vs an exact int64 reference).
  640x480 32S add: 0.48x of 5.x -> parity (memory-bound); 1080p: 6-8x.

- cv::texpr becomes CV_EXPORTS_W: python gets cv.texpr(expr, [inputs]) ->
  tuple of ndarrays, so `res, = cv.texpr(...)` and `mag, ang = cv.texpr(...)`
  unpacking both work. modules/python/test/test_expr.py covers arithmetic,
  the fused abs(a-b), casts, broadcasting, ?: and ** operators, math
  functions vs numpy, clamp, named temporaries, tuple outputs, the one-line
  cartToPolar and the int32 saturation cases.

- warnings: {}-init the parser args array (gcc -Wmaybe-uninitialized on
  Ubuntu 20/22); the compare short-row block gates sizeof(T) <= 4 as
  constexpr so the f64 instantiation does not leave set-but-unused locals
  (gcc 9 -Wunused-but-set-variable).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* arithm_op: direct-kernel fast path for small continuous arrays

Building and compiling the 1-instruction program plus the BroadcastOp setup
costs ~40-250ns per call - negligible on big images, dominant at 127x61-class
sizes where the classic 5.x functions were 1.3-2x faster. Mirror math_op two
tiers in arithm_op: two same-type same-shape continuous arrays, no mask, no
scalar, result depth == input depth, <= 100k elements -> call the T x T -> T
kernel directly over the flattened elements (checks ordered cheapest-first).
Applies to add/subtract/min/max/absdiff/multiply/addWeighted/and/or/xor;
compare and divide lower to more than a single kernel (boundary rewrites, int
guards) and keep the ordinary path. addWeighted falls through automatically
for the 32/64-bit int types whose lowering is wide-compute + cast
(getElemwiseFunc returns no direct kernel there).

127x61 vs 5.x, was -> now: add/subtract 8UC1 0.76x -> 1.3x, min/max u8
0.6x -> ~1x, addWeighted 1.0x -> 1.1-1.4x (32SC1 stays 4.5x); the one
remaining laggard is add/sub 32SC1 (0.74-0.82x) - the price of the new
SATURATING semantics (7-instruction AVX2 emulation vs the wrapping single
add of 5.x; single-instruction on NEON).

The 127x61 size is ADDED PERMANENTLY to the arithmetic/addWeighted/compare
perf grids: per-call overhead regressions in these base functions must be
caught by CI, not discovered by users.

dst creation goes through createSameSize (whole-shape transfer including
layout and future metadata, not piecemeal dims+sizes) here and in math_op.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* cv::pow rebuilt on the engine; integer-exponent and 1/sqrt(x) kernel branches

Routing: p = 0/1/2 keep their early special cases (fill/copy/multiply); an
INTEGER array with an INTEGER power keeps the classic iPow multiply chain -
bit-exact compatibility, including its wrap-around quirks (iPow squares in
int, so e.g. pow(255,4) on u8 wraps negative and saturates to 0 - somebody
may rely on that). Everything else goes through the engine with the math_op
two-tier scheme: small continuous arrays call powKernel directly (the
exponent rides as a broadcast T scalar), the rest run the tiled parallel
program. Integer arrays with fractional powers compute in the float domain
and saturate back; the 32U/64-bit depths (classic iPow asserted on them) and
f16/bf16 (the classic float path misread them) now just work.

powKernel gets two new per-row exponent branches:
- p == -0.5: 1/v_sqrt(x) (the classic path used IPP ippsInvSqrt_A21, a
  21-bit approximation; ours is exact - slightly slower on small arrays,
  4.5x faster at 1080p via parallelism);
- any other INTEGER p (|p| <= 65536): LSB-first binary exponentiation, the
  same multiply chain and order as iPow, fully vectorized - a few ulp
  accurate vs ~2e-7 of exp(p*log x), and exact on non-positive bases (the
  sign falls out of the multiplies, 0^negative divides to inf) - no scalar
  patching.

cv::pow f32 vs 5.x: p=0.5 365 -> 61 us at 1080p (6x), p=3 7.7x, p=5 7x AND
faster at every size (the old scalar chain: 0.81 -> 0.47 us at 127x61),
p=2.5 5.3x. The s16^5 iPow path is untouched (118.7 == 118.5 us).
pow_exponents accuracy tests extended to 11 exponents x f32/f64 against the
double std::pow reference.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* perf: SANITY_CHECK_NOTHING for the tests whose grids got the 127x61 size

The 127x61 entry added to guard per-call overhead has no regression data in
opencv_extra, so the legacy SANITY_CHECK in addWeighted/compare failed on CI
(locally it passes silently without the test-data path). Accuracy of both
functions is covered by the accuracy suite; the perf tests should measure
time. PatchNaNs/finiteMask keep their SANITY_CHECK - their grids are
untouched.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix a temp-buffer double release in the liveness pass ("d*d" crash)

When the same temp is passed as SEVERAL arguments of its last-use
instruction (e.g. the named-intermediate expression "d = {0} - {1}; d*d",
where the MUL consumes slot d twice), the buffer-reuse scan pushed the
temp's physical buffer onto the free list once per argument. That
overflows the ntemps-sized freeBufs array (caught by the AutoBuffer range
check in Debug: python test_expr.py::test_named_temporary) and, in larger
programs, would hand the same physical buffer to two live temps.

Release the buffer once by retiring lastUse[t] after the first hit.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* executor: recalibrate opCost to vectorized cycles + clamp the stripe count

The per-element op costs fed into the parallel_for_ stripe hint were
scalar-era estimates (~20x above the vectorized reality: the atan2/exp
polynomials run at ~1.5 cycles/element, not 30). The hint therefore split
transcendental/divide work into hundreds of ~1 us jobs, which the
macOS/GCD backend dispatches poorly under sustained load, on top of the
P/E-core equal-share straggler effect. Measured on M4 Max (12P+4E),
sustained medians @1920x1080 f32: texpr atan2 320 -> 133 us, cv::exp
280 -> 141 us, cv::log 301 -> ~200 us, cv::pow(x,2.5) 388 -> 376 us;
the PR tables' math rows improved ~1.5-2x across the board.

- opCost is now in units of ~1/4 cycle/element of the SIMD kernels:
  cheap ops 1 (unchanged), div/sqrt/hypot/convert_scale 10 -> 3,
  transcendentals 30 -> 6.
- the stripe hint is clamped by min(4*nthreads, max(32, 3*nthreads)):
  ~4 stripes/thread is plenty of granularity for element-wise work, and
  the ceiling is 32 pieces except on machines with many (heterogeneous)
  cores, where anything coarser than ~3 pieces/worker turns the slow
  cores into equal-share bottlenecks (measured: 32 stripes on 16 threads
  is the worst point of the curve - 193 us vs 137 us at 48 for atan2).
  getNumThreads() is clamped from below (WINRT/plugin backends may
  report 0).

Not addressed here (needs cross-machine data, M2/M3 Ultra): streaming
memory-bound ops saturate the M4 Max fabric at ~8 fat stripes and E-core
participation only adds contention - a cost model cannot express that;
candidate follow-up is a bytes-aware clamp or a GCD-backend-level fix.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* multiply: v_mul_sat integer kernels (full product clamped to the type)

v_mul_sat(V, V) -> V for u8/s8/u16/s16/u32/s32 - the full-precision
product clamped to the lane type, which is exactly cv::multiply's integer
semantics at scale == 1. Local to arithm.simd.hpp for now, next to
v_add_sat/v_sub_sat, to be promoted into proper universal intrinsics
later. NEON: widening vmull + saturating narrow (vqmovn); other backends:
the portable v_mul_expand + saturating v_pack composition for 8/16-bit
lanes. 32-bit lanes have no universal widening multiply (no v_mul_expand
for s32), so the 32-bit integer fast path is NEON-only for now and the
other backends keep the previous f64 work-vector kernels (which measure
well on x86 with IPP-free AVX2).

EwMul::vec() now routes the integer lane types through v_mul_sat, and
getMulFunc_ passes the NATIVE lane vector as the scale==1 fast-path type:
whole-register loads/stores, the widening happens inside the multiply.
Replaces both the half-register widening loads (u8/s8/u16/s16) and the
scalar-equivalent f64 path for 32S/32U on NEON.

M4 Max, 640x480 (the sizes where the old kernels lost to carotene):
8U 22.0 -> 13.6 us, 8S 15.0 -> 11.1, 16S 21.2 -> 17.4, 32S 84.8 -> 30.5
(parity with the classic path everywhere, 32S was 0.38x). 1920x1080:
8S 1.30x -> 1.78x, 16S 2.57x -> 2.98x, 32S 2.20x -> 4.02x vs 5.x.
Correctness: exhaustive 8-bit (all 65536 pairs per sign), directed
saturation corners for 16/32-bit (46341^2, INT_MIN*-1, 65536*65536, all
sign combinations) against an exact int64 reference.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* NEON: make v_cvt_f64(v_int32) exact (was via f32, losing bits > 2^24)

The NEON implementations of v_cvt_f64/v_cvt_f64_high for v_int32 did
s32 -> f32 -> f64 (vcvt_f32_s32 + vcvt_f64_f32), silently rounding any
|x| > 2^24. Every vectorized f64 work path with int32 inputs on AArch64
was affected: the engine's addWeighted/divide 32S kernels, convertTo
32S -> 64F, etc. Found via addWeighted 32SC1 on values ~1e9: max error
was 32 vs the exact double reference (the classic carotene path is worse
still - it computes in f32 end-to-end with f32-truncated weights, max
error 96 on the same data).

The exact sequence sxtl + scvtf (vmovl_s32 + vcvtq_f64_s64) is the same
2 instructions, so there is no cost. addWeighted 32SC1 on the engine now
matches the exact-double reference bit-for-bit and stays at parity/1.4x
vs the classic path (640x480/1920x1080).

Pre-existing upstream bug (same code in 4.x) - worth a standalone
backport with directed large-value tests.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* math_op: drop the temporary direct-IPP tier for exp/log

Upstream moved the IPP math wrappers into the hal/ipp HAL module (cv_hal_exp32f/
log32f & co now resolve to ipp_hal_* which honor cv::ipp::useIPP via
CV_HAL_CHECK_USE_IPP). The engine's single probeHalUnary(cv_hal_*) probe already
picks that up uniformly, so the stopgap #ifdef HAVE_IPP ippExp/ippLog tier and its
ipp::useIPP() branch in getMathFunc are now redundant - removed.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* arithm: restore cv::hal::and8u/or8u/xor8u/not8u as engine wrappers

These public CV_EXPORTS entry points (core/hal/hal.hpp) lost their definitions when
the bitwise ops moved to the element-wise engine, but they are still declared and called
by other modules (opencv_objdetect's aruco) and external code - the link broke with
undefined references to cv::hal::and8u/xor8u. Restore them as thin forwarders over the
engine's byte-wise bitwise kernels (getBitwiseFunc / getNotFunc), mirroring the existing
mul8u wrapper. CV_Assert guards the kernel lookup.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* blobdetector: guard empty contour when computing blob radius

The new AutoBuffer leaves its tail uninitialized for trivial types, which surfaced a
-Wmaybe-uninitialized in findBlobs where the median of per-point distances is read. Use a
std::vector, default the radius to 0, and compute the median only for a non-empty contour -
no unproven size invariant.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

modules/core/CMakeLists.txt

@@ -2,7 +2,8 @@ set(the_description "The Core Functionality")
 
 ocv_add_dispatched_file(mathfuncs_core SSE2 AVX AVX2 LASX)
 ocv_add_dispatched_file(stat SSE4_2 AVX2 AVX512_SKX AVX512_ICL LASX)
-ocv_add_dispatched_file(arithm SSE2 SSE4_1 AVX2 VSX3 LASX)
+ocv_add_dispatched_file(arithm SSE2 SSE4_1 AVX2 NEON_FP16 VSX3 LASX)
+ocv_add_dispatched_file(math SSE2 SSE4_1 AVX2 NEON_FP16 VSX3 LASX)
 ocv_add_dispatched_file(convert SSE2 AVX2 VSX3 LASX)
 ocv_add_dispatched_file(convert_scale SSE2 AVX2 LASX)
 ocv_add_dispatched_file(count_non_zero SSE2 AVX2 AVX512_SKX AVX512_ICL LASX)

modules/core/include/opencv2/core.hpp

@@ -1103,6 +1103,20 @@ CV_EXPORTS_W void broadcast(InputArray src, InputArray shape, OutputArray dst);
  */
 CV_EXPORTS void broadcast(InputArray src, const MatShape& shape, OutputArray dst);
 
+/** @brief Evaluate a broadcasting element-wise expression over the input arrays.
+
+The expression is a small std::format-like string over placeholders `{0}`, `{1}`, ... (the entries of
+@p inputs), C-style arithmetic / comparison / bitwise operators, type-cast and math function calls
+(`uint8(...)`, `min`, `max`, `absdiff`, `pow`, ...), `;`-separated named temporaries and a
+parenthesized tuple for multiple results. All operands broadcast against each other (numpy rules,
+channels innermost) and the whole expression is fused into a single traversal of the data.
+
+@param expr the expression string, e.g. `"{0} * 2.5 + {1}"` or `"({0} + {1}, {0} - {1})"`.
+@param inputs the arrays bound to `{0}`, `{1}`, ...
+@param outputs receives one array per top-level result (one entry, or several for a tuple).
+*/
+CV_EXPORTS_W void texpr(const String& expr, InputArrayOfArrays inputs, OutputArrayOfArrays outputs);
+
 enum RotateFlags {
     ROTATE_90_CLOCKWISE = 0, //!<Rotate 90 degrees clockwise
     ROTATE_180 = 1, //!<Rotate 180 degrees clockwise

modules/core/include/opencv2/core/hal/intrin_math.hpp

@@ -299,14 +299,19 @@ inline _TpVec32F v_log_default_32f(const _TpVec32F &x) {
 
     _vlog_z = v_mul(_vlog_x, _vlog_x);
 
-    _vlog_y = v_fma(_vlog_p0_fp32, _vlog_x, _vlog_p1_fp32);
+    // Estrin evaluation of the degree-8 polynomial: the former 8-FMA Horner chain is one long
-    _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p2_fp32);
+    // dependency (~32 cycles of latency); pairing evaluates it in ~4 dependent levels.
-    _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p3_fp32);
+    {
-    _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p4_fp32);
+        _TpVec32F _vlog_x4 = v_mul(_vlog_z, _vlog_z);
-    _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p5_fp32);
+        _TpVec32F _vlog_t0 = v_fma(_vlog_p0_fp32, _vlog_x, _vlog_p1_fp32);
-    _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p6_fp32);
+        _TpVec32F _vlog_t1 = v_fma(_vlog_p2_fp32, _vlog_x, _vlog_p3_fp32);
-    _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p7_fp32);
+        _TpVec32F _vlog_t2 = v_fma(_vlog_p4_fp32, _vlog_x, _vlog_p5_fp32);
-    _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p8_fp32);
+        _TpVec32F _vlog_t3 = v_fma(_vlog_p6_fp32, _vlog_x, _vlog_p7_fp32);
+        _TpVec32F _vlog_u0 = v_fma(_vlog_t0, _vlog_z, _vlog_t1);    // p0..p3 (deg 3)
+        _TpVec32F _vlog_u1 = v_fma(_vlog_t2, _vlog_z, _vlog_t3);    // p4..p7
+        _vlog_y = v_fma(_vlog_u0, _vlog_x4, _vlog_u1);              // p0..p7 (deg 7)
+        _vlog_y = v_fma(_vlog_y, _vlog_x, _vlog_p8_fp32);           // full degree-8
+    }
     _vlog_y = v_mul(_vlog_y, _vlog_x);
     _vlog_y = v_mul(_vlog_y, _vlog_z);
 

modules/core/include/opencv2/core/hal/intrin_neon.hpp

@@ -2610,12 +2610,14 @@ inline v_float32x4 v_cvt_f32(const v_float64x2& a, const v_float64x2& b)
 
 inline v_float64x2 v_cvt_f64(const v_int32x4& a)
 {
-    return v_float64x2(vcvt_f64_f32(vcvt_f32_s32(vget_low_s32(a.val))));
+    // sxtl + scvtf: EXACT over the whole int32 range, same 2 instructions as the former
+    // f32 round-trip (vcvt_f32_s32 + vcvt_f64_f32), which silently lost bits for |x| > 2^24
+    return v_float64x2(vcvtq_f64_s64(vmovl_s32(vget_low_s32(a.val))));
 }
 
 inline v_float64x2 v_cvt_f64_high(const v_int32x4& a)
 {
-    return v_float64x2(vcvt_f64_f32(vcvt_f32_s32(vget_high_s32(a.val))));
+    return v_float64x2(vcvtq_f64_s64(vmovl_s32(vget_high_s32(a.val))));
 }
 
 inline v_float64x2 v_cvt_f64(const v_float32x4& a)

modules/core/include/opencv2/core/mat.hpp

@@ -54,6 +54,7 @@
 #include "opencv2/core/bufferpool.hpp"
 
 #include <array>
+#include <functional>
 #include <type_traits>
 
 namespace cv
@@ -3857,6 +3858,66 @@ protected:
 };
 
 
+/////////////////////////////////// BroadcastOp //////////////////////////////////////
+
+/** @brief Op-agnostic driver for a broadcasting element-wise traversal.
+
+BroadcastOp takes a flat list of operand Mats (it does NOT distinguish inputs from outputs), computes
+the numpy-broadcast iteration space over all of them (channels = innermost dim), partitions it into
+tasks, runs them with parallel_for_, and for each tile hands the per-operand slices to a `body`
+callback. Everything semantic - which array is the output, which kernels run, temp buffers - lives in
+`body`. For a cv::Mat the innermost axis is always contiguous, so after dimension collapse every
+operand's innermost step is in {0,1} (1 = contiguous, 0 = broadcast-scalar) - there is no gather case.
+*/
+struct BroadcastOp
+{
+    //! One operand's slice for the current tile: base pointer + steps in ELEMENTS. stepx in {0,1}
+    //! (1 = contiguous along width, 0 = broadcast-scalar); stepy = step between the `height` rows
+    //! (0 = broadcast). ptr is non-const so the body can write the operand(s) it treats as outputs.
+    struct Slice
+    {
+        void*  ptr   = nullptr;
+        size_t stepy = 0;
+        size_t stepx = 0;
+    };
+
+    //! One 2D tile handed to the body. slices[k] corresponds to arrays[k] (same order); the body reads
+    //! width/height and the per-operand slices and owns all interpretation.
+    struct Tile
+    {
+        int width  = 0;                //!< innermost tile extent (elements)
+        int height = 0;                //!< 2nd-innermost extent (1 unless a 2D tile is handed out)
+        int narrays = 0;
+        const Slice* slices = nullptr; //!< [narrays], valid for the duration of the body call
+    };
+
+    /** @brief Drive a broadcasting element-wise traversal.
+    @param arrays   pointers to the operand Mats (inputs AND outputs, undistinguished); the iteration
+                    space is the numpy-broadcast of all their shapes (channels innermost). Headers must
+                    stay alive for the call - no Mat copies are made.
+    @param narrays  number of operands.
+    @param body     invoked once per tile with that tile's per-operand slices; runs the prepared program.
+                    Per-thread scratch is just locals in the body (declared per call => thread-safe).
+    @param expandChannels  true => channels are an explicit innermost iteration dim, so the body always
+                    sees single-channel data (1<->N channel broadcast handled geometrically). false =>
+                    channels stay folded into the element (esz = full elemSize); the body handles them.
+    @param nstripes parallel_for_ work hint; 0 => derive from the shapes (assuming ~100 cycles/element).
+    */
+    CV_EXPORTS static void run(const Mat* const* arrays, int narrays,
+                               const std::function<void(const Tile&)>& body,
+                               bool expandChannels = false,
+                               double nstripes = 0.);
+};
+
+//! Free-function shorthand for BroadcastOp::run (see BroadcastOp).
+inline void broadcastOp(const Mat* const* arrays, int narrays,
+                        const std::function<void(const BroadcastOp::Tile&)>& body,
+                        bool expandChannels = false,
+                        double nstripes = 0.)
+{
+    BroadcastOp::run(arrays, narrays, body, expandChannels, nstripes);
+}
+
 
 ///////////////////////////////// Matrix Expressions /////////////////////////////////
 

modules/core/include/opencv2/core/utility.hpp

@@ -127,10 +127,18 @@ public:
     void allocate(size_t _size);
     //! deallocates the buffer if it was dynamically allocated
     void deallocate();
-    //! resizes the buffer and preserves the content
+    //! resizes the buffer and preserves the content. A grown tail is left as `new _Tp[]` leaves it:
+    //! default-constructed for class types, UNINITIALIZED (raw) for trivial types. Use the two-arg
+    //! overload if you need every new slot set to a value.
     void resize(size_t _size);
+    //! resizes the buffer, preserving the content and setting every newly exposed slot to `value`
+    void resize(size_t _size, const _Tp& value);
+    //! grows the capacity to at least _cap (preserving the content); never shrinks
+    void reserve(size_t _cap);
     //! returns the current buffer size
     size_t size() const;
+    //! returns the current capacity (allocated element count; always >= size())
+    size_t capacity() const;
     //! returns pointer to the real buffer, stack-allocated or heap-allocated
     inline _Tp* data() { return ptr; }
     //! returns read-only pointer to the real buffer, stack-allocated or heap-allocated
@@ -162,8 +170,10 @@ public:
     inline const_reference back() const { CV_DbgCheckGT(sz, (size_t)0, "out of range"); return (*this)[size()-1] ;}
     inline reference back() { CV_DbgCheckGT(sz, (size_t)0, "out of range"); return (*this)[size()-1] ;}
 public:
-    inline void push_back( const _Tp& value ) {resize(size()+1); back() = value;}
+    inline void push_back( const _Tp& value )
-    inline void push_back( _Tp&& value ) {resize(size()+1); back() = std::move(value);}
+    { if (sz >= cap) reserve(cap + cap/2 > sz ? cap + cap/2 : sz + 1); ptr[sz++] = value; }
+    inline void push_back( _Tp&& value )
+    { if (sz >= cap) reserve(cap + cap/2 > sz ? cap + cap/2 : sz + 1); ptr[sz++] = std::move(value); }
     inline void emplace_back( _Tp&& value ) {push_back(value);}
     inline void pop_back() {CV_DbgCheckGT(sz, (size_t)0, "out of range"); resize(size()-1);}
 protected:
@@ -171,6 +181,8 @@ protected:
     _Tp* ptr;
     //! size of the real buffer
     size_t sz;
+    //! capacity - allocated element count (>= sz). Starts at fixed_size (the local buf), grows on demand.
+    size_t cap;
     //! pre-allocated buffer. At least 1 element to confirm C++ standard requirements
     _Tp buf[(fixed_size > 0) ? fixed_size : 1];
 };
@@ -1068,14 +1080,16 @@ template<typename _Tp, size_t fixed_size> inline
 AutoBuffer<_Tp, fixed_size>::AutoBuffer()
 {
     ptr = buf;
-    sz = fixed_size;
+    sz = 0;
+    cap = fixed_size;
 }
 
 template<typename _Tp, size_t fixed_size> inline
 AutoBuffer<_Tp, fixed_size>::AutoBuffer(size_t _size)
 {
     ptr = buf;
-    sz = fixed_size;
+    sz = 0;
+    cap = fixed_size;
     allocate(_size);
 }
 
@@ -1090,7 +1104,8 @@ template<typename _Tp, size_t fixed_size> inline
 AutoBuffer<_Tp, fixed_size>::AutoBuffer(const AutoBuffer<_Tp, fixed_size>& abuf )
 {
     ptr = buf;
-    sz = fixed_size;
+    sz = 0;
+    cap = fixed_size;
     allocate(abuf.size());
     for( size_t i = 0; i < sz; i++ )
         ptr[i] = abuf.ptr[i];
@@ -1116,17 +1131,8 @@ AutoBuffer<_Tp, fixed_size>::~AutoBuffer()
 template<typename _Tp, size_t fixed_size> inline void
 AutoBuffer<_Tp, fixed_size>::allocate(size_t _size)
 {
-    if(_size <= sz)
+    resize(_size);      // set the size (resize grows capacity as needed, preserves content); the new
-    {
+                        // tail is raw for trivial types - AutoBuffer is a scratch buffer, callers fill it
-        sz = _size;
-        return;
-    }
-    deallocate();
-    sz = _size;
-    if(_size > fixed_size)
-    {
-        ptr = new _Tp[_size];
-    }
 }
 
 template<typename _Tp, size_t fixed_size> inline void
@@ -1136,38 +1142,72 @@ AutoBuffer<_Tp, fixed_size>::deallocate()
     {
         delete[] ptr;
         ptr = buf;
-        sz = fixed_size;
     }
+    sz = 0;
+    cap = fixed_size;
+}
+
+template<typename _Tp, size_t fixed_size> inline void
+AutoBuffer<_Tp, fixed_size>::reserve(size_t _cap)
+{
+    if( _cap <= cap )       // never shrink; _cap > cap implies _cap > fixed_size, so always heap
+        return;
+    _Tp* prevptr = ptr;
+    ptr = new _Tp[_cap];
+    // only the LIVE elements [0, sz) are copied - for trivial types the inline buf tail beyond sz
+    // is intentionally raw (AutoBuffer is a scratch buffer), which gcc's -Wmaybe-uninitialized
+    // cannot prove when it inlines a grow-from-inline-storage call chain; the annotation below
+    // documents exactly that, it does not change behavior
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+    for( size_t i = 0; i < sz; i++ )    // preserve the live elements
+        ptr[i] = prevptr[i];
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+    if( prevptr != buf )
+        delete[] prevptr;
+    cap = _cap;
 }
 
 template<typename _Tp, size_t fixed_size> inline void
 AutoBuffer<_Tp, fixed_size>::resize(size_t _size)
 {
-    if(_size <= sz)
+    if(_size <= sz)         // shrink: keep the capacity and the surviving content
     {
         sz = _size;
         return;
     }
-    size_t i, prevsize = sz, minsize = MIN(prevsize, _size);
+    if(_size > cap)         // grow with geometric slack (like push_back) so incremental
-    _Tp* prevptr = ptr;
+        reserve(cap + cap/2 > _size ? cap + cap/2 : _size);   // resize(size()+delta) loops don't realloc every step
-
-    ptr = _size > fixed_size ? new _Tp[_size] : buf;
     sz = _size;
+    // !!! DO NOT ADD ANY INITIALIZATION OF THE NEW TAIL HERE (e.g. `for(i=sz..) ptr[i]=_Tp();`) !!!
+    // AutoBuffer IS A RAW SCRATCH BUFFER. Value-initializing the tail zero-fills it on EVERY grow, which
+    // silently dominates the cost of small allocations (measured: ~1.2us per few-KB resize) and there is
+    // NOTHING to init anyway - callers write before they read. Class-type elements are already
+    // constructed by `new _Tp[]` / the inline array. If you truly need filled slots, call the two-arg
+    // overload resize(size, value) EXPLICITLY.
+}
 
-    if( ptr != prevptr )
+template<typename _Tp, size_t fixed_size> inline void
-        for( i = 0; i < minsize; i++ )
+AutoBuffer<_Tp, fixed_size>::resize(size_t _size, const _Tp& value)
-            ptr[i] = prevptr[i];
+{
-    for( i = prevsize; i < _size; i++ )
+    const size_t old = sz;
-        ptr[i] = _Tp();
+    resize(_size);
-
+    for( size_t i = old; i < _size; i++ )   // fill every newly exposed slot
-    if( prevptr != buf )
+        ptr[i] = value;
-        delete[] prevptr;
 }
 
 template<typename _Tp, size_t fixed_size> inline size_t
 AutoBuffer<_Tp, fixed_size>::size() const
 { return sz; }
 
+template<typename _Tp, size_t fixed_size> inline size_t
+AutoBuffer<_Tp, fixed_size>::capacity() const
+{ return cap; }
+
 //! @endcond
 
 

modules/core/perf/perf_addWeighted.cpp

@@ -5,7 +5,7 @@ namespace opencv_test
 using namespace perf;
 
 #define TYPICAL_MAT_TYPES_ADWEIGHTED  CV_8UC1, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1
-#define TYPICAL_MATS_ADWEIGHTED       testing::Combine(testing::Values(szVGA, sz720p, sz1080p), testing::Values(TYPICAL_MAT_TYPES_ADWEIGHTED))
+#define TYPICAL_MATS_ADWEIGHTED       testing::Combine(testing::Values(szVGA, sz720p, sz1080p, Size(127, 61)), testing::Values(TYPICAL_MAT_TYPES_ADWEIGHTED))
 
 PERF_TEST_P(Size_MatType, addWeighted, TYPICAL_MATS_ADWEIGHTED)
 {
@@ -31,7 +31,9 @@ PERF_TEST_P(Size_MatType, addWeighted, TYPICAL_MATS_ADWEIGHTED)
 
     TEST_CYCLE() cv::addWeighted( src1, alpha, src2, beta, gamma, dst, dst.type() );
 
-    SANITY_CHECK(dst, depth == CV_32S ? 4 : 1);
+    // accuracy is covered by the accuracy tests; regression data does not exist for every
+    // size in the grid (127x61 guards per-call overhead only)
+    SANITY_CHECK_NOTHING();
 }
 
 } // namespace

modules/core/perf/perf_arithm.cpp

@@ -527,7 +527,7 @@ PERF_TEST_P_(BinaryOpTest, transposeND_generic_move_tail_order)
 
 INSTANTIATE_TEST_CASE_P(/*nothing*/ , BinaryOpTest,
     testing::Combine(
-        testing::Values(szVGA, sz720p, sz1080p),
+        testing::Values(szVGA, sz720p, sz1080p, Size(127, 61)),   // 127x61 guards per-call overhead
         testing::Values(CV_8UC1, CV_8UC3, CV_8UC4, CV_8SC1, CV_16SC1, CV_16SC2, CV_16SC3, CV_16SC4, CV_32SC1, CV_32FC1)
     )
 );

modules/core/perf/perf_compare.cpp

@@ -11,7 +11,7 @@ typedef perf::TestBaseWithParam<Size_MatType_CmpType_t> Size_MatType_CmpType;
 
 PERF_TEST_P( Size_MatType_CmpType, compare,
              testing::Combine(
-                 testing::Values(::perf::szVGA, ::perf::sz1080p),
+                 testing::Values(::perf::szVGA, ::perf::sz1080p, cv::Size(127, 61)),
                  testing::Values(CV_8UC1, CV_8UC4, CV_8SC1, CV_16UC1, CV_16SC1, CV_32SC1, CV_32FC1),
                  CmpType::all()
                  )
@@ -29,7 +29,9 @@ PERF_TEST_P( Size_MatType_CmpType, compare,
 
     TEST_CYCLE() cv::compare(src1, src2, dst, cmpType);
 
-    SANITY_CHECK(dst);
+    // accuracy is covered by the accuracy tests; regression data does not exist for every
+    // size in the grid (127x61 guards per-call overhead only)
+    SANITY_CHECK_NOTHING();
 }
 
 PERF_TEST_P( Size_MatType_CmpType, compareScalar,
@@ -53,7 +55,9 @@ PERF_TEST_P( Size_MatType_CmpType, compareScalar,
     int runs = (sz.width <= 640) ? 8 : 1;
     TEST_CYCLE_MULTIRUN(runs) cv::compare(src1, src2, dst, cmpType);
 
-    SANITY_CHECK(dst);
+    // TEMP: cv::compare with a multi-channel Scalar is now PER-CHANNEL (like cv::add), whereas the
+    // recorded sanity data assumes the legacy scalar[0]-broadcast; disable the value check for now.
+    SANITY_CHECK_NOTHING();
 }
 
 } // namespace

modules/core/perf/perf_new_arithm.cpp

@@ -0,0 +1,378 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// Ad-hoc perf comparison for the element-wise engine vs classic cv::add. Lives in
+// opencv_test_core for now (move to opencv_perf_core later). Each (type-combo, size) is run
+// 10..30 times; the minimum getTickCount() time is reported as the most stable metric.
+
+#include "perf_precomp.hpp"
+
+// TODO: these ad-hoc micro-benchmarks call the engine internals (cv::ew) directly and print min-times
+// by hand. They are DISABLED (#if 0) pending a rewrite onto the perf framework (PERF_TEST_P over the
+// PUBLIC cv::add/... ops), measured against a separate 5.x build with opencv_perf_core + the summary
+// script. Kept here so the intended coverage is not lost.
+#if 0
+#include "../src/arithm_expr.hpp"
+#include <iostream>
+#include <iomanip>
+
+namespace opencv_test { namespace {
+
+using namespace cv::ew;
+
+static Mat randMat(const std::vector<int>& shape, int cn, int depth, double lo, double hi)
+{
+    Mat m64((int)shape.size(), shape.data(), CV_MAKETYPE(CV_64F, cn));
+    cvtest::randUni(theRNG(), m64, Scalar::all(lo), Scalar::all(hi));
+    Mat m; m64.convertTo(m, CV_MAKETYPE(depth, cn));
+    return m;
+}
+
+// single-channel 0/1 mask of the given spatial shape
+static Mat randMask(const std::vector<int>& shape)
+{
+    Mat m((int)shape.size(), shape.data(), CV_8U);
+    cvtest::randUni(theRNG(), m, Scalar::all(0), Scalar::all(2));
+    return m;
+}
+
+// Min over `iters` trials of the per-call time in MICROSECONDS. Each trial runs f() `ninner`
+// times inside one timed region and divides by ninner, so the timer's coarse resolution is
+// amortized across many calls - essential for sub-microsecond operations.
+template<typename F>
+static double minUs(F&& f, int iters, int ninner)
+{
+    f();  // warmup (allocates reused output, warms caches)
+    double best = DBL_MAX;
+    for (int i = 0; i < iters; i++)
+    {
+        int64 t0 = getTickCount();
+        for (int j = 0; j < ninner; j++) f();
+        double us = (getTickCount() - t0) * 1e6 / getTickFrequency() / ninner;
+        best = std::min(best, us);
+    }
+    return best;
+}
+
+struct Combo { int da, db, Tr; std::string name; };
+struct Sz    { std::vector<int> shape; int cn; int ninner; const char* name; };
+
+// Shared add/sub sweep over (type-combo x size). `masked` adds a single-channel write-mask: the
+// engine builds the op-into-temp + copyMask program; the cv:: reference times cv::add/subtract with
+// the mask (only for same-type combos - mixed-type + mask isn't compared). Engine correctness is
+// always checked against a deterministic zero + copyTo(mask) reference.
+static void perfBinOp(TOp op, const char* title, bool masked)
+{
+    const std::string opname = opName(op);
+    const Combo combos[] = {
+        { CV_8U,  CV_8U,  CV_8U,  opname + "(u8,  u8)->u8   " },
+        { CV_16F, CV_16F, CV_16F, opname + "(f16, f16)->f16 " },
+        { CV_32F, CV_32F, CV_32F, opname + "(f32, f32)->f32 " },
+        { CV_8U,  CV_16F, CV_16F, opname + "(u8,  f16)->f16 " },
+    };
+    const Sz sizes[] = {
+        { {10,10,10},   1, 5000, "10x10x10    " },
+        { {165,121},    1, 2000, "165x121     " },
+        { {1024,1024},  3,    4, "1024x1024x3 " },
+    };
+
+    std::cout << "\n[ew-perf] " << title << "  (min us per call over 30 trials)\n";
+    std::cout << "  combo                size           engine     cv::op     speedup\n";
+    std::cout << "  -----------------------------------------------------------------\n";
+
+    for (const Combo& c : combos)
+        for (const Sz& s : sizes)
+        {
+            Mat a = randMat(s.shape, s.cn, c.da, 0, 100);
+            Mat b = randMat(s.shape, s.cn, c.db, 0, 100);
+            // div: make the divisor nonzero (the 0..100 data includes 0 for integer b); float-div by
+            // zero is UB, integer-div by zero is a separate (accuracy-tested) corner not timed here.
+            if (op == OP_DIV) { Mat b64; b.convertTo(b64, CV_64F); b64.setTo(1.0, b64 == 0.0); b64.convertTo(b, c.db); }
+            Mat mask = masked ? randMask(s.shape) : Mat();
+            Mat init = masked ? randMat(s.shape, s.cn, c.Tr, 0, 50) : Mat();   // pre-existing dst
+            Mat in2[] = {a, b}, in3[] = {a, b, mask}, out = masked ? init.clone() : Mat();
+            Mat* inps = masked ? in3 : in2;
+            const int mdepth = masked ? CV_8U : EW_DEPTH_NONE;
+            // u8*u8 mul: exercise a realistic non-unit scale (1/255, the normalized-blend case) -
+            // checks the specialized u8 mul branch still holds up when scale != 1.
+            const double scale = (op == OP_MUL && c.da == CV_8U && c.db == CV_8U) ? 1.0/255 : 1.0;
+
+            // Full per-call path (matches a future cv:: op): build the program every call.
+            // (masked preserves the pre-filled `out` where mask==0, so repeated calls are idempotent.)
+            double te = minUs([&]{ TExpr p; makeBinaryArithProgram(p, op, c.da, c.db, c.Tr, mdepth, scale);
+                                   p.exec(inps, &out); }, 30, s.ninner);
+
+            // engine correctness sanity: add/sub vs cv:: directly; mul/div vs a double reference (the
+            // extensive test owns exactness, so a generous tolerance here just guards against garbage).
+            const bool fp = (op == OP_MUL || op == OP_DIV);
+            Mat ref;
+            if (op == OP_ADD)      cv::add     (a, b, ref, noArray(), c.Tr);
+            else if (op == OP_SUB) cv::subtract(a, b, ref, noArray(), c.Tr);
+            else if (op == OP_MIN || op == OP_MAX || op == OP_ABSDIFF) {
+                   Mat aT, bT; a.convertTo(aT, c.Tr); b.convertTo(bT, c.Tr);
+                   if (op == OP_MIN) cv::min(aT, bT, ref);
+                   else if (op == OP_MAX) cv::max(aT, bT, ref);
+                   else cv::absdiff(aT, bT, ref); }
+            else { Mat aD, bD, q; a.convertTo(aD, CV_64F); b.convertTo(bD, CV_64F);
+                   if (op == OP_MUL) cv::multiply(aD, bD, q, scale); else cv::divide(aD, bD, q);
+                   q.convertTo(ref, c.Tr); }
+            if (masked) { Mat full = ref; ref = init.clone(); full.copyTo(ref, mask); }
+            double n = cvtest::norm(out, ref, NORM_INF);
+            double sc = std::max(1.0, cvtest::norm(ref, NORM_INF));
+            double tol = (c.Tr==CV_16F||c.Tr==CV_16BF) ? (fp ? 1e-2*sc : 1.0)
+                       : c.Tr==CV_32F                  ? (fp ? 1e-3*sc : 1e-3)
+                       : (fp ? 1.0 : 0.0);
+            EXPECT_LE(n, tol) << title << " " << c.name << " " << s.name;
+
+            // cv:: timing reference (skip for mixed-type masked / mul / div, where the cv:: array op
+            // needs same-type inputs). min/max/absdiff have no dtype arg and require identical input
+            // types, so they are only timed against cv:: when da == db.
+            const bool mm = (op == OP_MIN || op == OP_MAX || op == OP_ABSDIFF);
+            double tc = -1;
+            if (c.da == c.db || (!masked && !fp && !mm))
+            {
+                Mat tmp;
+                InputArray m = masked ? InputArray(mask) : noArray();
+                if      (op == OP_ADD) tc = minUs([&]{ cv::add     (a, b, tmp, m, c.Tr); }, 30, s.ninner);
+                else if (op == OP_SUB) tc = minUs([&]{ cv::subtract(a, b, tmp, m, c.Tr); }, 30, s.ninner);
+                else if (op == OP_MUL) tc = minUs([&]{ cv::multiply(a, b, tmp, scale, c.Tr); }, 30, s.ninner);
+                else if (op == OP_MIN) tc = minUs([&]{ cv::min     (a, b, tmp); }, 30, s.ninner);
+                else if (op == OP_MAX) tc = minUs([&]{ cv::max     (a, b, tmp); }, 30, s.ninner);
+                else if (op == OP_ABSDIFF) tc = minUs([&]{ cv::absdiff(a, b, tmp); }, 30, s.ninner);
+                else                   tc = minUs([&]{ cv::divide  (a, b, tmp, 1.0, c.Tr); }, 30, s.ninner);
+            }
+
+            std::cout << "  " << c.name << "  " << s.name << "  "
+                      << std::fixed << std::setprecision(3) << std::setw(8) << te << "   ";
+            if (tc >= 0)
+                std::cout << std::setw(8) << tc << "   " << std::setprecision(2) << std::setw(6) << (tc/te) << "x";
+            else
+                std::cout << "      -          -  ";
+            std::cout << "\n";
+        }
+}
+
+// Compare sweep over the same (type-combo x size) grid as perfBinOp, but the result is a u8 boolean
+// mask with the SAME shape and channel count as the inputs (a per-element compare, not a reduction).
+// The engine builds the compare program (auto rdepth = u8 mask). cv::compare is timed for context only
+// on the same-type single-channel combos (it needs identical input types). Correctness is checked
+// per channel against a compare in f64 (exact for the small [0,16] data).
+static void perfCompare(TOp op, const char* title)
+{
+    const std::string opname = opName(op);
+    const int cmpop = (op == OP_CMP_EQ) ? cv::CMP_EQ : cv::CMP_GT;
+    const Combo combos[] = {
+        { CV_8U,  CV_8U,  CV_8U, opname + "(u8,  u8) ->u8 " },
+        { CV_16F, CV_16F, CV_8U, opname + "(f16, f16)->u8 " },
+        { CV_32F, CV_32F, CV_8U, opname + "(f32, f32)->u8 " },
+        { CV_8U,  CV_16F, CV_8U, opname + "(u8,  f16)->u8 " },
+    };
+    const Sz sizes[] = {
+        { {10,10,10},   1, 5000, "10x10x10    " },
+        { {165,121},    1, 2000, "165x121     " },
+        { {1024,1024},  3,    4, "1024x1024x3 " },
+    };
+
+    std::cout << "\n[ew-perf] " << title << "  (min us per call over 30 trials)\n";
+    std::cout << "  combo                size           engine     cv::cmp    speedup\n";
+    std::cout << "  -----------------------------------------------------------------\n";
+
+    for (const Combo& c : combos)
+        for (const Sz& s : sizes)
+        {
+            Mat a = randMat(s.shape, s.cn, c.da, 0, 16);   // small range so EQ fires often
+            Mat b = randMat(s.shape, s.cn, c.db, 0, 16);
+            Mat in2[] = {a, b}, out;
+
+            double te = minUs([&]{ TExpr p; makeBinaryArithProgram(p, op, c.da, c.db, -1);
+                                   p.exec(in2, &out); }, 30, s.ninner);
+
+            // correctness: per-channel compare in f64 -> 0/255 (engine's default mask value)
+            std::vector<Mat> ach, bch; cv::split(a, ach); cv::split(b, bch);
+            std::vector<Mat> refch(s.cn);
+            for (int ch = 0; ch < s.cn; ch++) {
+                Mat af, bf; ach[ch].convertTo(af, CV_64F); bch[ch].convertTo(bf, CV_64F);
+                cv::compare(af, bf, refch[ch], cmpop);
+            }
+            Mat ref; cv::merge(refch, ref);
+            ASSERT_EQ(out.type(), CV_8UC(s.cn)) << title << " " << c.name;
+            EXPECT_EQ(0, cvtest::norm(out, ref, NORM_INF)) << title << " " << c.name << " " << s.name;
+
+            double tc = -1;
+            if (c.da == c.db)   // cv::compare needs identical input types (it handles multi-channel)
+            {
+                Mat tmp;
+                tc = minUs([&]{ cv::compare(a, b, tmp, cmpop); }, 30, s.ninner);
+            }
+
+            std::cout << "  " << c.name << "  " << s.name << "  "
+                      << std::fixed << std::setprecision(3) << std::setw(8) << te << "   ";
+            if (tc >= 0)
+                std::cout << std::setw(8) << tc << "   " << std::setprecision(2) << std::setw(6) << (tc/te) << "x";
+            else
+                std::cout << "      -          -  ";
+            std::cout << "\n";
+        }
+}
+
+TEST(Core_EW_Perf, cmpEQ)
+{
+    perfCompare(OP_CMP_EQ, "cmpEQ");
+    std::cout << std::endl;
+}
+
+TEST(Core_EW_Perf, cmpGT)
+{
+    perfCompare(OP_CMP_GT, "cmpGT");
+    std::cout << std::endl;
+}
+
+TEST(Core_EW_Perf, add)
+{
+    perfBinOp(OP_ADD, "add", false);
+
+    // per-channel scalar broadcast: (1024x1024) 8UC3 + (1x1) 8UC3  -> exercises the broadcast path
+    Mat a = randMat({1024,1024}, 3, CV_8U, 0, 100);
+    Mat b = randMat({1,1},      3, CV_8U, 0, 100);
+    Mat inps[] = {a, b}, out;
+
+    double te = minUs([&]{ TExpr p; makeBinaryArithProgram(p, OP_ADD, CV_8U, CV_8U, CV_8U, EW_DEPTH_NONE, 1.);
+                           p.exec(inps, &out); }, 30, 4);
+
+    Vec3b bv = b.at<Vec3b>(0, 0);
+    Scalar sb(bv[0], bv[1], bv[2]);
+    Mat ref;
+    double tc = minUs([&]{ cv::add(a, sb, ref); }, 30, 4);
+    EXPECT_EQ(0.0, cvtest::norm(out, ref, NORM_INF)) << "u8+scalar broadcast";
+
+    std::cout << "\n[ew-perf] addScalar  u8 +u8 ->u8   1024x1024x3 + (1x1)x3   "
+              << std::fixed << std::setprecision(3) << std::setw(8) << te << "   "
+              << std::setw(8) << tc << "   " << std::setprecision(2) << std::setw(6) << (tc/te) << "x\n";
+    std::cout << std::endl;
+}
+
+// Diagnostic: split the per-call cost into program BUILD (makeXxx + compile) vs EXEC (the run).
+// For each op we time (build+exec) and (exec-only, program built once). The gap = build overhead,
+// which a program cache would remove. 165x121 c1 (small, so overhead dominates).
+TEST(Core_EW_Perf, buildVsExec)
+{
+    const std::vector<int> shape{165,121};
+    std::cout << "\n[ew-perf] build-vs-exec  165x121 c1   (min us per call over 30 trials)\n";
+    std::cout << "  op                build+exec   exec-only    build    cv::\n";
+    std::cout << "  --------------------------------------------------------------\n";
+
+    auto row = [&](const char* name, TOp op, int da, int db, int Tr,
+                   std::function<void()> cvref)
+    {
+        Mat a = randMat(shape, 1, da, 1, 100);
+        Mat b = randMat(shape, 1, db, 1, 100);
+        if (op == OP_DIV) { Mat t; b.convertTo(t, CV_64F); t.setTo(1.0, t==0.0); t.convertTo(b, db); }
+        Mat in[] = {a, b}, out;
+
+        double tFull = minUs([&]{ TExpr p; makeBinaryArithProgram(p, op, da, db, Tr); p.exec(in, &out); }, 30, 2000);
+        TExpr p; makeBinaryArithProgram(p, op, da, db, Tr);
+        double tExec = minUs([&]{ p.exec(in, &out); }, 30, 2000);
+        double tBuild = minUs([&]{ TExpr q; makeBinaryArithProgram(q, op, da, db, Tr); }, 30, 2000);
+        double tcv = cvref ? minUs(cvref, 30, 2000) : -1;
+
+        std::cout << "  " << std::left << std::setw(18) << name << std::right << std::fixed << std::setprecision(3)
+                  << std::setw(8) << tFull << "   " << std::setw(8) << tExec << "   "
+                  << std::setw(7) << tBuild << "  ";
+        if (tcv >= 0) std::cout << std::setw(7) << tcv; else std::cout << "      -";
+        std::cout << "\n";
+    };
+
+    Mat tmp;
+    Mat a8 = randMat(shape,1,CV_8U,1,100), b8 = randMat(shape,1,CV_8U,1,100);
+    row("add u8->u8",  OP_ADD, CV_8U, CV_8U, CV_8U, [&]{ cv::add(a8,b8,tmp); });
+    row("mul u8->u8",  OP_MUL, CV_8U, CV_8U, CV_8U, [&]{ cv::multiply(a8,b8,tmp); });
+    row("div u8->u8",  OP_DIV, CV_8U, CV_8U, CV_8U, nullptr);
+    Mat af = randMat(shape,1,CV_32F,1,100), bf = randMat(shape,1,CV_32F,1,100);
+    row("mul f32->f32", OP_MUL, CV_32F, CV_32F, CV_32F, [&]{ cv::multiply(af,bf,tmp); });
+    std::cout << std::endl;
+}
+
+TEST(Core_EW_Perf, sub)
+{
+    perfBinOp(OP_SUB, "sub", false);
+    std::cout << std::endl;
+}
+
+TEST(Core_EW_Perf, mul)
+{
+    perfBinOp(OP_MUL, "mul", false);
+    std::cout << std::endl;
+}
+
+TEST(Core_EW_Perf, div)
+{
+    perfBinOp(OP_DIV, "div", false);
+    std::cout << std::endl;
+}
+
+TEST(Core_EW_Perf, min)
+{
+    perfBinOp(OP_MIN, "min", false);
+    std::cout << std::endl;
+}
+
+TEST(Core_EW_Perf, max)
+{
+    perfBinOp(OP_MAX, "max", false);
+    std::cout << std::endl;
+}
+
+TEST(Core_EW_Perf, absdiff)
+{
+    perfBinOp(OP_ABSDIFF, "absdiff", false);
+    std::cout << std::endl;
+}
+
+TEST(Core_EW_Perf, addMask)
+{
+    perfBinOp(OP_ADD, "add+mask", true);
+    std::cout << std::endl;
+}
+
+TEST(Core_EW_Perf, subMask)
+{
+    perfBinOp(OP_SUB, "sub+mask", true);
+    std::cout << std::endl;
+}
+
+TEST(Core_EW_Perf, addWeighted)
+{
+    // fused: addWeighted(a,alpha,b,beta,gamma) = a*alpha + b*beta + gamma. Two convert_scale MACs +
+    // an add => 2 temp buffers => exercises the body's L1 column-fragmentation.
+    std::cout << "\n[ew-perf] addWeighted  (min us per call over 30 trials)\n";
+    std::cout << "  combo         size           engine    cv::aW     speedup\n";
+
+    const double alpha = 1.5, beta = -0.75, gamma = 12.0;
+    struct Sz2 { std::vector<int> shape; int cn; int ninner; const char* name; };
+    const Sz2 sizes2[] = {
+        { {10,10,10},  1, 2000, "10x10x10    " },
+        { {165,121},   1, 1000, "165x121     " },
+        { {1024,1024}, 1,    8, "1024x1024   " },
+    };
+    for (const Sz2& s : sizes2)
+    {
+        Mat a = randMat(s.shape, s.cn, CV_32F, -100, 100);
+        Mat b = randMat(s.shape, s.cn, CV_32F, -100, 100);
+        Mat inps[] = {a, b}, out;
+        double te = minUs([&]{ TExpr p; makeAddWeightedProgram(p, CV_32F, CV_32F, CV_32F, alpha, beta, gamma);
+                               p.exec(inps, &out); }, 30, s.ninner);
+        Mat ref;
+        double tc = minUs([&]{ cv::addWeighted(a, alpha, b, beta, gamma, ref); }, 30, s.ninner);
+        EXPECT_LE(cvtest::norm(out, ref, NORM_INF), 1e-2) << "addWeighted " << s.name;
+
+        std::cout << "  f32 aW->f32   " << s.name << "  " << std::fixed << std::setprecision(3)
+                  << std::setw(8) << te << "   " << std::setw(8) << tc << "   "
+                  << std::setprecision(2) << std::setw(6) << (tc/te) << "x\n";
+    }
+    std::cout << std::endl;
+}
+
+}} // namespace
+
+#endif

modules/core/src/arithm.dispatch.cpp

@@ -1,11 +1,189 @@
 // This file is part of OpenCV project.
 // It is subject to the license terms in the LICENSE file found in the top-level directory
-// of this distribution and at http://opencv.org/license.html
+// of this distribution and at http://opencv.org/license.html.
+
+// Dispatch layer for the element-wise kernels (arithm.simd.hpp). Two tiers of plain
+// functions sit on top of the per-baseline get*Func_:
+//   - get*Func(...)      : forward to the CPU-optimal kernel via CV_CPU_DISPATCH (the useful op-
+//                          specific entry points; candidates for CV_EXPORTS later);
+//   - getElemwiseFunc(...): the op-level router used by the compiler.
 
 #include "precomp.hpp"
-#include "arithm_ipp.hpp"
+#include "arithm_expr.hpp"
 #include "arithm.simd.hpp"
 #include "arithm.simd_declarations.hpp"
 
-#define ARITHM_DISPATCHING_ONLY
+namespace cv { namespace ew {
-#include "arithm.simd.hpp"
+
+// ---- tier 2: pick the kernel optimized for the current CPU ---------------------------------------
+TKernel getAddFunc(int T, int R)            { CV_CPU_DISPATCH(getAddFunc_,     (T, R),          CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getSubFunc(int T, int R)            { CV_CPU_DISPATCH(getSubFunc_,     (T, R),          CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getMulFunc(int T, int R)            { CV_CPU_DISPATCH(getMulFunc_,     (T, R),          CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getDivFunc(int T, int R, bool chk)  { CV_CPU_DISPATCH(getDivFunc_,     (T, R, chk),     CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getMinFunc(int T, int R)            { CV_CPU_DISPATCH(getMinFunc_,     (T, R),          CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getMaxFunc(int T, int R)            { CV_CPU_DISPATCH(getMaxFunc_,     (T, R),          CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getAbsdiffFunc(int T, int R)        { CV_CPU_DISPATCH(getAbsdiffFunc_, (T, R),          CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getHypotFunc(int T, int R)          { CV_CPU_DISPATCH(getHypotFunc_,   (T, R),          CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getAtan2Func(int T, int R)          { CV_CPU_DISPATCH(getAtan2Func_,   (T, R),          CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getCmpFunc(TOp op, int T)           { CV_CPU_DISPATCH(getCmpFunc_,     (op, T),         CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getBitwiseFunc(TOp op, int esz)     { CV_CPU_DISPATCH(getBitwiseFunc_, (op, esz),       CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getNotFunc(int esz)                 { CV_CPU_DISPATCH(getNotFunc_,     (esz),           CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getAddWeightedFunc(int T, int R)    { CV_CPU_DISPATCH(getAddWeightedFunc_, (T, R),      CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getSelectFunc(int mdepth, int T)    { CV_CPU_DISPATCH(getSelectFunc_,  (mdepth, T),     CV_CPU_DISPATCH_MODES_ALL); }
+TKernel getClampFunc(int T)                 { CV_CPU_DISPATCH(getClampFunc_,   (T),             CV_CPU_DISPATCH_MODES_ALL); }
+static TKernel getCastFunc(int sd, int dd, bool scaled)
+                                            { CV_CPU_DISPATCH(getCastFunc_,    (sd, dd, scaled),CV_CPU_DISPATCH_MODES_ALL); }
+
+// ---- tier 3: op-level dispatcher used by the compiler --------------------------------------------
+TKernel getElemwiseFunc(TOp op, int depth0, int depth1, int depth2, int rdepth)
+{
+    (void)depth2;
+
+    if (op == OP_CAST)          return getCastFunc(depth0, rdepth, false);
+    if (op == OP_CONVERT_SCALE) return getCastFunc(depth0, rdepth, true);
+
+    if (op == OP_ADD || op == OP_SUB)
+    {
+        if (depth0 != depth1) return {};   // operands must be the same type
+        return op == OP_ADD ? getAddFunc(depth0, rdepth) : getSubFunc(depth0, rdepth);
+    }
+
+    // OP_ADDW (addWeighted): a*alpha+b*beta+gamma; operands same type T, result R (T/f32 for small ints
+    // + f16/bf16/f32, f64 otherwise). alpha/beta/gamma travel in the instruction's params.
+    if (op == OP_ADDW)
+    {
+        if (depth0 != depth1) return {};
+        return getAddWeightedFunc(depth0, rdepth);
+    }
+
+    // OP_MUL / OP_DIV / OP_POW: operands same type T; compute in the float work type (rdepth).
+    if (op == OP_MUL || op == OP_DIV || op == OP_POW)
+    {
+        if (depth0 != depth1) return {};
+        if (op == OP_MUL) return getMulFunc(depth0, rdepth);
+        if (op == OP_POW) return getPowFunc(depth0, rdepth);
+        // integer inputs guard divide-by-zero (-> 0); floats do not (a/0 -> inf, matching cv::divide).
+        const bool isflt = depth0==CV_16F || depth0==CV_16BF || depth0==CV_32F || depth0==CV_64F;
+        return getDivFunc(depth0, rdepth, !isflt);
+    }
+
+    // OP_MIN / OP_MAX: T x T -> T.
+    if (op == OP_MIN || op == OP_MAX)
+    {
+        if (depth0 != depth1 || rdepth != depth0) return {};
+        return op == OP_MIN ? getMinFunc(depth0, rdepth) : getMaxFunc(depth0, rdepth);
+    }
+
+    // OP_ABSDIFF: result is absdiffResultDepth(T) (unsigned same width for signed).
+    if (op == OP_ABSDIFF)
+    {
+        if (depth0 != depth1) return {};
+        return getAbsdiffFunc(depth0, rdepth);
+    }
+
+    // OP_CMP_*: T x T -> u8 mask (0 / 1 / 255, value via TKernel::flags).
+    if (opCategory(op) == CAT_COMPARE)
+    {
+        if (depth0 != depth1 || rdepth != CV_8U) return {};
+        return getCmpFunc(op, depth0);
+    }
+
+    // OP_AND / OP_OR / OP_XOR: bit-pattern op, T x T -> T (same depth), dispatched by element size.
+    if (op == OP_AND || op == OP_OR || op == OP_XOR)
+    {
+        if (depth0 != depth1 || rdepth != depth0) return {};
+        return getBitwiseFunc(op, CV_ELEM_SIZE1(depth0));
+    }
+
+    // OP_NOT: ~x, one input, T -> T (same depth), dispatched by element size.
+    if (op == OP_NOT)
+    {
+        if (rdepth != depth0) return {};
+        return getNotFunc(CV_ELEM_SIZE1(depth0));
+    }
+
+    // OP_HYPOT / OP_ATAN2: T x T -> T over the float depths (integer inputs are the compiler's job).
+    if (op == OP_HYPOT || op == OP_ATAN2)
+    {
+        if (depth0 != depth1) return {};
+        return op == OP_HYPOT ? getHypotFunc(depth0, rdepth) : getAtan2Func(depth0, rdepth);
+    }
+
+    // unary math: T -> T over the float depths (math.simd.hpp). Anything else - integer input,
+    // widening/narrowing result - is the compiler's job (cast to a float working type first).
+    if (op == OP_SQRT || op == OP_EXP || op == OP_LOG || op == OP_SIN || op == OP_COS ||
+        op == OP_TANH || op == OP_ERF || op == OP_RELU)
+    {
+        if (rdepth != depth0) return {};
+        return getMathFunc(op, depth0);
+    }
+
+    // OP_SELECT: depth0 is the (1-byte, never cast) mask; both branches and dst share one depth.
+    if (op == OP_SELECT)
+    {
+        if (depth1 != depth2 || rdepth != depth1) return {};
+        return getSelectFunc(depth0, rdepth);
+    }
+
+    // OP_CLAMP: x, lo, hi and dst all share one depth (emitTernary unifies them).
+    if (op == OP_CLAMP)
+    {
+        if (depth1 != depth0 || depth2 != depth0 || rdepth != depth0) return {};
+        return getClampFunc(rdepth);
+    }
+
+    return {};
+}
+
+}} // namespace cv::ew
+
+namespace cv { namespace hal {
+
+// Legacy cv::hal entry point, still declared in core/hal/hal.hpp and used by external code (the
+// G-API fluid backend in opencv_contrib calls it directly): forward to the element-wise engine's
+// u8 multiply kernel. `scale` is a pointer to a double, as in the old contract.
+void mul8u(const uchar* src1, size_t step1, const uchar* src2, size_t step2,
+           uchar* dst, size_t step, int width, int height, void* scale)
+{
+    const double params[] = { scale ? *(const double*)scale : 1.0 };
+    ew::TKernel k = ew::getMulFunc(CV_8U, CV_8U);
+    k.fptr(src1, step1, 1, src2, step2, 1, nullptr, 0, 0, dst, step, width, height,
+           params, k.flags, k.userdata);
+}
+
+// Legacy cv::hal bitwise entry points, still declared in core/hal/hal.hpp and used by other modules
+// (e.g. opencv_objdetect's aruco) and external code: forward to the element-wise engine's byte-wise
+// bitwise kernels. No scalar params - bitwise ops ignore them.
+static void bitwise8u(ew::TOp op, const uchar* src1, size_t step1, const uchar* src2, size_t step2,
+                      uchar* dst, size_t step, int width, int height)
+{
+    const double noparams[4] = {};
+    ew::TKernel k = ew::getBitwiseFunc(op, 1);
+    CV_Assert(k.fptr != nullptr);
+    k.fptr(src1, step1, 1, src2, step2, 1, nullptr, 0, 0, dst, step, width, height,
+           noparams, k.flags, k.userdata);
+}
+
+void and8u(const uchar* src1, size_t step1, const uchar* src2, size_t step2,
+           uchar* dst, size_t step, int width, int height, void*)
+{ bitwise8u(ew::OP_AND, src1, step1, src2, step2, dst, step, width, height); }
+
+void or8u(const uchar* src1, size_t step1, const uchar* src2, size_t step2,
+          uchar* dst, size_t step, int width, int height, void*)
+{ bitwise8u(ew::OP_OR, src1, step1, src2, step2, dst, step, width, height); }
+
+void xor8u(const uchar* src1, size_t step1, const uchar* src2, size_t step2,
+           uchar* dst, size_t step, int width, int height, void*)
+{ bitwise8u(ew::OP_XOR, src1, step1, src2, step2, dst, step, width, height); }
+
+void not8u(const uchar* src1, size_t step1, const uchar* /*src2*/, size_t /*step2*/,
+           uchar* dst, size_t step, int width, int height, void*)
+{
+    const double noparams[4] = {};
+    ew::TKernel k = ew::getNotFunc(1);
+    CV_Assert(k.fptr != nullptr);
+    k.fptr(src1, step1, 1, nullptr, 0, 0, nullptr, 0, 0, dst, step, width, height,
+           noparams, k.flags, k.userdata);
+}
+
+}} // namespace cv::hal

modules/core/src/arithm_expr.hpp

@@ -0,0 +1,346 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// The new element-wise expression engine - low-level contract shared by the kernels
+// (arithm.simd.hpp), the per-op dispatchers (arithm.dispatch.cpp) and the
+// graph compiler / executor / parser (arithm_expr.cpp).
+//
+// Private core header for now; once cv::add() is rebuilt on top of it, the public-facing parts
+// (cv::expression, the get*Func entry points) move to external headers. Assumes precomp.hpp (Mat,
+// MatShape, AutoBuffer, Scalar) is already included.
+//
+// Design notes (agreed):
+//  - Universal arity: every instruction is {fptr, arg0, arg1, arg2, result}; unused operands
+//    reference the reserved "none" arg slot (index 0).
+//  - A kernel processes one 2D tile of a single slice; broadcasting is per-operand y/x steps
+//    (step 0 = re-read). Steps are in ELEMENTS; dst is contiguous in x (dst.stepx == 1).
+
+#ifndef OPENCV_CORE_ARITHM_EXPR_HPP
+#define OPENCV_CORE_ARITHM_EXPR_HPP
+
+#include <array>
+#include <iosfwd>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+namespace cv { namespace ew {
+
+// Sentinel depth for an unused operand (note: CV_8U == 0 is a *valid* depth,
+// so the "no operand" marker must be negative).
+enum { EW_DEPTH_NONE = -1 };
+
+// Each op carries a fixed numerical value whose high bits encode its arity, so the arity
+// can be recovered with a shift and no lookup table:  arity = (op >> OP_ARITY_SHIFT) & 7.
+// The ops are grouped into contiguous arity blocks (unary = 1<<10, binary = 2<<10,
+// ternary = 3<<10); within a block the low bits are just a running index.
+enum { OP_ARITY_SHIFT = 10 };
+enum
+{
+    OP_UNARY_BASE   = 1 << OP_ARITY_SHIFT,   // 0x400
+    OP_BINARY_BASE  = 2 << OP_ARITY_SHIFT,   // 0x800
+    OP_TERNARY_BASE = 3 << OP_ARITY_SHIFT    // 0xC00
+};
+
+// The single enumeration of element-wise operations, used both in the IR and by the
+// kernel dispatcher.
+enum TOp
+{
+    OP_NOP = 0,
+
+    // ---------------- unary (arity 1) ----------------
+    OP_NEG = OP_UNARY_BASE, OP_ABS, OP_NOT,
+    OP_SQRT, OP_EXP, OP_LOG,
+    OP_SIN, OP_COS, OP_TANH, OP_ERF, OP_RELU,
+    OP_CAST,            // saturating type conversion, no scaling
+
+    // ---------------- binary (arity 2) ----------------
+    OP_ADD = OP_BINARY_BASE, OP_SUB, OP_MUL, OP_DIV, OP_POW,
+    OP_MIN, OP_MAX, OP_ABSDIFF,
+    OP_AND, OP_OR, OP_XOR,
+    // compare -> mask (result depth given explicitly, e.g. CV_Bool/CV_8U)
+    OP_CMP_EQ, OP_CMP_NE, OP_CMP_LT, OP_CMP_LE, OP_CMP_GT, OP_CMP_GE,
+    // addWeighted: a*alpha + b*beta + gamma (params = {alpha, beta, gamma}). A fused composite, not a
+    // kernel - emitBinary expands it. Placed last in the binary group so it doesn't renumber the ops
+    // above it (some dispatch is by enum value).
+    OP_ADDW,
+    // hypot(x, y) = sqrt(x^2 + y^2), the magnitude of a 2D vector. NAIVE evaluation (matching
+    // cv::magnitude), NOT the overflow-safe std::hypot. Computes in the float domain like OP_POW.
+    OP_HYPOT,
+    // atan2(y, x) in RADIANS, standard C range (-pi, pi] (NB: cv::phase/fastAtan2 use degrees
+    // [0, 360)). arg0 = y, arg1 = x, like std::atan2. Float domain, like OP_POW/OP_HYPOT.
+    OP_ATAN2,
+
+    // ---------------- ternary (arity 3) ----------------
+    OP_CLAMP = OP_TERNARY_BASE,   // clamp(x, lo, hi)
+    // select(mask, a, b) (a.k.a. where): dst = (mask != 0) ? a : b; mask is 1 byte (bool/u8/s8),
+    // never cast. Also the engine's masked-op tail: cv::add(..., mask) computes into a temp r,
+    // then select(mask, r, dst) -> dst overwrites only the masked subset of the (pre-existing)
+    // output (dst rides as both arg2 and the result slot; the kernel is alias-safe).
+    OP_SELECT,
+    OP_CONVERT_SCALE              // cast<rdepth>(src*scale + offset); scale/offset may be tensors
+};
+
+// Arity from the encoding above (0 for OP_NOP). No table to keep in lock-step with the enum.
+inline int opArity(TOp op) { return ((int)op >> OP_ARITY_SHIFT) & 7; }
+
+// Operation category — the graph compiler's type-inference rules differ per category.
+enum ElemwiseCategory
+{
+    CAT_ARITH = 0,  // numeric, result type follows promotion rules
+    CAT_BITWISE,    // integer-only, same-type
+    CAT_COMPARE,    // produces a mask, result depth is explicit
+    CAT_MATH,       // transcendental, float domain
+    CAT_CAST,       // type conversion (with/without scaling)
+    CAT_SELECT      // data-routing (select/where)
+};
+
+// Op metadata (implemented in arithm_expr.cpp).
+CV_EXPORTS const char* opName(TOp op);
+CV_EXPORTS ElemwiseCategory opCategory(TOp op);
+
+// numpy-style arithmetic promotion of two depths (see arithm_expr.cpp): INTEGER-PRESERVING and
+// COMMUTATIVE; mixed sign -> a wide-enough signed type; any float -> the smallest covering float.
+// EW_DEPTH_NONE on one side returns the other. The rdepth==-1 auto result-depth rule.
+CV_EXPORTS int promoteArith(int a, int b);
+
+// The 'safe' result depth of absdiff over a value of `depth`: a SIGNED integer difference can reach
+// 2^width-1 (|(-128)-127| = 255), so it needs the UNSIGNED type of the same width (8s->8u, 16s->16u,
+// 32s->32u, 64s->64u) to hold it without saturation. Unsigned/float depths keep their type.
+CV_EXPORTS int absdiffResultDepth(int depth);
+
+// ---------------------------------------------------------------------------
+// Steps for one operand, in elemsize1 units, one entry per shape dim (parallel to a
+// MatShape). A 0 entry means broadcast along that axis. Heap-free, like MatShape.
+// ---------------------------------------------------------------------------
+typedef std::array<size_t, MatShape::MAX_DIMS> EwSteps;
+
+// ---------------------------------------------------------------------------
+// The low-level kernel contract.
+//
+// Processes a width x height tile of one slice. Each source operand carries its own
+// (stepy, stepx) in elements; a 0 step means broadcast along that axis. stepx is restricted
+// to {0,1} (1 = contiguous, 0 = broadcast-scalar along x): the general strided/gather case is
+// excluded and the executor guarantees the invariant. The result is contiguous in x (dst stepx == 1).
+// Returns >= 0 on success, < 0 (a CV_HAL_ERROR_* code) to let the caller fall back.
+//
+// The trailing `params` points at the instruction's scalar parameter block (Insn::params, a cv::Scalar's
+// 4 doubles): mul/div read params[0] as a scale (1.0 = none). `flags` carries small per-kernel options
+// (e.g. a compare op's 0/1-vs-0/255 mask value); `userdata` carries a wrapped core BinaryFunc for casts.
+// ---------------------------------------------------------------------------
+typedef int (*KernelFunc)(
+    const void* src0, size_t step0y, size_t step0x,
+    const void* src1, size_t step1y, size_t step1x,
+    const void* src2, size_t step2y, size_t step2x,
+    void*       dst,  size_t dstepy,
+    int width, int height, const double* params,
+    int flags, void* userdata);
+
+// TKernel::flags - small per-kernel options, interpreted by the kernel itself (so the meaning is
+// per-kernel: the cast kernels read it as the dst element size, the compare kernels as the bits below).
+enum TKernelFlags
+{
+    EW_KERNEL_MASK1  = 1,   // compare: emit a 0/1 mask instead of the default 0/255 (cv::compare)
+    EW_KERNEL_SWAP01 = 2,   // compare: the kernel swaps its own src0<->src1 (with their steps), so
+                            // LT/LE reuse the GT/GE kernels (a<b == b>a, a<=b == b>=a)
+    // compare fuses its post-op fix-up: the u8 result is (rawmask & M) | V per channel. Uniform (this
+    // bit clear): M = trueVal (MASK1 ? 1 : 255), V = 0 - an ordinary compare. Per-channel (this bit
+    // set, only the divergent multi-channel scalar case): M/V come from the 4-bit fields below. This
+    // folds the former separate patch pass into the compare kernel (one pass, no extra kernel).
+    EW_CMP_PATCH     = 4,
+    EW_CMP_PATCH_SHIFT = 8, // per channel c in [0,4): bits [SHIFT+c*4 .. +4) = 2 bits M then 2 bits V;
+                            // each 2-bit field decodes 0->0x00, 1->0x01, 2|3->0xFF.
+};
+
+// Decode a 2-bit patch field (0->0, 1->1, else 255) - shared by the compare kernel and its builder.
+inline int cmpPatchByte(int twoBits) { return twoBits == 0 ? 0 : twoBits == 1 ? 1 : 255; }
+
+struct TKernel
+{
+    KernelFunc fptr = nullptr;
+    void* userdata = nullptr;
+    int flags = 0;
+};
+
+// ---- per-op kernel entry points (implemented in arithm.dispatch.cpp) ----------------------
+// Each returns the kernel optimized for the current CPU (it forwards through CV_CPU_DISPATCH to the
+// matching get*Func_ compiled per SIMD baseline in arithm.simd.hpp). `T` is the (common) input
+// depth, `R` the result depth; EW_DEPTH_NONE marks an unused operand. A null fptr means "no exact
+// kernel for this combination" - the compiler then inserts OP_CAST and retries with a working type.
+// These are the useful, op-specific intermediaries (candidates for CV_EXPORTS later).
+CV_EXPORTS TKernel getAddFunc(int T, int R);
+CV_EXPORTS TKernel getSubFunc(int T, int R);
+CV_EXPORTS TKernel getMulFunc(int T, int R);
+CV_EXPORTS TKernel getDivFunc(int T, int R, bool checked);   // `checked` => guard b==0 -> 0 (integer divide)
+CV_EXPORTS TKernel getPowFunc(int T, int R);
+CV_EXPORTS TKernel getMinFunc(int T, int R);
+CV_EXPORTS TKernel getMaxFunc(int T, int R);
+CV_EXPORTS TKernel getAbsdiffFunc(int T, int R);
+CV_EXPORTS TKernel getHypotFunc(int T, int R);               // OP_HYPOT, T x T -> T (float depths)
+CV_EXPORTS TKernel getAtan2Func(int T, int R);               // OP_ATAN2, T x T -> T (float depths)
+CV_EXPORTS TKernel getCmpFunc(TOp op, int T);                // T x T -> u8 mask (op = OP_CMP_*)
+CV_EXPORTS TKernel getBitwiseFunc(TOp op, int esz);          // OP_AND / OP_OR / OP_XOR, by element size
+CV_EXPORTS TKernel getNotFunc(int esz);                      // OP_NOT, by element size
+CV_EXPORTS TKernel getAddWeightedFunc(int T, int R);         // OP_ADDW, a*alpha+b*beta+gamma (T x T -> R)
+CV_EXPORTS TKernel getSelectFunc(int mdepth, int T);         // OP_SELECT: 1-byte mask, a/b/dst of T
+CV_EXPORTS TKernel getClampFunc(int T);                      // OP_CLAMP: min(max(x, lo), hi), all of T
+// math.dispatch.cpp (kernels in math.simd.hpp):
+CV_EXPORTS TKernel getMathFunc(TOp op, int T);               // unary math (OP_SQRT..OP_RELU), T -> T,
+                                                             // T in {f16, bf16, f32, f64}; exp/log at
+                                                             // f32/f64 route through HAL/IPP when installed
+// the engine's OWN vector kernel over one contiguous span - the built-in implementation behind
+// cv::hal::exp32f & co (their table kernels are gone), and getMathFunc's final fallback
+CV_EXPORTS void mathSpanEngine(TOp op, int depth, const void* src, void* dst, int n);
+// getPowFunc is declared above with the arithm getters but LIVES in math.dispatch.cpp too
+// (powKernel: special-cased scalar exponents + the exp(y*log(x)) general path)
+
+// The op-level dispatcher: routes (op, depths) to the right get*Func above. nullptr if the exact
+// combination is not provided. Unused operand depths are EW_DEPTH_NONE.
+CV_EXPORTS TKernel getElemwiseFunc(TOp op, int depth0, int depth1, int depth2, int rdepth);
+
+// An element-wise expression as ONE flat program (the analogue of cv::MatExpr for element-wise ops):
+// an arg table (`arginfo`, the typed operands) + an instruction list (`prog`). The program IS the
+// representation - it is built directly:
+//   - declare operands with addInput()/addConst()/addOutput() (and addTemp() for intermediates);
+//   - append operations with addInsn() (a single op, you pick the slots) or, for automatic type
+//     inference + cast insertion, with emitUnary()/emitBinary()/emitTernary().
+// Operand types are known at build time, so addInsn resolves each instruction's kernel on the spot;
+// compile() is a cheap finalize pass (pack temps into physical buffers via liveness).
+//
+// Heap-free for the common case: to back cv::add() the program is (re)built every call, so the
+// containers must not allocate for typical (small) expressions. AutoBuffer keeps a handful of
+// insns/slots inline on the stack and only spills to the heap for large expressions; it is copyable,
+// so TExpr is still returned/passed by value. A default-constructed AutoBuffer is empty (size()==0)
+// and grows like std::vector (push_back amortized 1.5x); clear() resets the size to 0.
+struct CV_EXPORTS TExpr
+{
+    // Static (shape-independent) classification of an arg slot.
+    enum ArgKind
+    {
+        NONE = 0,   // the reserved empty operand (slot 0)
+        INPUT,
+        CONST,
+        TEMP,
+        OUTPUT
+    };
+
+    struct Arg
+    {
+        ArgKind kind = NONE;
+        int depth = EW_DEPTH_NONE;  // EW_DEPTH_NONE on a CONST = "flexible" (the emit* layers type it per use)
+        int channels = 0;           // for CONST: # of per-channel values (0/1 => single broadcast value)
+        int index = -1;             // input#/output#/temp-id depending on kind
+        // CONST only: the constant's values live in TExpr::constbuf (in `srcdepth` until compile(),
+        // which converts them to the resolved `depth`). constofs = offset into constbuf, in uint64_t
+        // units. A per-channel scalar of any width is carried this way (no 4-channel Scalar limit).
+        int srcdepth = EW_DEPTH_NONE;
+        size_t constofs = 0;
+    };
+
+    // One compiled instruction: the op + arg-table indices + a resolved kernel (TKernel: fptr +
+    // userdata + flags). Every kernel uses the SAME calling convention (the universal KernelFunc);
+    // OP_CAST / OP_CONVERT_SCALE bind castKernel, which carries the core convert BinaryFunc in
+    // kernel.userdata. `params` is the per-instruction scalar block (mul/div scale in params[0];
+    // convert_scale {scale, offset} in params[0..1]). The kernel is bound by addInsn at build time.
+    struct Insn
+    {
+        TKernel kernel;
+        TOp op = OP_NOP;
+        int arg0 = 0, arg1 = 0, arg2 = 0, result = 0;
+        Scalar params = Scalar(1);          // op scalars; params[0]=scale defaults to 1 (identity)
+    };
+
+    AutoBuffer<Insn, 16>   prog;             // instructions, in execution order (kernels bound by addInsn)
+    AutoBuffer<Arg, 16>    arginfo;          // slot 0 is always NONE
+    AutoBuffer<uint64_t, 16> constbuf;       // CONST value store (uint64-aligned slots); Arg::constofs
+                                             // indexes it. Source values on build, resolved-type after compile()
+    int ninputs = 0;
+    int noutputs = 0;
+    int ntemps = 0;
+    int nbuffers = 0;                        // distinct physical temp buffers after liveness
+    int nconsts = 0;                         // # materialized CONST slots (set by compile()) - sizes
+                                             // the const store; nconsts==0 enables exec()'s fast path
+    int capElems = 0;                        // # elements one ~16KB L1 scratch fragment holds (set by
+                                             // compile()); INT_MAX when there are no temps.
+    AutoBuffer<int, 16>    bufferOfTemp;     // temp-id -> physical buffer id
+    AutoBuffer<int, 8>     bufEszPrefix;     // [nbuffers+1] prefix sums of each physical temp buffer's
+                                             // elem size (set by compile()); [nbuffers] = temp bytes
+                                             // per output element.
+
+    TExpr();
+    void clear();                            // reset to an empty program (slot 0 = NONE)
+    void dump(std::ostream& os) const;       // human-readable slot table + instruction list (debug)
+
+    // ---- operand / instruction builders (return the new slot / instruction index) ----
+    int  addInput(int depth);
+    int  addConst(int depth, const Scalar& v, int channels = 1);   // source = Scalar (f64); depth NONE => flexible
+    int  addConst(int depth, int srcdepth, const void* data, int channels);   // source = native bytes
+    // A typed copy of a flexible CONST `srcSlot` at the resolved `depth` (shares its source values;
+    // compile() converts them). Used by the emit* layers / parser cast where addConst(depth, cval) was.
+    int  typedConstFrom(int srcSlot, int depth);
+    int  addTemp(int depth);
+    int  addOutput(int depth);
+    // addInsn resolves the instruction's kernel NOW from the operand/result depths (final at build
+    // time). The 2nd form takes a pre-resolved kernel, for callers that already probed getElemwiseFunc.
+    int  addInsn(TOp op, int a0, int a1, int a2, int result, const Scalar& params = Scalar(1));
+    int  addInsn(TOp op, int a0, int a1, int a2, int result, const TKernel& kernel,
+                 const Scalar& params = Scalar(1));
+
+    // Return `arg` unchanged if it is already of depth `depth`; otherwise append an OP_CAST into a
+    // fresh temp of that depth and return the temp's slot. The one place casts are inserted.
+    int  maybeAddCast(int arg, int depth);
+
+    // ---- type-inference + cast-insertion policy layers (parser + hand builders) ----
+    // Each derives the result depth (promotion, or a forced `rdepth`), picks the compute depth and a
+    // wide fallback per op family, materializes flexible CONST operands, casts every operand to the
+    // compute depth, then emits `op` (direct when a kernel exists, else compute wide and cast down).
+    // Returns the slot holding the result. `rdepth` EW_DEPTH_NONE = auto.
+    int  emitUnary(TOp op, int a, int rdepth = EW_DEPTH_NONE, const Scalar& params = Scalar(1));
+    int  emitBinary(TOp op, int a, int b, int rdepth = EW_DEPTH_NONE, const Scalar& params = Scalar(1));
+    int  emitTernary(TOp op, int a, int b, int c, int rdepth = EW_DEPTH_NONE);
+
+    // Land `temp` in the existing slot `out`: redirect temp's single producer to write `out` directly
+    // (dropping a dead last temp so compile() keeps its no-temp fast exit); otherwise copy via OP_CAST.
+    int  moveToOutput(int temp, int out);
+
+    // Declare a result tensor fed by `rootSlot` (a fresh OUTPUT of its depth) and moveToOutput into it.
+    int  output(int rootSlot);
+
+    // Finalize: pack temps into physical buffers (liveness), count consts, size the L1 fragment cap.
+    void compile();
+
+    // The broadcast output geometry for the given inputs (spatial dims + channel count, channels
+    // innermost). All outputs share it; their depth comes from arginfo. Lets a caller pre-create the
+    // destination (dst.create(spatial, CV_MAKETYPE(depth, channels))) before exec writes into it.
+    // Inputs are passed as an array of pointers (no Mat-header copies in the hot path).
+    void outputShape(const Mat* const* inputs, MatShape& spatial, int& channels) const;
+
+    // Execute the compiled program over a set of input Mats, producing the broadcast result(s). If an
+    // output Mat already has the right shape/type it is reused (not reallocated). Inputs are passed as
+    // an array of pointers.
+    void exec(const Mat* const* inputs, Mat* outputs);
+
+    // Convenience overloads: inputs as a contiguous array of Mats (builds the pointer array + forwards).
+    // Handy for callers holding a Mat[]/vector<Mat>; the hot path should pass pointers directly.
+    void outputShape(const Mat* inputs, MatShape& spatial, int& channels) const;
+    void exec(const Mat* inputs, Mat* outputs);
+};
+
+// ---- hand builders (the stand-ins the future engine-backed cv::add etc. are built on) ----
+// Compose a binary op (ADD/SUB/MUL/DIV/MIN/MAX/ABSDIFF/CMP_*) for any (depth0, depth1, rdepth):
+// cast operands to a common type, op direct-or-wide-then-cast. maskDepth != EW_DEPTH_NONE adds a
+// write-mask input (#2); scale != 1 (mul/div) rides the instruction's params[0].
+CV_EXPORTS void makeBinaryArithProgram(TExpr& p, TOp op, int depth0, int depth1, int rdepth,
+                                       int maskDepth = EW_DEPTH_NONE, double scale = 1.0);
+
+// addWeighted(a,alpha,b,beta,gamma) = a*alpha + b*beta + gamma (two fused convert_scale MACs + add).
+CV_EXPORTS void makeAddWeightedProgram(TExpr& p, int depth0, int depth1, int rdepth,
+                                       double alpha, double beta, double gamma);
+
+// NOTE: the string front-end is the PUBLIC cv::texpr() (declared in opencv2/core.hpp, defined in
+// arithm_expr.cpp) - there is no cv::ew::expression() indirection.
+
+}} // namespace cv::ew
+
+#endif // OPENCV_CORE_ARITHM_EXPR_HPP

modules/core/src/broadcast.cpp

@@ -0,0 +1,401 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// Implementation of cv::BroadcastOp (declared in opencv2/core/mat.hpp): an op-agnostic driver for
+// broadcasting element-wise traversal. It computes the numpy-broadcast iteration space over a flat
+// list of operand Mats, collapses contiguous dims, partitions into tiles for parallel_for_, and hands
+// each 2D tile's per-operand slices to a `body` callback (which owns all semantics).
+
+#include "precomp.hpp"
+#include <algorithm>
+#include <array>
+#include <climits>
+#include <cmath>
+
+namespace cv {
+
+// Per-operand steps along the (collapsed) iteration axes are kept in a MatStep (a value-type holding
+// MAX_DIMS size_t entries). Here the entries are steps in ELEMENTS (one scalar / channel value), not
+// the byte steps a Mat stores - the container is reused for its fixed-size storage and [] access.
+
+// ---------------------------------------------------------------------------
+// Geometry helpers.
+// ---------------------------------------------------------------------------
+
+// How a Mat's channels are mapped into the logical (shape, step, esz1) handed to the geometry:
+//   CH_FOLD : channels stay scalar-wise, folded into the innermost dim (back() *= cn, step 1).
+//             Used (expandChannels=true) when no channel broadcast is needed (all single-channel,
+//             or all same-cn with equal back()) - the body then sees single-channel data.
+//   CH_DIM  : channels become an explicit innermost iteration dim (cn, step 1); single-channel
+//             operands get a size-1 channel that broadcasts 1->N. Used when channel broadcast is
+//             needed (mixed channel counts, or multichannel with differing back()).
+//   CH_ELEM : channels stay inside the element (esz = full elemSize, no channel dim). Used with
+//             expandChannels=false; the body handles channels itself (deinterleave fast path).
+enum ChMode { CH_FOLD, CH_DIM, CH_ELEM };
+
+static void matLayout(const Mat& m, ChMode mode, MatShape& shp, MatStep& step, int& esz1)
+{
+    const int nd = m.dims, cn = m.channels();
+    if (mode == CH_ELEM)
+    {
+        esz1 = (int)m.elemSize();                       // one full (cn-channel) pixel
+        shp.resize(nd);
+        for (int i = 0; i < nd; i++) { shp[i] = m.size[i]; step[i] = m.step[i] / esz1; }
+        return;
+    }
+    esz1 = (int)m.elemSize1();                           // one scalar (channel value)
+    if (mode == CH_DIM)
+    {
+        shp.resize(nd + 1);
+        for (int i = 0; i < nd; i++) { shp[i] = m.size[i]; step[i] = m.step[i] / esz1; }
+        shp[nd] = cn; step[nd] = 1;                      // channels = explicit innermost dim
+    }
+    else // CH_FOLD
+    {
+        if (nd == 0)                                     // 0-dim scalar: channels are the only dim
+        {
+            shp.assign(1, cn);
+            step[0] = 1;
+        }
+        else
+        {
+            shp.resize(nd);
+            for (int i = 0; i < nd; i++) { shp[i] = m.size[i]; step[i] = m.step[i] / esz1; }
+            shp[nd - 1] *= cn;                           // fold channels into the innermost dim
+            step[nd - 1] = 1;                            // scalars are contiguous there
+        }
+    }
+}
+
+// A single-channel scalar (one value, cn==1, total()==1) broadcasts into everything trivially
+// (step 0 on every axis incl. channels), so it must NOT force CH_DIM - it is excluded from the
+// channel-mode decision entirely.
+static bool isSingleChannelScalar(const Mat& m)
+{
+    return m.channels() == 1 && m.total() == 1;
+}
+
+// Decide (globally, across all operands) how channels are presented for expandChannels=true:
+// CH_FOLD when no channel broadcast is needed, CH_DIM when it is. Single-channel scalars are
+// excluded first; among the rest, multichannel operands must all share the same cn (an (n,m) mix
+// with both > 1 is an error).
+static ChMode decideChannelMode(const Mat* const* arrays, int K)
+{
+    int N = 1;                                           // the single multichannel count, if any
+    for (int k = 0; k < K; k++)
+    {
+        if (isSingleChannelScalar(*arrays[k])) continue;
+        int c = arrays[k]->channels();
+        if (c > 1) { if (N == 1) N = c; else CV_Assert(N == c && "ew: (n,m) channel mix unsupported"); }
+    }
+    if (N == 1) return CH_FOLD;                          // all single-channel -> fold (a no-op)
+
+    bool allMulti = true, sameBack = true;
+    int back = -1;
+    for (int k = 0; k < K; k++)
+    {
+        const Mat& a = *arrays[k];
+        if (isSingleChannelScalar(a)) continue;
+        if (a.channels() != N) allMulti = false;
+        int b = a.dims > 0 ? a.size[a.dims - 1] : 1;   // 0-dim scalar has no spatial back (=1)
+        if (back < 0) back = b; else if (b != back) sameBack = false;
+    }
+    return (allMulti && sameBack) ? CH_FOLD : CH_DIM;    // fold only if no channel broadcast
+}
+
+// numpy-style broadcast of several right-aligned shapes.
+static bool broadcastShape(const MatShape* shps, int K, MatShape& out)
+{
+    size_t nd = 0;
+    for (int k = 0; k < K; k++) nd = std::max(nd, shps[k].size());
+    out.assign(nd, 1);
+    for (int k = 0; k < K; k++)
+    {
+        const MatShape& s = shps[k];
+        size_t off = nd - s.size();
+        for (size_t i = 0; i < s.size(); i++)
+        {
+            int d = s[i], &o = out[off + i];
+            if (o == 1) o = d;
+            else if (d != 1 && d != o) return false;
+        }
+    }
+    return true;
+}
+
+// Right-align an arg's own (shp,step) to nd dims; broadcast dims get step 0.
+static void alignArg(const MatShape& shp, const MatStep& step, int nd,
+                     MatStep& as, MatShape& ash)
+{
+    as.clear();
+    ash.assign(nd, 1);
+    int off = nd - (int)shp.size();
+    for (int i = 0; i < (int)shp.size(); i++)
+    {
+        int d = shp[i];
+        ash[off + i] = d;
+        as[off + i] = (d == 1) ? 0 : step[i];
+    }
+}
+
+// Collapse adjacent dims that are contiguous (and broadcast-consistent) across all args.
+static int collapseDims(MatStep* S, MatShape* H, int K, MatShape& D)
+{
+    int nd = (int)D.size();
+    if (nd <= 1) return nd;
+
+    int j = nd - 1;
+    for (int i = j - 1; i >= 0; i--)
+    {
+        bool contig = true, scalar = true, consist = true;
+        for (int k = 0; k < K; k++)
+        {
+            size_t st = S[k][j] * (size_t)H[k][j];
+            bool prevScalar = H[k][j] == 1;
+            bool curScalar = H[k][i] == 1;
+            contig  = contig  && (st == S[k][i]);
+            scalar  = scalar  && curScalar;
+            consist = consist && (curScalar == prevScalar);
+        }
+        if (contig && (consist || scalar))
+        {
+            for (int k = 0; k < K; k++) H[k][j] *= H[k][i];
+            D[j] *= D[i];
+        }
+        else
+        {
+            j--;
+            if (i < j)
+            {
+                for (int k = 0; k < K; k++) { H[k][j] = H[k][i]; S[k][j] = S[k][i]; }
+                D[j] = D[i];
+            }
+        }
+    }
+
+    int m = nd - j;
+    for (int d = 0; d < m; d++)
+    {
+        D[d] = D[j + d];
+        for (int k = 0; k < K; k++) { S[k][d] = S[k][j + d]; H[k][d] = H[k][j + d]; }
+    }
+    D.resize(m);
+    for (int k = 0; k < K; k++) H[k].resize(m);
+
+    // Zero out steps of broadcast (size-1) dims (numpy step==0 trick).
+    for (int d = 0; d < m; d++)
+        for (int k = 0; k < K; k++)
+            if (H[k][d] == 1) S[k][d] = 0;
+
+    return m;
+}
+
+// Fast geometry for the dominant case: every operand is either (a) an array sharing ONE common
+// shape - same dims, sizes and channel count - and contiguous, or (b) a single-channel scalar
+// (cn==1, total()==1). Then the whole traversal is a single contiguous 1D run of `total` scalars
+// (channels folded in): arrays get stepx 1, scalars stepx 0. This skips decideChannelMode /
+// broadcastShape / alignArg / collapseDims and all their per-operand buffers entirely. Returns
+// false (leaving outputs untouched) when the operands don't fit, so the caller runs general
+// geometry. expandChannels=false (CH_ELEM) keeps channels in the element and is left to general.
+static bool fastSameShape(const Mat* const* arrays, int K, bool expandChannels,
+                          uchar** base, int* esz1, MatStep* S, MatShape& D, int& m)
+{
+    if (!expandChannels) return false;
+    int ref = -1;
+    for (int k = 0; k < K; k++)
+        if (!isSingleChannelScalar(*arrays[k])) { ref = k; break; }
+    if (ref < 0) return false;                       // all single-channel scalars: let general handle
+    const Mat& R = *arrays[ref];
+    const int rdims = R.dims, rcn = R.channels();
+    for (int k = 0; k < K; k++)
+    {
+        const Mat& a = *arrays[k];
+        if (isSingleChannelScalar(a)) continue;
+        if (a.channels() != rcn || a.dims != rdims || !a.isContinuous()) return false;
+        for (int i = 0; i < rdims; i++) if (a.size[i] != R.size[i]) return false;
+    }
+    const long long total = (long long)R.total() * rcn;   // channels folded into the 1D run
+    CV_Assert(total <= (long long)INT_MAX);
+    for (int k = 0; k < K; k++)
+    {
+        const Mat& a = *arrays[k];
+        base[k] = (uchar*)a.data;
+        esz1[k] = (int)a.elemSize1();
+        S[k][0] = isSingleChannelScalar(a) ? 0 : 1;
+    }
+    D.assign(1, (int)total);
+    m = 1;
+    return true;
+}
+
+// ---------------------------------------------------------------------------
+// BroadcastOp::run
+// ---------------------------------------------------------------------------
+// At namespace scope, NOT inside run(): MSVC 2019 loses the constexpr-ness of function-local
+// constants used as template arguments inside a lambda (C2975).
+static constexpr int MAX_DIMS = MatShape::MAX_DIMS;
+static constexpr int LOCAL_OPS = 8;
+
+void BroadcastOp::run(const Mat* const* arrays, int narrays,
+                      const std::function<void(const Tile&)>& body,
+                      bool expandChannels,
+                      double nstripes)
+{
+    const int K = narrays;
+    CV_Assert(K >= 1 && arrays != nullptr);
+
+    // ---- 1-3. geometry: per-operand collapsed steps S[k], element sizes esz1[k], base
+    //           pointers, and the collapsed iteration shape D (m dims). The fast path handles the
+    //           dominant "all same-shape arrays (+ single-channel scalars)" case in one shot; the
+    //           general path does decideChannelMode + broadcastShape + align + collapse. ----
+    AutoBuffer<MatStep, LOCAL_OPS>  S(K);
+    AutoBuffer<int, LOCAL_OPS>      esz1(K);
+    AutoBuffer<uchar*, LOCAL_OPS>   base(K);
+    MatShape D;
+    int m;
+
+    if (!fastSameShape(arrays, K, expandChannels, base.data(), esz1.data(), S.data(), D, m))
+    {
+        const ChMode mode = expandChannels ? decideChannelMode(arrays, K) : CH_ELEM;
+        AutoBuffer<MatShape, LOCAL_OPS> shp(K);
+        AutoBuffer<MatStep, LOCAL_OPS>  stp(K);
+        for (int k = 0; k < K; k++)
+        {
+            matLayout(*arrays[k], mode, shp[k], stp[k], esz1[k]);
+            base[k] = (uchar*)arrays[k]->data;
+        }
+        MatShape full;
+        CV_Assert(broadcastShape(shp.data(), K, full) && "ew: operands are not broadcast-compatible");
+        const int nd = (int)full.size();
+        AutoBuffer<MatShape, LOCAL_OPS> H(K);
+        for (int k = 0; k < K; k++) alignArg(shp[k], stp[k], nd, S[k], H[k]);
+        D = full;
+        m = collapseDims(S.data(), H.data(), K, D);
+
+        // For a cv::Mat the innermost (channel/last) axis is contiguous, so after collapse the
+        // innermost stride is always in {0,1}. No gather, no materialization.
+        for (int k = 0; k < K; k++)
+            CV_Assert(S[k][m - 1] <= 1 && "ew: unexpected innermost stride > 1");
+    }
+
+    // ---- 4. inner 2D tile axes: width = D[m-1], height = D[m-2] (if any) ----
+    const int wAxis = m - 1;
+    const int hAxis = (m >= 2) ? m - 2 : -1;
+    const int W   = D[wAxis];
+    const int Hgt = (hAxis >= 0) ? D[hAxis] : 1;
+    const int nOuter = (hAxis >= 0) ? m - 2 : m - 1;   // outer ("plane") axes = [0 .. nOuter)
+    long long nplanes = 1;
+    for (int d = 0; d < nOuter; d++) nplanes *= D[d];
+
+    // ---- 5. desired parallel stripe count (work hint) ----
+    const long long total = nplanes * (long long)Hgt * (long long)W;
+    double stripes = nstripes;
+    if (stripes <= 0)                                  // broadcastOp can't see the body's cost;
+        stripes = (double)total * 100.0 / (double)(1 << 18);  // assume ~100 cycles/element
+    const int wantTiles = std::max(1, (int)std::lround(stripes));
+
+    // ---- 6. tile only for PARALLELISM. broadcastOp is op-agnostic: it does not know the body's
+    //         temp-buffer footprint, so it does NOT tile for L1 - that is the body's job (it
+    //         re-fragments a tile's width into L1-sized chunks for the fused intermediates).
+    //         Start with the largest tile (one 2D block per plane) and split (height first, then
+    //         width) only until there are at least `wantTiles` tiles. Bigger tiles => fewer
+    //         body/decode calls. Width is G-aligned only in the fully-contiguous (1D) case. ----
+    const int G = 16;                  // SIMD/cacheline granule
+    int tw = W, th = Hgt;
+
+    auto ntilesOf = [&](int tw_, int th_) {
+        long long nw = (W + tw_ - 1) / tw_, nh = (Hgt + th_ - 1) / th_;
+        return nplanes * nh * nw;
+    };
+    long long ntiles = ntilesOf(tw, th);
+    while (ntiles < wantTiles && th > 1)               // split height for parallelism
+    {
+        th = (th + 1) / 2;
+        ntiles = ntilesOf(tw, th);
+    }
+    while (ntiles < wantTiles && tw > G)               // then split width
+    {
+        tw = std::max(G, tw / 2);
+        if (hAxis < 0 && tw > G) tw -= tw % G;          // keep width aligned in the 1D case
+        ntiles = ntilesOf(tw, th);
+    }
+    CV_Assert(ntiles <= (long long)INT_MAX);
+
+    const int ntilesW = (W + tw - 1) / tw;
+    const int ntilesH = (Hgt + th - 1) / th;
+
+    // ---- 7. execution; decode tile index -> per-operand slices. stepx/stepy are the same for
+    //         every tile, so they are set ONCE; only the per-tile base pointer is recomputed. ----
+    auto runRange = [&](const Range& r)
+    {
+        AutoBuffer<Slice, LOCAL_OPS> slices(K);
+
+        // Fast 1D path (m==1: one contiguous axis after collapse, no outer planes, height 1).
+        // ntilesH==1 and nplanes==1, so the tile index IS the width-tile index - no div/mod, no
+        // plane multi-index decode, no inner step loop. This is the same-shape / fully-contiguous
+        // common case.
+        if (m == 1)
+        {
+            for (int k = 0; k < K; k++) { slices[k].stepy = 0; slices[k].stepx = S[k][0]; }
+            Tile tile;
+            tile.height = 1; tile.narrays = K; tile.slices = slices.data();
+            for (int t = r.start; t < r.end; t++)
+            {
+                const int wofs = t * tw, ww = std::min(tw, W - wofs);
+                for (int k = 0; k < K; k++)
+                    slices[k].ptr = base[k] + (size_t)wofs * S[k][0] * (size_t)esz1[k];
+                tile.width = ww;
+                body(tile);
+            }
+            return;
+        }
+
+        std::array<int, MAX_DIMS> idx;
+        for (int k = 0; k < K; k++)                     // steps are tile-independent: set once
+        {
+            slices[k].stepy = (hAxis >= 0) ? S[k][hAxis] : 0;
+            slices[k].stepx = S[k][wAxis];
+        }
+        for (int t = r.start; t < r.end; t++)
+        {
+            int wt = t % ntilesW;
+            int rest = t / ntilesW;
+            int ht = rest % ntilesH;
+            int plane = rest / ntilesH;
+
+            const int wofs = wt * tw, ww = std::min(tw, W - wofs);
+            const int hofs = ht * th, hh = std::min(th, Hgt - hofs);
+
+            int p = plane;                              // decode plane -> outer multi-index
+            for (int d = nOuter - 1; d >= 0; d--) {
+                int dd = D[d];
+                int np = p / dd;
+                idx[d] = p - np * dd;
+                p = np;
+            }
+
+            for (int k = 0; k < K; k++)
+            {
+                size_t off = (size_t)wofs * S[k][wAxis];
+                for (int d = 0; d < nOuter; d++) off += (size_t)idx[d] * S[k][d];
+                if (hAxis >= 0) off += (size_t)hofs * S[k][hAxis];
+                slices[k].ptr = base[k] + off * (size_t)esz1[k];
+            }
+
+            Tile tile;
+            tile.width = ww; tile.height = hh; tile.narrays = K; tile.slices = slices.data();
+            body(tile);
+        }
+    };
+
+    // Single tile (small work, wantTiles==1) => run inline and skip the parallel framework
+    // entirely: its dispatch (std::function wrap + Range machinery + backend hop) is pure
+    // overhead when there is nothing to parallelize, and dominates small-array latency.
+    if (ntiles == 1)
+        runRange(Range(0, 1));
+    else
+        parallel_for_(Range(0, (int)ntiles), runRange, stripes);
+}
+
+} // namespace cv

modules/core/src/convert.hpp

@@ -140,6 +140,11 @@ static inline void vx_load_pair_as(const ushort* ptr, v_int32& a, v_int32& b)
     b = v_reinterpret_as_s32(ub);
 }
 
+static inline void vx_load_pair_as(const ushort* ptr, v_uint32& a, v_uint32& b)
+{
+    v_expand(vx_load(ptr), a, b);
+}
+
 static inline void vx_load_pair_as(const short* ptr, v_int32& a, v_int32& b)
 {
     v_expand(vx_load(ptr), a, b);
@@ -428,11 +433,12 @@ static inline void v_store_pair_as(float* ptr, const v_float32& a, const v_float
 
 static inline void v_store_pair_as(unsigned* ptr, const v_float32& a, const v_float32& b)
 {
-    v_int32 z = vx_setzero_s32();
+    // v_round(f32) narrows to v_int32, so values in [2^31, 2^32) saturate to INT32_MAX. Scalar for now
-    v_int32 ia = v_max(v_round(a), z);
+    // (same class as the f64->{u64,s64,u32} stores above); a proper f32->u32 intrinsic can replace it.
-    v_int32 ib = v_max(v_round(b), z);
+    const int n = VTraits<v_float32>::vlanes();
-    v_store(ptr, v_reinterpret_as_u32(ia));
+    float buf[VTraits<v_float32>::max_nlanes*2];
-    v_store(ptr + VTraits<v_int32>::vlanes(), v_reinterpret_as_u32(ib));
+    v_store(buf, a); v_store(buf + n, b);
+    for (int i = 0; i < 2*n; i++) ptr[i] = saturate_cast<unsigned>(buf[i]);
 }
 
 static inline void v_store_pair_as(uchar* ptr, const v_uint32& a, const v_uint32& b)
@@ -657,27 +663,31 @@ static inline void v_store_pair_as(hfloat* ptr, const v_float64& a, const v_floa
     v_pack_store(ptr, v);
 }
 
+// f64 -> {u64, s64, u32}: no correct vector path yet - v_round(f64,f64) narrows to v_int32, which
+// truncates the 64-bit range (u64/s64) and the upper half of u32. Scalar for now (matches the scalar
+// tail these functions already fall back to); a proper f64->s64/u64 intrinsic can replace it later.
 static inline void v_store_pair_as(uint64_t* ptr, const v_float64& a, const v_float64& b)
 {
-    v_float64 z = vx_setzero_f64();
+    const int n = VTraits<v_float64>::vlanes();
-    v_int64 ia, ib;
+    double buf[VTraits<v_float64>::max_nlanes*2];
-    v_expand(v_round(v_max(a, z), v_max(b, z)), ia, ib);
+    v_store(buf, a); v_store(buf + n, b);
-    v_store(ptr, v_reinterpret_as_u64(ia));
+    for (int i = 0; i < 2*n; i++) ptr[i] = saturate_cast<uint64_t>(buf[i]);
-    v_store(ptr + VTraits<v_uint64>::vlanes(), v_reinterpret_as_u64(ib));
 }
 
 static inline void v_store_pair_as(int64_t* ptr, const v_float64& a, const v_float64& b)
 {
-    v_int64 ia, ib;
+    const int n = VTraits<v_float64>::vlanes();
-    v_expand(v_round(a, b), ia, ib);
+    double buf[VTraits<v_float64>::max_nlanes*2];
-    v_store(ptr, ia);
+    v_store(buf, a); v_store(buf + n, b);
-    v_store(ptr + VTraits<v_uint64>::vlanes(), ib);
+    for (int i = 0; i < 2*n; i++) ptr[i] = saturate_cast<int64_t>(buf[i]);
 }
 
 static inline void v_store_pair_as(unsigned* ptr, const v_float64& a, const v_float64& b)
 {
-    v_int32 iab = v_max(v_round(a, b), vx_setzero_s32());
+    const int n = VTraits<v_float64>::vlanes();
-    v_store(ptr, v_reinterpret_as_u32(iab));
+    double buf[VTraits<v_float64>::max_nlanes*2];
+    v_store(buf, a); v_store(buf + n, b);
+    for (int i = 0; i < 2*n; i++) ptr[i] = saturate_cast<unsigned>(buf[i]);
 }
 
 #else

modules/core/src/convert.simd.hpp

@@ -432,7 +432,7 @@ DEF_CVT_FUNC(64f32u, cvt_64f, double, unsigned, v_float32)
 DEF_CVT_FUNC(64f32s, cvt_, double, int,    v_int32)
 DEF_CVT_FUNC(64f32f, cvt_, double, float,  v_float32)
 DEF_CVT_FUNC(64f64u, cvt_64f, double, uint64_t, v_float64)
-DEF_CVT_FUNC(64f64s, cvt_64f, double, int64_t, v_float32)
+DEF_CVT_FUNC(64f64s, cvt_64f, double, int64_t, v_float64)
 DEF_CVT_FUNC(64f16f, cvt1_,double, hfloat, v_float32)
 DEF_CVT_FUNC(64f16bf, cvt1_,double, bfloat, v_float32)
 DEF_CVT2BOOL_FUNC(64f8b, int64_t, 1)

modules/core/src/math.dispatch.cpp

@@ -0,0 +1,107 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// Dispatch layer for the element-wise MATH + SELECT kernels (math.simd.hpp) - the sibling of
+// arithm.dispatch.cpp: plain functions forwarding to the CPU-optimal kernel via CV_CPU_DISPATCH.
+// getElemwiseFunc (arithm.dispatch.cpp) routes the corresponding TOps here.
+
+#include "precomp.hpp"
+#include "arithm_expr.hpp"
+#include "hal_replacement.hpp"
+#include "math.simd.hpp"
+#include "math.simd_declarations.hpp"
+
+namespace cv { namespace ew {
+
+// ---- pluggable-HAL bridge for exp/log --------------------------------------------------------
+// The raw cv_hal_* entry points return int for a reason: without an installed HAL they are stubs
+// returning CV_HAL_ERROR_NOT_IMPLEMENTED. getMathFunc PROBES each one once (a 1-element call on
+// the safe input 1.0 - fine for both exp and log): implemented -> wrap it as an engine kernel
+// (the function pointer rides in TKernel::userdata, castKernel-style) and the engine adds tiling
+// and parallelism on top of the vendor code; not implemented -> the engine's own v_exp/v_log
+// kernels. Uniform over ANY HAL (an external vendor one, the IPP HAL module, ...) - the get is
+// called once per program build, the probe cost is nothing next to the kernel calls that follow.
+template<typename T>
+static int halUnaryKernel(const void* src0_, size_t s0y, size_t s0x,
+                          const void*, size_t, size_t, const void*, size_t, size_t,
+                          void* dst_, size_t dsty, int width, int height,
+                          const double*, int, void* userdata)
+{
+    typedef int (*HalFunc)(const T*, T*, int);
+    const HalFunc fn = (HalFunc)userdata;
+    s0y /= sizeof(T);
+    dsty /= sizeof(T);
+    CV_Assert(s0x <= 1u);
+    const T* src0 = (const T*)src0_;
+    T* dst = (T*)dst_;
+    if (height > 1 && dsty == (size_t)width && s0y == s0x*(size_t)width) { width *= height; height = 1; }
+    const int urows = (s0y == 0 && height > 1) ? 1 : height;   // vertical broadcast: 1 row + copies
+    for (int y = 0; y < urows; y++, src0 += s0y, dst += dsty)
+    {
+        int code;
+        if (s0x == 0)                     // broadcast-scalar source: one value covers the row
+        {
+            T v;
+            code = fn(src0, &v, 1);
+            for (int x = 0; x < width; x++) dst[x] = v;
+        }
+        else
+            code = fn(src0, dst, width);
+        if (code != CV_HAL_ERROR_OK)
+            return code;                  // shouldn't happen (probed at get time) - let exec assert
+    }
+    dst = (T*)dst_;
+    for (int y = urows; y < height; y++)
+        memcpy(dst + (size_t)y*dsty, dst, (size_t)width*sizeof(T));
+    return 0;
+}
+
+template<typename T, typename HalFunc>
+static TKernel probeHalUnary(HalFunc fn)
+{
+    T one = (T)1, r = (T)0;
+    if (fn(&one, &r, 1) == CV_HAL_ERROR_OK)
+        return {halUnaryKernel<T>, (void*)fn, 0};
+    return {};
+}
+
+// The engine's OWN kernel for (op, T) - v_exp/v_log & co, no HAL/IPP tiers. The final fallback of
+// getMathFunc, and what hal::exp32f & co use as THEIR built-in implementation (the former table
+// kernels are gone), via mathSpanEngine below.
+static TKernel getEngineMathFunc(TOp op, int T)
+{
+    CV_CPU_DISPATCH(getMathFunc_,   (op, T),      CV_CPU_DISPATCH_MODES_ALL);
+}
+
+// run the engine's own math kernel over one contiguous span (the shape hal::exp32f & co need)
+void mathSpanEngine(TOp op, int depth, const void* src, void* dst, int n)
+{
+    TKernel k = getEngineMathFunc(op, depth);
+    CV_Assert(k.fptr);
+    const double noparams[4] = {};
+    k.fptr(src, 0, 1, nullptr, 0, 0, nullptr, 0, 0, dst, 0, n, 1, noparams, k.flags, k.userdata);
+}
+
+TKernel getMathFunc(TOp op, int T)
+{
+    if ((op == OP_EXP || op == OP_LOG) && (T == CV_32F || T == CV_64F))
+    {
+        // IPP now rides the cv_hal_* hooks too (hal/ipp), so the single probe below picks it up
+        // together with any external vendor HAL - no separate IPP tier needed here.
+        // probe results are process-lifetime stable; cache them (thread-safe magic statics)
+        static const TKernel exp32 = probeHalUnary<float >(cv_hal_exp32f);
+        static const TKernel exp64 = probeHalUnary<double>(cv_hal_exp64f);
+        static const TKernel log32 = probeHalUnary<float >(cv_hal_log32f);
+        static const TKernel log64 = probeHalUnary<double>(cv_hal_log64f);
+        const TKernel* k = op == OP_EXP ? (T == CV_32F ? &exp32 : &exp64)
+                                        : (T == CV_32F ? &log32 : &log64);
+        if (k->fptr)
+            return *k;
+    }
+    return getEngineMathFunc(op, T);
+}
+
+TKernel getPowFunc(int T, int R)            { CV_CPU_DISPATCH(getPowFunc_,    (T, R),       CV_CPU_DISPATCH_MODES_ALL); }
+
+}} // namespace cv::ew

modules/core/src/math.simd.hpp

@@ -0,0 +1,487 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// Element-wise MATH kernels (sqrt/exp/log/sin/cos/tanh/erf/relu) and SELECT for the new arithmetic
+// engine, SIMD-dispatched per CPU baseline - the unary/ternary sibling of arithm.simd.hpp.
+//
+// This file is compiled once per SIMD baseline (registered via ocv_add_dispatched_file). The per-op
+// entry points get*Func_(...) live in cv::ew::CV_CPU_OPTIMIZATION_NAMESPACE and return the kernel
+// optimized for that baseline; the regular get*Func dispatchers live in math.dispatch.cpp.
+//
+// Kernel shape (house style of arithm.simd.hpp):
+//  - one 2D tile; per-row outer loop with stepy (bytes); dst contiguous in x; stepx in {0,1}.
+//  - continuity collapse 2D->1D when every operand+dst is gap-free.
+//  - halide right-edge backoff for the SIMD tail, SUPPRESSED when dst aliases an input (in-place
+//    unary math would re-apply Op to already-written values).
+//
+// Math is T -> T over the four float depths: f32/f64 compute natively (v_exp & co exist for both);
+// f16/bf16 ride the f32 hub (vx_load_pair_as widens one native vector into two f32 vectors, the
+// saturating v_store_pair_as packs them back) - more accurate than a native f16 polynomial and
+// works on every baseline. Integer inputs never reach these kernels: emitUnary computes integer
+// math in the float domain and casts.
+
+#include "opencv2/core/hal/intrin.hpp"
+#include "convert.hpp"          // typed vx_load_pair_as / v_store_pair_as helpers (cv::)
+#include "arithm_expr.hpp"      // the kernel contract: TOp / TKernel / KernelFunc
+#include <cmath>
+
+namespace cv {
+
+// Everything outside cv::ew::CV_CPU_OPTIMIZATION_NAMESPACE must be skipped in the
+// declarations-only re-includes (one per dispatched mode), or it gets redefined.
+#ifndef CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+
+// f32-pair -> f16/bf16 stores for the half-float hub (convert.hpp covers the other pairs)
+static inline void v_store_pair_as(hfloat* p, const v_float32& a, const v_float32& b)
+{
+    v_pack_store(p, a);
+    v_pack_store(p + VTraits<v_float32>::vlanes(), b);
+}
+static inline void v_store_pair_as(bfloat* p, const v_float32& a, const v_float32& b)
+{
+    v_pack_store(p, a);
+    v_pack_store(p + VTraits<v_float32>::vlanes(), b);
+}
+
+#endif
+#endif // CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY
+
+namespace ew {
+CV_CPU_OPTIMIZATION_NAMESPACE_BEGIN
+
+// ---- per-op kernel entry points for THIS baseline (the regular dispatchers in
+//      math.dispatch.cpp reach them through CV_CPU_DISPATCH). ----
+TKernel getMathFunc_(TOp op, int T);                 // unary math, T -> T, T in {f16, bf16, f32, f64}
+TKernel getPowFunc_(int T, int R);                   // OP_POW, T x T -> T (R must equal T)
+
+#ifndef CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY
+
+// ===========================================================================
+// Op functors: vec(Wvec) over the work vector (f32 or f64), scl(WT) for the scalar path/tail.
+// New unary math ops slot in here.
+// ===========================================================================
+struct MSqrt {
+    template<typename V> static V vec(const V& x) { return v_sqrt(x); }
+    template<typename W> static W scl(W x) { return std::sqrt(x); }
+};
+struct MExp {
+    template<typename V> static V vec(const V& x) { return v_exp(x); }
+    template<typename W> static W scl(W x) { return std::exp(x); }
+};
+struct MLog {
+    template<typename V> static V vec(const V& x) { return v_log(x); }
+    template<typename W> static W scl(W x) { return std::log(x); }
+};
+struct MSin {
+    template<typename V> static V vec(const V& x) { return v_sin(x); }
+    template<typename W> static W scl(W x) { return std::sin(x); }
+};
+struct MCos {
+    template<typename V> static V vec(const V& x) { return v_cos(x); }
+    template<typename W> static W scl(W x) { return std::cos(x); }
+};
+// tanh(x) = (e^2x - 1) / (e^2x + 1), on top of v_exp (no v_tanh intrinsic). The input is clamped
+// first: tanh saturates to +/-1 well inside |x| <= 10 (f32) / 20 (f64), while an unclamped large x
+// would push e^2x to inf and the ratio to inf/inf = NaN. (A NaN input may map to a saturated value
+// on some ISAs instead of NaN - the polynomial v_exp has relaxed NaN semantics anyway.)
+struct MTanh {
+    static v_float32 vec(const v_float32& x)
+    {
+        const v_float32 one = vx_setall_f32(1.f), lim = vx_setall_f32(10.f);
+        v_float32 cx = v_min(v_max(x, v_sub(vx_setzero_f32(), lim)), lim);
+        v_float32 e = v_exp(v_add(cx, cx));
+        return v_div(v_sub(e, one), v_add(e, one));
+    }
+#if CV_SIMD_64F || CV_SIMD_SCALABLE_64F
+    static v_float64 vec(const v_float64& x)
+    {
+        const v_float64 one = vx_setall_f64(1.), lim = vx_setall_f64(20.);
+        v_float64 cx = v_min(v_max(x, v_sub(vx_setzero_f64(), lim)), lim);
+        v_float64 e = v_exp(v_add(cx, cx));
+        return v_div(v_sub(e, one), v_add(e, one));
+    }
+#endif
+    template<typename W> static W scl(W x) { return std::tanh(x); }
+};
+struct MErf {
+    static v_float32 vec(const v_float32& x) { return v_erf(x); }
+#if CV_SIMD_64F || CV_SIMD_SCALABLE_64F
+    // no f64 SIMD erf primitive: apply std::erf per lane (keeps the one kernel shape; the
+    // store/load round-trip is noise next to libm erf itself)
+    static v_float64 vec(const v_float64& x)
+    {
+        double buf[VTraits<v_float64>::max_nlanes];
+        v_store(buf, x);
+        for (int i = 0; i < VTraits<v_float64>::vlanes(); i++) buf[i] = std::erf(buf[i]);
+        return vx_load(buf);
+    }
+#endif
+    template<typename W> static W scl(W x) { return std::erf(x); }
+};
+struct MRelu {
+    template<typename V> static V vec(const V& x) { return v_max(x, v_setzero_<V>()); }
+    template<typename W> static W scl(W x) { return x > W(0) ? x : W(0); }
+};
+
+// ===========================================================================
+// The unary kernel: dst = Op(src), T -> T. Wvec picks the work vector: v_float32 / v_float64 for
+// the native depths, v_float32 for the f16/bf16 hub (vx_load_pair_as does the widening).
+// ===========================================================================
+template<typename T, typename Wvec, class Op>
+static int vecUnaryKernel(const void* src0_, size_t s0y, size_t s0x,
+                          const void*, size_t, size_t, const void*, size_t, size_t,
+                          void* dst_, size_t dsty, int width, int height,
+                          const double*, int, void*)
+{
+    s0y /= sizeof(T);
+    dsty /= sizeof(T);
+    CV_Assert(s0x <= 1u);
+
+    const T* src0 = (const T*)src0_;
+    T* dst = (T*)dst_;
+    using WT = typename VTraits<Wvec>::lane_type;
+
+    if (height > 1 && dsty == (size_t)width && s0y == s0x*(size_t)width) { width *= height; height = 1; }
+
+    // vertical broadcast (a row expanded into a matrix, s0y == 0): every output row is identical -
+    // compute the first one, memcpy the rest (transcendentals cost far more than a row copy)
+    const int urows = (s0y == 0 && height > 1) ? 1 : height;
+
+    for (int y = 0; y < urows; y++, src0 += s0y, dst += dsty)
+    {
+        if (s0x == 0)                     // broadcast-scalar source: one value covers the row
+        {
+            T v = saturate_cast<T>(Op::scl((WT)src0[0]));
+            for (int x = 0; x < width; x++) dst[x] = v;
+            continue;
+        }
+        int x = 0;
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+        const int VECSZ = VTraits<Wvec>::vlanes();
+        // in-place (dst == src) forbids the right-edge backoff: it would re-read already-written
+        // values and apply Op twice. Those rows finish in the scalar tail instead.
+        const bool use_tail_trick = width >= VECSZ*4 && src0_ != dst_;
+        for (; x < width; x += VECSZ*2)
+        {
+            if (x + VECSZ*2 > width) { if (!use_tail_trick || x == 0) break; x = width - VECSZ*2; }
+            Wvec a0, a1;
+            vx_load_pair_as(src0 + x, a0, a1);
+            a0 = Op::vec(a0); a1 = Op::vec(a1);
+            v_store_pair_as(dst + x, a0, a1);
+        }
+#endif
+        for (; x < width; x++)
+            dst[x] = saturate_cast<T>(Op::scl((WT)src0[x]));
+    }
+    dst = (T*)dst_;
+    for (int y = urows; y < height; y++)
+        memcpy(dst + (size_t)y*dsty, dst, (size_t)width*sizeof(T));
+    return 0;
+}
+
+// Scalar-only variant for (op, depth) pairs with no SIMD primitive (erf on f64; every op's f64
+// when the baseline has no 64-bit float SIMD).
+template<typename T, typename WT, class Op>
+static int scalarUnaryKernel(const void* src0_, size_t s0y, size_t s0x,
+                             const void*, size_t, size_t, const void*, size_t, size_t,
+                             void* dst_, size_t dsty, int width, int height,
+                             const double*, int, void*)
+{
+    s0y /= sizeof(T);
+    dsty /= sizeof(T);
+    CV_Assert(s0x <= 1u);
+    const T* src0 = (const T*)src0_;
+    T* dst = (T*)dst_;
+    if (height > 1 && dsty == (size_t)width && s0y == s0x*(size_t)width) { width *= height; height = 1; }
+    const int urows = (s0y == 0 && height > 1) ? 1 : height;   // vertical broadcast: 1 row + copies
+    for (int y = 0; y < urows; y++, src0 += s0y, dst += dsty)
+    {
+        if (s0x == 0)
+        {
+            T v = saturate_cast<T>(Op::scl((WT)src0[0]));
+            for (int x = 0; x < width; x++) dst[x] = v;
+            continue;
+        }
+        for (int x = 0; x < width; x++)
+            dst[x] = saturate_cast<T>(Op::scl((WT)src0[x]));
+    }
+    dst = (T*)dst_;
+    for (int y = urows; y < height; y++)
+        memcpy(dst + (size_t)y*dsty, dst, (size_t)width*sizeof(T));
+    return 0;
+}
+
+// ===========================================================================
+// OP_POW: dst = pow(x, y), T x T -> T over the float depths. Exact std::pow semantics.
+//
+// The exponent is USUALLY a broadcast scalar (pow(x, 2), texpr literals ride as 0-dim consts with
+// stepx == 0) - dispatched PER ROW to the important special cases: y==2 -> x*x, y==3 -> x*x*x,
+// y==0.5 -> v_sqrt, y==1 -> copy, y==0 -> fill 1 (std::pow(anything, 0) == 1, NaN included).
+// Everything else - and the per-element exponent - runs the general vectorized path
+// exp(y * log(x)), which is only valid for x > 0: any lane with x <= 0 falls back to scalar
+// std::pow for the whole vector pair (v_check_any per pair; negative/zero bases are rare, and the
+// scalar path preserves every std::pow subtlety - signed results for integer y, NaN for
+// fractional y, the x == 0 family). One knowing deviation: y==0.5 uses v_sqrt, so pow(-0., .5)
+// returns -0. instead of std::pow's +0.
+//
+// The halide right-edge tail backoff is used in every SIMD loop, SUPPRESSED when dst aliases an
+// input: pow is not idempotent, so an in-place backoff would re-read already-written values (the
+// overlap region is otherwise just recomputed from the untouched source). Suppressed rows finish
+// in the scalar tail.
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+static inline v_float32 vxSetallW(float v,  const v_float32&) { return vx_setall_f32(v); }
+#if CV_SIMD_64F || CV_SIMD_SCALABLE_64F
+static inline v_float64 vxSetallW(double v, const v_float64&) { return vx_setall_f64(v); }
+#endif
+#endif
+
+// Plain scalar pow for baselines without the needed SIMD float width (f64 without 64-bit SIMD).
+template<typename T, typename WT>
+static int scalarPowKernel(const void* src0_, size_t s0y, size_t s0x,
+                           const void* src1_, size_t s1y, size_t s1x,
+                           const void*, size_t, size_t,
+                           void* dst_, size_t dsty, int width, int height,
+                           const double*, int, void*)
+{
+    s0y /= sizeof(T); s1y /= sizeof(T); dsty /= sizeof(T);
+    CV_Assert(s0x <= 1u && s1x <= 1u);
+    const T* src0 = (const T*)src0_;
+    const T* src1 = (const T*)src1_;
+    T* dst = (T*)dst_;
+    if (height > 1 && dsty == (size_t)width && s0y == s0x*(size_t)width && s1y == s1x*(size_t)width)
+    { width *= height; height = 1; }
+    for (int y = 0; y < height; y++, src0 += s0y, src1 += s1y, dst += dsty)
+        for (int x = 0; x < width; x++)
+            dst[x] = saturate_cast<T>(std::pow((WT)src0[x*s0x], (WT)src1[x*s1x]));
+    return 0;
+}
+
+template<typename T, typename Wvec>
+static int powKernel(const void* src0_, size_t s0y, size_t s0x,
+                     const void* src1_, size_t s1y, size_t s1x,
+                     const void*, size_t, size_t,
+                     void* dst_, size_t dsty, int width, int height,
+                     const double*, int, void*)
+{
+    s0y /= sizeof(T);
+    s1y /= sizeof(T);
+    dsty /= sizeof(T);
+    CV_Assert(s0x <= 1u && s1x <= 1u);
+
+    const T* src0 = (const T*)src0_;
+    const T* src1 = (const T*)src1_;
+    T* dst = (T*)dst_;
+    using WT = typename VTraits<Wvec>::lane_type;
+
+    if (height > 1 && dsty == (size_t)width && s0y == s0x*(size_t)width && s1y == s1x*(size_t)width)
+    { width *= height; height = 1; }
+
+    [[maybe_unused]] const bool tail_trick = src0_ != dst_ && src1_ != dst_;
+
+    // both operands vertically broadcast: every output row is identical - compute one, copy
+    const int urows = (s0y == 0 && s1y == 0 && height > 1) ? 1 : height;
+
+    for (int y = 0; y < urows; y++, src0 += s0y, src1 += s1y, dst += dsty)
+    {
+        int x = 0;
+        if (s1x == 0)                                   // scalar exponent for this row
+        {
+            const WT p = (WT)src1[0];
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+            const int VECSZ = VTraits<Wvec>::vlanes();
+            if (s0x == 1)
+            {
+                if (p == WT(2) || p == WT(3))
+                {
+                    for (; x < width; x += VECSZ*2)
+                    {
+                        if (x + VECSZ*2 > width) { if (!tail_trick || x == 0) break; x = width - VECSZ*2; }
+                        Wvec a0, a1;
+                        vx_load_pair_as(src0 + x, a0, a1);
+                        Wvec r0 = v_mul(a0, a0), r1 = v_mul(a1, a1);
+                        if (p == WT(3)) { r0 = v_mul(r0, a0); r1 = v_mul(r1, a1); }
+                        v_store_pair_as(dst + x, r0, r1);
+                    }
+                }
+                else if (p == WT(0.5))
+                {
+                    for (; x < width; x += VECSZ*2)
+                    {
+                        if (x + VECSZ*2 > width) { if (!tail_trick || x == 0) break; x = width - VECSZ*2; }
+                        Wvec a0, a1;
+                        vx_load_pair_as(src0 + x, a0, a1);
+                        a0 = v_sqrt(a0); a1 = v_sqrt(a1);
+                        v_store_pair_as(dst + x, a0, a1);
+                    }
+                }
+                else if (p == WT(1))
+                {
+                    if ((const void*)src0 != (const void*)dst)
+                        for (; x < width; x++) dst[x] = src0[x];
+                    x = width;
+                }
+                else if (p == WT(0))
+                {
+                    const T one = saturate_cast<T>(1);
+                    for (; x < width; x++) dst[x] = one;
+                }
+                else if (p == WT(-0.5))
+                {
+                    const Wvec one = vxSetallW(WT(1), Wvec());
+                    for (; x < width; x += VECSZ*2)
+                    {
+                        if (x + VECSZ*2 > width) { if (!tail_trick || x == 0) break; x = width - VECSZ*2; }
+                        Wvec a0, a1;
+                        vx_load_pair_as(src0 + x, a0, a1);
+                        a0 = v_div(one, v_sqrt(a0)); a1 = v_div(one, v_sqrt(a1));
+                        v_store_pair_as(dst + x, a0, a1);
+                    }
+                }
+                else if (p == std::rint(p) && std::abs(p) <= WT(65536))
+                {
+                    // any other INTEGER exponent: LSB-first binary exponentiation - the same
+                    // multiply chain (and order) as the classic iPow, fully vectorized. Also more
+                    // accurate than exp(p*log x) (a few ulp vs ~2e-7 rel) and semantically exact
+                    // on non-positive bases: the sign falls out of the multiplies, 0^negative
+                    // divides to inf - no scalar patching needed.
+                    const int ip = (int)p, ap = ip < 0 ? -ip : ip;   // ap >= 1 (0..3 handled above)
+                    const Wvec one = vxSetallW(WT(1), Wvec());
+                    for (; x < width; x += VECSZ*2)
+                    {
+                        if (x + VECSZ*2 > width) { if (!tail_trick || x == 0) break; x = width - VECSZ*2; }
+                        Wvec b0, b1;
+                        vx_load_pair_as(src0 + x, b0, b1);
+                        Wvec a0 = one, a1 = one;
+                        for (int q = ap; q > 1; q >>= 1)
+                        {
+                            if (q & 1) { a0 = v_mul(a0, b0); a1 = v_mul(a1, b1); }
+                            b0 = v_mul(b0, b0); b1 = v_mul(b1, b1);
+                        }
+                        a0 = v_mul(a0, b0); a1 = v_mul(a1, b1);
+                        if (ip < 0) { a0 = v_div(one, a0); a1 = v_div(one, a1); }
+                        v_store_pair_as(dst + x, a0, a1);
+                    }
+                }
+                else                                    // general scalar exponent: exp(p * log(x))
+                {
+                    const Wvec vp = vxSetallW(p, Wvec()), z = v_setzero_<Wvec>();
+                    for (; x < width; x += VECSZ*2)
+                    {
+                        if (x + VECSZ*2 > width) { if (!tail_trick || x == 0) break; x = width - VECSZ*2; }
+                        Wvec a0, a1;
+                        vx_load_pair_as(src0 + x, a0, a1);
+                        if (v_check_any(v_le(a0, z)) || v_check_any(v_le(a1, z)))
+                        {                               // exact std::pow for x <= 0 lanes
+                            for (int i = 0; i < VECSZ*2; i++)
+                                dst[x + i] = saturate_cast<T>(std::pow((WT)src0[x + i], p));
+                            continue;
+                        }
+                        a0 = v_exp(v_mul(vp, v_log(a0)));
+                        a1 = v_exp(v_mul(vp, v_log(a1)));
+                        v_store_pair_as(dst + x, a0, a1);
+                    }
+                }
+            }
+#endif
+            for (; x < width; x++)
+                dst[x] = saturate_cast<T>(std::pow((WT)src0[x*s0x], p));
+            continue;
+        }
+        // per-element exponent
+#if (CV_SIMD || CV_SIMD_SCALABLE)
+        if (s0x == 1)
+        {
+            const int VECSZ = VTraits<Wvec>::vlanes();
+            const Wvec z = v_setzero_<Wvec>();
+            for (; x < width; x += VECSZ*2)
+            {
+                if (x + VECSZ*2 > width) { if (!tail_trick || x == 0) break; x = width - VECSZ*2; }
+                Wvec a0, a1, b0, b1;
+                vx_load_pair_as(src0 + x, a0, a1);
+                vx_load_pair_as(src1 + x, b0, b1);
+                if (v_check_any(v_le(a0, z)) || v_check_any(v_le(a1, z)))
+                {
+                    for (int i = 0; i < VECSZ*2; i++)
+                        dst[x + i] = saturate_cast<T>(std::pow((WT)src0[x + i], (WT)src1[x + i]));
+                    continue;
+                }
+                a0 = v_exp(v_mul(b0, v_log(a0)));
+                a1 = v_exp(v_mul(b1, v_log(a1)));
+                v_store_pair_as(dst + x, a0, a1);
+            }
+        }
+#endif
+        for (; x < width; x++)
+            dst[x] = saturate_cast<T>(std::pow((WT)src0[x*s0x], (WT)src1[x]));
+    }
+    dst = (T*)dst_;
+    for (int y = urows; y < height; y++)
+        memcpy(dst + (size_t)y*dsty, dst, (size_t)width*sizeof(T));
+    return 0;
+}
+
+TKernel getPowFunc_(int T, int R)
+{
+    if (R != T)
+        return {};
+    KernelFunc fptr = nullptr;
+    switch (T)
+    {
+    case CV_16F:  fptr = powKernel<hfloat, v_float32>; break;
+    case CV_16BF: fptr = powKernel<bfloat, v_float32>; break;
+    case CV_32F:  fptr = powKernel<float,  v_float32>; break;
+#if CV_SIMD_64F || CV_SIMD_SCALABLE_64F
+    case CV_64F:  fptr = powKernel<double, v_float64>; break;
+#else
+    case CV_64F:  fptr = scalarPowKernel<double, double>; break;
+#endif
+    default: ;
+    }
+    return {fptr, nullptr, 0};
+}
+
+// ===========================================================================
+// getters for THIS baseline
+// ===========================================================================
+template<class Op>
+static KernelFunc mathByDepth(int T)
+{
+    switch (T)
+    {
+    case CV_16F:  return vecUnaryKernel<hfloat, v_float32, Op>;
+    case CV_16BF: return vecUnaryKernel<bfloat, v_float32, Op>;
+    case CV_32F:  return vecUnaryKernel<float,  v_float32, Op>;
+#if CV_SIMD_64F || CV_SIMD_SCALABLE_64F
+    case CV_64F:  return vecUnaryKernel<double, v_float64, Op>;
+#else
+    case CV_64F:  return scalarUnaryKernel<double, double, Op>;
+#endif
+    default:      return nullptr;
+    }
+}
+
+TKernel getMathFunc_(TOp op, int T)
+{
+    KernelFunc f = nullptr;
+    switch (op)
+    {
+    case OP_SQRT: f = mathByDepth<MSqrt>(T); break;
+    case OP_EXP:  f = mathByDepth<MExp >(T); break;
+    case OP_LOG:  f = mathByDepth<MLog >(T); break;
+    case OP_SIN:  f = mathByDepth<MSin >(T); break;
+    case OP_COS:  f = mathByDepth<MCos >(T); break;
+    case OP_TANH: f = mathByDepth<MTanh>(T); break;
+    case OP_RELU: f = mathByDepth<MRelu>(T); break;
+    case OP_ERF:  f = mathByDepth<MErf >(T); break;
+    default: ;
+    }
+    return {f, nullptr, 0};
+}
+
+
+#endif // CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY
+
+CV_CPU_OPTIMIZATION_NAMESPACE_END
+}} // namespace cv::ew

modules/core/src/mathfuncs.cpp

@@ -49,6 +49,7 @@
 #include <algorithm>
 #include <cmath>
 #include "mathfuncs.hpp"
+#include "arithm_expr.hpp"      // the element-wise engine: getMathFunc + TExpr for cv::exp/log/sqrt
 
 namespace cv
 {
@@ -436,32 +437,57 @@ void polarToCart( InputArray src1, InputArray src2,
 *                                          E X P                                         *
 \****************************************************************************************/
 
+// The master function of the unary math family (cv::exp/log/sqrt - the analogue of arithm_op):
+// same-shape same-type output over the four float depths, computed by the element-wise engine's
+// kernels (math.simd.hpp). Two tiers:
+//  - SMALL and continuous (a common pattern - exp() over one image row as a lookup substitute):
+//    call the kernel DIRECTLY over the flattened elements. No TExpr, no broadcastOp, no
+//    parallel_for machinery - their setup dominates at these sizes.
+//  - everything else (large arrays - worth parallelizing; ROIs - need real steps): the usual
+//    1-instruction program via compile()/exec().
+enum { MATH_OP_SMALL = 100000 };     // elements; tune with a benchmark if the crossover moves
+
+static void math_op(ew::TOp op, InputArray _src, OutputArray _dst)
+{
+    int type = _src.type(), depth = CV_MAT_DEPTH(type);
+    CV_Assert(depth == CV_16F || depth == CV_16BF || depth == CV_32F || depth == CV_64F);
+
+    Mat src = _src.getMat();
+    _dst.createSameSize(_src, type);   // whole-shape transfer (layout & future metadata included)
+    Mat dst = _dst.getMat();
+    if (src.empty())
+        return;
+
+    const size_t total = src.total() * src.channels();
+    if (src.isContinuous() && dst.isContinuous() && total <= (size_t)MATH_OP_SMALL)
+    {
+        ew::TKernel k = ew::getMathFunc(op, depth);
+        CV_Assert(k.fptr);
+        static const double noparams[4] = {};
+        k.fptr(src.data, 0, 1, nullptr, 0, 0, nullptr, 0, 0,
+               dst.data, 0, (int)total, 1, noparams, k.flags, k.userdata);
+        return;
+    }
+
+    ew::TExpr p;
+    const int a = p.addInput(depth);
+    const int out = p.addOutput(depth);
+    p.moveToOutput(p.emitUnary(op, a, depth), out);
+    p.compile();
+    const Mat* inputs[] = { &src };
+    p.exec(inputs, &dst);
+}
+
 void exp( InputArray _src, OutputArray _dst )
 {
     CV_INSTRUMENT_REGION();
 
-    int type = _src.type(), depth = _src.depth(), cn = _src.channels();
+    [[maybe_unused]] int depth = _src.depth();   // consumed by CV_OCL_RUN only
-    CV_Assert( depth == CV_32F || depth == CV_64F );
 
-    CV_OCL_RUN(_dst.isUMat() && _src.dims() <= 2,
+    CV_OCL_RUN(_dst.isUMat() && _src.dims() <= 2 && (depth == CV_32F || depth == CV_64F),
                ocl_math_op(_src, noArray(), _dst, OCL_OP_EXP))
 
-    Mat src = _src.getMat();
+    math_op(ew::OP_EXP, _src, _dst);
-    _dst.create( src.size, type );
-    Mat dst = _dst.getMat();
-
-    const Mat* arrays[] = {&src, &dst, 0};
-    uchar* ptrs[2] = {};
-    NAryMatIterator it(arrays, ptrs);
-    int len = (int)(it.size*cn);
-
-    for( size_t i = 0; i < it.nplanes; i++, ++it )
-    {
-        if( depth == CV_32F )
-            hal::exp32f((const float*)ptrs[0], (float*)ptrs[1], len);
-        else
-            hal::exp64f((const double*)ptrs[0], (double*)ptrs[1], len);
-    }
 }
 
 
@@ -473,28 +499,12 @@ void log( InputArray _src, OutputArray _dst )
 {
     CV_INSTRUMENT_REGION();
 
-    int type = _src.type(), depth = _src.depth(), cn = _src.channels();
+    [[maybe_unused]] int depth = _src.depth();   // consumed by CV_OCL_RUN only
-    CV_Assert( depth == CV_32F || depth == CV_64F );
 
-    CV_OCL_RUN( _dst.isUMat() && _src.dims() <= 2,
+    CV_OCL_RUN( _dst.isUMat() && _src.dims() <= 2 && (depth == CV_32F || depth == CV_64F),
                 ocl_math_op(_src, noArray(), _dst, OCL_OP_LOG))
 
-    Mat src = _src.getMat();
+    math_op(ew::OP_LOG, _src, _dst);
-    _dst.create( src.size, type );
-    Mat dst = _dst.getMat();
-
-    const Mat* arrays[] = {&src, &dst, 0};
-    uchar* ptrs[2] = {};
-    NAryMatIterator it(arrays, ptrs);
-    int len = (int)(it.size*cn);
-
-    for( size_t i = 0; i < it.nplanes; i++, ++it )
-    {
-        if( depth == CV_32F )
-            hal::log32f( (const float*)ptrs[0], (float*)ptrs[1], len );
-        else
-            hal::log64f( (const double*)ptrs[0], (double*)ptrs[1], len );
-    }
 }
 
 /****************************************************************************************\
@@ -1033,133 +1043,81 @@ void pow( InputArray _src, double power, OutputArray _dst )
 
     CV_OCL_RUN(useOpenCL, ocl_pow(_src, power, _dst, is_ipower, ipower))
 
-    Mat src = _src.getMat();
+    const bool floatDepth = depth == CV_16F || depth == CV_16BF || depth == CV_32F || depth == CV_64F;
-    _dst.create( src.size, type );
-    Mat dst = _dst.getMat();
 
-    const Mat* arrays[] = {&src, &dst, 0};
+    // INTEGER array ** INTEGER power: keep the classic iPow kernels (an exact multiply chain with
-    uchar* ptrs[2] = {};
+    // the classic wrap-around semantics) - full bit-exact compatibility for whoever relies on it.
-    NAryMatIterator it(arrays, ptrs);
+    // Everything else - any power on a float array, a fractional power on an integer one (computed
-    int len = (int)(it.size*cn);
+    // in the float domain and saturated back), plus the 32U/64-bit depths iPow never supported -
-
+    // goes through the engine below.
-    if( is_ipower )
+    if( is_ipower && !floatDepth && ipowTab[depth] )
     {
+        Mat src = _src.getMat();
+        _dst.createSameSize(_src, type);
+        Mat dst = _dst.getMat();
+
+        const Mat* arrays[] = {&src, &dst, 0};
+        uchar* ptrs[2] = {};
+        NAryMatIterator it(arrays, ptrs);
+        int len = (int)(it.size*cn);
         IPowFunc func = ipowTab[depth];
-        CV_Assert( func != 0 );
 
         for( size_t i = 0; i < it.nplanes; i++, ++it )
             func( ptrs[0], ptrs[1], len, ipower );
+        return;
     }
-    else if( fabs(fabs(power) - 0.5) < DBL_EPSILON )
+
+    // The engine path, two tiers like math_op: the pow kernel special-cases the exponents
+    // 3/0.5 (2/1/0 never reach here) per row and vectorizes the general exp(p*log x) with an exact
+    // std::pow patch for non-positive bases (0^negative -> inf, negative^fractional -> NaN).
+    Mat src = _src.getMat();
+    _dst.createSameSize(_src, type);
+    Mat dst = _dst.getMat();
+    if (src.empty())
+        return;
+
+    const size_t total = src.total() * cn;
+    if (floatDepth && src.isContinuous() && dst.isContinuous() && total <= (size_t)MATH_OP_SMALL)
     {
-        MathFunc func = power < 0 ?
+        ew::TKernel k = ew::getPowFunc(depth, depth);
-            (depth == CV_32F ? (MathFunc)hal::invSqrt32f : (MathFunc)hal::invSqrt64f) :
+        if (k.fptr)
-            (depth == CV_32F ? (MathFunc)hal::sqrt32f : (MathFunc)hal::sqrt64f);
-
-        for( size_t i = 0; i < it.nplanes; i++, ++it )
-            func( ptrs[0], ptrs[1], len );
-    }
-    else
-    {
-        int j, k, blockSize = std::min(len, ((BLOCK_SIZE + cn-1)/cn)*cn);
-        size_t esz1 = src.elemSize1();
-        AutoBuffer<uchar> buf;
-        Cv32suf inf32, nan32;
-        Cv64suf inf64, nan64;
-        float* fbuf = 0;
-        double* dbuf = 0;
-#ifndef __EMSCRIPTEN__
-        inf32.i = 0x7f800000;
-        nan32.i = 0x7fffffff;
-        inf64.i = CV_BIG_INT(0x7FF0000000000000);
-        nan64.i = CV_BIG_INT(0x7FFFFFFFFFFFFFFF);
-#else
-        inf32.f = std::numeric_limits<float>::infinity();
-        nan32.f = std::numeric_limits<float>::quiet_NaN();
-        inf64.f = std::numeric_limits<double>::infinity();
-        nan64.f = std::numeric_limits<double>::quiet_NaN();
-#endif
-
-        if( src.ptr() == dst.ptr() )
         {
-            buf.allocate(blockSize*esz1);
+            double pvstore;                    // the broadcast exponent, stored as T
-            fbuf = (float*)buf.data();
+            void* pv = &pvstore;
-            dbuf = (double*)buf.data();
+            switch (depth)
-        }
-
-        for( size_t i = 0; i < it.nplanes; i++, ++it )
-        {
-            for( j = 0; j < len; j += blockSize )
             {
-                int bsz = std::min(len - j, blockSize);
+            case CV_16F:  *(hfloat*)pv = saturate_cast<hfloat>(power); break;
-
+            case CV_16BF: *(bfloat*)pv = saturate_cast<bfloat>(power); break;
-                if( depth == CV_32F )
+            case CV_32F:  *(float*)pv = (float)power; break;
-                {
+            default:      pvstore = power; break;
-                    float* x0 = (float*)ptrs[0];
-                    float* x = fbuf ? fbuf : x0;
-                    float* y = (float*)ptrs[1];
-
-                    if( x != x0 )
-                        memcpy(x, x0, bsz*esz1);
-
-                    hal::log32f(x, y, bsz);
-                    for( k = 0; k < bsz; k++ )
-                        y[k] = (float)(y[k]*power);
-                    hal::exp32f(y, y, bsz);
-                    for( k = 0; k < bsz; k++ )
-                    {
-                        if( x0[k] <= 0 )
-                        {
-                            if( x0[k] == 0.f )
-                            {
-                                if( power < 0 )
-                                    y[k] = inf32.f;
-                            }
-                            else
-                                y[k] = nan32.f;
-                        }
-                    }
-                }
-                else
-                {
-                    double* x0 = (double*)ptrs[0];
-                    double* x = dbuf ? dbuf : x0;
-                    double* y = (double*)ptrs[1];
-
-                    if( x != x0 )
-                        memcpy(x, x0, bsz*esz1);
-
-                    hal::log64f(x, y, bsz);
-                    for( k = 0; k < bsz; k++ )
-                        y[k] *= power;
-                    hal::exp64f(y, y, bsz);
-
-                    for( k = 0; k < bsz; k++ )
-                    {
-                        if( x0[k] <= 0 )
-                        {
-                            if( x0[k] == 0. )
-                            {
-                                if( power < 0 )
-                                    y[k] = inf64.f;
-                            }
-                            else
-                                y[k] = nan64.f;
-                        }
-                    }
-                }
-                ptrs[0] += bsz*esz1;
-                ptrs[1] += bsz*esz1;
             }
+            static const double noparams[4] = {};
+            k.fptr(src.data, 0, 1, pv, 0, 0, nullptr, 0, 0,
+                   dst.data, 0, (int)total, 1, noparams, k.flags, k.userdata);
+            return;
         }
     }
+
+    ew::TExpr prog;
+    const int a = prog.addInput(depth);
+    const int c = prog.addConst(ew::EW_DEPTH_NONE, Scalar(power), 1);
+    const int out = prog.addOutput(depth);
+    prog.moveToOutput(prog.emitBinary(ew::OP_POW, a, c, depth), out);
+    prog.compile();
+    const Mat* inputs[] = { &src };
+    prog.exec(inputs, &dst);
 }
 
 void sqrt(InputArray a, OutputArray b)
 {
     CV_INSTRUMENT_REGION();
 
-    cv::pow(a, 0.5, b);
+    if (b.isUMat() && a.dims() <= 2)     // the OpenCL route (via ocl_pow) is unchanged
+    {
+        cv::pow(a, 0.5, b);
+        return;
+    }
+    math_op(ew::OP_SQRT, a, b);
 }
 
 /************************** CheckArray for NaN's, Inf's *********************************/
@@ -1702,381 +1660,5 @@ double cv::solvePoly( InputArray _coeffs0, OutputArray _roots0, int maxIters )
     return maxDiff;
 }
 
-// Common constants for dispatched code
-namespace cv { namespace details {
-
-#define EXPTAB_SCALE 6
-#define EXPTAB_MASK  ((1 << EXPTAB_SCALE) - 1)
-
-#define EXPPOLY_32F_A0 .9670371139572337719125840413672004409288e-2
-
-static const double CV_DECL_ALIGNED(64) expTab[EXPTAB_MASK + 1] = {
-    1.0 * EXPPOLY_32F_A0,
-    1.0108892860517004600204097905619 * EXPPOLY_32F_A0,
-    1.0218971486541166782344801347833 * EXPPOLY_32F_A0,
-    1.0330248790212284225001082839705 * EXPPOLY_32F_A0,
-    1.0442737824274138403219664787399 * EXPPOLY_32F_A0,
-    1.0556451783605571588083413251529 * EXPPOLY_32F_A0,
-    1.0671404006768236181695211209928 * EXPPOLY_32F_A0,
-    1.0787607977571197937406800374385 * EXPPOLY_32F_A0,
-    1.0905077326652576592070106557607 * EXPPOLY_32F_A0,
-    1.1023825833078409435564142094256 * EXPPOLY_32F_A0,
-    1.1143867425958925363088129569196 * EXPPOLY_32F_A0,
-    1.126521618608241899794798643787 * EXPPOLY_32F_A0,
-    1.1387886347566916537038302838415 * EXPPOLY_32F_A0,
-    1.151189229952982705817759635202 * EXPPOLY_32F_A0,
-    1.1637248587775775138135735990922 * EXPPOLY_32F_A0,
-    1.1763969916502812762846457284838 * EXPPOLY_32F_A0,
-    1.1892071150027210667174999705605 * EXPPOLY_32F_A0,
-    1.2021567314527031420963969574978 * EXPPOLY_32F_A0,
-    1.2152473599804688781165202513388 * EXPPOLY_32F_A0,
-    1.2284805361068700056940089577928 * EXPPOLY_32F_A0,
-    1.2418578120734840485936774687266 * EXPPOLY_32F_A0,
-    1.2553807570246910895793906574423 * EXPPOLY_32F_A0,
-    1.2690509571917332225544190810323 * EXPPOLY_32F_A0,
-    1.2828700160787782807266697810215 * EXPPOLY_32F_A0,
-    1.2968395546510096659337541177925 * EXPPOLY_32F_A0,
-    1.3109612115247643419229917863308 * EXPPOLY_32F_A0,
-    1.3252366431597412946295370954987 * EXPPOLY_32F_A0,
-    1.3396675240533030053600306697244 * EXPPOLY_32F_A0,
-    1.3542555469368927282980147401407 * EXPPOLY_32F_A0,
-    1.3690024229745906119296011329822 * EXPPOLY_32F_A0,
-    1.3839098819638319548726595272652 * EXPPOLY_32F_A0,
-    1.3989796725383111402095281367152 * EXPPOLY_32F_A0,
-    1.4142135623730950488016887242097 * EXPPOLY_32F_A0,
-    1.4296133383919700112350657782751 * EXPPOLY_32F_A0,
-    1.4451808069770466200370062414717 * EXPPOLY_32F_A0,
-    1.4609177941806469886513028903106 * EXPPOLY_32F_A0,
-    1.476826145939499311386907480374 * EXPPOLY_32F_A0,
-    1.4929077282912648492006435314867 * EXPPOLY_32F_A0,
-    1.5091644275934227397660195510332 * EXPPOLY_32F_A0,
-    1.5255981507445383068512536895169 * EXPPOLY_32F_A0,
-    1.5422108254079408236122918620907 * EXPPOLY_32F_A0,
-    1.5590044002378369670337280894749 * EXPPOLY_32F_A0,
-    1.5759808451078864864552701601819 * EXPPOLY_32F_A0,
-    1.5931421513422668979372486431191 * EXPPOLY_32F_A0,
-    1.6104903319492543081795206673574 * EXPPOLY_32F_A0,
-    1.628027421857347766848218522014 * EXPPOLY_32F_A0,
-    1.6457554781539648445187567247258 * EXPPOLY_32F_A0,
-    1.6636765803267364350463364569764 * EXPPOLY_32F_A0,
-    1.6817928305074290860622509524664 * EXPPOLY_32F_A0,
-    1.7001063537185234695013625734975 * EXPPOLY_32F_A0,
-    1.7186192981224779156293443764563 * EXPPOLY_32F_A0,
-    1.7373338352737062489942020818722 * EXPPOLY_32F_A0,
-    1.7562521603732994831121606193753 * EXPPOLY_32F_A0,
-    1.7753764925265212525505592001993 * EXPPOLY_32F_A0,
-    1.7947090750031071864277032421278 * EXPPOLY_32F_A0,
-    1.8142521755003987562498346003623 * EXPPOLY_32F_A0,
-    1.8340080864093424634870831895883 * EXPPOLY_32F_A0,
-    1.8539791250833855683924530703377 * EXPPOLY_32F_A0,
-    1.8741676341102999013299989499544 * EXPPOLY_32F_A0,
-    1.8945759815869656413402186534269 * EXPPOLY_32F_A0,
-    1.9152065613971472938726112702958 * EXPPOLY_32F_A0,
-    1.9360617934922944505980559045667 * EXPPOLY_32F_A0,
-    1.9571441241754002690183222516269 * EXPPOLY_32F_A0,
-    1.9784560263879509682582499181312 * EXPPOLY_32F_A0,
-};
-
-const double* getExpTab64f()
-{
-    return expTab;
-}
-
-const float* getExpTab32f()
-{
-    static float CV_DECL_ALIGNED(64) expTab_f[EXPTAB_MASK+1];
-    static std::atomic<bool> expTab_f_initialized(false);
-    if (!expTab_f_initialized.load())
-    {
-        for( int j = 0; j <= EXPTAB_MASK; j++ )
-            expTab_f[j] = (float)expTab[j];
-        expTab_f_initialized = true;
-    }
-    return expTab_f;
-}
-
-
-
-#define LOGTAB_SCALE        8
-#define LOGTAB_MASK         ((1 << LOGTAB_SCALE) - 1)
-
-static const double CV_DECL_ALIGNED(64) logTab[(LOGTAB_MASK+1)*2] = {
-    0.0000000000000000000000000000000000000000,    1.000000000000000000000000000000000000000,
-    .00389864041565732288852075271279318258166,    .9961089494163424124513618677042801556420,
-    .00778214044205494809292034119607706088573,    .9922480620155038759689922480620155038760,
-    .01165061721997527263705585198749759001657,    .9884169884169884169884169884169884169884,
-    .01550418653596525274396267235488267033361,    .9846153846153846153846153846153846153846,
-    .01934296284313093139406447562578250654042,    .9808429118773946360153256704980842911877,
-    .02316705928153437593630670221500622574241,    .9770992366412213740458015267175572519084,
-    .02697658769820207233514075539915211265906,    .9733840304182509505703422053231939163498,
-    .03077165866675368732785500469617545604706,    .9696969696969696969696969696969696969697,
-    .03455238150665972812758397481047722976656,    .9660377358490566037735849056603773584906,
-    .03831886430213659461285757856785494368522,    .9624060150375939849624060150375939849624,
-    .04207121392068705056921373852674150839447,    .9588014981273408239700374531835205992509,
-    .04580953603129420126371940114040626212953,    .9552238805970149253731343283582089552239,
-    .04953393512227662748292900118940451648088,    .9516728624535315985130111524163568773234,
-    .05324451451881227759255210685296333394944,    .9481481481481481481481481481481481481481,
-    .05694137640013842427411105973078520037234,    .9446494464944649446494464944649446494465,
-    .06062462181643483993820353816772694699466,    .9411764705882352941176470588235294117647,
-    .06429435070539725460836422143984236754475,    .9377289377289377289377289377289377289377,
-    .06795066190850773679699159401934593915938,    .9343065693430656934306569343065693430657,
-    .07159365318700880442825962290953611955044,    .9309090909090909090909090909090909090909,
-    .07522342123758751775142172846244648098944,    .9275362318840579710144927536231884057971,
-    .07884006170777602129362549021607264876369,    .9241877256317689530685920577617328519856,
-    .08244366921107458556772229485432035289706,    .9208633093525179856115107913669064748201,
-    .08603433734180314373940490213499288074675,    .9175627240143369175627240143369175627240,
-    .08961215868968712416897659522874164395031,    .9142857142857142857142857142857142857143,
-    .09317722485418328259854092721070628613231,    .9110320284697508896797153024911032028470,
-    .09672962645855109897752299730200320482256,    .9078014184397163120567375886524822695035,
-    .10026945316367513738597949668474029749630,    .9045936395759717314487632508833922261484,
-    .10379679368164355934833764649738441221420,    .9014084507042253521126760563380281690141,
-    .10731173578908805021914218968959175981580,    .8982456140350877192982456140350877192982,
-    .11081436634029011301105782649756292812530,    .8951048951048951048951048951048951048951,
-    .11430477128005862852422325204315711744130,    .8919860627177700348432055749128919860627,
-    .11778303565638344185817487641543266363440,    .8888888888888888888888888888888888888889,
-    .12124924363286967987640707633545389398930,    .8858131487889273356401384083044982698962,
-    .12470347850095722663787967121606925502420,    .8827586206896551724137931034482758620690,
-    .12814582269193003360996385708858724683530,    .8797250859106529209621993127147766323024,
-    .13157635778871926146571524895989568904040,    .8767123287671232876712328767123287671233,
-    .13499516453750481925766280255629681050780,    .8737201365187713310580204778156996587031,
-    .13840232285911913123754857224412262439730,    .8707482993197278911564625850340136054422,
-    .14179791186025733629172407290752744302150,    .8677966101694915254237288135593220338983,
-    .14518200984449788903951628071808954700830,    .8648648648648648648648648648648648648649,
-    .14855469432313711530824207329715136438610,    .8619528619528619528619528619528619528620,
-    .15191604202584196858794030049466527998450,    .8590604026845637583892617449664429530201,
-    .15526612891112392955683674244937719777230,    .8561872909698996655518394648829431438127,
-    .15860503017663857283636730244325008243330,    .8533333333333333333333333333333333333333,
-    .16193282026931324346641360989451641216880,    .8504983388704318936877076411960132890365,
-    .16524957289530714521497145597095368430010,    .8476821192052980132450331125827814569536,
-    .16855536102980664403538924034364754334090,    .8448844884488448844884488448844884488449,
-    .17185025692665920060697715143760433420540,    .8421052631578947368421052631578947368421,
-    .17513433212784912385018287750426679849630,    .8393442622950819672131147540983606557377,
-    .17840765747281828179637841458315961062910,    .8366013071895424836601307189542483660131,
-    .18167030310763465639212199675966985523700,    .8338762214983713355048859934853420195440,
-    .18492233849401198964024217730184318497780,    .8311688311688311688311688311688311688312,
-    .18816383241818296356839823602058459073300,    .8284789644012944983818770226537216828479,
-    .19139485299962943898322009772527962923050,    .8258064516129032258064516129032258064516,
-    .19461546769967164038916962454095482826240,    .8231511254019292604501607717041800643087,
-    .19782574332991986754137769821682013571260,    .8205128205128205128205128205128205128205,
-    .20102574606059073203390141770796617493040,    .8178913738019169329073482428115015974441,
-    .20421554142869088876999228432396193966280,    .8152866242038216560509554140127388535032,
-    .20739519434607056602715147164417430758480,    .8126984126984126984126984126984126984127,
-    .21056476910734961416338251183333341032260,    .8101265822784810126582278481012658227848,
-    .21372432939771812687723695489694364368910,    .8075709779179810725552050473186119873817,
-    .21687393830061435506806333251006435602900,    .8050314465408805031446540880503144654088,
-    .22001365830528207823135744547471404075630,    .8025078369905956112852664576802507836991,
-    .22314355131420973710199007200571941211830,    .8000000000000000000000000000000000000000,
-    .22626367865045338145790765338460914790630,    .7975077881619937694704049844236760124611,
-    .22937410106484582006380890106811420992010,    .7950310559006211180124223602484472049689,
-    .23247487874309405442296849741978803649550,    .7925696594427244582043343653250773993808,
-    .23556607131276688371634975283086532726890,    .7901234567901234567901234567901234567901,
-    .23864773785017498464178231643018079921600,    .7876923076923076923076923076923076923077,
-    .24171993688714515924331749374687206000090,    .7852760736196319018404907975460122699387,
-    .24478272641769091566565919038112042471760,    .7828746177370030581039755351681957186544,
-    .24783616390458124145723672882013488560910,    .7804878048780487804878048780487804878049,
-    .25088030628580937353433455427875742316250,    .7781155015197568389057750759878419452888,
-    .25391520998096339667426946107298135757450,    .7757575757575757575757575757575757575758,
-    .25694093089750041913887912414793390780680,    .7734138972809667673716012084592145015106,
-    .25995752443692604627401010475296061486000,    .7710843373493975903614457831325301204819,
-    .26296504550088134477547896494797896593800,    .7687687687687687687687687687687687687688,
-    .26596354849713793599974565040611196309330,    .7664670658682634730538922155688622754491,
-    .26895308734550393836570947314612567424780,    .7641791044776119402985074626865671641791,
-    .27193371548364175804834985683555714786050,    .7619047619047619047619047619047619047619,
-    .27490548587279922676529508862586226314300,    .7596439169139465875370919881305637982196,
-    .27786845100345625159121709657483734190480,    .7573964497041420118343195266272189349112,
-    .28082266290088775395616949026589281857030,    .7551622418879056047197640117994100294985,
-    .28376817313064456316240580235898960381750,    .7529411764705882352941176470588235294118,
-    .28670503280395426282112225635501090437180,    .7507331378299120234604105571847507331378,
-    .28963329258304265634293983566749375313530,    .7485380116959064327485380116959064327485,
-    .29255300268637740579436012922087684273730,    .7463556851311953352769679300291545189504,
-    .29546421289383584252163927885703742504130,    .7441860465116279069767441860465116279070,
-    .29836697255179722709783618483925238251680,    .7420289855072463768115942028985507246377,
-    .30126133057816173455023545102449133992200,    .7398843930635838150289017341040462427746,
-    .30414733546729666446850615102448500692850,    .7377521613832853025936599423631123919308,
-    .30702503529491181888388950937951449304830,    .7356321839080459770114942528735632183908,
-    .30989447772286465854207904158101882785550,    .7335243553008595988538681948424068767908,
-    .31275571000389684739317885942000430077330,    .7314285714285714285714285714285714285714,
-    .31560877898630329552176476681779604405180,    .7293447293447293447293447293447293447293,
-    .31845373111853458869546784626436419785030,    .7272727272727272727272727272727272727273,
-    .32129061245373424782201254856772720813750,    .7252124645892351274787535410764872521246,
-    .32411946865421192853773391107097268104550,    .7231638418079096045197740112994350282486,
-    .32694034499585328257253991068864706903700,    .7211267605633802816901408450704225352113,
-    .32975328637246797969240219572384376078850,    .7191011235955056179775280898876404494382,
-    .33255833730007655635318997155991382896900,    .7170868347338935574229691876750700280112,
-    .33535554192113781191153520921943709254280,    .7150837988826815642458100558659217877095,
-    .33814494400871636381467055798566434532400,    .7130919220055710306406685236768802228412,
-    .34092658697059319283795275623560883104800,    .7111111111111111111111111111111111111111,
-    .34370051385331840121395430287520866841080,    .7091412742382271468144044321329639889197,
-    .34646676734620857063262633346312213689100,    .7071823204419889502762430939226519337017,
-    .34922538978528827602332285096053965389730,    .7052341597796143250688705234159779614325,
-    .35197642315717814209818925519357435405250,    .7032967032967032967032967032967032967033,
-    .35471990910292899856770532096561510115850,    .7013698630136986301369863013698630136986,
-    .35745588892180374385176833129662554711100,    .6994535519125683060109289617486338797814,
-    .36018440357500774995358483465679455548530,    .6975476839237057220708446866485013623978,
-    .36290549368936841911903457003063522279280,    .6956521739130434782608695652173913043478,
-    .36561919956096466943762379742111079394830,    .6937669376693766937669376693766937669377,
-    .36832556115870762614150635272380895912650,    .6918918918918918918918918918918918918919,
-    .37102461812787262962487488948681857436900,    .6900269541778975741239892183288409703504,
-    .37371640979358405898480555151763837784530,    .6881720430107526881720430107526881720430,
-    .37640097516425302659470730759494472295050,    .6863270777479892761394101876675603217158,
-    .37907835293496944251145919224654790014030,    .6844919786096256684491978609625668449198,
-    .38174858149084833769393299007788300514230,    .6826666666666666666666666666666666666667,
-    .38441169891033200034513583887019194662580,    .6808510638297872340425531914893617021277,
-    .38706774296844825844488013899535872042180,    .6790450928381962864721485411140583554377,
-    .38971675114002518602873692543653305619950,    .6772486772486772486772486772486772486772,
-    .39235876060286384303665840889152605086580,    .6754617414248021108179419525065963060686,
-    .39499380824086893770896722344332374632350,    .6736842105263157894736842105263157894737,
-    .39762193064713846624158577469643205404280,    .6719160104986876640419947506561679790026,
-    .40024316412701266276741307592601515352730,    .6701570680628272251308900523560209424084,
-    .40285754470108348090917615991202183067800,    .6684073107049608355091383812010443864230,
-    .40546510810816432934799991016916465014230,    .6666666666666666666666666666666666666667,
-    .40806588980822172674223224930756259709600,    .6649350649350649350649350649350649350649,
-    .41065992498526837639616360320360399782650,    .6632124352331606217616580310880829015544,
-    .41324724855021932601317757871584035456180,    .6614987080103359173126614987080103359173,
-    .41582789514371093497757669865677598863850,    .6597938144329896907216494845360824742268,
-    .41840189913888381489925905043492093682300,    .6580976863753213367609254498714652956298,
-    .42096929464412963239894338585145305842150,    .6564102564102564102564102564102564102564,
-    .42353011550580327293502591601281892508280,    .6547314578005115089514066496163682864450,
-    .42608439531090003260516141381231136620050,    .6530612244897959183673469387755102040816,
-    .42863216738969872610098832410585600882780,    .6513994910941475826972010178117048346056,
-    .43117346481837132143866142541810404509300,    .6497461928934010152284263959390862944162,
-    .43370832042155937902094819946796633303180,    .6481012658227848101265822784810126582278,
-    .43623676677491801667585491486534010618930,    .6464646464646464646464646464646464646465,
-    .43875883620762790027214350629947148263450,    .6448362720403022670025188916876574307305,
-    .44127456080487520440058801796112675219780,    .6432160804020100502512562814070351758794,
-    .44378397241030093089975139264424797147500,    .6416040100250626566416040100250626566416,
-    .44628710262841947420398014401143882423650,    .6400000000000000000000000000000000000000,
-    .44878398282700665555822183705458883196130,    .6384039900249376558603491271820448877805,
-    .45127464413945855836729492693848442286250,    .6368159203980099502487562189054726368159,
-    .45375911746712049854579618113348260521900,    .6352357320099255583126550868486352357320,
-    .45623743348158757315857769754074979573500,    .6336633663366336633663366336633663366337,
-    .45870962262697662081833982483658473938700,    .6320987654320987654320987654320987654321,
-    .46117571512217014895185229761409573256980,    .6305418719211822660098522167487684729064,
-    .46363574096303250549055974261136725544930,    .6289926289926289926289926289926289926290,
-    .46608972992459918316399125615134835243230,    .6274509803921568627450980392156862745098,
-    .46853771156323925639597405279346276074650,    .6259168704156479217603911980440097799511,
-    .47097971521879100631480241645476780831830,    .6243902439024390243902439024390243902439,
-    .47341577001667212165614273544633761048330,    .6228710462287104622871046228710462287105,
-    .47584590486996386493601107758877333253630,    .6213592233009708737864077669902912621359,
-    .47827014848147025860569669930555392056700,    .6198547215496368038740920096852300242131,
-    .48068852934575190261057286988943815231330,    .6183574879227053140096618357487922705314,
-    .48310107575113581113157579238759353756900,    .6168674698795180722891566265060240963855,
-    .48550781578170076890899053978500887751580,    .6153846153846153846153846153846153846154,
-    .48790877731923892879351001283794175833480,    .6139088729016786570743405275779376498801,
-    .49030398804519381705802061333088204264650,    .6124401913875598086124401913875598086124,
-    .49269347544257524607047571407747454941280,    .6109785202863961813842482100238663484487,
-    .49507726679785146739476431321236304938800,    .6095238095238095238095238095238095238095,
-    .49745538920281889838648226032091770321130,    .6080760095011876484560570071258907363420,
-    .49982786955644931126130359189119189977650,    .6066350710900473933649289099526066350711,
-    .50219473456671548383667413872899487614650,    .6052009456264775413711583924349881796690,
-    .50455601075239520092452494282042607665050,    .6037735849056603773584905660377358490566,
-    .50691172444485432801997148999362252652650,    .6023529411764705882352941176470588235294,
-    .50926190178980790257412536448100581765150,    .6009389671361502347417840375586854460094,
-    .51160656874906207391973111953120678663250,    .5995316159250585480093676814988290398126,
-    .51394575110223428282552049495279788970950,    .5981308411214953271028037383177570093458,
-    .51627947444845445623684554448118433356300,    .5967365967365967365967365967365967365967,
-    .51860776420804555186805373523384332656850,    .5953488372093023255813953488372093023256,
-    .52093064562418522900344441950437612831600,    .5939675174013921113689095127610208816705,
-    .52324814376454775732838697877014055848100,    .5925925925925925925925925925925925925926,
-    .52556028352292727401362526507000438869000,    .5912240184757505773672055427251732101617,
-    .52786708962084227803046587723656557500350,    .5898617511520737327188940092165898617512,
-    .53016858660912158374145519701414741575700,    .5885057471264367816091954022988505747126,
-    .53246479886947173376654518506256863474850,    .5871559633027522935779816513761467889908,
-    .53475575061602764748158733709715306758900,    .5858123569794050343249427917620137299771,
-    .53704146589688361856929077475797384977350,    .5844748858447488584474885844748858447489,
-    .53932196859560876944783558428753167390800,    .5831435079726651480637813211845102505695,
-    .54159728243274429804188230264117009937750,    .5818181818181818181818181818181818181818,
-    .54386743096728351609669971367111429572100,    .5804988662131519274376417233560090702948,
-    .54613243759813556721383065450936555862450,    .5791855203619909502262443438914027149321,
-    .54839232556557315767520321969641372561450,    .5778781038374717832957110609480812641084,
-    .55064711795266219063194057525834068655950,    .5765765765765765765765765765765765765766,
-    .55289683768667763352766542084282264113450,    .5752808988764044943820224719101123595506,
-    .55514150754050151093110798683483153581600,    .5739910313901345291479820627802690582960,
-    .55738115013400635344709144192165695130850,    .5727069351230425055928411633109619686801,
-    .55961578793542265941596269840374588966350,    .5714285714285714285714285714285714285714,
-    .56184544326269181269140062795486301183700,    .5701559020044543429844097995545657015590,
-    .56407013828480290218436721261241473257550,    .5688888888888888888888888888888888888889,
-    .56628989502311577464155334382667206227800,    .5676274944567627494456762749445676274945,
-    .56850473535266865532378233183408156037350,    .5663716814159292035398230088495575221239,
-    .57071468100347144680739575051120482385150,    .5651214128035320088300220750551876379691,
-    .57291975356178548306473885531886480748650,    .5638766519823788546255506607929515418502,
-    .57511997447138785144460371157038025558000,    .5626373626373626373626373626373626373626,
-    .57731536503482350219940144597785547375700,    .5614035087719298245614035087719298245614,
-    .57950594641464214795689713355386629700650,    .5601750547045951859956236323851203501094,
-    .58169173963462239562716149521293118596100,    .5589519650655021834061135371179039301310,
-    .58387276558098266665552955601015128195300,    .5577342047930283224400871459694989106754,
-    .58604904500357812846544902640744112432000,    .5565217391304347826086956521739130434783,
-    .58822059851708596855957011939608491957200,    .5553145336225596529284164859002169197397,
-    .59038744660217634674381770309992134571100,    .5541125541125541125541125541125541125541,
-    .59254960960667157898740242671919986605650,    .5529157667386609071274298056155507559395,
-    .59470710774669277576265358220553025603300,    .5517241379310344827586206896551724137931,
-    .59685996110779382384237123915227130055450,    .5505376344086021505376344086021505376344,
-    .59900818964608337768851242799428291618800,    .5493562231759656652360515021459227467811,
-    .60115181318933474940990890900138765573500,    .5481798715203426124197002141327623126338,
-    .60329085143808425240052883964381180703650,    .5470085470085470085470085470085470085470,
-    .60542532396671688843525771517306566238400,    .5458422174840085287846481876332622601279,
-    .60755525022454170969155029524699784815300,    .5446808510638297872340425531914893617021,
-    .60968064953685519036241657886421307921400,    .5435244161358811040339702760084925690021,
-    .61180154110599282990534675263916142284850,    .5423728813559322033898305084745762711864,
-    .61391794401237043121710712512140162289150,    .5412262156448202959830866807610993657505,
-    .61602987721551394351138242200249806046500,    .5400843881856540084388185654008438818565,
-    .61813735955507864705538167982012964785100,    .5389473684210526315789473684210526315789,
-    .62024040975185745772080281312810257077200,    .5378151260504201680672268907563025210084,
-    .62233904640877868441606324267922900617100,    .5366876310272536687631027253668763102725,
-    .62443328801189346144440150965237990021700,    .5355648535564853556485355648535564853556,
-    .62652315293135274476554741340805776417250,    .5344467640918580375782881002087682672234,
-    .62860865942237409420556559780379757285100,    .5333333333333333333333333333333333333333,
-    .63068982562619868570408243613201193511500,    .5322245322245322245322245322245322245322,
-    .63276666957103777644277897707070223987100,    .5311203319502074688796680497925311203320,
-    .63483920917301017716738442686619237065300,    .5300207039337474120082815734989648033126,
-    .63690746223706917739093569252872839570050,    .5289256198347107438016528925619834710744,
-    .63897144645792069983514238629140891134750,    .5278350515463917525773195876288659793814,
-    .64103117942093124081992527862894348800200,    .5267489711934156378600823045267489711934,
-    .64308667860302726193566513757104985415950,    .5256673511293634496919917864476386036961,
-    .64513796137358470073053240412264131009600,    .5245901639344262295081967213114754098361,
-    .64718504499530948859131740391603671014300,    .5235173824130879345603271983640081799591,
-    .64922794662510974195157587018911726772800,    .5224489795918367346938775510204081632653,
-    .65126668331495807251485530287027359008800,    .5213849287169042769857433808553971486762,
-    .65330127201274557080523663898929953575150,    .5203252032520325203252032520325203252033,
-    .65533172956312757406749369692988693714150,    .5192697768762677484787018255578093306288,
-    .65735807270835999727154330685152672231200,    .5182186234817813765182186234817813765182,
-    .65938031808912778153342060249997302889800,    .5171717171717171717171717171717171717172,
-    .66139848224536490484126716182800009846700,    .5161290322580645161290322580645161290323,
-    .66341258161706617713093692145776003599150,    .5150905432595573440643863179074446680080,
-    .66542263254509037562201001492212526500250,    .5140562248995983935742971887550200803213,
-    .66742865127195616370414654738851822912700,    .5130260521042084168336673346693386773547,
-    .66943065394262923906154583164607174694550,    .5120000000000000000000000000000000000000,
-    .67142865660530226534774556057527661323550,    .5109780439121756487025948103792415169661,
-    .67342267521216669923234121597488410770900,    .5099601593625498007968127490039840637450,
-    .67541272562017662384192817626171745359900,    .5089463220675944333996023856858846918489,
-    .67739882359180603188519853574689477682100,    .5079365079365079365079365079365079365079,
-    .67938098479579733801614338517538271844400,    .5069306930693069306930693069306930693069,
-    .68135922480790300781450241629499942064300,    .5059288537549407114624505928853754940711,
-    .68333355911162063645036823800182901322850,    .5049309664694280078895463510848126232742,
-    .68530400309891936760919861626462079584600,    .5039370078740157480314960629921259842520,
-    .68727057207096020619019327568821609020250,    .5029469548133595284872298624754420432220,
-    .68923328123880889251040571252815425395950,    .5019607843137254901960784313725490196078,
-    .69314718055994530941723212145818, 5.0e-01,
-};
-
-const double* getLogTab64f()
-{
-    return logTab;
-}
-
-const float* getLogTab32f()
-{
-    static float CV_DECL_ALIGNED(64) logTab_f[(LOGTAB_MASK+1)*2];
-    static std::atomic<bool> logTab_f_initialized(false);
-    if (!logTab_f_initialized.load())
-    {
-        for (int j = 0; j < (LOGTAB_MASK+1)*2; j++)
-            logTab_f[j] = (float)logTab[j];
-        logTab_f_initialized = true;
-    }
-    return logTab_f;
-}
-
-}} // namespace
 
 /* End of file. */

modules/core/src/mathfuncs.hpp

@@ -5,11 +5,7 @@
 #ifndef OPENCV_CORE_SRC_MATHFUNCS_HPP
 #define OPENCV_CORE_SRC_MATHFUNCS_HPP
 
-namespace cv { namespace details {
+// (the exp/log table kernels and their tables are gone - cv::hal::exp32f & co now fall back
-const double* getExpTab64f();
+//  to the element-wise engine's vector kernels; see mathfuncs_core.dispatch.cpp)
-const float*  getExpTab32f();
-const double* getLogTab64f();
-const float*  getLogTab32f();
-}} // namespace
 
 #endif // OPENCV_CORE_SRC_MATHFUNCS_HPP

modules/core/src/mathfuncs_core.dispatch.cpp

@@ -3,6 +3,7 @@
 // of this distribution and at http://opencv.org/license.html.
 
 #include "precomp.hpp"
+#include "arithm_expr.hpp"      // ew::mathSpanEngine - the engine fallback for exp/log
 
 #include "mathfuncs_core.simd.hpp"
 #include "mathfuncs_core.simd_declarations.hpp" // defines CV_CPU_DISPATCH_MODES_ALL=AVX2,...,BASELINE based on CMakeLists.txt content
@@ -151,8 +152,8 @@ void exp32f(const float *src, float *dst, int n)
 
     CALL_HAL(exp32f, cv_hal_exp32f, src, dst, n);
 
-    CV_CPU_DISPATCH(exp32f, (src, dst, n),
+    ew::mathSpanEngine(ew::OP_EXP, CV_32F, src, dst, n);   // the engine's vector kernel (the old
-        CV_CPU_DISPATCH_MODES_ALL);
+                                                       // table implementation is removed)
 }
 
 void exp64f(const double *src, double *dst, int n)
@@ -161,8 +162,8 @@ void exp64f(const double *src, double *dst, int n)
 
     CALL_HAL(exp64f, cv_hal_exp64f, src, dst, n);
 
-    CV_CPU_DISPATCH(exp64f, (src, dst, n),
+    ew::mathSpanEngine(ew::OP_EXP, CV_64F, src, dst, n);   // the engine's vector kernel (the old
-        CV_CPU_DISPATCH_MODES_ALL);
+                                                       // table implementation is removed)
 }
 
 void log32f(const float *src, float *dst, int n)
@@ -171,8 +172,8 @@ void log32f(const float *src, float *dst, int n)
 
     CALL_HAL(log32f, cv_hal_log32f, src, dst, n);
 
-    CV_CPU_DISPATCH(log32f, (src, dst, n),
+    ew::mathSpanEngine(ew::OP_LOG, CV_32F, src, dst, n);   // the engine's vector kernel (the old
-        CV_CPU_DISPATCH_MODES_ALL);
+                                                       // table implementation is removed)
 }
 
 void log64f(const double *src, double *dst, int n)
@@ -181,8 +182,8 @@ void log64f(const double *src, double *dst, int n)
 
     CALL_HAL(log64f, cv_hal_log64f, src, dst, n);
 
-    CV_CPU_DISPATCH(log64f, (src, dst, n),
+    ew::mathSpanEngine(ew::OP_LOG, CV_64F, src, dst, n);   // the engine's vector kernel (the old
-        CV_CPU_DISPATCH_MODES_ALL);
+                                                       // table implementation is removed)
 }
 
 //=============================================================================

modules/core/src/mathfuncs_core.simd.hpp

@@ -22,10 +22,6 @@ void invSqrt32f(const float* src, float* dst, int len);
 void invSqrt64f(const double* src, double* dst, int len);
 void sqrt32f(const float* src, float* dst, int len);
 void sqrt64f(const double* src, double* dst, int len);
-void exp32f(const float *src, float *dst, int n);
-void exp64f(const double *src, double *dst, int n);
-void log32f(const float *src, float *dst, int n);
-void log64f(const double *src, double *dst, int n);
 float fastAtan2(float y, float x);
 
 #ifndef CV_CPU_OPTIMIZATION_DECLARATIONS_ONLY
@@ -638,422 +634,6 @@ void log64f(const double *src, double *dst, int n)
 
 ////////////////////////////////////// EXP /////////////////////////////////////
 
-#define EXPTAB_SCALE 6
-#define EXPTAB_MASK  ((1 << EXPTAB_SCALE) - 1)
-
-#define EXPPOLY_32F_A0 .9670371139572337719125840413672004409288e-2
-
-// the code below uses _mm_cast* intrinsics, which are not available on VS2005
-#if (defined _MSC_VER && _MSC_VER < 1500) || \
-(!defined __APPLE__ && defined __GNUC__ && __GNUC__*100 + __GNUC_MINOR__ < 402)
-#undef CV_SSE2
-#define CV_SSE2 0
-#endif
-
-static const double exp_prescale = 1.4426950408889634073599246810019 * (1 << EXPTAB_SCALE);
-static const double exp_postscale = 1./(1 << EXPTAB_SCALE);
-static const double exp_max_val = 3000.*(1 << EXPTAB_SCALE); // log10(DBL_MAX) < 3000
-
-void exp32f( const float *_x, float *y, int n )
-{
-    CV_INSTRUMENT_REGION();
-
-    const float* const expTab_f = cv::details::getExpTab32f();
-
-    const float
-    A4 = (float)(1.000000000000002438532970795181890933776 / EXPPOLY_32F_A0),
-    A3 = (float)(.6931471805521448196800669615864773144641 / EXPPOLY_32F_A0),
-    A2 = (float)(.2402265109513301490103372422686535526573 / EXPPOLY_32F_A0),
-    A1 = (float)(.5550339366753125211915322047004666939128e-1 / EXPPOLY_32F_A0);
-
-    int i = 0;
-    const Cv32suf* x = (const Cv32suf*)_x;
-    float minval = (float)(-exp_max_val/exp_prescale);
-    float maxval = (float)(exp_max_val/exp_prescale);
-    float postscale = (float)exp_postscale;
-
-#if (CV_SIMD || CV_SIMD_SCALABLE)
-    const int VECSZ = VTraits<v_float32>::vlanes();
-    const v_float32 vprescale = vx_setall_f32((float)exp_prescale);
-    const v_float32 vpostscale = vx_setall_f32((float)exp_postscale);
-    const v_float32 vminval = vx_setall_f32(minval);
-    const v_float32 vmaxval = vx_setall_f32(maxval);
-
-    const v_float32 vA1 = vx_setall_f32((float)A1);
-    const v_float32 vA2 = vx_setall_f32((float)A2);
-    const v_float32 vA3 = vx_setall_f32((float)A3);
-    const v_float32 vA4 = vx_setall_f32((float)A4);
-
-    const v_int32 vidxmask = vx_setall_s32(EXPTAB_MASK);
-    bool y_aligned = (size_t)(void*)y % 32 == 0;
-
-    for( ; i < n; i += VECSZ*2 )
-    {
-        if( i + VECSZ*2 > n )
-        {
-            if( i == 0 || _x == y )
-                break;
-            i = n - VECSZ*2;
-            y_aligned = false;
-        }
-
-        v_float32 xf0 = vx_load(&x[i].f), xf1 = vx_load(&x[i + VECSZ].f);
-
-        xf0 = v_min(v_max(xf0, vminval), vmaxval);
-        xf1 = v_min(v_max(xf1, vminval), vmaxval);
-
-        xf0 = v_mul(xf0, vprescale);
-        xf1 = v_mul(xf1, vprescale);
-
-        v_int32 xi0 = v_round(xf0);
-        v_int32 xi1 = v_round(xf1);
-        xf0 = v_mul(v_sub(xf0, v_cvt_f32(xi0)), vpostscale);
-        xf1 = v_mul(v_sub(xf1, v_cvt_f32(xi1)), vpostscale);
-
-        v_float32 yf0 = v_lut(expTab_f, v_and(xi0, vidxmask));
-        v_float32 yf1 = v_lut(expTab_f, v_and(xi1, vidxmask));
-
-        v_int32 v0 = vx_setzero_s32(), v127 = vx_setall_s32(127), v255 = vx_setall_s32(255);
-        xi0 = v_min(v_max(v_add(v_shr<6>(xi0), v127), v0), v255);
-        xi1 = v_min(v_max(v_add(v_shr<6>(xi1), v127), v0), v255);
-
-        yf0 = v_mul(yf0, v_reinterpret_as_f32(v_shl<23>(xi0)));
-        yf1 = v_mul(yf1, v_reinterpret_as_f32(v_shl<23>(xi1)));
-
-        v_float32 zf0 = v_add(xf0, vA1);
-        v_float32 zf1 = v_add(xf1, vA1);
-
-        zf0 = v_fma(zf0, xf0, vA2);
-        zf1 = v_fma(zf1, xf1, vA2);
-
-        zf0 = v_fma(zf0, xf0, vA3);
-        zf1 = v_fma(zf1, xf1, vA3);
-
-        zf0 = v_fma(zf0, xf0, vA4);
-        zf1 = v_fma(zf1, xf1, vA4);
-
-        zf0 = v_mul(zf0, yf0);
-        zf1 = v_mul(zf1, yf1);
-
-        if( y_aligned )
-        {
-            v_store_aligned(y + i, zf0);
-            v_store_aligned(y + i + VECSZ, zf1);
-        }
-        else
-        {
-            v_store(y + i, zf0);
-            v_store(y + i + VECSZ, zf1);
-        }
-    }
-    vx_cleanup();
-#endif
-
-    for( ; i < n; i++ )
-    {
-        float x0 = x[i].f;
-        x0 = std::min(std::max(x0, minval), maxval);
-        x0 *= (float)exp_prescale;
-        Cv32suf buf;
-
-        int xi = saturate_cast<int>(x0);
-        x0 = (x0 - xi)*postscale;
-
-        int t = (xi >> EXPTAB_SCALE) + 127;
-        t = !(t & ~255) ? t : t < 0 ? 0 : 255;
-        buf.i = t << 23;
-
-        y[i] = buf.f * expTab_f[xi & EXPTAB_MASK] * ((((x0 + A1)*x0 + A2)*x0 + A3)*x0 + A4);
-    }
-}
-
-void exp64f( const double *_x, double *y, int n )
-{
-    CV_INSTRUMENT_REGION();
-
-    const double* const expTab = cv::details::getExpTab64f();
-
-    const double
-    A5 = .99999999999999999998285227504999 / EXPPOLY_32F_A0,
-    A4 = .69314718055994546743029643825322 / EXPPOLY_32F_A0,
-    A3 = .24022650695886477918181338054308 / EXPPOLY_32F_A0,
-    A2 = .55504108793649567998466049042729e-1 / EXPPOLY_32F_A0,
-    A1 = .96180973140732918010002372686186e-2 / EXPPOLY_32F_A0,
-    A0 = .13369713757180123244806654839424e-2 / EXPPOLY_32F_A0;
-
-    int i = 0;
-    const Cv64suf* x = (const Cv64suf*)_x;
-    double minval = (-exp_max_val/exp_prescale);
-    double maxval = (exp_max_val/exp_prescale);
-
-#if (CV_SIMD_64F || CV_SIMD_SCALABLE_64F)
-    const int VECSZ = VTraits<v_float64>::vlanes();
-    const v_float64 vprescale = vx_setall_f64(exp_prescale);
-    const v_float64 vpostscale = vx_setall_f64(exp_postscale);
-    const v_float64 vminval = vx_setall_f64(minval);
-    const v_float64 vmaxval = vx_setall_f64(maxval);
-
-    const v_float64 vA1 = vx_setall_f64(A1);
-    const v_float64 vA2 = vx_setall_f64(A2);
-    const v_float64 vA3 = vx_setall_f64(A3);
-    const v_float64 vA4 = vx_setall_f64(A4);
-    const v_float64 vA5 = vx_setall_f64(A5);
-
-    const v_int32 vidxmask = vx_setall_s32(EXPTAB_MASK);
-    bool y_aligned = (size_t)(void*)y % 32 == 0;
-
-    for( ; i < n; i += VECSZ*2 )
-    {
-        if( i + VECSZ*2 > n )
-        {
-            if( i == 0 || _x == y )
-                break;
-            i = n - VECSZ*2;
-            y_aligned = false;
-        }
-
-        v_float64 xf0 = vx_load(&x[i].f), xf1 = vx_load(&x[i + VECSZ].f);
-
-        xf0 = v_min(v_max(xf0, vminval), vmaxval);
-        xf1 = v_min(v_max(xf1, vminval), vmaxval);
-
-        xf0 = v_mul(xf0, vprescale);
-        xf1 = v_mul(xf1, vprescale);
-
-        v_int32 xi0 = v_round(xf0);
-        v_int32 xi1 = v_round(xf1);
-        xf0 = v_mul(v_sub(xf0, v_cvt_f64(xi0)), vpostscale);
-        xf1 = v_mul(v_sub(xf1, v_cvt_f64(xi1)), vpostscale);
-
-        v_float64 yf0 = v_lut(expTab, v_and(xi0, vidxmask));
-        v_float64 yf1 = v_lut(expTab, v_and(xi1, vidxmask));
-
-        v_int32 v0 = vx_setzero_s32(), v1023 = vx_setall_s32(1023), v2047 = vx_setall_s32(2047);
-        xi0 = v_min(v_max(v_add(v_shr<6>(xi0), v1023), v0), v2047);
-        xi1 = v_min(v_max(v_add(v_shr<6>(xi1), v1023), v0), v2047);
-
-        v_int64 xq0, xq1, dummy;
-        v_expand(xi0, xq0, dummy);
-        v_expand(xi1, xq1, dummy);
-
-        yf0 = v_mul(yf0, v_reinterpret_as_f64(v_shl<52>(xq0)));
-        yf1 = v_mul(yf1, v_reinterpret_as_f64(v_shl<52>(xq1)));
-
-        v_float64 zf0 = v_add(xf0, vA1);
-        v_float64 zf1 = v_add(xf1, vA1);
-
-        zf0 = v_fma(zf0, xf0, vA2);
-        zf1 = v_fma(zf1, xf1, vA2);
-
-        zf0 = v_fma(zf0, xf0, vA3);
-        zf1 = v_fma(zf1, xf1, vA3);
-
-        zf0 = v_fma(zf0, xf0, vA4);
-        zf1 = v_fma(zf1, xf1, vA4);
-
-        zf0 = v_fma(zf0, xf0, vA5);
-        zf1 = v_fma(zf1, xf1, vA5);
-
-        zf0 = v_mul(zf0, yf0);
-        zf1 = v_mul(zf1, yf1);
-
-        if( y_aligned )
-        {
-            v_store_aligned(y + i, zf0);
-            v_store_aligned(y + i + VECSZ, zf1);
-        }
-        else
-        {
-            v_store(y + i, zf0);
-            v_store(y + i + VECSZ, zf1);
-        }
-    }
-    vx_cleanup();
-#endif
-
-    for( ; i < n; i++ )
-    {
-        double x0 = x[i].f;
-        x0 = std::min(std::max(x0, minval), maxval);
-        x0 *= exp_prescale;
-        Cv64suf buf;
-
-        int xi = saturate_cast<int>(x0);
-        x0 = (x0 - xi)*exp_postscale;
-
-        int t = (xi >> EXPTAB_SCALE) + 1023;
-        t = !(t & ~2047) ? t : t < 0 ? 0 : 2047;
-        buf.i = (int64)t << 52;
-
-        y[i] = buf.f * expTab[xi & EXPTAB_MASK] * (((((A0*x0 + A1)*x0 + A2)*x0 + A3)*x0 + A4)*x0 + A5);
-    }
-}
-
-#undef EXPTAB_SCALE
-#undef EXPTAB_MASK
-#undef EXPPOLY_32F_A0
-
-/////////////////////////////////////////// LOG ///////////////////////////////////////
-
-#define LOGTAB_SCALE        8
-#define LOGTAB_MASK         ((1 << LOGTAB_SCALE) - 1)
-
-#define LOGTAB_TRANSLATE(tab, x, h) (((x) - 1.f)*tab[(h)+1])
-static const double ln_2 = 0.69314718055994530941723212145818;
-
-void log32f( const float *_x, float *y, int n )
-{
-    CV_INSTRUMENT_REGION();
-
-    const float* const logTab_f = cv::details::getLogTab32f();
-
-    const int LOGTAB_MASK2_32F = (1 << (23 - LOGTAB_SCALE)) - 1;
-    const float
-    A0 = 0.3333333333333333333333333f,
-    A1 = -0.5f,
-    A2 = 1.f;
-
-    int i = 0;
-    const int* x = (const int*)_x;
-
-#if (CV_SIMD || CV_SIMD_SCALABLE)
-    const int VECSZ = VTraits<v_float32>::vlanes();
-    const v_float32 vln2 = vx_setall_f32((float)ln_2);
-    const v_float32 v1 = vx_setall_f32(1.f);
-    const v_float32 vshift = vx_setall_f32(-1.f/512);
-
-    const v_float32 vA0 = vx_setall_f32(A0);
-    const v_float32 vA1 = vx_setall_f32(A1);
-    const v_float32 vA2 = vx_setall_f32(A2);
-
-    for( ; i < n; i += VECSZ )
-    {
-        if( i + VECSZ > n )
-        {
-            if( i == 0 || _x == y )
-                break;
-            i = n - VECSZ;
-        }
-
-        v_int32 h0 = vx_load(x + i);
-        v_int32 yi0 = v_sub(v_and(v_shr<23>(h0), vx_setall_s32(255)), vx_setall_s32(127));
-        v_int32 xi0 = v_or(v_and(h0, vx_setall_s32(LOGTAB_MASK2_32F)), vx_setall_s32(127 << 23));
-
-        h0 = v_and(v_shr<23 - 8 - 1>(h0), vx_setall_s32(((1 << 8) - 1) * 2));
-        v_float32 yf0, xf0;
-
-        v_lut_deinterleave(logTab_f, h0, yf0, xf0);
-
-        yf0 = v_fma(v_cvt_f32(yi0), vln2, yf0);
-
-        v_float32 delta = v_select(v_reinterpret_as_f32(v_eq(h0, vx_setall_s32(510))), vshift, vx_setall<float>(0));
-        xf0 = v_fma((v_sub(v_reinterpret_as_f32(xi0), v1)), xf0, delta);
-
-        v_float32 zf0 = v_fma(xf0, vA0, vA1);
-        zf0 = v_fma(zf0, xf0, vA2);
-        zf0 = v_fma(zf0, xf0, yf0);
-
-        v_store(y + i, zf0);
-    }
-    vx_cleanup();
-#endif
-
-    for( ; i < n; i++ )
-    {
-        Cv32suf buf;
-        int i0 = x[i];
-
-        buf.i = (i0 & LOGTAB_MASK2_32F) | (127 << 23);
-        int idx = (i0 >> (23 - LOGTAB_SCALE - 1)) & (LOGTAB_MASK*2);
-
-        float y0 = (((i0 >> 23) & 0xff) - 127) * (float)ln_2 + logTab_f[idx];
-        float x0 = (buf.f - 1.f)*logTab_f[idx + 1] + (idx == 510 ? -1.f/512 : 0.f);
-        y[i] = ((A0*x0 + A1)*x0 + A2)*x0 + y0;
-    }
-}
-
-void log64f( const double *x, double *y, int n )
-{
-    CV_INSTRUMENT_REGION();
-
-    const double* const logTab = cv::details::getLogTab64f();
-
-    const int64 LOGTAB_MASK2_64F = ((int64)1 << (52 - LOGTAB_SCALE)) - 1;
-    const double
-    A7 = 1.0,
-    A6 = -0.5,
-    A5 = 0.333333333333333314829616256247390992939472198486328125,
-    A4 = -0.25,
-    A3 = 0.2,
-    A2 = -0.1666666666666666574148081281236954964697360992431640625,
-    A1 = 0.1428571428571428769682682968777953647077083587646484375,
-    A0 = -0.125;
-
-    int i = 0;
-
-#if (CV_SIMD_64F || CV_SIMD_SCALABLE_64F)
-    const int VECSZ = VTraits<v_float64>::vlanes();
-    const v_float64 vln2 = vx_setall_f64(ln_2);
-
-    const v_float64
-        vA0 = vx_setall_f64(A0), vA1 = vx_setall_f64(A1),
-        vA2 = vx_setall_f64(A2), vA3 = vx_setall_f64(A3),
-        vA4 = vx_setall_f64(A4), vA5 = vx_setall_f64(A5),
-        vA6 = vx_setall_f64(A6), vA7 = vx_setall_f64(A7);
-
-    for( ; i < n; i += VECSZ )
-    {
-        if( i + VECSZ > n )
-        {
-            if( i == 0 || x == y )
-                break;
-            i = n - VECSZ;
-        }
-
-        v_int64 h0 = vx_load((const int64*)x + i);
-        v_int32 yi0 = v_pack(v_shr<52>(h0), vx_setzero_s64());
-        yi0 = v_sub(v_and(yi0, vx_setall_s32(2047)), vx_setall_s32(1023));
-
-        v_int64 xi0 = v_or(v_and(h0, vx_setall_s64(LOGTAB_MASK2_64F)), vx_setall_s64((int64)1023 << 52));
-        h0 = v_shr<52 - LOGTAB_SCALE - 1>(h0);
-        v_int32 idx = v_and(v_pack(h0, h0), vx_setall_s32(((1 << 8) - 1) * 2));
-
-        v_float64 xf0, yf0;
-        v_lut_deinterleave(logTab, idx, yf0, xf0);
-
-        yf0 = v_fma(v_cvt_f64(yi0), vln2, yf0);
-        v_float64 delta = v_mul(v_cvt_f64(v_eq(idx, vx_setall_s32(510))), vx_setall_f64(1. / 512));
-        xf0 = v_fma(v_sub(v_reinterpret_as_f64(xi0), vx_setall_f64(1.)), xf0, delta);
-
-        v_float64 xq = v_mul(xf0, xf0);
-        v_float64 zf0 = v_fma(xq, vA0, vA2);
-        v_float64 zf1 = v_fma(xq, vA1, vA3);
-        zf0 = v_fma(zf0, xq, vA4);
-        zf1 = v_fma(zf1, xq, vA5);
-        zf0 = v_fma(zf0, xq, vA6);
-        zf1 = v_fma(zf1, xq, vA7);
-        zf1 = v_fma(zf1, xf0, yf0);
-        zf0 = v_fma(zf0, xq, zf1);
-
-        v_store(y + i, zf0);
-    }
-#endif
-
-    for( ; i < n; i++ )
-    {
-        Cv64suf buf;
-        int64 i0 = ((const int64*)x)[i];
-
-        buf.i = (i0 & LOGTAB_MASK2_64F) | ((int64)1023 << 52);
-        int idx = (int)(i0 >> (52 - LOGTAB_SCALE - 1)) & (LOGTAB_MASK*2);
-
-        double y0 = (((int)(i0 >> 52) & 0x7ff) - 1023) * ln_2 + logTab[idx];
-        double x0 = (buf.f - 1.)*logTab[idx + 1] + (idx == 510 ? -1./512 : 0.);
-
-        double xq = x0*x0;
-        y[i] = (((A0*xq + A2)*xq + A4)*xq + A6)*xq + (((A1*xq + A3)*xq + A5)*xq + A7)*x0 + y0;
-    }
-}
 
 #endif // issue 7795
 

modules/core/src/ocl.cpp

@@ -7253,12 +7253,21 @@ int predictOptimalVectorWidth(InputArray src1, InputArray src2, InputArray src3,
     return checkOptimalVectorWidth(vectorWidths, src1, src2, src3, src4, src5, src6, src7, src8, src9, strat);
 }
 
-int checkOptimalVectorWidth(const int *vectorWidths,
+int checkOptimalVectorWidth([[maybe_unused]] const int *vectorWidths,
-                            InputArray src1, InputArray src2, InputArray src3,
+                            [[maybe_unused]] InputArray src1,
-                            InputArray src4, InputArray src5, InputArray src6,
+                            [[maybe_unused]] InputArray src2,
-                            InputArray src7, InputArray src8, InputArray src9,
+                            [[maybe_unused]] InputArray src3,
-                            OclVectorStrategy strat)
+                            [[maybe_unused]] InputArray src4,
+                            [[maybe_unused]] InputArray src5,
+                            [[maybe_unused]] InputArray src6,
+                            [[maybe_unused]] InputArray src7,
+                            [[maybe_unused]] InputArray src8,
+                            [[maybe_unused]] InputArray src9,
+                            [[maybe_unused]] OclVectorStrategy strat)
 {
+#ifdef __APPLE__
+    return 1;
+#else
     CV_Assert(vectorWidths);
 
     int ref_type = src1.type();
@@ -7285,6 +7294,7 @@ int checkOptimalVectorWidth(const int *vectorWidths,
     int kercn = *std::min_element(kercns.begin(), kercns.end());
 
     return kercn;
+#endif
 }
 
 int predictOptimalVectorWidthMax(InputArray src1, InputArray src2, InputArray src3,

modules/core/src/precomp.hpp

@@ -261,8 +261,12 @@ typedef void (*BinaryFuncC)(const uchar* src1, size_t step1,
                        uchar* dst, size_t step, int width, int height,
                        void*);
 
-BinaryFunc getConvertFunc(int sdepth, int ddepth);
+// Exported so the new element-wise expression engine can reuse the already-optimized,
-BinaryFunc getConvertScaleFunc(int sdepth, int ddepth);
+// CPU-dispatched convert / convert-scale kernels through a thin ElemwiseFunc adapter,
+// instead of re-implementing the whole cast matrix. (Prototype: declarations are mirrored
+// engine-side; relocate into a public core header at integration time.)
+CV_EXPORTS BinaryFunc getConvertFunc(int sdepth, int ddepth);
+CV_EXPORTS BinaryFunc getConvertScaleFunc(int sdepth, int ddepth);
 BinaryFunc getCopyMaskFunc(size_t esz);
 
 /* default memory block for sparse array elements */
@@ -328,6 +332,149 @@ inline bool checkScalar(InputArray sc, int atype, _InputArray::KindFlag sckind,
            (sz == Size(1, 4) && sc.type() == CV_64F && cn <= 4);
 }
 
+// New element-wise engine scalar handling. A genuine number / Scalar / Vec / Matx operand to an
+// arithmetic op arrives via _InputArray::MATX (its data is inline in the caller's object;
+// getObj() points straight at it). In addition, the EXACT Scalar materialization that the
+// python/java bindings and operator-(Mat, Matx) produce - a 2-D 4x1 CV_64F single-channel Mat or
+// UMat - is a scalar UNCONDITIONALLY: by coincidence it can be broadcast-COMPATIBLE with the array
+// (a 4-row array, a 1-D array make (4,1) legal numpy-wise), and the 4.x per-channel-scalar
+// semantics must win there for binding users. Any other real Mat/UMat rides normal broadcasting
+// (but see isScalarLikeMat below for the shape-incompatible compat fallback).
+inline bool isScalarArg(const _InputArray& sc, int cn)
+{
+    const _InputArray::KindFlag kind = sc.kind();
+    if (kind == _InputArray::MATX)
+    {
+        Size sz = sc.getSz();
+        int scn0 = sz.width * sz.height;
+        // A genuine scalar is a 1D MATX (a Vec/Scalar/number: one of width/height is 1). A 2D MATX
+        // (e.g. a Matx33) is a real matrix operand and rides broadcasting - never a scalar.
+        if (scn0 != sz.width + sz.height - 1)
+            return false;
+        // Per-channel match (incl. Vec<_,N> for an N-channel array), a 4-elem Scalar on a <4-channel
+        // array, or a single broadcast value. No 4-channel cap: a multichannel scalar rides as a 0-dim
+        // per-channel CONST over the caller's data (not squeezed into a 4-slot Scalar).
+        return scn0 == cn || (cn < 4 && scn0 == 4) || scn0 == 1;
+    }
+    // the bindings-style Scalar column. dims must be exactly 2: a 1-D [4] CV_64F array is an honest
+    // broadcast operand. Direct field reads (no _InputArray getter dispatch) - this runs on EVERY
+    // engine call with Mat operands, and `rows == 4` alone rejects almost every real array.
+    if (kind == _InputArray::MAT)
+    {
+        const Mat& m = *(const Mat*)sc.getObj();
+        return m.rows == 4 && m.cols == 1 && cn <= 4 && m.dims == 2 &&
+               m.type() == CV_64F && m.isContinuous();
+    }
+    if (kind == _InputArray::UMAT)
+    {
+        const UMat& m = *(const UMat*)sc.getObj();
+        return m.rows == 4 && m.cols == 1 && cn <= 4 && m.dims == 2 &&
+               m.type() == CV_64F && m.isContinuous();
+    }
+    return false;
+}
+
+// The remaining old arithm_op checkScalar geometry: a real Mat/UMat that LOOKS like a scalar - 1x1
+// or a 1xcn/cnx1 vector (the 4x1 CV_64F column is handled unconditionally by isScalarArg above).
+// arithm_op treats such an operand as a per-channel scalar ONLY as a fallback, when the shapes are
+// not broadcast-compatible - a call that is valid under numpy rules keeps its numpy meaning, one
+// that would throw gets the 4.x scalar semantics instead.
+inline bool isScalarLikeMat(const _InputArray& sc, int cn)
+{
+    // direct field reads, like isScalarArg: this probe also runs per engine call (see arithm_op's
+    // compat fallback). `rows != 1 && cols != 1` exits in two inline compares for ordinary arrays.
+    int rows, cols, nval;
+    bool continuous;
+    const _InputArray::KindFlag kind = sc.kind();
+    if (kind == _InputArray::MAT)
+    {
+        const Mat& m = *(const Mat*)sc.getObj();
+        if ((m.rows != 1 && m.cols != 1) || m.dims > 2) return false;
+        rows = m.rows; cols = m.cols; nval = rows * cols * m.channels(); continuous = m.isContinuous();
+    }
+    else if (kind == _InputArray::UMAT)
+    {
+        const UMat& m = *(const UMat*)sc.getObj();
+        if ((m.rows != 1 && m.cols != 1) || m.dims > 2) return false;
+        rows = m.rows; cols = m.cols; nval = rows * cols * m.channels(); continuous = m.isContinuous();
+    }
+    else
+        return false;
+    if (!continuous || nval > 4)
+        return false;
+    return (rows == 1 && cols == 1) || (rows == cn && cols == 1) || (rows == 1 && cols == cn);
+}
+
+// The size of the caller-provided stack buffer for scalarArgElems (4 slots of the widest depth).
+// A scalar is <= 4 values by contract, so it NEVER touches the heap.
+enum { EW_SCALAR_BUF_SIZE = 4 * sizeof(double) };
+
+// A scalar operand's raw payload: the MATX inline storage or the Mat data, both returned in place.
+// A UMAT scalar's values are copied device->host into `scbuf` (>= EW_SCALAR_BUF_SIZE bytes, on the
+// CALLER's stack - no heap, no UMat::getMat mapping machinery for 32 bytes of data).
+// p/d receive the data pointer and depth; returns the value count (elems x channels).
+inline int scalarArgElems(const _InputArray& sc, const uchar*& p, int& d, uchar* scbuf)
+{
+    const _InputArray::KindFlag kind = sc.kind();
+    if (kind == _InputArray::MAT)
+    {
+        const Mat& m = *(const Mat*)sc.getObj();
+        p = m.data;
+        d = m.depth();
+        return (int)m.total() * m.channels();
+    }
+    if (kind == _InputArray::UMAT)
+    {
+        const UMat& u = *(const UMat*)sc.getObj();
+        d = u.depth();
+        int n = (int)u.total() * u.channels();
+        CV_Assert(n * (int)CV_ELEM_SIZE1(d) <= (int)EW_SCALAR_BUF_SIZE);
+        Mat header(u.dims, u.size.p, u.type(), scbuf);   // header over the caller's stack buffer
+        u.copyTo(header);                                // create() is a no-op (exact match) -> the
+        p = scbuf;                                       // copy lands straight in scbuf
+        return n;
+    }
+    p = (const uchar*)sc.getObj();
+    d = sc.depth();
+    Size sz = sc.getSz();
+    return sz.width * sz.height;
+}
+
+// Read one element of depth `d` at p as a double (no Mat, no convertTo, no dispatcher).
+inline double elemToDouble(int d, const uchar* p)
+{
+    switch (d)
+    {
+    case CV_8U:   return *(const uchar*)p;
+    case CV_8S:   return *(const schar*)p;
+    case CV_16U:  return *(const ushort*)p;
+    case CV_16S:  return *(const short*)p;
+    case CV_32U:  return *(const unsigned*)p;
+    case CV_32S:  return *(const int*)p;
+    case CV_64U:  return (double)*(const uint64_t*)p;
+    case CV_64S:  return (double)*(const int64_t*)p;
+    case CV_16F:  return (float)*(const hfloat*)p;
+    case CV_16BF: return (float)*(const bfloat*)p;
+    case CV_32F:  return *(const float*)p;
+    case CV_64F:  return *(const double*)p;
+    default:      CV_Error(Error::StsUnsupportedFormat, "unsupported scalar depth");
+    }
+}
+
+// Extract a scalar operand's values (see isScalarArg) as up to 4 doubles, straight from its
+// storage. Returns the element count.
+inline int readScalarArg(const _InputArray& sc, Scalar& out)
+{
+    out = Scalar();                      // unused channels stay 0 (independent of the caller's Scalar)
+    const uchar* p; int d; uchar scbuf[EW_SCALAR_BUF_SIZE];
+    int n = scalarArgElems(sc, p, d, scbuf);
+    CV_Assert(n <= 4);                   // Scalar holds 4 slots; isScalarArg admits more only for MATX
+    size_t esz = CV_ELEM_SIZE1(d);
+    for (int i = 0; i < n; i++)
+        out[i] = elemToDouble(d, p + (size_t)i * esz);
+    return n;
+}
+
 void convertAndUnrollScalar( const Mat& sc, int buftype, uchar* scbuf, size_t blocksize );
 
 #ifdef CV_COLLECT_IMPL_DATA

modules/core/test/test_arithm.cpp

@@ -2514,10 +2514,14 @@ TEST(Compare, empty)
 
 TEST(Compare, regression_8999)
 {
+    // Issue #8999 predates broadcasting element-wise ops: comparing a 4x1 array against a 1x1 operand
+    // used to throw (both look like a Scalar). It now broadcasts the 1x1 operand across the 4x1 array.
     Mat_<double> A(4,1); A << 1, 3, 2, 4;
     Mat_<double> B(1,1); B << 2;
     Mat C;
-    EXPECT_THROW(cv::compare(A, B, C, CMP_LT), cv::Exception);
+    cv::compare(A, B, C, CMP_LT);
+    Mat expected = (Mat_<uchar>(4,1) << 255, 0, 0, 0);   // A < 2
+    EXPECT_EQ(0, cvtest::norm(C, expected, NORM_INF));
 }
 
 TEST(Compare, regression_16F_do_not_crash)

modules/core/test/test_arithm_expr.cpp

@@ -0,0 +1,512 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// Tests for the public cv::texpr() string frontend. Exercises placeholders, operator precedence,
+// function calls, type casts, assignments and tuple (multi-) outputs. Limited to ops with kernels
+// today (arithmetic / cast / pow / min / max / absdiff).
+
+#include "test_precomp.hpp"
+#include "../src/arithm_expr.hpp"   // ew::absdiffResultDepth - the engine's absdiff auto-type rule
+
+namespace opencv_test { namespace {
+
+static Mat expr1(const String& e, const std::vector<Mat>& in)
+{
+    std::vector<Mat> out;
+    cv::texpr(e, in, out);
+    return out[0];
+}
+
+TEST(Core_TExpr, add)
+{
+    Mat a(12, 15, CV_32F), b(12, 15, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 1.f, 10.f);
+    theRNG().fill(b, RNG::UNIFORM, 1.f, 10.f);
+
+    Mat got = expr1("{0} + {1}", { a, b });
+    Mat exp; cv::add(a, b, exp);
+    EXPECT_LE(cvtest::norm(got, exp, NORM_INF), 1e-3);
+}
+
+// Built-in binary functions min/max/absdiff parsed and dispatched through emitBinary.
+TEST(Core_TExpr, minmax_absdiff)
+{
+    Mat a(18, 21, CV_8U), b(18, 21, CV_8U);
+    theRNG().fill(a, RNG::UNIFORM, 0, 255);
+    theRNG().fill(b, RNG::UNIFORM, 0, 255);
+
+    Mat gmin = expr1("min({0}, {1})", { a, b });
+    Mat gmax = expr1("max({0}, {1})", { a, b });
+    Mat gabs = expr1("absdiff({0}, {1})", { a, b });
+
+    Mat emin, emax, eabs;
+    cv::min(a, b, emin); cv::max(a, b, emax); cv::absdiff(a, b, eabs);
+    EXPECT_EQ(0, cvtest::norm(gmin, emin, NORM_INF));
+    EXPECT_EQ(0, cvtest::norm(gmax, emax, NORM_INF));
+    EXPECT_EQ(0, cvtest::norm(gabs, eabs, NORM_INF));
+}
+
+// Operator precedence: '*' binds tighter than '+', unary minus on a literal.
+TEST(Core_TExpr, addweighted_precedence)
+{
+    Mat a(20, 16, CV_32F), b(20, 16, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 1.f, 10.f);
+    theRNG().fill(b, RNG::UNIFORM, 1.f, 10.f);
+
+    Mat got = expr1("{0} * 2.5 + {1} * -1.5 + 7", { a, b });
+    Mat exp; cv::addWeighted(a, 2.5, b, -1.5, 7.0, exp);
+    EXPECT_LE(cvtest::norm(got, exp, NORM_INF), 1e-3);
+}
+
+// Named temporary via ';' assignment.
+TEST(Core_TExpr, assignment)
+{
+    Mat a(18, 22, CV_32F), b(18, 22, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 1.f, 10.f);
+    theRNG().fill(b, RNG::UNIFORM, 1.f, 10.f);
+
+    Mat got = expr1("t = {0} * 2.5; t + {1}", { a, b });
+    Mat exp; cv::addWeighted(a, 2.5, b, 1.0, 0.0, exp);
+    EXPECT_LE(cvtest::norm(got, exp, NORM_INF), 1e-3);
+}
+
+// Tuple -> several outputs.
+TEST(Core_TExpr, tuple_outputs)
+{
+    Mat a(14, 19, CV_32F), b(14, 19, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 1.f, 10.f);
+    theRNG().fill(b, RNG::UNIFORM, 1.f, 10.f);
+
+    std::vector<Mat> out;
+    cv::texpr("({0} + {1}, {0} - {1})", std::vector<Mat>{ a, b }, out);
+    ASSERT_EQ(out.size(), 2u);
+    Mat eadd, esub; cv::add(a, b, eadd); cv::subtract(a, b, esub);
+    EXPECT_LE(cvtest::norm(out[0], eadd, NORM_INF), 1e-3) << "sum";
+    EXPECT_LE(cvtest::norm(out[1], esub, NORM_INF), 1e-3) << "diff";
+}
+
+// Grouping parens (NOT a tuple) inside a larger expression.
+TEST(Core_TExpr, grouping_parens)
+{
+    Mat a(11, 13, CV_32F), b(11, 13, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 1.f, 10.f);
+    theRNG().fill(b, RNG::UNIFORM, 1.f, 10.f);
+
+    Mat got = expr1("({0} + {1}) * 2", { a, b });
+    Mat exp; cv::add(a, b, exp); exp *= 2.0;
+    EXPECT_LE(cvtest::norm(got, exp, NORM_INF), 1e-3);
+}
+
+// Type-cast function: float -> uint8 (saturating).
+TEST(Core_TExpr, cast_uint8)
+{
+    Mat a(23, 17, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, -50.f, 300.f);
+
+    Mat got = expr1("uint8({0})", { a });
+    Mat exp; a.convertTo(exp, CV_8U);
+    ASSERT_EQ(got.type(), exp.type());
+    EXPECT_EQ(0, cvtest::norm(got, exp, NORM_INF));
+}
+
+// pow() function call with a scalar exponent.
+TEST(Core_TExpr, pow_call)
+{
+    Mat a(16, 16, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 1.f, 5.f);
+
+    Mat got = expr1("pow({0}, 2)", { a });
+    Mat exp; cv::pow(a, 2.0, exp);
+    EXPECT_LE(cvtest::norm(got, exp, NORM_INF), 1e-3);
+}
+
+// pow over the interesting exponents: the special-cased 2/3/0.5/1/0, the general exp/log path
+// (2.5, -1.5), and negative bases (integer exponent -> exact signed result, fractional -> NaN),
+// against the double std::pow reference. Sizes chosen to exercise both the SIMD body and the tail.
+TEST(Core_TExpr, pow_exponents)
+{
+    for (int depth : { CV_32F, CV_64F })
+    {
+        const double eps = depth == CV_32F ? 1e-6 : 1e-9;
+        Mat a0(37, 41, CV_64F), a;
+        theRNG().fill(a0, RNG::UNIFORM, 0.05, 9.);
+        a0.convertTo(a, depth);
+        for (double p : { 2., 3., 0.5, 1., 0., 2.5, -1.5, -0.5, 5., -2., 11. })
+        {
+            Mat got = expr1(cv::format("pow({0}, %.10g)", p), { a });
+            ASSERT_EQ(got.depth(), depth) << "p=" << p;
+            Mat ad, gd;
+            a.convertTo(ad, CV_64F); got.convertTo(gd, CV_64F);
+            double maxerr = 0;
+            for (int y = 0; y < a.rows; y++)
+                for (int x = 0; x < a.cols; x++)
+                {
+                    double r = std::pow(ad.at<double>(y, x), p);
+                    maxerr = std::max(maxerr, std::abs(gd.at<double>(y, x) - r) / std::max(1.0, std::abs(r)));
+                }
+            EXPECT_LE(maxerr, eps) << "depth=" << depth << " p=" << p;
+        }
+    }
+}
+
+// negative bases: integer exponents keep exact signed results (scalar patch path), a fractional
+// exponent yields NaN - both matching std::pow
+TEST(Core_TExpr, pow_negative_base)
+{
+    Mat a(9, 13, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, -5.f, -1.f);
+
+    Mat got3 = expr1("pow({0}, 3)", { a });
+    for (int y = 0; y < a.rows; y++)
+        for (int x = 0; x < a.cols; x++)
+            ASSERT_NEAR(got3.at<float>(y, x), std::pow((double)a.at<float>(y, x), 3.), 1e-2);
+
+    Mat gotf = expr1("pow({0}, 2.5)", { a });
+    for (int y = 0; y < a.rows; y++)
+        for (int x = 0; x < a.cols; x++)
+            ASSERT_TRUE(cvIsNaN(gotf.at<float>(y, x))) << "pow(neg, frac) must be NaN";
+}
+
+// unary minus and abs() - compositions over the binary family (no dedicated kernels)
+TEST(Core_TExpr, neg_abs)
+{
+    for (int depth : { CV_32F, CV_16S })
+    {
+        Mat a(15, 19, depth);
+        theRNG().fill(a, RNG::UNIFORM, -100, 100);
+
+        Mat gneg = expr1("-{0}", { a });
+        Mat eneg; cv::subtract(Scalar(0), a, eneg);
+        ASSERT_EQ(gneg.depth(), depth);
+        EXPECT_EQ(0, cvtest::norm(gneg, eneg, NORM_INF)) << "neg depth=" << depth;
+
+        // abs == absdiff(a, 0) INCLUDING the texpr auto result type rule: signed input -> the
+        // UNSIGNED type of the same width (|SHRT_MIN| fits u16 exactly, no saturation). NB this
+        // deliberately differs from the public cv::absdiff, whose auto depth keeps the source
+        // type for 4.x compatibility - the VALUES agree, the depth rule is the engine's own.
+        Mat gabs = expr1("abs({0})", { a });
+        ASSERT_EQ(gabs.depth(), cv::ew::absdiffResultDepth(depth)) << "texpr absdiff type rule";
+        Mat eabs; cv::absdiff(a, Scalar(0), eabs);
+        eabs.convertTo(eabs, gabs.depth());
+        EXPECT_EQ(0, cvtest::norm(gabs, eabs, NORM_INF)) << "abs depth=" << depth;
+    }
+}
+
+// the abs(a - b) -> absdiff(a, b) peephole: on unsigned data the literal semantics (saturating
+// subtract) would give max(a-b, 0) - the rewrite must give the true |a - b| everywhere
+TEST(Core_TExpr, abs_sub_peephole)
+{
+    for (int depth : { CV_8U, CV_16S, CV_32F })
+    {
+        Mat a(23, 17, depth), b(23, 17, depth);
+        theRNG().fill(a, RNG::UNIFORM, 0, 100);
+        theRNG().fill(b, RNG::UNIFORM, 0, 100);
+
+        Mat got = expr1("abs({0} - {1})", { a, b });
+        ASSERT_EQ(got.depth(), cv::ew::absdiffResultDepth(depth)) << "depth=" << depth;
+        Mat exp; cv::absdiff(a, b, exp);
+        exp.convertTo(exp, got.depth());          // cv::absdiff auto KEEPS the source depth (4.x)
+        EXPECT_EQ(0, cvtest::norm(got, exp, NORM_INF)) << "depth=" << depth;
+    }
+}
+
+// clamp: scalar bounds (the common shape), array bounds, and type preservation
+TEST(Core_TExpr, clamp)
+{
+    for (int depth : { CV_8U, CV_16S, CV_32F, CV_64F })
+    {
+        Mat a(25, 31, depth);
+        theRNG().fill(a, RNG::UNIFORM, -100, 355);
+
+        Mat got = expr1("clamp({0}, 10, 200)", { a });
+        Mat emax, exp;
+        cv::max(a, 10.0, emax); cv::min(emax, 200.0, exp);
+        ASSERT_EQ(got.depth(), depth) << "clamp must keep the operand type";
+        EXPECT_EQ(0, cvtest::norm(got, exp, NORM_INF)) << "depth=" << depth;
+    }
+    // array bounds
+    Mat x(14, 22, CV_32F), lo(14, 22, CV_32F), hi(14, 22, CV_32F);
+    theRNG().fill(x, RNG::UNIFORM, -10.f, 10.f);
+    theRNG().fill(lo, RNG::UNIFORM, -5.f, 0.f);
+    theRNG().fill(hi, RNG::UNIFORM, 0.f, 5.f);
+    Mat got = expr1("clamp({0}, {1}, {2})", { x, lo, hi });
+    Mat emax, exp;
+    cv::max(x, lo, emax); cv::min(emax, hi, exp);
+    EXPECT_EQ(0, cvtest::norm(got, exp, NORM_INF));
+}
+
+// '**' operator: pow alias, binds tighter than '*', right-associative
+TEST(Core_TExpr, pow_operator)
+{
+    Mat a(13, 18, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 0.5f, 2.f);
+
+    Mat got = expr1("{0} ** 2", { a });
+    Mat exp; cv::pow(a, 2.0, exp);
+    EXPECT_EQ(0, cvtest::norm(got, exp, NORM_INF));
+
+    // precedence: 3 * a ** 2 == 3 * (a ** 2)
+    Mat got2 = expr1("3 * {0} ** 2", { a });
+    Mat exp2 = 3.0 * exp;
+    EXPECT_LE(cvtest::norm(got2, exp2, NORM_INF), 1e-4);
+
+    // right associativity: a ** 2 ** 3 == a ** (2 ** 3) == a ** 8
+    Mat got3 = expr1("{0} ** 2 ** 3", { a });
+    Mat exp3; cv::pow(a, 8.0, exp3);
+    EXPECT_LE(cvtest::norm(got3, exp3, NORM_INF), 1e-4);
+}
+
+// '?:' conditional: select alias with the lowest precedence; right-associative chains
+TEST(Core_TExpr, ternary_operator)
+{
+    Mat a(19, 23, CV_32F), b(19, 23, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 0.f, 100.f);
+    theRNG().fill(b, RNG::UNIFORM, 0.f, 100.f);
+
+    // max via ?: - the condition is a full comparison (lower precedence than '>')
+    Mat got = expr1("{0} > {1} ? {0} : {1}", { a, b });
+    Mat exp; cv::max(a, b, exp);
+    EXPECT_EQ(0, cvtest::norm(got, exp, NORM_INF));
+
+    // arithmetic in every position without parentheses
+    Mat got2 = expr1("{0} - {1} > 10 ? {0} + 1 : {1} * 2", { a, b });
+    Mat mask = (a - b > 10), e1 = a + 1, e2 = b * 2, exp2 = e2.clone();
+    e1.copyTo(exp2, mask);
+    EXPECT_LE(cvtest::norm(got2, exp2, NORM_INF), 1e-4);
+
+    // right-associative chain: c1 ? x : c2 ? y : z
+    Mat got3 = expr1("{0} > 66 ? 1 : {0} > 33 ? 2 : 3", { a });
+    Mat exp3(a.size(), CV_32F);
+    for (int y = 0; y < a.rows; y++)
+        for (int x = 0; x < a.cols; x++)
+        {
+            float v = a.at<float>(y, x);
+            exp3.at<float>(y, x) = v > 66 ? 1.f : v > 33 ? 2.f : 3.f;
+        }
+    EXPECT_EQ(0, cvtest::norm(got3, exp3, NORM_INF));
+}
+
+// hypot(x, y) / its cv-flavored alias mag(x, y): naive sqrt(x^2 + y^2), matching cv::magnitude;
+// kernels exist for the float depths only (f16/bf16/f32/f64)
+TEST(Core_TExpr, hypot_mag)
+{
+    for (int depth : { CV_32F, CV_64F })
+    {
+        Mat x(23, 31, depth), y(23, 31, depth);
+        theRNG().fill(x, RNG::UNIFORM, -100, 100);
+        theRNG().fill(y, RNG::UNIFORM, -100, 100);
+
+        Mat got = expr1("hypot({0}, {1})", { x, y });
+        ASSERT_EQ(got.depth(), depth);
+        Mat exp; cv::magnitude(x, y, exp);
+        EXPECT_LE(cvtest::norm(got, exp, NORM_INF), depth == CV_32F ? 1e-4 : 1e-9);
+
+        Mat got2 = expr1("mag({0}, {1})", { x, y });   // alias
+        EXPECT_EQ(0, cvtest::norm(got2, got, NORM_INF));
+    }
+    // broadcast branch: hypot(array, scalar)
+    Mat x(11, 17, CV_32F);
+    theRNG().fill(x, RNG::UNIFORM, -10.f, 10.f);
+    Mat got = expr1("hypot({0}, 3)", { x });
+    for (int r = 0; r < x.rows; r++)
+        for (int c = 0; c < x.cols; c++)
+        {
+            float v = x.at<float>(r, c);
+            ASSERT_NEAR(got.at<float>(r, c), std::sqrt(v*v + 9.f), 1e-4) << r << "," << c;
+        }
+    // f16: T -> T through the native kernel (f32 hub inside)
+    Mat xh, yh, y16(11, 17, CV_32F);
+    x.convertTo(xh, CV_16F);
+    theRNG().fill(y16, RNG::UNIFORM, -10.f, 10.f);
+    y16.convertTo(yh, CV_16F);
+    Mat goth = expr1("hypot({0}, {1})", { xh, yh });
+    ASSERT_EQ(goth.depth(), CV_16F);
+}
+
+// atan2(y, x): radians, the standard C range (-pi, pi], all four quadrants; the f32 kernel is the
+// fastAtan2 minimax polynomial (~1e-5 rad absolute), f64 is exact std::atan2
+TEST(Core_TExpr, atan2)
+{
+    Mat y(23, 31, CV_32F), x(23, 31, CV_32F);
+    theRNG().fill(y, RNG::UNIFORM, -10.f, 10.f);   // both signs -> all quadrants
+    theRNG().fill(x, RNG::UNIFORM, -10.f, 10.f);
+
+    Mat got = expr1("atan2({0}, {1})", { y, x });
+    ASSERT_EQ(got.depth(), CV_32F);
+    double maxerr = 0;
+    for (int r = 0; r < y.rows; r++)
+        for (int c = 0; c < y.cols; c++)
+        {
+            double ref = std::atan2((double)y.at<float>(r, c), (double)x.at<float>(r, c));
+            maxerr = std::max(maxerr, std::abs((double)got.at<float>(r, c) - ref));
+        }
+    EXPECT_LE(maxerr, 2e-4) << "fastAtan2-class polynomial accuracy (measured ~1.6e-4 rad)";
+
+    // f64: exact std::atan2 per element
+    Mat y64, x64;
+    y.convertTo(y64, CV_64F); x.convertTo(x64, CV_64F);
+    Mat got64 = expr1("atan2({0}, {1})", { y64, x64 });
+    ASSERT_EQ(got64.depth(), CV_64F);
+    for (int r = 0; r < y.rows; r++)
+        for (int c = 0; c < y.cols; c++)
+            ASSERT_EQ(got64.at<double>(r, c),
+                      std::atan2(y64.at<double>(r, c), x64.at<double>(r, c)));
+
+    // axis cases: atan2(0, 1) = 0, atan2(1, 0) = pi/2, atan2(0, -1) = pi, atan2(-1, 0) = -pi/2
+    Mat ya = (Mat_<float>(1, 4) << 0.f, 1.f, 0.f, -1.f);
+    Mat xa = (Mat_<float>(1, 4) << 1.f, 0.f, -1.f, 0.f);
+    Mat ga = expr1("atan2({0}, {1})", { ya, xa });
+    const float expctd[] = { 0.f, (float)(CV_PI/2), (float)CV_PI, (float)(-CV_PI/2) };
+    for (int i = 0; i < 4; i++)
+        ASSERT_NEAR(ga.at<float>(0, i), expctd[i], 1e-4) << "axis case " << i;
+}
+
+// per-element (array) exponent
+TEST(Core_TExpr, pow_array_exponent)
+{
+    Mat a(21, 27, CV_32F), b(21, 27, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 0.1f, 5.f);
+    theRNG().fill(b, RNG::UNIFORM, -2.f, 3.f);
+
+    Mat got = expr1("pow({0}, {1})", { a, b });
+    double maxerr = 0;
+    for (int y = 0; y < a.rows; y++)
+        for (int x = 0; x < a.cols; x++)
+        {
+            double r = std::pow((double)a.at<float>(y, x), (double)b.at<float>(y, x));
+            maxerr = std::max(maxerr, std::abs(got.at<float>(y, x) - r) / std::max(1.0, std::abs(r)));
+        }
+    EXPECT_LE(maxerr, 1e-6);
+}
+
+// ---------------------------------------------------------------------------------- unary math
+// Golden result = the double-precision std:: function applied per element (never the op under
+// test); the tolerance is relative, scaled by the output depth's precision.
+
+typedef double (*mathRef)(double);
+struct MathOpRef { const char* name; mathRef ref; };
+static const MathOpRef mathOps[] = {
+    { "sqrt", std::sqrt }, { "exp", std::exp }, { "log", std::log },
+    { "sin", std::sin }, { "cos", std::cos }, { "tanh", std::tanh }, { "erf", std::erf },
+    { "relu", [](double x) { return x > 0 ? x : 0.; } },
+};
+
+// max |got - ref| / max(1, |ref|) over the array, both evaluated in f64
+static double relErr(const Mat& got, const Mat& in, mathRef ref)
+{
+    Mat gotd, ind;
+    got.convertTo(gotd, CV_64F);
+    in.convertTo(ind, CV_64F);
+    double maxerr = 0;
+    for (int y = 0; y < ind.rows; y++)
+        for (int x = 0; x < ind.cols; x++)
+        {
+            double r = ref(ind.at<double>(y, x));
+            double e = std::abs(gotd.at<double>(y, x) - r) / std::max(1.0, std::abs(r));
+            maxerr = std::max(maxerr, e);
+        }
+    return maxerr;
+}
+
+typedef testing::TestWithParam<MatDepth> Core_TExpr_Math;
+
+TEST_P(Core_TExpr_Math, unary_accuracy)
+{
+    const int depth = GetParam();
+    // eps: half-precision types are exact to ~2^-8/2^-11 per element; the f32 kernels are
+    // polynomial approximations (a few ulp); f64 sqrt/exp/log are also vectorized polynomials
+    const double eps = depth == CV_16F ? 2e-3 : depth == CV_16BF ? 1.6e-2
+                     : depth == CV_32F ? 1e-6 : 1e-9;
+    Mat a0(37, 41, CV_32F);
+    theRNG().fill(a0, RNG::UNIFORM, 0.05f, 9.f);   // positive: one range serves log/sqrt too
+    Mat a;
+    a0.convertTo(a, depth);
+
+    for (const MathOpRef& m : mathOps)
+    {
+        Mat got = expr1(cv::format("%s({0})", m.name), { a });
+        ASSERT_EQ(got.depth(), depth) << m.name << ": math must be T -> T on float inputs";
+        EXPECT_LE(relErr(got, a, m.ref), eps) << m.name << " depth=" << depth;
+    }
+
+    // negative inputs for the ops defined there (skip log/sqrt)
+    Mat b0(37, 41, CV_32F), b;
+    theRNG().fill(b0, RNG::UNIFORM, -8.f, 8.f);
+    b0.convertTo(b, depth);
+    for (const char* name : { "exp", "sin", "cos", "tanh", "erf", "relu" })
+    {
+        const MathOpRef* m = nullptr;
+        for (const MathOpRef& c : mathOps) if (!strcmp(c.name, name)) m = &c;
+        Mat got = expr1(cv::format("%s({0})", name), { b });
+        EXPECT_LE(relErr(got, b, m->ref), eps) << name << "(neg) depth=" << depth;
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(/**/, Core_TExpr_Math,
+                        testing::Values(CV_16F, CV_16BF, CV_32F, CV_64F));
+
+// integer input computes in the float domain and lands in f32
+TEST(Core_TExpr, math_int_input)
+{
+    Mat a(19, 23, CV_8U);
+    theRNG().fill(a, RNG::UNIFORM, 1, 100);
+    Mat got = expr1("sqrt({0})", { a });
+    ASSERT_EQ(got.depth(), CV_32F);
+    EXPECT_LE(relErr(got, a, std::sqrt), 1e-6);
+}
+
+// in-place unary math (dst aliases src): the tail backoff must not re-apply the op
+TEST(Core_TExpr, math_inplace)
+{
+    Mat a(21, 31, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 0.1f, 9.f);
+    Mat ref = expr1("sqrt({0})", { a });
+    std::vector<Mat> out{ a };                     // preallocated == input => in-place
+    cv::texpr("sqrt({0})", std::vector<Mat>{ a }, out);
+    EXPECT_EQ(0, cvtest::norm(out[0], ref, NORM_INF));
+}
+
+// ------------------------------------------------------------------------------------- select
+TEST(Core_TExpr, select_basic)
+{
+    for (int type : { CV_8UC1, CV_16SC1, CV_32FC1, CV_64FC1 })
+    {
+        Mat a(25, 33, type), b(25, 33, type);
+        theRNG().fill(a, RNG::UNIFORM, 0, 100);
+        theRNG().fill(b, RNG::UNIFORM, 0, 100);
+
+        Mat got = expr1("select({0} > {1}, {0}, {1})", { a, b });   // == max(a, b)
+        Mat exp; cv::max(a, b, exp);
+        ASSERT_EQ(got.type(), exp.type()) << "type=" << type;
+        EXPECT_EQ(0, cvtest::norm(got, exp, NORM_INF)) << "type=" << type;
+    }
+}
+
+// one branch is a scalar constant (broadcast stepx == 0 inside the kernel)
+TEST(Core_TExpr, select_const_branch)
+{
+    Mat a(17, 29, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, -10.f, 10.f);
+    Mat got = expr1("select({0} > 0, {0}, 0)", { a });   // == relu
+    Mat exp = expr1("relu({0})", { a });
+    EXPECT_EQ(0, cvtest::norm(got, exp, NORM_INF));
+}
+
+// non-1-byte mask is normalized via `mask != 0`, not a value cast
+TEST(Core_TExpr, select_float_mask)
+{
+    Mat m(15, 27, CV_32F), a(15, 27, CV_32F), b(15, 27, CV_32F);
+    theRNG().fill(m, RNG::UNIFORM, -1.f, 1.f);
+    theRNG().fill(a, RNG::UNIFORM, 0.f, 10.f);
+    theRNG().fill(b, RNG::UNIFORM, 0.f, 10.f);
+    m.at<float>(3, 5) = 0.f;                       // exact zero -> must take branch b
+    m.at<float>(7, 7) = 0.25f;                     // would round/saturate to 0 under a value cast
+
+    Mat got = expr1("select({0}, {1}, {2})", { m, a, b });
+    Mat mask = (m != 0), exp;
+    exp = b.clone(); a.copyTo(exp, mask);
+    EXPECT_EQ(0, cvtest::norm(got, exp, NORM_INF));
+}
+
+}} // namespace

modules/core/test/test_new_arithm.cpp

@@ -0,0 +1,364 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// White-box tests for the element-wise engine internals (cv::ew, declared in the module-internal
+// src/arithm_expr.hpp - NOT part of the public API; the public surface is cv::add/... and cv::texpr,
+// covered by test_new_arithm_extensive.cpp / test_arithm_expr.cpp). Two groups:
+//   - the type-inference + cast-insertion policy (emitBinary) compiled and run through the executor;
+//   - the single-op vertical slice (makeBinaryArithProgram / maybeAddCast) end-to-end.
+// Both check against the classic cv:: ops.
+
+#include "test_precomp.hpp"
+#include "../src/arithm_expr.hpp"
+
+namespace opencv_test { namespace {
+
+using namespace cv::ew;
+
+// emit shortcuts: a flexible literal, and a binary op over two slots.
+static int K(TExpr& e, double v)              { return e.addConst(EW_DEPTH_NONE, Scalar(v), 1); }
+static int bin(TExpr& e, TOp op, int a, int b){ return e.emitBinary(op, a, b); }
+
+// Compile `e` and run it over the given inputs. The operands were already typed at build time
+// (addInput carries each input's depth), so compile() just binds kernels + packs temp buffers.
+static std::vector<Mat> run(TExpr& e, const std::vector<Mat>& inps)
+{
+    e.compile();
+    std::vector<Mat> outs(e.noutputs);
+    e.exec(inps.data(), outs.data());
+    return outs;
+}
+
+// addWeighted(a,alpha,b,beta,gamma) = a*alpha + b*beta + gamma, built op-by-op via emitBinary
+// (the temp buffers are allocated automatically by compile()'s liveness pass).
+TEST(Core_EW_Compile, addweighted_f32)
+{
+    const int chans[] = { 1, 3 };
+    double alpha = 2.5, beta = -1.5, gamma = 7.0;
+    for (int ci = 0; ci < 2; ci++)
+    {
+        int H = 19, W = 23, cn = chans[ci];
+        Mat a(H, W, CV_32FC(cn)), b(H, W, CV_32FC(cn));
+        theRNG().fill(a, RNG::UNIFORM, 1.f, 10.f);
+        theRNG().fill(b, RNG::UNIFORM, 1.f, 10.f);
+
+        TExpr g;
+        int ia = g.addInput(CV_32F), ib = g.addInput(CV_32F);
+        int t0 = bin(g, OP_MUL, ia, K(g, alpha));
+        int t1 = bin(g, OP_MUL, ib, K(g, beta));
+        int t2 = bin(g, OP_ADD, t0, t1);
+        g.output(bin(g, OP_ADD, t2, K(g, gamma)));
+
+        std::vector<Mat> out = run(g, { a, b });
+
+        Mat exp; cv::addWeighted(a, alpha, b, beta, gamma, exp);
+        ASSERT_EQ(out[0].type(), exp.type());
+        EXPECT_LE(cvtest::norm(out[0], exp, NORM_INF), 1e-3) << "cn=" << cn;
+    }
+}
+
+// Mixed integer types: out = saturate_u8( saturate_u8(a*2.5) + b ), a,b are u8.
+// emitBinary must insert u8->f32 input casts and f32->u8 result casts around each op (2.5 does not
+// fit u8, so the direct u8 kernel is refused and the float working path is taken).
+TEST(Core_EW_Compile, mixed_u8_inserts_casts)
+{
+    int H = 16, W = 24;
+    Mat a(H, W, CV_8U), b(H, W, CV_8U);
+    theRNG().fill(a, RNG::UNIFORM, 0, 60);
+    theRNG().fill(b, RNG::UNIFORM, 0, 60);
+
+    TExpr g;
+    int ia = g.addInput(CV_8U), ib = g.addInput(CV_8U);
+    int mul = bin(g, OP_MUL, ia, K(g, 2.5));   // -> u8 (natural)
+    g.output(bin(g, OP_ADD, mul, ib));         // -> u8
+
+    std::vector<Mat> out = run(g, { a, b });
+
+    Mat t0, exp;
+    a.convertTo(t0, CV_8U, 2.5);          // saturate_u8(a*2.5)
+    cv::add(t0, b, exp);                  // saturate_u8(t0 + b)
+    ASSERT_EQ(out[0].type(), exp.type());
+    EXPECT_EQ(0, cvtest::norm(out[0], exp, NORM_INF));
+}
+
+// Tuple of two outputs from shared inputs: (a+b, a-b).
+TEST(Core_EW_Compile, multi_output_tuple)
+{
+    int H = 14, W = 18;
+    Mat a(H, W, CV_32F), b(H, W, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 1.f, 10.f);
+    theRNG().fill(b, RNG::UNIFORM, 1.f, 10.f);
+
+    TExpr g;
+    int ia = g.addInput(CV_32F), ib = g.addInput(CV_32F);
+    g.output(bin(g, OP_ADD, ia, ib));
+    g.output(bin(g, OP_SUB, ia, ib));
+
+    std::vector<Mat> out = run(g, { a, b });
+    ASSERT_EQ(out.size(), 2u);
+
+    Mat eadd, esub; cv::add(a, b, eadd); cv::subtract(a, b, esub);
+    EXPECT_LE(cvtest::norm(out[0], eadd, NORM_INF), 1e-3) << "sum";
+    EXPECT_LE(cvtest::norm(out[1], esub, NORM_INF), 1e-3) << "diff";
+}
+
+// Liveness: a linear chain of temps with disjoint lifetimes must share physical buffers.
+// out = (((a+1)+1)+1)+1 == a+4 : the last add is redirected straight into the output slot, the
+// three live temps share just 2 physical buffers.
+TEST(Core_EW_Compile, temp_buffer_reuse)
+{
+    int H = 10, W = 13;
+    Mat a(H, W, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 1.f, 10.f);
+
+    TExpr g;
+    int x = g.addInput(CV_32F);
+    for (int k = 0; k < 4; k++)
+        x = bin(g, OP_ADD, x, K(g, 1.0));
+    g.output(x);
+
+    std::vector<Mat> out = run(g, { a });
+
+    // last instruction writes straight into the OUTPUT slot (its producing temp was redirected)
+    EXPECT_EQ(g.arginfo[g.prog[g.prog.size() - 1].result].kind, TExpr::OUTPUT);
+    EXPECT_EQ(g.nbuffers, 2);        // disjoint lifetimes => only 2 physical buffers
+
+    Mat exp; cv::add(a, Scalar(4.0), exp);
+    EXPECT_LE(cvtest::norm(out[0], exp, NORM_INF), 1e-4);
+}
+
+// promoteArith is the auto result-depth rule (rdepth == -1). Checked against an INDEPENDENT hardcoded
+// table (NOT computed from the engine): the extensive tests feed promoteArith to BOTH the engine and
+// their own reference, so a wrong-but-consistent rule slips through there - this catches it. Also
+// asserts commutativity, which a max-rank scheme silently breaks for mixed-sign / same-width floats.
+TEST(Core_EW_Compile, promoteArith_rules)
+{
+    struct { int a, b, want; } cases[] = {
+        // same signedness -> the wider one, sign kept
+        { CV_8U, CV_8U, CV_8U }, { CV_8U, CV_16U, CV_16U }, { CV_8U, CV_64U, CV_64U },
+        { CV_16S, CV_64S, CV_64S }, { CV_8S, CV_32S, CV_32S },
+        // mixed sign, same width -> next-wider signed (64-bit has no wider int -> f64)
+        { CV_8U, CV_8S, CV_16S }, { CV_16U, CV_16S, CV_32S },
+        { CV_32U, CV_32S, CV_64S }, { CV_64U, CV_64S, CV_64F },
+        // mixed sign, different width
+        { CV_8S, CV_16U, CV_32S }, { CV_8U, CV_16S, CV_16S }, { CV_32S, CV_64U, CV_64F },
+        // float + int -> smallest covering float
+        { CV_16F, CV_8U, CV_16F }, { CV_16BF, CV_8U, CV_16BF }, { CV_16F, CV_16U, CV_32F },
+        { CV_16F, CV_32S, CV_64F }, { CV_32F, CV_32S, CV_64F }, { CV_32F, CV_16S, CV_32F },
+        // float + float
+        { CV_16F, CV_32F, CV_32F }, { CV_16F, CV_16BF, CV_32F }, { CV_64F, CV_8U, CV_64F },
+        // flexible operand (EW_DEPTH_NONE) does not force promotion
+        { EW_DEPTH_NONE, CV_16U, CV_16U }, { CV_16U, EW_DEPTH_NONE, CV_16U },
+        { EW_DEPTH_NONE, EW_DEPTH_NONE, EW_DEPTH_NONE },
+    };
+    for (auto& c : cases)
+    {
+        int got = promoteArith(c.a, c.b);
+        EXPECT_EQ(got, c.want) << "promoteArith(" << c.a << "," << c.b << ")";
+        EXPECT_EQ(promoteArith(c.b, c.a), got) << "not commutative at " << c.a << "," << c.b;
+    }
+
+    // exhaustive commutativity over all real depths
+    const int depths[] = { CV_8U, CV_8S, CV_16U, CV_16S, CV_32U, CV_32S, CV_64U, CV_64S,
+                           CV_16F, CV_16BF, CV_32F, CV_64F };
+    for (int a : depths) for (int b : depths)
+        EXPECT_EQ(promoteArith(a, b), promoteArith(b, a)) << "noncommutative at " << a << "," << b;
+}
+
+// ---------------------------------------------------------------------------
+// Vertical slice: single-op programs (ADD/SUB/MUL/DIV/POW f32 and CAST) built via the hand builders
+// (makeBinaryArithProgram / maybeAddCast) and run through the executor, checked against classic cv::.
+// ---------------------------------------------------------------------------
+
+// out = op(a, b), composed via the general binary-arith builder (the engine backing cv::add).
+static Mat runBinary(TOp op, const Mat& a, const Mat& b, int rdepth)
+{
+    TExpr p; makeBinaryArithProgram(p, op, a.depth(), b.depth(), rdepth);
+    Mat inps[] = {a, b}, out;
+    p.exec(inps, &out);
+    return out;
+}
+
+// out = cast(a), built through maybeAddCast (a single OP_CAST) and compiled.
+static Mat runCast(const Mat& a, int rdepth)
+{
+    TExpr e;
+    int s = e.addInput(a.depth());
+    e.output(e.maybeAddCast(s, rdepth));
+    e.compile();
+    Mat out;
+    e.exec(&a, &out);
+    return out;
+}
+
+static void cvRef(TOp op, const Mat& a, const Mat& b, Mat& dst)
+{
+    switch (op)
+    {
+    case OP_ADD: cv::add(a, b, dst); break;
+    case OP_SUB: cv::subtract(a, b, dst); break;
+    case OP_MUL: cv::multiply(a, b, dst); break;
+    case OP_DIV: cv::divide(a, b, dst); break;
+    default: CV_Error(Error::StsBadArg, "unexpected op");
+    }
+}
+
+// ADD/SUB/MUL/DIV on f32, single- and multi-channel, same shape.
+TEST(Core_EW_Slice, binary_f32_same_shape)
+{
+    const TOp ops[] = { OP_ADD, OP_SUB, OP_MUL, OP_DIV };
+    const int chans[] = { 1, 3, 4 };
+    RNG& rng = theRNG();
+    for (int oi = 0; oi < 4; oi++)
+        for (int ci = 0; ci < 3; ci++)
+        {
+            int H = 17, W = 33, cn = chans[ci];
+            Mat a(H, W, CV_32FC(cn)), b(H, W, CV_32FC(cn));
+            rng.fill(a, RNG::UNIFORM, 1.f, 10.f);
+            rng.fill(b, RNG::UNIFORM, 1.f, 10.f);
+
+            Mat got = runBinary(ops[oi], a, b, CV_32F);
+            Mat exp; cvRef(ops[oi], a, b, exp);
+
+            ASSERT_EQ(got.size(), exp.size());
+            ASSERT_EQ(got.type(), exp.type());
+            EXPECT_LE(cvtest::norm(got, exp, NORM_INF), 1e-3)
+                << "op=" << opName(ops[oi]) << " cn=" << cn;
+        }
+}
+
+// POW with a 1x1 (broadcast) exponent vs cv::pow(a, scalar).
+TEST(Core_EW_Slice, pow_f32_scalar_exp)
+{
+    Mat a(20, 25, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 1.f, 5.f);
+    Mat e(1, 1, CV_32F, Scalar(2.0));
+
+    Mat got = runBinary(OP_POW, a, e, CV_32F);
+    Mat exp; cv::pow(a, 2.0, exp);
+
+    EXPECT_LE(cvtest::norm(got, exp, NORM_INF), 1e-3);
+}
+
+// Row / column broadcasting (single channel) checked against repeat()+cv::add.
+TEST(Core_EW_Slice, broadcast_row_col)
+{
+    int H = 12, W = 19;
+    Mat a(H, W, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, 1.f, 10.f);
+
+    {   // row vector broadcast over rows
+        Mat brow(1, W, CV_32F);
+        theRNG().fill(brow, RNG::UNIFORM, 1.f, 10.f);
+        Mat got = runBinary(OP_ADD, a, brow, CV_32F);
+        Mat bb, exp; cv::repeat(brow, H, 1, bb); cv::add(a, bb, exp);
+        EXPECT_LE(cvtest::norm(got, exp, NORM_INF), 1e-3) << "row";
+    }
+    {   // column vector broadcast over columns
+        Mat bcol(H, 1, CV_32F);
+        theRNG().fill(bcol, RNG::UNIFORM, 1.f, 10.f);
+        Mat got = runBinary(OP_ADD, a, bcol, CV_32F);
+        Mat bb, exp; cv::repeat(bcol, 1, W, bb); cv::add(a, bb, exp);
+        EXPECT_LE(cvtest::norm(got, exp, NORM_INF), 1e-3) << "col";
+    }
+}
+
+// Channel broadcasting: HxWx3 * HxWx1 -> HxWx3.
+TEST(Core_EW_Slice, broadcast_channel)
+{
+    int H = 15, W = 21;
+    Mat a(H, W, CV_32FC3), b(H, W, CV_32FC1);
+    theRNG().fill(a, RNG::UNIFORM, 1.f, 10.f);
+    theRNG().fill(b, RNG::UNIFORM, 1.f, 10.f);
+
+    Mat got = runBinary(OP_MUL, a, b, CV_32F);
+
+    std::vector<Mat> ach; cv::split(a, ach);
+    for (size_t c = 0; c < ach.size(); c++) cv::multiply(ach[c], b, ach[c]);
+    Mat exp; cv::merge(ach, exp);
+
+    ASSERT_EQ(got.type(), exp.type());
+    EXPECT_LE(cvtest::norm(got, exp, NORM_INF), 1e-3);
+}
+
+// Saturating cast f32 <-> {u8, s32}.
+TEST(Core_EW_Slice, cast_basic)
+{
+    Mat a(23, 31, CV_32F);
+    theRNG().fill(a, RNG::UNIFORM, -50.f, 300.f);   // exercise saturation for u8
+
+    {
+        Mat got = runCast(a, CV_8U);
+        Mat exp; a.convertTo(exp, CV_8U);
+        EXPECT_EQ(0, cvtest::norm(got, exp, NORM_INF)) << "f32->u8";
+    }
+    {
+        Mat got = runCast(a, CV_32S);
+        Mat exp; a.convertTo(exp, CV_32S);
+        EXPECT_EQ(0, cvtest::norm(got, exp, NORM_INF)) << "f32->s32";
+    }
+    {
+        Mat u; a.convertTo(u, CV_8U);
+        Mat got = runCast(u, CV_32F);
+        Mat exp; u.convertTo(exp, CV_32F);
+        EXPECT_EQ(0, cvtest::norm(got, exp, NORM_INF)) << "u8->f32";
+    }
+}
+
+// cv::add / cv::subtract on 32-bit ints SATURATE (SIMD via the local v_add_sat/v_sub_sat, scalar
+// tail via the int64 work type) - uniform random data essentially never crosses the boundaries,
+// so directed cases are mandatory (see the v_sat_arith brief): both rails, the 0 - INT_MIN case,
+// mixed-sign non-overflow, and a random block checked against an exact int64 reference.
+TEST(Core_EW_AddSub, saturation_s32_u32)
+{
+    const int W = 37;                       // odd width: SIMD body + scalar tail both covered
+    {
+        const int mx = INT_MAX, mn = INT_MIN;
+        const int a[] = { mx,      mn,      mx, mn,  0,          -1, mx,      12345 };
+        const int b[] = { 1,       -1,      mx, mn,  mn,         mx, -1,      -54321 };
+        // exact int64 references
+        Mat A(1, 8, CV_32S, (void*)a), B(1, 8, CV_32S, (void*)b), sum, dif;
+        cv::add(A, B, sum);
+        cv::subtract(A, B, dif);
+        for (int i = 0; i < 8; i++)
+        {
+            int64_t rs = (int64_t)a[i] + b[i], rd = (int64_t)a[i] - b[i];
+            EXPECT_EQ(sum.at<int>(i), (int)std::min<int64_t>(std::max<int64_t>(rs, mn), mx)) << "add s32 case " << i;
+            EXPECT_EQ(dif.at<int>(i), (int)std::min<int64_t>(std::max<int64_t>(rd, mn), mx)) << "sub s32 case " << i;
+        }
+    }
+    {
+        const unsigned mx = UINT_MAX;
+        const unsigned a[] = { mx, 0, mx, 5,  0, 100 };
+        const unsigned b[] = { 1,  1, mx, 5,  0, 7 };
+        Mat A(1, 6, CV_32U, (void*)a), B(1, 6, CV_32U, (void*)b), sum, dif;
+        cv::add(A, B, sum);
+        cv::subtract(A, B, dif);
+        for (int i = 0; i < 6; i++)
+        {
+            uint64_t rs = (uint64_t)a[i] + b[i];
+            int64_t  rd = (int64_t)a[i] - b[i];
+            EXPECT_EQ(sum.at<unsigned>(i), (unsigned)std::min<uint64_t>(rs, mx)) << "add u32 case " << i;
+            EXPECT_EQ(dif.at<unsigned>(i), (unsigned)std::max<int64_t>(rd, 0)) << "sub u32 case " << i;
+        }
+    }
+    // random block spanning the full range (so saturation DOES occur), vs the int64 reference
+    {
+        Mat a(15, W, CV_32S), b(15, W, CV_32S), sum, dif;
+        theRNG().fill(a, RNG::UNIFORM, INT_MIN, INT_MAX);
+        theRNG().fill(b, RNG::UNIFORM, INT_MIN, INT_MAX);
+        cv::add(a, b, sum);
+        cv::subtract(a, b, dif);
+        for (int y = 0; y < a.rows; y++)
+            for (int x = 0; x < W; x++)
+            {
+                int64_t rs = (int64_t)a.at<int>(y, x) + b.at<int>(y, x);
+                int64_t rd = (int64_t)a.at<int>(y, x) - b.at<int>(y, x);
+                ASSERT_EQ(sum.at<int>(y, x), (int)std::min<int64_t>(std::max<int64_t>(rs, INT_MIN), INT_MAX)) << y << "," << x;
+                ASSERT_EQ(dif.at<int>(y, x), (int)std::min<int64_t>(std::max<int64_t>(rd, INT_MIN), INT_MAX)) << y << "," << x;
+            }
+    }
+}
+
+}} // namespace

modules/core/test/test_new_arithm_extensive.cpp

@@ -0,0 +1,551 @@
+// This file is part of OpenCV project.
+// It is subject to the license terms in the LICENSE file found in the top-level directory
+// of this distribution and at http://opencv.org/license.html.
+
+// Randomized property-based accuracy tests for the broadcasting element-wise ops, exercised through
+// the PUBLIC cv:: entry points (add/subtract/multiply/divide/min/max/absdiff/compare with a mask,
+// dtype, in-place aliasing and mixed input types). For each caseidx a deterministic splitmix64 seed
+// picks random depths and broadcast-compatible shapes (ndims<=4, total<=100000) and every axis of each
+// operand independently keeps its size or drops to 1, so full/row/col/channel broadcast are all hit.
+// The reference decomposes each op into per-channel cv::broadcast + convertTo + the same op on aligned
+// same-shape single-channel arrays. The module-internal header is included only for the promotion rule
+// (promoteArith / absdiffResultDepth) the reference needs to predict each op's auto result depth.
+
+#include "test_precomp.hpp"
+#include "../src/arithm_expr.hpp"
+
+namespace opencv_test { namespace {
+
+using namespace cv::ew;
+
+static inline uint64_t mix64(uint64_t x)
+{
+    x += 0x9E3779B97F4A7C15ULL;
+    x = (x ^ (x >> 30)) * 0xBF58476D1CE4E5B9ULL;
+    x = (x ^ (x >> 27)) * 0x94D049BB133111EBULL;
+    return x ^ (x >> 31);
+}
+static const uint64_t kSuiteSalt = 0x9ADD0CA57ULL;
+static const int kNumCases = 1000;
+static const int kMaxElems = 100000;
+
+// engine-supported depths
+static const int kDepths[] = { CV_8U, CV_8S, CV_16U, CV_16S, CV_32U, CV_32S,
+                               CV_64U, CV_64S, CV_16F, CV_16BF, CV_32F, CV_64F };
+static int sampleDepth(RNG& rng) { return kDepths[rng.uniform(0, (int)(sizeof(kDepths)/sizeof(kDepths[0])))]; }
+
+static bool isFloat(int d) { return d==CV_16F || d==CV_16BF || d==CV_32F || d==CV_64F; }
+
+// numpy-ish promotion (must mirror ew_exec.cpp's promote2 so the reference adds the same values)
+static int promote2(int a, int b)
+{
+    if (a == b) return a;
+
+    constexpr unsigned lbits = 3, lmask = (1u << lbits) - 1u;
+    const uint64_t typelut = (uint64_t)((0ULL << CV_8U*lbits) | (0ULL << CV_8S*lbits) |
+                                        (1ULL << CV_16U*lbits) | (1ULL << CV_16S*lbits) |
+                                        (2ULL << CV_32U*lbits) | (2ULL << CV_32S*lbits) |
+                                        (3ULL << CV_16F*lbits) | (3ULL << CV_16BF*lbits) |
+                                        (3ULL << CV_32F*lbits) | (4ULL << CV_64F*lbits) |
+                                        (4ULL << CV_64S*lbits) | (4ULL << CV_64U*lbits));
+    unsigned pr_a = unsigned((typelut >> (a*lbits)) & lmask);
+    unsigned pr_b = unsigned((typelut >> (b*lbits)) & lmask);
+    unsigned max_pr = std::max(pr_a, pr_b);
+    constexpr unsigned dbits = CV_CN_SHIFT, dmask = (1u << dbits) - 1u;
+    const unsigned ctypelut = ((CV_16S << 0*dbits) | (CV_32S << 1*dbits) | (CV_64S << 2*dbits) |
+                            (CV_32F << 3*dbits) | (CV_64F << 4*dbits));
+    return int((ctypelut >> (max_pr*dbits)) & dmask);
+}
+
+// data range per depth: 8/16-bit wide enough to exercise saturation; 32/64-bit kept modest.
+static void depthRange(int d, double& lo, double& hi)
+{
+    switch (d)
+    {
+    case CV_8U:  lo = 0;    hi = 255;   break;
+    case CV_8S:  lo = -128; hi = 127;   break;
+    case CV_16U: lo = 0;    hi = 65535; break;
+    case CV_16S: lo = -32768; hi = 32767; break;
+    default:     lo = -1000; hi = 1000; break;   // 32/64-bit ints and floats: no overflow
+    }
+}
+
+static int sampleSize(RNG& rng, int lo, int hi)
+{
+    if (hi <= lo) return lo;
+    if (rng.uniform(0.0, 1.0) < 0.35)
+    {
+        static const int cand[] = {1,2,3,4,7,8,15,16,17,31,32,33};
+        int picks[16], n = 0;
+        for (int c : cand) if (c >= lo && c <= hi) picks[n++] = c;
+        picks[n++] = lo; picks[n++] = hi;
+        return picks[rng.uniform(0, n)];
+    }
+    double v = std::exp(rng.uniform(std::log((double)lo), std::log((double)hi)));
+    return std::min(hi, std::max(lo, cvRound(v)));
+}
+
+// a random shape (ndims in 1..4) with product <= kMaxElems
+static std::vector<int> sampleShape(RNG& rng)
+{
+    int nd = rng.uniform(1, 5);
+    std::vector<int> s(nd);
+    long long prod = 1;
+    for (int d = 0; d < nd; d++)
+    {
+        int hi = (int)std::min<long long>(512, std::max<long long>(1, kMaxElems / prod));
+        s[d] = sampleSize(rng, 1, hi);
+        prod *= s[d];
+    }
+    return s;
+}
+
+// build a random Mat of the given depth & shape, filled via a CV_64F master (randUni can't fill
+// 16f/16bf/32u/64u/64s directly), values in the per-depth range. ~1/3 of the time the result is
+// a NON-contiguous sub-array: the parent is padded by 1..2 on each edge of each axis and we
+// return the inner view (gapped outer steps), to exercise the engine's non-continuous path.
+static Mat makeRandom(RNG& rng, const std::vector<int>& shape, int cn, int depth,
+                      double rlo = 1, double rhi = 0)
+{
+    const bool crop = rng.uniform(0, 3) == 0;
+    const int nd = (int)shape.size();
+    std::vector<int> pad(nd);
+    std::vector<Range> ranges(nd);
+    for (int d = 0; d < nd; d++)
+    {
+        int lo = crop ? rng.uniform(1, 3) : 0;   // 1..2
+        int hi = crop ? rng.uniform(1, 3) : 0;
+        pad[d] = shape[d] + lo + hi;
+        ranges[d] = Range(lo, lo + shape[d]);
+    }
+    Mat m64(nd, pad.data(), CV_MAKETYPE(CV_64F, cn));
+    double lo = rlo, hi = rhi;
+    if (rlo > rhi) depthRange(depth, lo, hi);     // rlo>rhi (default) => per-depth range
+    cvtest::randUni(rng, m64, Scalar::all(lo), Scalar::all(hi));
+    Mat big; m64.convertTo(big, CV_MAKETYPE(depth, cn));
+    return big(ranges);                          // full range when !crop => contiguous
+}
+
+static std::string shapeStr(const std::vector<int>& s)
+{
+    std::string r = "[";
+    for (size_t i = 0; i < s.size(); i++) r += (i ? "x" : "") + std::to_string(s[i]);
+    return r + "]";
+}
+
+// per-output-depth tolerance. `floatPath` = a float was involved on the way to an integer
+// output, so a final float->int rounding tie may differ from cv:: by 1 (benign).
+static void checkClose(const Mat& got, const Mat& ref, int rdepth, bool floatPath, const char* what)
+{
+    ASSERT_EQ(got.dims, ref.dims) << what;
+    ASSERT_EQ(got.type(), ref.type()) << what;
+    double n = cvtest::norm(got, ref, NORM_INF);
+    if (!isFloat(rdepth))
+    {
+        EXPECT_LE(n, floatPath ? 1.0 : 0.0) << what;   // integer output: exact, or ±1 via float
+    }
+    else
+    {
+        double scale = std::max(1.0, cvtest::norm(ref, NORM_INF));
+        double rel = rdepth==CV_16BF ? 1e-2 : rdepth==CV_16F ? 2e-3 : 1e-5;
+        EXPECT_LE(n, rel*scale) << what << " (n=" << n << " scale=" << scale << ")";
+    }
+}
+
+// ------------------------------------------------------------------------------- add / sub
+// Parameterized on (op, caseidx): op 0 = ADD, 1 = SUB. The two ops share the same per-case data
+// (seed depends only on caseidx), so they run on identical inputs.
+class EW_Extensive_BinOp : public ::testing::TestWithParam<std::tuple<int,int>> {};
+
+TEST_P(EW_Extensive_BinOp, accuracy)
+{
+    const int opSel = std::get<0>(GetParam());
+    const int caseidx = std::get<1>(GetParam());
+    const TOp op = opSel ? OP_SUB : OP_ADD;
+    const char* opStr = opSel ? "sub" : "add";
+    RNG rng(mix64(kSuiteSalt ^ (uint64_t)caseidx));
+
+    std::vector<int> shape = sampleShape(rng);
+    const int da = sampleDepth(rng), db = sampleDepth(rng);
+
+    // channels: pick a base count (biased toward 1); each operand keeps it or drops to 1, so we
+    // get C1+C1 (fold), Cn+Cn (fold) and the Cn+C1 / C1+Cn channel-broadcast (CH_DIM) mix.
+    static const int cncand[] = { 1, 1, 2, 3, 4 };
+    const int rcn = cncand[rng.uniform(0, 5)];
+    const int cn_a = rng.uniform(0, 2) ? rcn : 1;
+    const int cn_b = rng.uniform(0, 2) ? rcn : 1;
+    const int ocn = std::max(cn_a, cn_b);
+
+    // each operand independently keeps or broadcasts (->1) every axis
+    std::vector<int> sa(shape.size()), sb(shape.size()), res(shape.size());
+    for (size_t d = 0; d < shape.size(); d++)
+    {
+        sa[d] = rng.uniform(0, 2) ? shape[d] : 1;
+        sb[d] = rng.uniform(0, 2) ? shape[d] : 1;
+        res[d] = std::max(sa[d], sb[d]);
+    }
+
+    // in-place: ~1/3 of cases attempt it. When an input is spatially & channel "full" (its shape ==
+    // the output shape res, channels == ocn), alias the output onto it and force Tr to that input's
+    // depth so the buffer is truly reused. Exercises the executor's in-place handling AND the
+    // kernels' dst==src aliasing (the halide-tail backoff). Otherwise Tr is a free random depth.
+    int aliasIn = -1;
+    if (rng.uniform(0, 3) == 0)
+    {
+        if      (sa == res && cn_a == ocn) aliasIn = 0;
+        else if (sb == res && cn_b == ocn) aliasIn = 1;
+    }
+    const bool inplace = aliasIn >= 0;
+    const int Tr = aliasIn == 0 ? da : aliasIn == 1 ? db : sampleDepth(rng);
+
+    SCOPED_TRACE(cv::format("%s caseidx=%d da=%s db=%s Tr=%s a=%sC%d b=%sC%d inplace=%d",
+                            opStr, caseidx, depthToString(da), depthToString(db), depthToString(Tr), shapeStr(sa).c_str(), cn_a,
+                            shapeStr(sb).c_str(), cn_b, inplace ? aliasIn : -1));
+
+    Mat a = makeRandom(rng, sa, cn_a, da), b = makeRandom(rng, sb, cn_b, db);
+
+    // reference FIRST (an in-place exec may overwrite an input): per output channel pick a's/b's
+    // channel (C1->Cn broadcast), spatial-broadcast, cast to common type C, op(Tr), then merge.
+    int C = (da == db) ? da : promote2(da, db);
+    std::vector<Mat> ach, bch; cv::split(a, ach); cv::split(b, bch);
+    std::vector<Mat> refch(ocn);
+    for (int c = 0; c < ocn; c++)
+    {
+        Mat apC, bpC;
+        cvtest::convert(ach[cn_a == 1 ? 0 : c], apC, C);
+        cvtest::convert(bch[cn_b == 1 ? 0 : c], bpC, C);
+        Mat aB, bB; cv::broadcast(apC, res, aB); cv::broadcast(bpC, res, bB);
+        cvtest::add(aB, 1, bB, op == OP_SUB ? -1 : 1, Scalar(), refch[c], Tr);
+    }
+    Mat ref; cv::merge(refch, ref);
+
+    // public op: dst aliases input #aliasIn for the in-place case, else a fresh Mat.
+    Mat outOwn;
+    Mat& out = inplace ? (aliasIn == 0 ? a : b) : outOwn;
+    if (op == OP_SUB) cv::subtract(a, b, out, noArray(), Tr);
+    else              cv::add     (a, b, out, noArray(), Tr);
+
+    checkClose(out, ref, Tr, isFloat(da) || isFloat(db), opStr);
+}
+
+INSTANTIATE_TEST_CASE_P(Core_EW, EW_Extensive_BinOp,
+    testing::Combine(testing::Values(0, 1), testing::Range(0, kNumCases)),
+    [](const testing::TestParamInfo<std::tuple<int,int>>& ti) {
+        return cv::format("%s_case%04d", std::get<0>(ti.param) ? "sub" : "add",
+                          std::get<1>(ti.param));
+    });
+
+// ------------------------------------------------------------------- min / max / absdiff
+// op 0 = MIN, 1 = MAX, 2 = ABSDIFF: operands promoted to a common type C; MIN/MAX result C, ABSDIFF
+// result Cr = absdiffResultDepth(C) (unsigned same width for signed ints, since |a-b| can hit 2^w-1).
+// cv::min/max/absdiff auto-promote mixed input types (no dtype arg), so this exercises the engine's
+// promotion + cast insertion for a fresh family of ops through the public entry points.
+class EW_Extensive_MinMax : public ::testing::TestWithParam<std::tuple<int,int>> {};
+
+TEST_P(EW_Extensive_MinMax, accuracy)
+{
+    const int opSel = std::get<0>(GetParam());
+    const int caseidx = std::get<1>(GetParam());
+    const TOp op = opSel == 0 ? OP_MIN : opSel == 1 ? OP_MAX : OP_ABSDIFF;
+    const char* opStr = opSel == 0 ? "min" : opSel == 1 ? "max" : "absdiff";
+    RNG rng(mix64(kSuiteSalt ^ (uint64_t)(caseidx * 3 + opSel)));   // distinct stream per op
+
+    std::vector<int> shape = sampleShape(rng);
+    const int da = sampleDepth(rng), db = sampleDepth(rng);
+    const int C = promoteArith(da, db);   // common compute/result type (auto), shared with the ref.
+    const int Cr = C;   // min/max/absdiff all resolve to C (absdiff saturates its wide |a-b| back to C)
+
+    static const int cncand[] = { 1, 1, 2, 3, 4 };
+    const int rcn = cncand[rng.uniform(0, 5)];
+    const int cn_a = rng.uniform(0, 2) ? rcn : 1;
+    const int cn_b = rng.uniform(0, 2) ? rcn : 1;
+    const int ocn = std::max(cn_a, cn_b);
+
+    std::vector<int> sa(shape.size()), sb(shape.size()), res(shape.size());
+    for (size_t d = 0; d < shape.size(); d++)
+    {
+        sa[d] = rng.uniform(0, 2) ? shape[d] : 1;
+        sb[d] = rng.uniform(0, 2) ? shape[d] : 1;
+        res[d] = std::max(sa[d], sb[d]);
+    }
+
+    SCOPED_TRACE(cv::format("%s caseidx=%d da=%d db=%d C=%d a=%sC%d b=%sC%d",
+                            opStr, caseidx, da, db, C, shapeStr(sa).c_str(), cn_a,
+                            shapeStr(sb).c_str(), cn_b));
+
+    Mat a = makeRandom(rng, sa, cn_a, da), b = makeRandom(rng, sb, cn_b, db);
+
+    // reference: per output channel pick a's/b's channel (C1->Cn), spatial-broadcast, cast to C, op.
+    std::vector<Mat> ach, bch; cv::split(a, ach); cv::split(b, bch);
+    std::vector<Mat> refch(ocn);
+    for (int c = 0; c < ocn; c++)
+    {
+        Mat apC, bpC;
+        cvtest::convert(ach[cn_a == 1 ? 0 : c], apC, C);
+        cvtest::convert(bch[cn_b == 1 ? 0 : c], bpC, C);
+        Mat aB, bB; cv::broadcast(apC, res, aB); cv::broadcast(bpC, res, bB);
+        if (op == OP_MIN)      cvtest::min(aB, bB, refch[c]);
+        else if (op == OP_MAX) cvtest::max(aB, bB, refch[c]);
+        else                   cvtest::add(aB, 1, bB, -1, Scalar(), refch[c], Cr, /*calcAbs=*/true);
+    }
+    Mat ref; cv::merge(refch, ref);
+
+    // public op: min/max/absdiff auto-promote mixed input types to C (= promoteArith(da,db)) and
+    // broadcast, exactly like the reference; absdiff's result is the unsigned same-width Cr.
+    Mat out;
+    if (op == OP_MIN)      cv::min(a, b, out);
+    else if (op == OP_MAX) cv::max(a, b, out);
+    else                   cv::absdiff(a, b, out);
+
+    checkClose(out, ref, Cr, isFloat(da) || isFloat(db), opStr);
+}
+
+INSTANTIATE_TEST_CASE_P(Core_EW, EW_Extensive_MinMax,
+    testing::Combine(testing::Values(0, 1, 2), testing::Range(0, kNumCases)),
+    [](const testing::TestParamInfo<std::tuple<int,int>>& ti) {
+        const int o = std::get<0>(ti.param);
+        return cv::format("%s_case%04d", o == 0 ? "min" : o == 1 ? "max" : "absdiff",
+                          std::get<1>(ti.param));
+    });
+
+// ----------------------------------------------------------------------------------- compare
+// op 0 = CMP_EQ, 1 = CMP_GT: operands promoted to a common type C, result a u8 mask. Exercises
+// emitBinary's compare branch (result forced to u8) and the optional mask value (0/255 default, or
+// 0/1 set through TKernel::flags). Inputs are drawn from a small shared range so equality fires.
+class EW_Extensive_Compare : public ::testing::TestWithParam<std::tuple<int,int>> {};
+
+TEST_P(EW_Extensive_Compare, accuracy)
+{
+    const int opSel = std::get<0>(GetParam());   // 0 = EQ, 1 = GT
+    const int caseidx = std::get<1>(GetParam());
+    const int cmpop = opSel == 0 ? cv::CMP_EQ : cv::CMP_GT;
+    const char* opStr = opSel == 0 ? "cmpEQ" : "cmpGT";
+    RNG rng(mix64(kSuiteSalt ^ 0xC0FFEEULL ^ (uint64_t)(caseidx * 2 + opSel)));
+
+    std::vector<int> shape = sampleShape(rng);
+    const int da = sampleDepth(rng), db = sampleDepth(rng);
+    const int C = (da == db) ? da : promote2(da, db);
+
+    static const int cncand[] = { 1, 1, 2, 3, 4 };
+    const int rcn = cncand[rng.uniform(0, 5)];
+    const int cn_a = rng.uniform(0, 2) ? rcn : 1;
+    const int cn_b = rng.uniform(0, 2) ? rcn : 1;
+    const int ocn = std::max(cn_a, cn_b);
+
+    std::vector<int> sa(shape.size()), sb(shape.size()), res(shape.size());
+    for (size_t d = 0; d < shape.size(); d++)
+    {
+        sa[d] = rng.uniform(0, 2) ? shape[d] : 1;
+        sb[d] = rng.uniform(0, 2) ? shape[d] : 1;
+        res[d] = std::max(sa[d], sb[d]);
+    }
+
+    SCOPED_TRACE(cv::format("%s caseidx=%d da=%d db=%d C=%d a=%sC%d b=%sC%d",
+                            opStr, caseidx, da, db, C, shapeStr(sa).c_str(), cn_a,
+                            shapeStr(sb).c_str(), cn_b));
+
+    // small shared range [0,12] (well within every depth) so EQ is hit on a healthy fraction
+    Mat a = makeRandom(rng, sa, cn_a, da, 0, 12), b = makeRandom(rng, sb, cn_b, db, 0, 12);
+
+    // reference: per channel, cast to C, compare in f64 (exact for these ranges) -> 0/255 mask
+    std::vector<Mat> ach, bch; cv::split(a, ach); cv::split(b, bch);
+    std::vector<Mat> refch(ocn);
+    for (int c = 0; c < ocn; c++)
+    {
+        Mat apC, bpC;
+        cvtest::convert(ach[cn_a == 1 ? 0 : c], apC, C);
+        cvtest::convert(bch[cn_b == 1 ? 0 : c], bpC, C);
+        Mat aB, bB; cv::broadcast(apC, res, aB); cv::broadcast(bpC, res, bB);
+        Mat af, bf; cvtest::convert(aB, af, CV_64F); cvtest::convert(bB, bf, CV_64F);
+        cvtest::compare(af, bf, refch[c], cmpop);      // 0 / 255
+    }
+    Mat ref255; cv::merge(refch, ref255);
+
+    // public op: cv::compare auto-promotes mixed input types to the common type, broadcasts, and
+    // yields a u8 0/255 mask per channel. (The engine's optional 0/1 mask is not exposed here.)
+    Mat out; cv::compare(a, b, out, cmpop);
+    ASSERT_EQ(out.type(), CV_8UC(ocn)) << opStr;
+    EXPECT_EQ(0, cvtest::norm(out, ref255, NORM_INF)) << opStr;
+}
+
+INSTANTIATE_TEST_CASE_P(Core_EW, EW_Extensive_Compare,
+    testing::Combine(testing::Values(0, 1), testing::Range(0, kNumCases)),
+    [](const testing::TestParamInfo<std::tuple<int,int>>& ti) {
+        return cv::format("%s_case%04d", std::get<0>(ti.param) == 0 ? "cmpEQ" : "cmpGT",
+                          std::get<1>(ti.param));
+    });
+
+// ------------------------------------------------------------------------------------- mul / div
+// Parameterized on (op, caseidx): op 0 = MUL, 1 = DIV. Both compute in the float work type (float
+// for <=16-bit, double for 32/64-bit), matching cv::multiply/divide; integer divide-by-zero => 0.
+class EW_Extensive_MulDiv : public ::testing::TestWithParam<std::tuple<int,int>> {};
+
+TEST_P(EW_Extensive_MulDiv, accuracy)
+{
+    const int opSel = std::get<0>(GetParam());
+    const int caseidx = std::get<1>(GetParam());
+    const TOp op = opSel ? OP_DIV : OP_MUL;
+    const char* opStr = opSel ? "div" : "mul";
+    RNG rng(mix64(kSuiteSalt ^ 0x3DD17ULL ^ (uint64_t)caseidx));
+
+    std::vector<int> shape = sampleShape(rng);
+    const int da = sampleDepth(rng), db = sampleDepth(rng);
+
+    static const int cncand[] = { 1, 1, 2, 3, 4 };
+    const int rcn = cncand[rng.uniform(0, 5)];
+    const int cn_a = rng.uniform(0, 2) ? rcn : 1;
+    const int cn_b = rng.uniform(0, 2) ? rcn : 1;
+    const int ocn = std::max(cn_a, cn_b);
+
+    std::vector<int> sa(shape.size()), sb(shape.size()), res(shape.size());
+    for (size_t d = 0; d < shape.size(); d++)
+    {
+        sa[d] = rng.uniform(0, 2) ? shape[d] : 1;
+        sb[d] = rng.uniform(0, 2) ? shape[d] : 1;
+        res[d] = std::max(sa[d], sb[d]);
+    }
+
+    int aliasIn = -1;
+    if (rng.uniform(0, 3) == 0)
+    {
+        if      (sa == res && cn_a == ocn) aliasIn = 0;
+        else if (sb == res && cn_b == ocn) aliasIn = 1;
+    }
+    const bool inplace = aliasIn >= 0;
+    const int Tr = aliasIn == 0 ? da : aliasIn == 1 ? db : sampleDepth(rng);
+
+    // half the cases use a non-unit scale (mul: a*b*scale, div: a*scale/b), like cv::multiply/
+    // divide. Kept in [1/256, 2] so it can shrink (e.g. 1/255) or modestly amplify without pushing
+    // a product/quotient past the integer-output range (which would be float->int UB on both sides).
+    double scale = 1.0;
+    if (rng.uniform(0, 2)) scale = rng.uniform(1.0/256, 2.0);
+
+    SCOPED_TRACE(cv::format("%s caseidx=%d da=%d db=%d Tr=%d a=%sC%d b=%sC%d inplace=%d scale=%.4f",
+                            opStr, caseidx, da, db, Tr, shapeStr(sa).c_str(), cn_a,
+                            shapeStr(sb).c_str(), cn_b, inplace ? aliasIn : -1, scale));
+
+    // modest magnitudes: mul/div compute in a float work type, so a product/quotient that overflows
+    // the integer output's range hits float->int UB (cv::multiply is UB there too). [-1000,1000]
+    // keeps products <= 1e6 (no overflow), while still exercising saturation for small outputs.
+    Mat a = makeRandom(rng, sa, cn_a, da, -1000, 1000), b = makeRandom(rng, sb, cn_b, db, -1000, 1000);
+
+    const bool bothInt = !isFloat(da) && !isFloat(db);
+    // Integer divide-by-zero is well-defined (=> 0) and IS exercised. Float-involved divide-by-zero
+    // is UB (a/0 -> inf -> int), so avoid it here: make the divisor (b) nonzero for the float path.
+    if (op == OP_DIV && !bothInt)
+    {
+        Mat b64; b.convertTo(b64, CV_64F);
+        b64.setTo(1.0, b64 == 0.0);
+        b64.convertTo(b, db);
+    }
+
+    // reference FIRST (in-place may overwrite an input): mirror the engine's spec - cast both to the
+    // float work type Wf (float for <=16-bit common type, double for 32/64-bit), op in Wf, then cast
+    // to Tr (same final cast the engine uses). For both-integer div, guard divide-by-zero -> 0.
+    const int C = (da == db) ? da : promote2(da, db);
+    const bool wide = (C==CV_32U || C==CV_32S || C==CV_64U || C==CV_64S || C==CV_64F);
+    const int Wf = wide ? CV_64F : CV_32F;
+    std::vector<Mat> ach, bch; cv::split(a, ach); cv::split(b, bch);
+    std::vector<Mat> refch(ocn);
+    for (int c = 0; c < ocn; c++)
+    {
+        Mat aWf, bWf;
+        cvtest::convert(ach[cn_a == 1 ? 0 : c], aWf, Wf);
+        cvtest::convert(bch[cn_b == 1 ? 0 : c], bWf, Wf);
+        Mat aB, bB; cv::broadcast(aWf, res, aB); cv::broadcast(bWf, res, bB);
+        Mat q;
+        if (op == OP_DIV) { cvtest::divide(aB, bB, q, scale); if (bothInt) q.setTo(0, bB == 0); }
+        else              cvtest::multiply(aB, bB, q, scale);
+        cvtest::convert(q, refch[c], Tr);
+    }
+    Mat ref; cv::merge(refch, ref);
+
+    // public op: dst aliases input #aliasIn for the in-place case, else a fresh Mat.
+    Mat outOwn;
+    Mat& out = inplace ? (aliasIn == 0 ? a : b) : outOwn;
+    if (op == OP_DIV) cv::divide  (a, b, out, scale, Tr);
+    else              cv::multiply(a, b, out, scale, Tr);
+
+    checkClose(out, ref, Tr, true, opStr);   // float work => integer output may differ by <=1
+}
+
+INSTANTIATE_TEST_CASE_P(Core_EW, EW_Extensive_MulDiv,
+    testing::Combine(testing::Values(0, 1), testing::Range(0, kNumCases)),
+    [](const testing::TestParamInfo<std::tuple<int,int>>& ti) {
+        return cv::format("%s_case%04d", std::get<0>(ti.param) ? "div" : "mul",
+                          std::get<1>(ti.param));
+    });
+
+// ------------------------------------------------------------------------------- masked add / sub
+// add/sub with a write-mask. The data inputs share the output shape (a, b, out all `shape`-spatial,
+// cn channels); the mask is single-channel, the output spatial shape, type bool/u8/s8. The output
+// PRE-EXISTS (filled with random content): copyMask overwrites only the masked subset and leaves
+// the rest unchanged (dst = mask ? op : dst). cn==1 exercises the per-element mask (CH_FOLD); cn>1
+// the channel-axis broadcast (CH_DIM, mask stepx 0 => a whole n-channel row copied under one test).
+class EW_Extensive_Mask : public ::testing::TestWithParam<std::tuple<int,int>> {};
+
+TEST_P(EW_Extensive_Mask, accuracy)
+{
+    const int opSel = std::get<0>(GetParam());
+    const int caseidx = std::get<1>(GetParam());
+    const TOp op = opSel ? OP_SUB : OP_ADD;
+    const char* opStr = opSel ? "sub" : "add";
+    RNG rng(mix64(kSuiteSalt ^ 0x5A5C0DEULL ^ (uint64_t)caseidx));
+
+    std::vector<int> shape = sampleShape(rng);
+    const int da = sampleDepth(rng), db = sampleDepth(rng), Tr = sampleDepth(rng);
+
+    static const int cncand[] = { 1, 1, 2, 3, 4 };
+    const int cn = cncand[rng.uniform(0, 5)];
+
+    static const int maskDepths[] = { CV_8U, CV_8S, CV_Bool };
+    const int md = maskDepths[rng.uniform(0, 3)];
+
+    SCOPED_TRACE(cv::format("%s caseidx=%d da=%d db=%d Tr=%d cn=%d md=%d shape=%s",
+                            opStr, caseidx, da, db, Tr, cn, md, shapeStr(shape).c_str()));
+
+    Mat a = makeRandom(rng, shape, cn, da), b = makeRandom(rng, shape, cn, db);
+
+    // mask: single-channel, output spatial shape, ~half zero. Build a u8 0/1 master, convert it to
+    // the chosen mask depth for the engine; the u8 master drives the reference copyTo.
+    const int nd = (int)shape.size();
+    Mat m8(nd, shape.data(), CV_8U);
+    cvtest::randUni(rng, m8, Scalar::all(0), Scalar::all(2));   // 0 or 1
+    Mat mask; m8.convertTo(mask, md);
+
+    // pre-existing output content (preserved where mask==0): dst = mask ? op : dst.
+    Mat init = makeRandom(rng, shape, cn, Tr).clone();   // contiguous Tr-typed dst
+
+    // reference: full op per channel (cast to common type C, op to Tr), merge, then overwrite the
+    // masked subset of `init` (the rest stays as the pre-existing content).
+    int C = (da == db) ? da : promote2(da, db);
+    std::vector<Mat> ach, bch; cv::split(a, ach); cv::split(b, bch);
+    std::vector<Mat> refch(cn);
+    for (int c = 0; c < cn; c++)
+    {
+        Mat apC, bpC; cvtest::convert(ach[c], apC, C); cvtest::convert(bch[c], bpC, C);
+        cvtest::add(apC, 1, bpC, op == OP_SUB ? -1 : 1, Scalar(), refch[c], Tr);
+    }
+    Mat refFull; cv::merge(refch, refFull);
+    Mat ref = init.clone();
+    cvtest::copy(refFull, ref, m8);
+
+    // public op with a write-mask: the pre-existing output is preserved where mask==0.
+    Mat out = init.clone();
+    if (op == OP_SUB) cv::subtract(a, b, out, mask, Tr);
+    else              cv::add     (a, b, out, mask, Tr);
+
+    checkClose(out, ref, Tr, isFloat(da) || isFloat(db), opStr);
+}
+
+INSTANTIATE_TEST_CASE_P(Core_EW, EW_Extensive_Mask,
+    testing::Combine(testing::Values(0, 1), testing::Range(0, kNumCases)),
+    [](const testing::TestParamInfo<std::tuple<int,int>>& ti) {
+        return cv::format("%s_case%04d", std::get<0>(ti.param) ? "sub" : "add",
+                          std::get<1>(ti.param));
+    });
+
+// NOTE: a standalone cast group was dropped - the engine cast == cv::convertTo (comparing them would
+// be a tautology), and mixed-type casts are already exercised inside the add/sub/mul/div groups above.
+
+}} // namespace

modules/core/test/test_operations.cpp

@@ -1592,7 +1592,11 @@ TEST(Core_MatExpr, mul_scalar_use_after_scope_23577)
     EXPECT_EQ(0, cvtest::norm(res, Mat(2, 3, CV_32FC1, Scalar::all(21.0f)), NORM_INF));
 }
 
-TEST(Core_Arithm, scalar_handling_19599)  // https://github.com/opencv/opencv/issues/19599 (OpenCV 4.x+ only)
+// Disabled with the new broadcasting element-wise engine: a 4x1 CV_64F *Mat* is no longer treated as a
+// Scalar (only true scalars - numbers / cv::Scalar / Vec / Matx, which arrive via _InputArray::MATX -
+// are scalars; real Mats ride broadcasting). Here b broadcasts against a(1x1) -> 4x1, not 1x1. A
+// follow-up OpenCV issue tracks this intended behavior change.
+TEST(Core_Arithm, DISABLED_scalar_handling_19599)  // https://github.com/opencv/opencv/issues/19599 (OpenCV 4.x+ only)
 {
     Mat a(1, 1, CV_32F, Scalar::all(1));
     Mat b(4, 1, CV_64F, Scalar::all(1));  // MatExpr may convert Scalar to Mat

modules/dnn/include/opencv2/dnn/dict.hpp

@@ -60,13 +60,13 @@ CV__DNN_INLINE_NS_BEGIN
 struct CV_EXPORTS_W DictValue
 {
     DictValue(const DictValue &r);
-    explicit DictValue(bool i)           : type(Param::INT), pi(new AutoBuffer<int64,1>) { (*pi)[0] = i ? 1 : 0; }       //!< Constructs integer scalar
+    explicit DictValue(bool i)           : type(Param::INT), pi(new AutoBuffer<int64,1>(1)) { (*pi)[0] = i ? 1 : 0; }       //!< Constructs integer scalar
-    explicit DictValue(int64 i = 0)      : type(Param::INT), pi(new AutoBuffer<int64,1>) { (*pi)[0] = i; }       //!< Constructs integer scalar
+    explicit DictValue(int64 i = 0)      : type(Param::INT), pi(new AutoBuffer<int64,1>(1)) { (*pi)[0] = i; }       //!< Constructs integer scalar
-    CV_WRAP explicit DictValue(int i)    : type(Param::INT), pi(new AutoBuffer<int64,1>) { (*pi)[0] = i; }       //!< Constructs integer scalar
+    CV_WRAP explicit DictValue(int i)    : type(Param::INT), pi(new AutoBuffer<int64,1>(1)) { (*pi)[0] = i; }       //!< Constructs integer scalar
-    explicit DictValue(unsigned p)       : type(Param::INT), pi(new AutoBuffer<int64,1>) { (*pi)[0] = p; }       //!< Constructs integer scalar
+    explicit DictValue(unsigned p)       : type(Param::INT), pi(new AutoBuffer<int64,1>(1)) { (*pi)[0] = p; }       //!< Constructs integer scalar
-    CV_WRAP explicit DictValue(double p)         : type(Param::REAL), pd(new AutoBuffer<double,1>) { (*pd)[0] = p; }     //!< Constructs floating point scalar
+    CV_WRAP explicit DictValue(double p)         : type(Param::REAL), pd(new AutoBuffer<double,1>(1)) { (*pd)[0] = p; }     //!< Constructs floating point scalar
-    CV_WRAP explicit DictValue(const String &s)  : type(Param::STRING), ps(new AutoBuffer<String,1>) { (*ps)[0] = s; }   //!< Constructs string scalar
+    CV_WRAP explicit DictValue(const String &s)  : type(Param::STRING), ps(new AutoBuffer<String,1>(1)) { (*ps)[0] = s; }   //!< Constructs string scalar
-    explicit DictValue(const char *s)            : type(Param::STRING), ps(new AutoBuffer<String,1>) { (*ps)[0] = s; }   //!< @overload
+    explicit DictValue(const char *s)            : type(Param::STRING), ps(new AutoBuffer<String,1>(1)) { (*ps)[0] = s; }   //!< @overload
 
     template<typename TypeIter>
     static DictValue arrayInt(TypeIter begin, int size);    //!< Constructs integer array

modules/dnn/src/layers/batch_norm_layer.cpp

@@ -92,8 +92,12 @@ public:
         const float* weightsData = hasWeights ? blobs[weightsBlobIndex].ptr<float>() : 0;
         const float* biasData = hasBias ? blobs[biasBlobIndex].ptr<float>() : 0;
 
-        origin_weights.create(1, (int)n, CV_32F);
+        // 1-D [n], NOT 1xn: the fused scale/bias participate in element-wise ops against 0/1-D
-        origin_bias.create(1, (int)n, CV_32F);
+        // inputs, and under the broadcasting rules (4) op (1,4) yields (1,4) - a 2-D result that
+        // would not fit a preallocated 1-D output blob. 1-D weights keep every shape exact.
+        const int sz1d[] = { (int)n };
+        origin_weights.create(1, sz1d, CV_32F);
+        origin_bias.create(1, sz1d, CV_32F);
 
         float* dstWeightsData = origin_weights.ptr<float>();
         float* dstBiasData = origin_bias.ptr<float>();
@@ -108,8 +112,8 @@ public:
 
     virtual void finalize(InputArrayOfArrays, OutputArrayOfArrays) CV_OVERRIDE
     {
-        origin_weights.reshape(1, 1).copyTo(weights_);
+        origin_weights.copyTo(weights_);
-        origin_bias.reshape(1, 1).copyTo(bias_);
+        origin_bias.copyTo(bias_);
     }
 
     void getScaleShift(Mat& scale, Mat& shift) const CV_OVERRIDE
@@ -133,9 +137,11 @@ public:
             (numFusedBias != numChannels && numFusedBias != 1 && !b.empty()))
             return false;
 
+        // reshape the fused factors to 1-D [numChannels], matching weights_/bias_ - a 1xn operand
+        // would broadcast the result up to 2-D and detach weights_ from its expected 1-D shape
+        const int fsz[] = { numChannels };
         if (!w.empty())
         {
-            w = w.reshape(1, 1);
             if (numFusedWeights == 1)
             {
                 multiply(weights_, w.at<float>(0), weights_);
@@ -143,17 +149,17 @@ public:
             }
             else
             {
+                w = w.reshape(1, 1, fsz);
                 multiply(weights_, w, weights_);
                 multiply(bias_, w, bias_);
             }
         }
         if (!b.empty())
         {
-            b = b.reshape(1, 1);
             if (numFusedBias == 1)
                 add(bias_, b.at<float>(0), bias_);
             else
-                add(bias_, b.reshape(1, 1), bias_);
+                add(bias_, b.reshape(1, 1, fsz), bias_);
         }
         return true;
     }
@@ -281,8 +287,13 @@ public:
             Mat &inpBlob = inputs[0];
             Mat &outBlob = outputs[0];
             CV_Assert(inpBlob.total() == weights_.total());
-            cv::multiply(inpBlob, weights_, outBlob);
+            // run on 1-D [n] views (a 0-D blob views as [1]) so every operand shape matches exactly:
-            cv::add(outBlob, bias_, outBlob);
+            // the result lands in the preallocated output blob in place, no realloc/detach possible
+            const int n1[] = { (int)inpBlob.total() };
+            Mat inp1d = inpBlob.reshape(1, 1, n1);
+            Mat out1d = outBlob.reshape(1, 1, n1);
+            cv::multiply(inp1d, weights_, out1d);
+            cv::add(out1d, bias_, out1d);
             return;
         }
 

modules/dnn/src/layers/recurrent2_layers.cpp

@@ -143,24 +143,34 @@ class LSTM2LayerImpl CV_FINAL : public LSTM2Layer
                 if (layout == SEQ_BATCH_HID) {
                     _batchSize = inp0[1];
                     _seqLen = inp0[0];
+                    outResShape.push_back(_seqLen);
+                    outResShape.push_back(1 + static_cast<int>(bidirectional));
+                    outResShape.push_back(_batchSize);
                 } else {
+                    // ONNX layout=1: Y is (batch, seq, dirs, hid) - this must match what forward()
+                    // actually writes, the graph engine preallocates the output by this shape
                     _batchSize = inp0[0];
                     _seqLen = inp0[1];
+                    outResShape.push_back(_batchSize);
+                    outResShape.push_back(_seqLen);
+                    outResShape.push_back(1 + static_cast<int>(bidirectional));
                 }
-                outResShape.push_back(_seqLen);
             }
             else
             {
                 CV_Assert(inp0.size() >= 2 && total(inp0, 1) == _inpSize);
                 _batchSize = inp0[0];
+                outResShape.push_back(1 + static_cast<int>(bidirectional));
+                outResShape.push_back(_batchSize);
             }
 
-            outResShape.push_back(1 + static_cast<int>(bidirectional));
-            outResShape.push_back(_batchSize);
             outResShape.push_back(_hidSize);
             outputs.assign(1, outResShape);
 
+            // Yh / Yc: ONNX layout=0 -> (dirs, batch, hid), layout=1 -> (batch, dirs, hid)
             int shp[] = {1 + static_cast<int>(bidirectional), _batchSize, numHidden};
+            if (layout == BATCH_SEQ_HID)
+                std::swap(shp[0], shp[1]);
             MatShape newShape(shp, shp + sizeof(shp)/sizeof(shp[0]));
 
             // compute output shape of yc
@@ -302,13 +312,16 @@ class LSTM2LayerImpl CV_FINAL : public LSTM2Layer
 
 
             Mat cOutTs;
-            Mat cOut = produceCellOutput ? output[0].clone() : Mat();
+            // seq-major scratch for the cell states, (seq, batch, dirs, hid) like the recurrence writes
+            int cOutShape[] = {seqLenth, batchSize, numDirs, numHidden};
+            Mat cOut = produceCellOutput ? Mat::zeros(4, cOutShape, output[0].type()) : Mat();
             Mat hOutTs = Mat::zeros(seqLenth * batchSize, hidSize, output[0].type());
             Mat xTs = input[0].reshape(1, batchSizeTotal);
 
-            // Prepare output[0] buffer to store the results
+            // seq-major assembly buffer for Y. The final result is transposed from it INTO output[0]:
-            int shp0[] = {seqLenth * batchSize, numDirs * numHidden};
+            // the preallocated output tensor must never be reallocated or get its header replaced,
-            output[0] = output[0].reshape(1, sizeof(shp0)/sizeof(shp0[0]), shp0);
+            // or the result would silently detach from the graph.
+            Mat hOutAll(batchSizeTotal, numDirs * numHidden, output[0].type());
 
             // Initialize Wx, Wh, bias, h_0, c_0, pI, pF, pO
             Mat Wx, Wh, bias, h_0, c_0, pI, pF, pO;
@@ -416,32 +429,31 @@ class LSTM2LayerImpl CV_FINAL : public LSTM2Layer
 
                 }
 
-                // slice in the result from each direction to the output[0] buffer
+                // slice in the result from each direction to the assembly buffer
-                hOutTs.copyTo(output[0].colRange(i * hOutTs.cols, (i + 1) * hOutTs.cols));
+                hOutTs.copyTo(hOutAll.colRange(i * hOutTs.cols, (i + 1) * hOutTs.cols));
             }
 
-            // this one is needed to make make the output[0] compatible with ONNX LSTM layer standard
+            // (seq*batch, dirs*hid) -> (seq, batch, dirs, hid), then into the ONNX Y layout for this
+            // `layout` attribute, written INTO the preallocated output[0] (transposeND's exact-shape
+            // create() keeps it in place)
             int shp1[] = {seqLenth, batchSize, numDirs, numHidden};
-            output[0] = output[0].reshape(1, sizeof(shp1)/sizeof(shp1[0]), shp1);
+            Mat y4d = hOutAll.reshape(1, sizeof(shp1)/sizeof(shp1[0]), shp1);
-
+            Mat ySeqFirst;   // (seq, dirs, batch, hid) - the layout=0 Y; Yh is sliced from it
-            // this transpose is needed to make the output[0] compatible with ONNX LSTM layer standard
+            if (layout == SEQ_BATCH_HID) {
-            Mat tmp = output[0].clone();
+                cv::transposeND(y4d, {0, 2, 1, 3}, output[0]);
-            cv::transposeND(tmp, {0, 2, 1, 3}, output[0]);
+                ySeqFirst = output[0];
+            } else {
+                cv::transposeND(y4d, {0, 2, 1, 3}, ySeqFirst);
+                cv::transposeND(y4d, {1, 0, 2, 3}, output[0]);   // (batch, seq, dirs, hid)
+            }
 
             if (produceOutputYh){
-                getCellStateYh(output[0], output[1], numDirs);
+                getCellStateYh(ySeqFirst, output[1], numDirs);
             }
 
             if (produceCellOutput){
                 getCellStateYc(cOut, output[2], numDirs);
             }
-
-            if (layout == BATCH_SEQ_HID) {
-                cv::transposeND(output[0], {2, 0, 1, 3}, output[0]);
-            }
-
-            // Make sure changes are written back to outputs_arr
-            outputs_arr.assign(output);
         }
 
         void getCellStateYh(Mat& scr, Mat& dst, int numDirs)
@@ -463,28 +475,30 @@ class LSTM2LayerImpl CV_FINAL : public LSTM2Layer
                 }
 
             } else {
-                // there is issue here.
                 // Slice: SxDxBxH -> last sequence, first direction
                 Range ranges1[] = {cv::Range(scr.size[0] - 1, scr.size[0]), cv::Range(0, 1), cv::Range::all(), cv::Range::all()};
                 Mat part1 = scr(ranges1);
 
-
                 // Slice: SxDxBxH -> first sequence, last direction
                 Range ranges2[] = {cv::Range(0, 1), cv::Range(scr.size[1] - 1, scr.size[1]), cv::Range::all(), cv::Range::all()};
                 Mat part2 = scr(ranges2);
 
-
                 int shp[] = {1, part1.size[2] * part1.size[3]};
                 part1 = part1.reshape(1, sizeof(shp)/sizeof(shp[0]), shp);
                 part2 = part2.reshape(1, sizeof(shp)/sizeof(shp[0]), shp);
 
-                vconcat(part1, part2, dst);
+                // build into a temp, then write into the preallocated dst in place (vconcat straight
+                // into dst would replace its header and detach it from the graph's output tensor)
+                Mat tmp;
+                vconcat(part1, part2, tmp);
 
                 int finalShape[] = {2, batchSize, numHidden};
-                dst = dst.reshape(1, sizeof(finalShape)/sizeof(finalShape[0]), finalShape);
+                tmp = tmp.reshape(1, sizeof(finalShape)/sizeof(finalShape[0]), finalShape);
 
                 if (layout == BATCH_SEQ_HID){
-                    cv::transposeND(dst, {1, 0, 2}, dst);
+                    cv::transposeND(tmp, {1, 0, 2}, dst);
+                } else {
+                    tmp.copyTo(dst);
                 }
             }
         }
@@ -496,15 +510,10 @@ class LSTM2LayerImpl CV_FINAL : public LSTM2Layer
             int shp[] = {0, batchSize, numDirs, numHidden};
             cOut = cOut.reshape(1, sizeof(shp)/sizeof(shp[0]), shp);
 
-            // permute to {0, 2, 1, 3};
+            // permute to (seq, dirs, batch, hidden); the `layout` only affects the FINAL Yc order
+            // below, the last-timestep/last-direction slicing is layout-independent
             cv::Mat newCellState;
-            // transpose to match batch first output
+            cv::transposeND(cOut, {0, 2, 1, 3}, newCellState);
-            if (layout == BATCH_SEQ_HID){
-                cv::transposeND(cOut, {2, 0, 1, 3}, newCellState);
-            }
-            else{
-                cv::transposeND(cOut, {0, 2, 1, 3}, newCellState);
-            }
             cOut = newCellState;
 
             if (numDirs == 1)
@@ -515,7 +524,6 @@ class LSTM2LayerImpl CV_FINAL : public LSTM2Layer
                 // Reshape: 1x1xBxH -> 1xBxH
                 int shp[] = {1, batchSize, numHidden};
                 cOut = cOut.reshape(1, sizeof(shp)/sizeof(shp[0]), shp);
-                cOut.copyTo(dst);
             }
             else
             {
@@ -536,6 +544,13 @@ class LSTM2LayerImpl CV_FINAL : public LSTM2Layer
                 // Reshape: 1x2xBxH -> 2xBxH
                 int finalShape[] = {2, batchSize, numHidden};
                 cOut = cOut.reshape(1, sizeof(finalShape)/sizeof(finalShape[0]), finalShape);
+            }
+
+            // (dirs, batch, hid), or (batch, dirs, hid) for the batch-first layout - written into the
+            // preallocated dst in place
+            if (layout == BATCH_SEQ_HID){
+                cv::transposeND(cOut, {1, 0, 2}, dst);
+            } else {
                 cOut.copyTo(dst);
             }
         }

modules/dnn/src/layers/recurrent_layers.cpp

@@ -314,8 +314,12 @@ public:
             if (layout == SEQ_BATCH_HID) {
                 _numSamples = inp0[1];
                 outResShape.push_back(inp0[0]);
+                outResShape.push_back(_numSamples);
             } else {
+                // batch-first layout: the output keeps the (batch, seq, ...) order - this must match
+                // what forward() actually writes, the graph engine preallocates outputs by this shape
                 _numSamples = inp0[0];
+                outResShape.push_back(_numSamples);
                 outResShape.push_back(inp0[1]);
             }
         }
@@ -323,9 +327,9 @@ public:
         {
             CV_Assert(inp0.size() >= 2 && total(inp0, 1) == _numInp);
             _numSamples = inp0[0];
+            outResShape.push_back(_numSamples);
         }
 
-        outResShape.push_back(_numSamples);
         outResShape.insert(outResShape.end(), outTailShape_.begin(), outTailShape_.end());
         outResShape.back() *= (1 + static_cast<int>(bidirectional));
 
@@ -428,7 +432,19 @@ public:
             input[0] = tmp;
         }
 
-        Mat cOut = produceCellOutput ? output[0].clone() : Mat();
+        // For the batch-first layout the (preallocated) output[0] is (batch, seq, ...), but the
+        // recurrence below assembles rows in seq-major order - run it on a seq-first temp, then
+        // transpose INTO output[0] at the end. output[0] itself must never be reallocated/replaced:
+        // it is the tensor the graph engine preallocated, a new header would silently detach from it.
+        Mat hOutSeqFirst = output[0];
+        if (layout == BATCH_SEQ_HID)
+        {
+            MatShape seqFirstShape = output[0].shape();
+            std::swap(seqFirstShape[0], seqFirstShape[1]);
+            hOutSeqFirst = Mat(seqFirstShape, output[0].type());
+        }
+
+        Mat cOut = produceCellOutput ? hOutSeqFirst.clone() : Mat();
         const bool needYcTransform = !originalBlobs.empty(); // if the producer is onnx
         const int numDirs = 1 + static_cast<int>(bidirectional);
         for (int i = 0; i < numDirs; ++i)
@@ -484,7 +500,7 @@ public:
             int numSamplesTotal = numTimeStamps*numSamples;
             Mat xTs = input[0].reshape(1, numSamplesTotal);
 
-            Mat hOutTs = output[0].reshape(1, numSamplesTotal);
+            Mat hOutTs = hOutSeqFirst.reshape(1, numSamplesTotal);
             hOutTs = hOutTs.colRange(i * hOutTs.cols / numDirs, (i + 1) * hOutTs.cols / numDirs);
             Mat cOutTs;
             if (produceCellOutput)
@@ -727,11 +743,10 @@ public:
                     cInternal.copyTo(cOutTs.rowRange(curRowRange));
             }
         }
-        // transpose to match batch first output
+        // transpose to match batch first output - into the preallocated tensor (exact-shape create()
+        // inside transposeND reuses it, so the graph's output blob is written in place)
         if (layout == BATCH_SEQ_HID){
-            cv::Mat tmp;
+            cv::transposeND(hOutSeqFirst, {1, 0, 2}, output[0]);
-            cv::transposeND(output[0], {1, 0, 2}, tmp);
-            output[0] = tmp;
         }
         if (needYcTransform && produceCellOutput)
         {

modules/dnn/src/net_impl2.cpp

@@ -1342,6 +1342,24 @@ void Net::Impl::forwardGraph(Ptr<Graph>& graph, InputArrayOfArrays inputs_,
                     m.copyTo(buf);
                 }
             } else {
+                if (!dynamicOutShapes) {
+                    // the same sanity check for non-temp (graph output/state) tensors: the layer must
+                    // write into the preallocated tensor of the inferred shape/type. A mismatch here
+                    // means some op inside Layer::forward() reallocated it (e.g. a broadcast produced
+                    // an unexpected shape) and the result would silently detach from the graph.
+                    if (m.shape() != outShapes[i] || m.type() != outTypes[i] ||
+                        (m.u && (m.u->data != outOrigData[i].first || m.u->size != outOrigData[i].second)))
+                    {
+                        std::ostringstream oss;
+                        oss << "layer '" << layer->name << "' (" << layer->type << "): output #" << i
+                            << " changed during forward(): inferred shape " << outShapes[i]
+                            << " / type " << typeToString(outTypes[i])
+                            << ", actual " << m.shape() << " / " << typeToString(m.type())
+                            << (m.u && m.u->data != outOrigData[i].first
+                                ? "; the tensor was reallocated (the layer must write in place)" : "");
+                        CV_Error(Error::StsInternal, oss.str());
+                    }
+                }
                 __tensors__.at(out.idx) = m;
             }
         }

modules/features/src/blobdetector.cpp

@@ -47,7 +47,7 @@
 #include <opencv2/core/utils/logger.hpp>
 
 // Requires CMake flag: DEBUG_opencv_features=ON
-//#define DEBUG_BLOB_DETECTOR
+// #define DEBUG_BLOB_DETECTOR
 
 #ifdef DEBUG_BLOB_DETECTOR
 #include "opencv2/highgui.hpp"
@@ -253,6 +253,8 @@ void SimpleBlobDetectorImpl::findBlobs(InputArray _image, InputArray _binaryImag
     imshow("contours", contoursImage );
 #endif
 
+    std::vector<double> dists;
+
     for (size_t contourIdx = 0; contourIdx < contours.size(); contourIdx++)
     {
         Center center;
@@ -317,6 +319,7 @@ void SimpleBlobDetectorImpl::findBlobs(InputArray _image, InputArray _binaryImag
         if(moms.m00 == 0.0)
             continue;
         center.location = Point2d(moms.m10 / moms.m00, moms.m01 / moms.m00);
+        center.radius = 0.;
 
         if (params.filterByColor)
         {
@@ -328,14 +331,17 @@ void SimpleBlobDetectorImpl::findBlobs(InputArray _image, InputArray _binaryImag
         {
             const std::vector<cv::Point>& contour = contours[contourIdx];
             const size_t contourSize = contour.size();
-            AutoBuffer<double> dists(contourSize);
+
-            for (size_t pointIdx = 0; pointIdx < contourSize; pointIdx++)
+            if (contourSize > 0u) {
-            {
+                dists.resize(contourSize);
-                const Point2d& pt = contour[pointIdx];
+                for (size_t pointIdx = 0; pointIdx < contourSize; pointIdx++)
-                dists[pointIdx] = norm(center.location - pt);
+                {
+                    const Point2d& pt = contour[pointIdx];
+                    dists[pointIdx] = norm(center.location - pt);
+                }
+                std::sort(dists.begin(), dists.end());
+                center.radius = (dists[(contourSize - 1) / 2] + dists[contourSize / 2]) / 2.;
             }
-            std::sort(dists.begin(), dists.end());
-            center.radius = (dists[(dists.size() - 1) / 2] + dists[dists.size() / 2]) / 2.;
         }
 
         centers.push_back(center);

modules/python/test/test_expr.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+'''
+cv.texpr() - the string front-end of the broadcasting element-wise expression engine
+'''
+
+# Python 2/3 compatibility
+from __future__ import print_function
+
+import numpy as np
+import cv2 as cv
+
+from tests_common import NewOpenCVTests
+
+
+class texpr_test(NewOpenCVTests):
+
+    def test_basic_arith(self):
+        a = np.random.uniform(1, 10, (12, 15)).astype(np.float32)
+        b = np.random.uniform(1, 10, (12, 15)).astype(np.float32)
+        res = cv.texpr("{0} * 2.5 + {1}", [a, b])
+        self.assertIsInstance(res, tuple)
+        self.assertEqual(len(res), 1)
+        self.assertLessEqual(np.max(np.abs(res[0] - (a * 2.5 + b))), 1e-3)
+        # the idiomatic single-result unpacking
+        r, = cv.texpr("{0} * 2.5 + {1}", [a, b])
+        self.assertTrue(np.array_equal(r, res[0]))
+
+    def test_fused_absdiff(self):
+        a = np.random.randint(0, 255, (20, 30)).astype(np.uint8)
+        b = np.random.randint(0, 255, (20, 30)).astype(np.uint8)
+        got = cv.texpr("abs({0} - {1})", [a, b])[0]
+        self.assertEqual(got.dtype, np.uint8)
+        self.assertTrue(np.array_equal(got, cv.absdiff(a, b)))
+
+    def test_type_cast(self):
+        a = np.random.uniform(-50, 300, (10, 10)).astype(np.float32)
+        got = cv.texpr("uint8({0})", [a])[0]
+        self.assertEqual(got.dtype, np.uint8)
+        ref = np.clip(np.rint(a), 0, 255).astype(np.uint8)
+        self.assertTrue(np.array_equal(got, ref))
+
+    def test_broadcasting(self):
+        img = np.random.uniform(0, 255, (8, 6, 3)).astype(np.float32)
+        row = np.random.uniform(1, 2, (1, 6, 3)).astype(np.float32)
+        got = cv.texpr("{0} * {1}", [img, row])[0]
+        self.assertLessEqual(np.max(np.abs(got - img * row)), 1e-3)
+
+    def test_ternary_and_compare(self):
+        a = np.random.uniform(0, 100, (9, 14)).astype(np.float32)
+        b = np.random.uniform(0, 100, (9, 14)).astype(np.float32)
+        got = cv.texpr("{0} > {1} ? {0} : {1}", [a, b])[0]
+        self.assertTrue(np.array_equal(got, np.maximum(a, b)))
+
+    def test_pow_operator(self):
+        a = np.random.uniform(0.5, 2, (7, 11)).astype(np.float32)
+        got = cv.texpr("3 * {0} ** 2", [a])[0]     # ** binds tighter than *
+        self.assertLessEqual(np.max(np.abs(got - 3 * a ** 2) / (3 * a ** 2)), 1e-5)
+
+    def test_math_functions(self):
+        x = np.random.uniform(0.05, 9, (13, 17)).astype(np.float32)
+        got = cv.texpr("exp(-{0}) + log({0}) + sqrt({0})", [x])[0]
+        ref = np.exp(-x.astype(np.float64)) + np.log(x.astype(np.float64)) + np.sqrt(x.astype(np.float64))
+        self.assertLessEqual(np.max(np.abs(got - ref)), 1e-4)
+
+    def test_clamp_scalar_literals(self):
+        a = np.random.uniform(-100, 355, (10, 21)).astype(np.float32)
+        got = cv.texpr("clamp({0}, 10, 200)", [a])[0]
+        self.assertTrue(np.array_equal(got, np.clip(a, 10, 200)))
+
+    def test_named_temporary(self):
+        a = np.random.uniform(1, 10, (6, 8)).astype(np.float32)
+        b = np.random.uniform(1, 10, (6, 8)).astype(np.float32)
+        got = cv.texpr("d = {0} - {1}; d*d", [a, b])[0]
+        self.assertLessEqual(np.max(np.abs(got - (a - b) ** 2)), 1e-3)
+
+    def test_tuple_outputs(self):
+        a = np.random.uniform(1, 10, (5, 9)).astype(np.float32)
+        b = np.random.uniform(1, 10, (5, 9)).astype(np.float32)
+        res = cv.texpr("({0} + {1}, {0} - {1})", [a, b])
+        self.assertEqual(len(res), 2)
+        self.assertLessEqual(np.max(np.abs(res[0] - (a + b))), 1e-3)
+        self.assertLessEqual(np.max(np.abs(res[1] - (a - b))), 1e-3)
+
+    def test_cart_to_polar(self):
+        x = np.random.uniform(-5, 5, (11, 13)).astype(np.float32)
+        y = np.random.uniform(-5, 5, (11, 13)).astype(np.float32)
+        mag, ang = cv.texpr("(hypot({0},{1}), atan2({1},{0}))", [x, y])
+        self.assertLessEqual(np.max(np.abs(mag - np.hypot(x, y))), 1e-3)
+        self.assertLessEqual(np.max(np.abs(ang - np.arctan2(y, x))), 2e-4)
+
+    def test_int_saturation(self):
+        # 32-bit add/subtract saturate (the new v_add_sat kernels)
+        a = np.array([[2**31 - 1, -2**31, 0]], dtype=np.int32)
+        b = np.array([[1, -1, -2**31]], dtype=np.int32)
+        s = cv.texpr("{0} + {1}", [a, b])[0]
+        d = cv.texpr("{0} - {1}", [a, b])[0]
+        self.assertEqual(s[0, 0], 2**31 - 1)   # MAX + 1 -> MAX
+        self.assertEqual(s[0, 1], -2**31)      # MIN - 1 -> MIN
+        self.assertEqual(d[0, 2], 2**31 - 1)   # 0 - MIN -> MAX
+
+
+if __name__ == '__main__':
+    NewOpenCVTests.bootstrap()