Operation Cost Index

Search and filter counted runtime operations across flopscope.numpy and flopscope.stats.

Operation cost index

Counted operations, free helpers, and blocked calls from the public flopscope API surface.

553 entries

553 of 553

Operation	Area	Type	Weight
fnp.absolute	core	counted	$\text{numel}(\text{output})$
fnp.add	core	counted	$\text{numel}(\text{output})$
fnp.all	core	counted	$\text{numel}(\text{input})$
fnp.allclose	core	custom	per-operation
fnp.angle	core	counted	16× $\text{numel}(\text{output})$
fnp.any	core	counted	$\text{numel}(\text{input})$
fnp.append	core	custom	per-operation
fnp.apply_along_axis	core	custom	per-operation
fnp.apply_over_axes	core	custom	per-operation
fnp.arange	core	custom	per-operation
fnp.arccos	core	counted	16× $\text{numel}(\text{output})$
fnp.arccosh	core	counted	16× $\text{numel}(\text{output})$
fnp.arcsin	core	counted	16× $\text{numel}(\text{output})$
fnp.arcsinh	core	counted	16× $\text{numel}(\text{output})$
fnp.arctan	core	counted	16× $\text{numel}(\text{output})$
fnp.arctan2	core	counted	16× $\text{numel}(\text{output})$
fnp.arctanh	core	counted	16× $\text{numel}(\text{output})$
fnp.argmax	core	counted	$\text{numel}(\text{input})$
fnp.argmin	core	counted	$\text{numel}(\text{input})$
fnp.argpartition	core	custom	4×per-operation
fnp.argsort	core	custom	4×per-operation
fnp.argwhere	core	custom	per-operation
fnp.array	core	custom	per-operation
fnp.array_equal	core	custom	per-operation
fnp.array_equiv	core	custom	per-operation
fnp.array_split	core	free	0
fnp.as_symmetric	core	custom	per-operation
fnp.asarray	core	custom	per-operation
fnp.asarray_chkfinite	core	custom	per-operation
fnp.astype	core	custom	per-operation
fnp.atleast_1d	core	free	0
fnp.atleast_2d	core	free	0
fnp.atleast_3d	core	free	0
fnp.average	core	counted	$\text{numel}(\text{input})$
fnp.bartlett	core	custom	$4n$
fnp.bincount	core	custom	4×per-operation
fnp.bitwise_and	core	counted	$\text{numel}(\text{output})$
fnp.bitwise_count	core	counted	$\text{numel}(\text{output})$
fnp.bitwise_left_shift	core	counted	$\text{numel}(\text{output})$
fnp.bitwise_not	core	counted	$\text{numel}(\text{output})$
fnp.bitwise_or	core	counted	$\text{numel}(\text{output})$
fnp.bitwise_right_shift	core	counted	$\text{numel}(\text{output})$
fnp.bitwise_xor	core	counted	$\text{numel}(\text{output})$
fnp.blackman	core	custom	$40n$
fnp.block	core	custom	per-operation
fnp.bmat	core	custom	per-operation
fnp.broadcast_arrays	core	free	0
fnp.broadcast_shapes	core	custom	per-operation
fnp.broadcast_to	core	free	0
fnp.can_cast	core	free	0
fnp.cbrt	core	counted	16× $\text{numel}(\text{output})$
fnp.ceil	core	counted	$\text{numel}(\text{output})$
fnp.choose	core	custom	4×per-operation
fnp.clip	core	custom	$\max(n_{\text{bounds}}, 1) \cdot \text{numel}(\text{output})$
fnp.column_stack	core	custom	per-operation
fnp.common_type	core	free	0
fnp.compress	core	custom	per-operation
fnp.concatenate	core	custom	per-operation
fnp.conj	core	counted	$\text{numel}(\text{output})$
fnp.conjugate	core	counted	$\text{numel}(\text{output})$
fnp.convolve	core	custom	full: 2nm - n - m; valid: (2min - 1)(max - min + 1); same: variable-length dot sum
fnp.copy	core	custom	per-operation
fnp.copysign	core	counted	$\text{numel}(\text{output})$
fnp.copyto	core	custom	per-operation
fnp.corrcoef	core	custom	$2f^2 s + 2fs + 2f^2 + f$
fnp.correlate	core	custom	full: 2nm - n - m + 1; valid: (2min - 1)(max - min + 1); same: variable-length dot sum
fnp.cos	core	counted	16× $\text{numel}(\text{output})$
fnp.cosh	core	counted	16× $\text{numel}(\text{output})$
fnp.count_nonzero	core	counted	$\text{numel}(\text{input})$
fnp.cov	core	custom	$2f^2 s + 2fs$
fnp.cross	core	custom	$\text{numel}(\text{output})$
fnp.cumprod	core	counted	$\text{numel}(\text{input})$
fnp.cumsum	core	counted	$\text{numel}(\text{input})$
fnp.cumulative_prod	core	counted	$\text{numel}(\text{input})$
fnp.cumulative_sum	core	counted	$\text{numel}(\text{input})$
fnp.degrees	core	counted	$\text{numel}(\text{output})$
fnp.delete	core	custom	per-operation
fnp.diag	core	custom	per-operation
fnp.diag_indices	core	custom	per-operation
fnp.diag_indices_from	core	custom	per-operation
fnp.diagflat	core	custom	per-operation
fnp.diagonal	core	custom	0×per-operation
fnp.diff	core	custom	$\prod_{\text{other}} (nL - n(n+1)/2)$
fnp.digitize	core	custom	4×per-operation
fnp.divide	core	counted	$\text{numel}(\text{output})$
fnp.dot	core	custom	$2 \cdot m \cdot k \cdot n - m \cdot n$
fnp.dsplit	core	free	0
fnp.dstack	core	custom	per-operation
fnp.ediff1d	core	custom	$\text{numel}(\text{input}) - 1$
fnp.einsum	core	custom	$\text{op\_factor} \cdot \prod_i d_i$
fnp.einsum_path	core	custom	$1$
fnp.empty	core	free	0
fnp.empty_like	core	free	0
fnp.equal	core	counted	$\text{numel}(\text{output})$
fnp.exp	core	counted	16× $\text{numel}(\text{output})$
fnp.exp2	core	counted	16× $\text{numel}(\text{output})$
fnp.expand_dims	core	free	0
fnp.expm1	core	counted	16× $\text{numel}(\text{output})$
fnp.extract	core	custom	per-operation
fnp.eye	core	custom	per-operation
fnp.fabs	core	counted	$\text{numel}(\text{output})$
fnp.fft.fft	fft	custom	5n * ceil(log2(n)) for length > 1; length 1: 2 per batch item before dtype rates/weight
fnp.fft.fft2	fft	custom	sum of executed 1-D stage costs at each intermediate shape; each length-one stage: 2*batch_i before dtype rates/weight
fnp.fft.fftfreq	fft	custom	per-operation
fnp.fft.fftn	fft	custom	sum of executed 1-D stage costs at each intermediate shape; each length-one stage: 2*batch_i before dtype rates/weight
fnp.fft.fftshift	fft	custom	per-operation
fnp.fft.hfft	fft	custom	5n * ceil(log2(n)) for length > 1; length 1: 2 per batch item before dtype rates/weight
fnp.fft.ifft	fft	custom	5n * ceil(log2(n)) for length > 1; length 1: 2 per batch item before dtype rates/weight
fnp.fft.ifft2	fft	custom	sum of executed 1-D stage costs at each intermediate shape; each length-one stage: 2*batch_i before dtype rates/weight
fnp.fft.ifftn	fft	custom	sum of executed 1-D stage costs at each intermediate shape; each length-one stage: 2*batch_i before dtype rates/weight
fnp.fft.ifftshift	fft	custom	per-operation
fnp.fft.ihfft	fft	custom	5n * ceil(log2(n)) for length > 1; length 1: 2 per batch item before dtype rates/weight
fnp.fft.irfft	fft	custom	5(n/2) * ceil(log2(n)) for length > 1; length 1: 2 per batch item before dtype rates/weight
fnp.fft.irfft2	fft	custom	sum of executed 1-D stage costs at each intermediate shape; each length-one stage: 2*batch_i before dtype rates/weight
fnp.fft.irfftn	fft	custom	sum of executed 1-D stage costs at each intermediate shape; each length-one stage: 2*batch_i before dtype rates/weight
fnp.fft.rfft	fft	custom	5(n/2) * ceil(log2(n)) for length > 1; length 1: 2 per batch item before dtype rates/weight
fnp.fft.rfft2	fft	custom	sum of executed 1-D stage costs at each intermediate shape; each length-one stage: 2*batch_i before dtype rates/weight
fnp.fft.rfftfreq	fft	custom	per-operation
fnp.fft.rfftn	fft	custom	sum of executed 1-D stage costs at each intermediate shape; each length-one stage: 2*batch_i before dtype rates/weight
fnp.fill_diagonal	core	custom	per-operation
fnp.flatnonzero	core	custom	per-operation
fnp.flip	core	free	0
fnp.fliplr	core	free	0
fnp.flipud	core	free	0
fnp.float_power	core	counted	16× $\text{numel}(\text{output})$
fnp.floor	core	counted	$\text{numel}(\text{output})$
fnp.floor_divide	core	counted	16× $\text{numel}(\text{output})$
fnp.fmax	core	counted	$\text{numel}(\text{output})$
fnp.fmin	core	counted	$\text{numel}(\text{output})$
fnp.fmod	core	counted	16× $\text{numel}(\text{output})$
fnp.frexp	core	counted	$2 \cdot \text{numel}(\text{output})$
fnp.from_dlpack	core	free	0
fnp.frombuffer	core	free	0
fnp.fromfunction	core	custom	per-operation
fnp.fromiter	core	custom	per-operation
fnp.full	core	custom	per-operation
fnp.full_like	core	custom	per-operation
fnp.gcd	core	counted	16× $\text{numel}(\text{output})$
fnp.geomspace	core	custom	16×per-operation
fnp.getitem	core	custom	per-operation
fnp.gradient	core	custom	$\sum_{\text{ax}} \left(2S + [\text{edge\_order} \ne 1]\, 6S/L\right)$
fnp.greater	core	counted	$\text{numel}(\text{output})$
fnp.greater_equal	core	counted	$\text{numel}(\text{output})$
fnp.hamming	core	custom	$18n$
fnp.hanning	core	custom	$18n$
fnp.heaviside	core	counted	$\text{numel}(\text{output})$
fnp.histogram	core	custom	4×binning/estimator at weight 4 + int/string edge construction as linspace at weight 1 + density arithmetic at sub-op weights; each term uses its own dtype
fnp.histogram2d	core	custom	4× $\max(n\sum_i\lceil\log_2 b_i\rceil,1)$
fnp.histogram_bin_edges	core	custom	4×input/estimator term at weight 4 + int/string bins+1 edges as linspace at weight 1; array edges add no construction term
fnp.histogramdd	core	custom	4× $\max(n\sum_i\lceil\log_2 b_i\rceil,1)$
fnp.hsplit	core	free	0
fnp.hstack	core	custom	per-operation
fnp.hypot	core	counted	16× $\text{numel}(\text{output})$
fnp.i0	core	counted	16× $\text{numel}(\text{output})$
fnp.identity	core	custom	per-operation
fnp.imag	core	free	0
fnp.in1d	core	custom	per-operation
fnp.indices	core	custom	per-operation
fnp.inner	core	custom	$(2K - 1) \cdot M$
fnp.insert	core	custom	per-operation
fnp.interp	core	custom	3m+mceil(log2(p)); period= adds 16(m+p)+4p*ceil(log2(p))+8p+2(p+2)+2 at sub-op weights, searching p+2 edges; m=numel(x), p=numel(xp); logarithmic search/sort counts are clamped to at least 1
fnp.intersect1d	core	custom	4×per-operation
fnp.invert	core	counted	$\text{numel}(\text{output})$
fnp.is_symmetric	core	custom	per-operation
fnp.isclose	core	counted	$\text{numel}(\text{output})$
fnp.iscomplex	core	counted	$\text{numel}(\text{output})$
fnp.iscomplexobj	core	free	0
fnp.isdtype	core	free	0
fnp.isfinite	core	custom	per-operation
fnp.isfortran	core	free	0
fnp.isin	core	custom	per-operation
fnp.isinf	core	custom	per-operation
fnp.isnan	core	custom	per-operation
fnp.isneginf	core	counted	$\text{numel}(\text{output})$
fnp.isposinf	core	counted	$\text{numel}(\text{output})$
fnp.isreal	core	counted	$\text{numel}(\text{output})$
fnp.isrealobj	core	free	0
fnp.isscalar	core	free	0
fnp.issubdtype	core	free	0
fnp.iterable	core	free	0
fnp.ix_	core	custom	per-operation
fnp.kaiser	core	custom	$23n$
fnp.kron	core	custom	$m_1 m_2 \cdot n_1 n_2$
fnp.lcm	core	counted	16× $\text{numel}(\text{output})$
fnp.ldexp	core	counted	$\text{numel}(\text{output})$
fnp.left_shift	core	counted	$\text{numel}(\text{output})$
fnp.less	core	counted	$\text{numel}(\text{output})$
fnp.less_equal	core	counted	$\text{numel}(\text{output})$
fnp.lexsort	core	custom	4×per-operation
fnp.linalg.cholesky	linalg	custom	$n^3$
fnp.linalg.cond	linalg	custom	$m \cdot n \cdot \min(m,n)$
fnp.linalg.cross	linalg	custom	delegates to flops.cross
fnp.linalg.det	linalg	custom	$n^3$
fnp.linalg.diagonal	linalg	free	0
fnp.linalg.eig	linalg	custom	$n^3$
fnp.linalg.eigh	linalg	custom	$n^3$
fnp.linalg.eigvals	linalg	custom	$n^3$
fnp.linalg.eigvalsh	linalg	custom	$n^3$
fnp.linalg.inv	linalg	custom	$n^3$
fnp.linalg.lstsq	linalg	custom	$m \cdot n \cdot \min(m,n)$
fnp.linalg.matmul	linalg	custom	delegates to flops.matmul
fnp.linalg.matrix_norm	linalg	custom	depends on ord
fnp.linalg.matrix_power	linalg	custom	$\lfloor\log_2 k\rfloor \cdot n^3$
fnp.linalg.matrix_rank	linalg	custom	values-only SVD per matrix + b comparisons per broadcast (matrix,tol/rtol) pair; b=min(m,n)
fnp.linalg.matrix_transpose	linalg	free	0
fnp.linalg.multi_dot	linalg	custom	optimal chain cost
fnp.linalg.norm	linalg	custom	depends on ord
fnp.linalg.outer	linalg	custom	delegates to flops.outer
fnp.linalg.pinv	linalg	custom	$m \cdot n \cdot \min(m,n)$
fnp.linalg.qr	linalg	custom	$m \cdot n \cdot \min(m,n)$
fnp.linalg.slogdet	linalg	custom	$n^3$
fnp.linalg.solve	linalg	custom	$n^3$
fnp.linalg.svd	linalg	custom	top-k vectors: min(4mnk+6(m+n)k^2+20k^3,6ab^2+20b^3); top-k values: min(4mnk+2(m+n)k^2+2k^3,2ab^2+2b^3); full costs and rectangular full-vector premium: see notes
fnp.linalg.svdvals	linalg	custom	full: 2ab^2+2b^3; top-k: min(4mnk+2(m+n)k^2+2k^3,2ab^2+2b^3); a=max(m,n), b=min(m,n)
fnp.linalg.tensordot	linalg	custom	delegates to flops.tensordot
fnp.linalg.tensorinv	linalg	custom	$n^3$
fnp.linalg.tensorsolve	linalg	custom	$n^3$
fnp.linalg.trace	linalg	custom	$n$
fnp.linalg.vecdot	linalg	custom	delegates to fnp.vecdot, including selected axes and batches
fnp.linalg.vector_norm	linalg	custom	$n$
fnp.linspace	core	custom	per-operation
fnp.load	core	free	0
fnp.log	core	counted	16× $\text{numel}(\text{output})$
fnp.log10	core	counted	16× $\text{numel}(\text{output})$
fnp.log1p	core	counted	16× $\text{numel}(\text{output})$
fnp.log2	core	counted	16× $\text{numel}(\text{output})$
fnp.logaddexp	core	counted	16× $\text{numel}(\text{output})$
fnp.logaddexp2	core	counted	16× $\text{numel}(\text{output})$
fnp.logical_and	core	counted	$\text{numel}(\text{output})$
fnp.logical_not	core	counted	$\text{numel}(\text{output})$
fnp.logical_or	core	counted	$\text{numel}(\text{output})$
fnp.logical_xor	core	counted	$\text{numel}(\text{output})$
fnp.logspace	core	custom	16×per-operation
fnp.mask_indices	core	custom	per-operation
fnp.matmul	core	custom	$2 \cdot m \cdot k \cdot n - m \cdot n$
fnp.matrix_transpose	core	free	0
fnp.matvec	core	counted	$(2K-1)M$
fnp.max	core	counted	$\text{numel}(\text{input})$
fnp.maximum	core	counted	$\text{numel}(\text{output})$
fnp.may_share_memory	core	free	0
fnp.mean	core	counted	$\text{numel}(\text{input})$
fnp.median	core	counted	$\text{numel}(\text{input})$
fnp.meshgrid	core	custom	per-operation
fnp.min	core	counted	$\text{numel}(\text{input})$
fnp.min_scalar_type	core	free	0
fnp.minimum	core	counted	$\text{numel}(\text{output})$
fnp.mintypecode	core	free	0
fnp.mod	core	counted	16× $\text{numel}(\text{output})$
fnp.modf	core	counted	$2 \cdot \text{numel}(\text{output})$
fnp.moveaxis	core	free	0
fnp.multiply	core	counted	$\text{numel}(\text{output})$
fnp.nan_to_num	core	counted	$\text{numel}(\text{output})$
fnp.nanargmax	core	counted	$\text{numel}(\text{input})$
fnp.nanargmin	core	counted	$\text{numel}(\text{input})$
fnp.nancumprod	core	counted	$\text{numel}(\text{input})$
fnp.nancumsum	core	counted	$\text{numel}(\text{input})$
fnp.nanmax	core	counted	$\text{numel}(\text{input})$
fnp.nanmean	core	counted	$\text{numel}(\text{input})$
fnp.nanmedian	core	counted	$\text{numel}(\text{input})$
fnp.nanmin	core	counted	$\text{numel}(\text{input})$
fnp.nanpercentile	core	counted	$\text{numel}(\text{input})$
fnp.nanprod	core	counted	$\text{numel}(\text{input})$
fnp.nanquantile	core	counted	$\text{numel}(\text{input})$
fnp.nanstd	core	counted	$\text{numel}(\text{input})$
fnp.nansum	core	counted	$\text{numel}(\text{input})$
fnp.nanvar	core	counted	$\text{numel}(\text{input})$
fnp.ndim	core	free	0
fnp.negative	core	counted	$\text{numel}(\text{output})$
fnp.nextafter	core	counted	$\text{numel}(\text{output})$
fnp.nonzero	core	custom	per-operation
fnp.not_equal	core	counted	$\text{numel}(\text{output})$
fnp.ones	core	custom	per-operation
fnp.ones_like	core	custom	per-operation
fnp.outer	core	custom	$m \cdot n$
fnp.packbits	core	custom	per-operation
fnp.pad	core	custom	per-operation
fnp.partition	core	custom	4×per-operation
fnp.percentile	core	counted	$\text{numel}(\text{input})$
fnp.permute_dims	core	free	0
fnp.piecewise	core	custom	per-operation
fnp.place	core	custom	per-operation
fnp.poly	core	custom	$n^2$
fnp.polyadd	core	custom	$\text{numel}(\text{polyadd}(a_1, a_2))$
fnp.polyder	core	custom	$n$
fnp.polydiv	core	custom	$n_1 \cdot n_2$
fnp.polyfit	core	custom	mdeg+lstsq_cost(m,p,ncols); cov without full=True adds matmul_cost(p,m,p)+inv_cost(p)+p(p+1)//2+p^2+numel(covariance), plus one residual division per scaled covariance slice; p=deg+1
fnp.polyint	core	custom	$n$
fnp.polymul	core	custom	$n_1 \cdot n_2$
fnp.polysub	core	custom	$\text{numel}(\text{polysub}(a_1, a_2))$
fnp.polyval	core	custom	$2 \cdot m \cdot \text{deg}$
fnp.positive	core	counted	$\text{numel}(\text{output})$
fnp.power	core	counted	16× $\text{numel}(\text{output})$
fnp.prod	core	counted	$\text{numel}(\text{input})$
fnp.promote_types	core	free	0
fnp.ptp	core	counted	$\text{numel}(\text{input})$
fnp.put	core	custom	per-operation
fnp.put_along_axis	core	custom	per-operation
fnp.putmask	core	custom	per-operation
fnp.quantile	core	counted	$\text{numel}(\text{input})$
fnp.radians	core	counted	$\text{numel}(\text{output})$
fnp.random.Generator.beta	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.binomial	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.bit_generator	random	free	0
fnp.random.Generator.bytes	random	counted	$\text{length}$
fnp.random.Generator.chisquare	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.choice	random	counted	4× $\text{numel}(\text{output})$ if replace, else $n \cdot \lceil \log_2 n \rceil$
fnp.random.Generator.dirichlet	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.exponential	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.f	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.gamma	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.geometric	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.gumbel	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.hypergeometric	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.integers	random	counted	$\text{numel}(\text{output})$
fnp.random.Generator.laplace	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.logistic	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.lognormal	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.logseries	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.multinomial	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.multivariate_hypergeometric	random	counted	16×per-method
fnp.random.Generator.multivariate_normal	random	counted	per-method
fnp.random.Generator.negative_binomial	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.noncentral_chisquare	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.noncentral_f	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.normal	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.pareto	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.permutation	random	counted	4× $\text{shape}[\text{axis}]$
fnp.random.Generator.permuted	random	counted	4× $\text{numel}(\text{input})$
fnp.random.Generator.poisson	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.power	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.random	random	counted	$\text{numel}(\text{output})$
fnp.random.Generator.rayleigh	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.shuffle	random	counted	4× $\text{shape}[\text{axis}]$
fnp.random.Generator.spawn	random	free	0
fnp.random.Generator.standard_cauchy	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.standard_exponential	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.standard_gamma	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.standard_normal	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.standard_t	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.triangular	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.uniform	random	counted	per-method
fnp.random.Generator.vonmises	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.wald	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.weibull	random	counted	16× $\text{numel}(\text{output})$
fnp.random.Generator.zipf	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.beta	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.binomial	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.bytes	random	counted	$\text{length}$
fnp.random.RandomState.chisquare	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.choice	random	counted	4× $\text{numel}(\text{output})$ if replace, else $n \cdot \lceil \log_2 n \rceil$
fnp.random.RandomState.dirichlet	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.exponential	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.f	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.gamma	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.geometric	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.get_state	random	free	0
fnp.random.RandomState.gumbel	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.hypergeometric	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.laplace	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.logistic	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.lognormal	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.logseries	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.multinomial	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.multivariate_normal	random	counted	per-method
fnp.random.RandomState.negative_binomial	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.noncentral_chisquare	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.noncentral_f	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.normal	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.pareto	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.permutation	random	counted	4× $\text{shape}[\text{axis}]$
fnp.random.RandomState.poisson	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.power	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.rand	random	counted	$\text{numel}(\text{output})$
fnp.random.RandomState.randint	random	counted	$\text{numel}(\text{output})$
fnp.random.RandomState.randn	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.random	random	counted	$\text{numel}(\text{output})$
fnp.random.RandomState.random_integers	random	counted	$\text{numel}(\text{output})$
fnp.random.RandomState.random_sample	random	counted	$\text{numel}(\text{output})$
fnp.random.RandomState.rayleigh	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.seed	random	free	0
fnp.random.RandomState.set_state	random	free	0
fnp.random.RandomState.shuffle	random	counted	4× $\text{shape}[\text{axis}]$
fnp.random.RandomState.standard_cauchy	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.standard_exponential	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.standard_gamma	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.standard_normal	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.standard_t	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.tomaxint	random	counted	$\text{numel}(\text{output})$
fnp.random.RandomState.triangular	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.uniform	random	counted	per-method
fnp.random.RandomState.vonmises	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.wald	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.weibull	random	counted	16× $\text{numel}(\text{output})$
fnp.random.RandomState.zipf	random	counted	16× $\text{numel}(\text{output})$
fnp.random.beta	random	custom	16×per-operation
fnp.random.binomial	random	custom	16×per-operation
fnp.random.bytes	random	custom	per-operation
fnp.random.chisquare	random	custom	16×per-operation
fnp.random.choice	random	custom	4×per-operation
fnp.random.default_rng	random	free	0
fnp.random.dirichlet	random	custom	16×per-operation
fnp.random.exponential	random	custom	16×per-operation
fnp.random.f	random	custom	16×per-operation
fnp.random.gamma	random	custom	16×per-operation
fnp.random.geometric	random	custom	16×per-operation
fnp.random.get_state	random	free	0
fnp.random.gumbel	random	custom	16×per-operation
fnp.random.hypergeometric	random	custom	16×per-operation
fnp.random.laplace	random	custom	16×per-operation
fnp.random.logistic	random	custom	16×per-operation
fnp.random.lognormal	random	custom	16×per-operation
fnp.random.logseries	random	custom	16×per-operation
fnp.random.multinomial	random	custom	16×per-operation
fnp.random.multivariate_normal	random	custom	per-operation
fnp.random.negative_binomial	random	custom	16×per-operation
fnp.random.noncentral_chisquare	random	custom	16×per-operation
fnp.random.noncentral_f	random	custom	16×per-operation
fnp.random.normal	random	custom	16×per-operation
fnp.random.pareto	random	custom	16×per-operation
fnp.random.permutation	random	custom	4×per-operation
fnp.random.poisson	random	custom	16×per-operation
fnp.random.power	random	custom	16×per-operation
fnp.random.rand	random	custom	per-operation
fnp.random.randint	random	custom	per-operation
fnp.random.randn	random	custom	16×per-operation
fnp.random.random	random	custom	per-operation
fnp.random.random_sample	random	custom	per-operation
fnp.random.rayleigh	random	custom	16×per-operation
fnp.random.sample	random	custom	per-operation
fnp.random.seed	random	free	0
fnp.random.set_state	random	free	0
fnp.random.shuffle	random	custom	4×per-operation
fnp.random.standard_cauchy	random	custom	16×per-operation
fnp.random.standard_exponential	random	custom	16×per-operation
fnp.random.standard_gamma	random	custom	16×per-operation
fnp.random.standard_normal	random	custom	16×per-operation
fnp.random.standard_t	random	custom	16×per-operation
fnp.random.symmetric	random	custom	per-operation
fnp.random.triangular	random	custom	16×per-operation
fnp.random.uniform	random	custom	per-operation
fnp.random.vonmises	random	custom	16×per-operation
fnp.random.wald	random	custom	16×per-operation
fnp.random.weibull	random	custom	16×per-operation
fnp.random.zipf	random	custom	16×per-operation
fnp.ravel	core	custom	per-operation
fnp.ravel_multi_index	core	custom	per-operation
fnp.real	core	free	0
fnp.real_if_close	core	counted	$\text{numel}(\text{output})$
fnp.reciprocal	core	counted	$\text{numel}(\text{output})$
fnp.remainder	core	counted	16× $\text{numel}(\text{output})$
fnp.repeat	core	custom	per-operation
fnp.require	core	custom	per-operation
fnp.reshape	core	custom	per-operation
fnp.resize	core	custom	per-operation
fnp.result_type	core	free	0
fnp.right_shift	core	counted	$\text{numel}(\text{output})$
fnp.rint	core	counted	$\text{numel}(\text{output})$
fnp.roll	core	custom	per-operation
fnp.rollaxis	core	free	0
fnp.roots	core	custom	$10n^3$
fnp.rot90	core	free	0
fnp.save	core	custom	per-operation
fnp.savez	core	custom	per-operation
fnp.savez_compressed	core	custom	per-operation
fnp.searchsorted	core	custom	4×per-operation
fnp.select	core	custom	per-operation
fnp.setdiff1d	core	custom	4×per-operation
fnp.setxor1d	core	custom	4×per-operation
fnp.shape	core	free	0
fnp.shares_memory	core	free	0
fnp.sign	core	counted	$\text{numel}(\text{output})$
fnp.signbit	core	counted	$\text{numel}(\text{output})$
fnp.sin	core	counted	16× $\text{numel}(\text{output})$
fnp.sinc	core	counted	16× $\text{numel}(\text{output})$
fnp.sinh	core	counted	16× $\text{numel}(\text{output})$
fnp.size	core	free	0
fnp.sort	core	custom	4×per-operation
fnp.sort_complex	core	custom	per-operation
fnp.spacing	core	counted	$\text{numel}(\text{output})$
fnp.split	core	free	0
fnp.sqrt	core	counted	$\text{numel}(\text{output})$
fnp.square	core	counted	$\text{numel}(\text{output})$
fnp.squeeze	core	free	0
fnp.stack	core	custom	per-operation
flops.stats.cauchy.cdf	stats	custom	$5n$
flops.stats.cauchy.pdf	stats	custom	$6n$
flops.stats.cauchy.ppf	stats	custom	$5n$
flops.stats.expon.cdf	stats	custom	$5n$
flops.stats.expon.pdf	stats	custom	$5n$
flops.stats.expon.ppf	stats	custom	$5n$
flops.stats.laplace.cdf	stats	custom	$5n$
flops.stats.laplace.pdf	stats	custom	$5n$
flops.stats.laplace.ppf	stats	custom	$5n$
flops.stats.logistic.cdf	stats	custom	$5n$
flops.stats.logistic.pdf	stats	custom	$8n$
flops.stats.logistic.ppf	stats	custom	$5n$
flops.stats.lognorm.cdf	stats	custom	$25n$
flops.stats.lognorm.pdf	stats	custom	$15n$
flops.stats.lognorm.ppf	stats	custom	$45n$
flops.stats.norm.cdf	stats	custom	$20n$
flops.stats.norm.pdf	stats	custom	$10n$
flops.stats.norm.ppf	stats	custom	$40n$
flops.stats.truncnorm.cdf	stats	custom	$30n$
flops.stats.truncnorm.pdf	stats	custom	$30n$
flops.stats.truncnorm.ppf	stats	custom	$50n$
flops.stats.uniform.cdf	stats	custom	$3n$
flops.stats.uniform.pdf	stats	custom	$3n$
flops.stats.uniform.ppf	stats	custom	$3n$
fnp.std	core	counted	$4N+M$
fnp.subtract	core	counted	$\text{numel}(\text{output})$
fnp.sum	core	counted	$\text{numel}(\text{input})$
fnp.swapaxes	core	free	0
fnp.symmetrize	core	custom	per-operation
fnp.take	core	custom	4×per-operation
fnp.take_along_axis	core	custom	4×per-operation
fnp.tan	core	counted	16× $\text{numel}(\text{output})$
fnp.tanh	core	counted	16× $\text{numel}(\text{output})$
fnp.tensordot	core	custom	$2 \cdot K \cdot \text{out} - \text{out}$
fnp.tile	core	custom	per-operation
fnp.trace	core	custom	per-operation
fnp.transpose	core	free	0
fnp.trapezoid	core	custom	$4\,\mathrm{numel}(y)K$
fnp.tri	core	custom	per-operation
fnp.tril	core	custom	per-operation
fnp.tril_indices	core	custom	per-operation
fnp.tril_indices_from	core	custom	per-operation
fnp.trim_zeros	core	custom	per-operation
fnp.triu	core	custom	per-operation
fnp.triu_indices	core	custom	per-operation
fnp.triu_indices_from	core	custom	per-operation
fnp.true_divide	core	counted	$\text{numel}(\text{output})$
fnp.trunc	core	counted	$\text{numel}(\text{output})$
fnp.typename	core	free	0
fnp.union1d	core	custom	4×per-operation
fnp.unique	core	custom	4×per-operation
fnp.unique_all	core	custom	4×per-operation
fnp.unique_counts	core	custom	4×per-operation
fnp.unique_inverse	core	custom	4×per-operation
fnp.unique_values	core	custom	4×per-operation
fnp.unpackbits	core	custom	per-operation
fnp.unravel_index	core	custom	per-operation
fnp.unstack	core	free	0
fnp.unwrap	core	custom	$13 \cdot \text{numel}(\text{input})$
fnp.vander	core	custom	per-operation
fnp.var	core	counted	$4N$
fnp.vdot	core	custom	$2n - 1$
fnp.vecdot	core	counted	$(2K-1)M$
fnp.vecmat	core	counted	$(2K-1)M$
fnp.vsplit	core	free	0
fnp.vstack	core	custom	per-operation
fnp.where	core	custom	4×per-operation
fnp.zeros	core	free	0
fnp.zeros_like	core	free	0