IMPORTANT: To view this page as Markdown, append `.md` to the URL (e.g. /max/get-started.md). For the complete documentation index, see llms.txt.
Skip to main content
For the complete documentation index, see llms.txt. Markdown versions of all pages are available by appending .md to any URL (e.g. /max/get-started.md).

Mojo struct

MinMax

struct MinMax[dtype: DType, W: Int = simd_width_of[dtype]()]

Fused min+max reduction monoid: tracks both min(self, x) and max(self, x) in one state. Cuts the axis walk in half vs running separate ReduceMin + ReduceMax.

Two SIMD fields — min_acc (running minimum) and max_acc (running maximum). accumulate is one expression per field; reduce reduces each into its lane 0.

Parameters​

  • ​dtype (DType): The accumulator dtype.
  • ​W (Int): SIMD width of the lane-wise accumulators. Defaults to the target's simd_width_of[dtype].

Fields​

  • ​min_acc (SIMD[dtype, W]): Lane-wise running minimum. Final scalar in min_acc[0].
  • ​max_acc (SIMD[dtype, W]): Lane-wise running maximum. Final scalar in max_acc[0].

Implemented traits​

AnyType, Copyable, ImplicitlyCopyable, ImplicitlyDeletable, Movable, ReduceOp, RegisterPassable, TrivialRegisterPassable

comptime members​

Single​

comptime Single = MinMax[dtype, Int(1)]

width​

comptime width = W

Methods​

__init__​

def __init__() -> Self

Identity: min_acc = +inf_W, max_acc = -inf_W.

__getitem__​

def __getitem__(self, j: Int) -> Self.Single

Returns lane j as a width-1 monoid.

Returns:

Self.Single

__setitem__​

def __setitem__(mut self, j: Int, s: MinMax[dtype, Int(1)])

Writes width-1 monoid s into lane j.

accumulate​

def accumulate[val_dtype: DType, w: Int](mut self, val: SIMD[val_dtype, w], idx: SIMD[DType.int64, w] = 0)

Folds a SIMD tile into both accumulators. Each field uses its own identity padding via Self.pad: +inf/MAX for the min field, -inf/MIN for the max field, so padded lanes never affect the result.

Parameters:

  • ​val_dtype (DType): The tile's source dtype.
  • ​w (Int): SIMD width of the tile.

Args:

join​

def join(mut self, other: Self)

Sequential combine: lane-wise min and max.

Args:

  • ​other (Self): The state to combine into self.

reduce​

def reduce(self) -> Self.Single

Collapses each field's W lane partials via the reduce_min / reduce_max intrinsics.

Overrides the default lane-fold so the vectorized horizontal min/max are emitted explicitly (a measured CPU win; GPU-neutral).

Returns:

Self.Single: A width-1 MinMax with the min in min_acc[0] and the max in max_acc[0].

join_parallel​

def join_parallel[R: Reducer](mut self, reducer: R)

Cross-thread combine via reducer.min / reducer.max, splatting each scalar result across its field's lanes. Runs after reduce.

Parameters:

  • ​R (Reducer): The parallel scalar reducer.

Args:

  • ​reducer (R): The reducer instance.

Models

Cookbook

Puzzles

Blog

Community

Contact