NumSharp vs NumPy Performance

Baseline: NumPy · measured across all array sizes (per-(op, dtype, N))

Ratio = NumPy ÷ NumSharp → Higher is better (>1.0× = NumSharp faster)

%NumPy🕐 = NumSharp ÷ NumPy × 100 = the share of NumPy's time NumSharp uses (30% = NumSharp takes only 30% of the time NumPy would; <100% = faster).

	Status	Ratio	%NumPy🕐	Meaning
✅	Faster	≥1.0×	≤100%	NumSharp ≥ NumPy speed
🟡	Close	0.5–1.0×	100–200%	within 2× slower
🟠	Slower	0.2–0.5×	200–500%	optimization target
🔴	Slow	<0.2×	>500%	priority fix
▫	Negligible	<1µs / >20×	—	too fast to compare — excluded from rankings
⚪	Pending	-	—	C# benchmark not run

---

Summary: 1851 ops | ✅ 792 | 🟡 357 | 🟠 177 | 🔴 72 | ▫ 384 | ⚪ 69

Summary by size

N	ops	✅ faster	🟡 close	🟠 slower	🔴 much	▫ negl	⚪ n/a	geomean	%NP🕐
500	1	0	0	0	0	0	1	-	-
900	3	0	0	0	0	0	3	-	-
1,000	615	115	69	27	13	366	25	1.14x	87%
50,000	1	0	0	0	0	0	1	-	-
100,000	615	280	138	119	48	9	21	0.90x	111%
5,000,000	1	0	0	0	0	0	1	-	-
10,000,000	615	397	150	31	11	9	17	1.26x	80%

---

🏆 Top 15 Best (NumSharp fastest vs NumPy)

Ranked over 1398 credible comparisons (both sides ≥1µs, within 20×); 384 negligible rows excluded as non-comparable (▫). Ratio = NumPy ÷ NumSharp — above 1.0× = NumSharp faster · %NumPy🕐 = share of NumPy's time NumSharp uses.

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
✅	np.dot(a, b) (float64)	float64	100,000	0.099	0.007	14.17×	7%
✅	np.prod (float64)	float64	100,000	2.336	0.170	13.75×	7%
✅	np.nanstd(a) (float64)	float64	1,000	0.020	0.002	13.33×	8%
✅	np.nanstd(a) (float16)	float16	1,000	0.034	0.003	12.50×	8%
✅	np.percentile(a, 50) (float64)	float64	1,000	0.030	0.003	12.18×	8%
✅	np.nanquantile(a, 0.5) (float32)	float32	1,000	0.028	0.002	11.86×	8%
✅	np.nanvar(a) (float16)	float16	1,000	0.032	0.003	11.67×	9%
✅	np.nanpercentile(a, 50) (float32)	float32	1,000	0.027	0.002	11.51×	9%
✅	np.nanpercentile(a, 50) (float64)	float64	1,000	0.030	0.003	11.42×	9%
✅	np.nanvar(a) (float64)	float64	1,000	0.017	0.002	11.42×	9%
✅	np.nanstd(a) (float32)	float32	1,000	0.019	0.002	11.39×	9%
✅	np.nanvar(a) (float32)	float32	1,000	0.019	0.002	11.19×	9%
✅	np.sum axis=0 (int8)	int8	10,000,000	4.456	0.399	11.16×	9%
✅	np.sum axis=0 (int8)	int8	100,000	0.047	0.004	10.78×	9%
✅	np.percentile(a, 50) (float32)	float32	1,000	0.024	0.002	10.51×	10%

🔻 Top 15 Worst (Optimization priorities)

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
🔴	np.left_shift(a, 2) (int32)	int32	100,000	0.019	0.390	0.049×	2035%
🔴	np.left_shift(a, 2) (uint64)	uint64	100,000	0.020	0.392	0.050×	1992%
🔴	np.left_shift(a, 2) (int64)	int64	100,000	0.020	0.392	0.051×	1945%
🔴	np.left_shift(a, 2) (uint32)	uint32	100,000	0.020	0.391	0.051×	1944%
🔴	np.right_shift(a, 2) (uint64)	uint64	100,000	0.021	0.393	0.052×	1908%
🔴	np.right_shift(a, 2) (uint32)	uint32	100,000	0.020	0.390	0.052×	1930%
🔴	np.zeros_like (float64)	float64	1,000	0.001	0.015	0.068×	1471%
🔴	np.right_shift(a, 2) (int64)	int64	100,000	0.029	0.393	0.074×	1357%
🔴	np.right_shift(a, 2) (int32)	int32	100,000	0.029	0.390	0.074×	1353%
🔴	np.right_shift(a, 2) (uint16)	uint16	100,000	0.029	0.387	0.074×	1355%
🔴	np.left_shift(a, 2) (int16)	int16	100,000	0.028	0.381	0.074×	1350%
🔴	np.sum (float64)	float64	100,000	0.016	0.214	0.074×	1345%
🔴	np.left_shift(a, 2) (uint8)	uint8	100,000	0.028	0.375	0.075×	1330%
🔴	np.left_shift(a, 2) (uint16)	uint16	100,000	0.029	0.388	0.076×	1322%
🔴	np.right_shift(a, 2) (uint8)	uint8	100,000	0.029	0.376	0.076×	1315%

---

Arithmetic

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
🟡	a % 7 (literal) (float32)	float32	1,000	0.0142	0.0165	0.86×	116%
🟡	a % 7 (literal) (float32)	float32	100,000	1.6193	1.8327	0.88×	113%
🟡	a % 7 (literal) (float32)	float32	10,000,000	165.1953	184.8168	0.89×	112%
🟡	a % 7 (literal) (float64)	float64	1,000	0.0113	0.0189	0.60×	168%
🟡	a % 7 (literal) (float64)	float64	100,000	1.4311	1.6867	0.85×	118%
🟡	a % 7 (literal) (float64)	float64	10,000,000	150.3030	165.2969	0.91×	110%
🟡	a % 7 (literal) (int32)	int32	1,000	0.0022	0.0042	0.54×	187%
🟡	a % 7 (literal) (int32)	int32	100,000	0.3976	0.6615	0.60×	166%
🟡	a % 7 (literal) (int32)	int32	10,000,000	46.0503	67.4094	0.68×	146%
🟡	a % 7 (literal) (int64)	int64	1,000	0.0043	0.0063	0.69×	145%
🟡	a % 7 (literal) (int64)	int64	100,000	0.4006	0.6741	0.59×	168%
🟡	a % 7 (literal) (int64)	int64	10,000,000	50.6103	73.6394	0.69×	146%
✅	a % b (element-wise) (float32)	float32	1,000	0.0119	0.0117	1.02×	98%
🟡	a % b (element-wise) (float32)	float32	100,000	1.4839	1.5770	0.94×	106%
🟡	a % b (element-wise) (float32)	float32	10,000,000	153.9273	163.2286	0.94×	106%
✅	a % b (element-wise) (float64)	float64	1,000	0.0097	0.0091	1.06×	94%
🟡	a % b (element-wise) (float64)	float64	100,000	1.2816	1.4386	0.89×	112%
🟡	a % b (element-wise) (float64)	float64	10,000,000	136.3744	147.5928	0.92×	108%
🟡	a % b (element-wise) (int32)	int32	1,000	0.0020	0.0033	0.62×	162%
🟡	a % b (element-wise) (int32)	int32	100,000	0.3675	0.5980	0.61×	163%
🟡	a % b (element-wise) (int32)	int32	10,000,000	42.8057	60.0063	0.71×	140%
🟡	a % b (element-wise) (int64)	int64	1,000	0.0035	0.0039	0.91×	110%
🟡	a % b (element-wise) (int64)	int64	100,000	0.3695	0.5992	0.62×	162%
🟡	a % b (element-wise) (int64)	int64	10,000,000	49.1915	67.0192	0.73×	136%
🟠	a * 2 (literal) (complex128)	complex128	1,000	0.0011	0.0040	0.28×	357%
✅	a * 2 (literal) (complex128)	complex128	100,000	0.2823	0.2208	1.28×	78%
✅	a * 2 (literal) (complex128)	complex128	10,000,000	31.0176	25.6395	1.21×	83%
🟡	a * 2 (literal) (float16)	float16	1,000	0.0046	0.0062	0.74×	135%
🟡	a * 2 (literal) (float16)	float16	100,000	0.2800	0.4677	0.60×	167%
🟡	a * 2 (literal) (float16)	float16	10,000,000	30.4948	46.4060	0.66×	152%
▫	a * 2 (literal) (float32)	float32	1,000	0.0007	0.0037	0.20×	504%
🟠	a * 2 (literal) (float32)	float32	100,000	0.0063	0.0282	0.22×	449%
✅	a * 2 (literal) (float32)	float32	10,000,000	7.8622	5.1811	1.52×	66%
▫	a * 2 (literal) (float64)	float64	1,000	0.0008	0.0047	0.17×	604%
🟠	a * 2 (literal) (float64)	float64	100,000	0.0118	0.0573	0.20×	487%
✅	a * 2 (literal) (float64)	float64	10,000,000	15.8476	13.6947	1.16×	86%
▫	a * 2 (literal) (int16)	int16	1,000	0.0010	0.0034	0.29×	338%
✅	a * 2 (literal) (int16)	int16	100,000	0.0216	0.0203	1.06×	94%
✅	a * 2 (literal) (int16)	int16	10,000,000	4.2690	2.4718	1.73×	58%
▫	a * 2 (literal) (int32)	int32	1,000	0.0010	0.0025	0.39×	256%
🟡	a * 2 (literal) (int32)	int32	100,000	0.0217	0.0279	0.78×	128%
✅	a * 2 (literal) (int32)	int32	10,000,000	7.6682	5.0877	1.51×	66%
▫	a * 2 (literal) (int64)	int64	1,000	0.0009	0.0046	0.20×	501%
🟠	a * 2 (literal) (int64)	int64	100,000	0.0226	0.0598	0.38×	265%
✅	a * 2 (literal) (int64)	int64	10,000,000	15.0941	13.3295	1.13×	88%
▫	a * 2 (literal) (int8)	int8	1,000	0.0009	0.0033	0.26×	380%
✅	a * 2 (literal) (int8)	int8	100,000	0.0218	0.0153	1.42×	70%
✅	a * 2 (literal) (int8)	int8	10,000,000	3.0346	1.2741	2.38×	42%
▫	a * 2 (literal) (uint16)	uint16	1,000	0.0010	0.0034	0.29×	344%
✅	a * 2 (literal) (uint16)	uint16	100,000	0.0219	0.0192	1.14×	87%
✅	a * 2 (literal) (uint16)	uint16	10,000,000	4.3429	2.5632	1.69×	59%
▫	a * 2 (literal) (uint32)	uint32	1,000	0.0010	0.0037	0.26×	383%
🟡	a * 2 (literal) (uint32)	uint32	100,000	0.0218	0.0303	0.72×	139%
✅	a * 2 (literal) (uint32)	uint32	10,000,000	7.7703	5.0405	1.54×	65%
▫	a * 2 (literal) (uint64)	uint64	1,000	0.0009	0.0044	0.21×	477%
🟠	a * 2 (literal) (uint64)	uint64	100,000	0.0223	0.0599	0.37×	269%
✅	a * 2 (literal) (uint64)	uint64	10,000,000	14.8103	13.1645	1.12×	89%
▫	a * 2 (literal) (uint8)	uint8	1,000	0.0009	0.0031	0.27×	364%
✅	a * 2 (literal) (uint8)	uint8	100,000	0.0218	0.0148	1.47×	68%
✅	a * 2 (literal) (uint8)	uint8	10,000,000	3.0832	1.3091	2.35×	42%
▫	a * a (square) (complex128)	complex128	1,000	0.0008	0.0038	0.22×	449%
✅	a * a (square) (complex128)	complex128	100,000	0.2826	0.2203	1.28×	78%
✅	a * a (square) (complex128)	complex128	10,000,000	29.7792	25.4938	1.17×	86%
✅	a * a (square) (float16)	float16	1,000	0.0060	0.0052	1.15×	87%
🟡	a * a (square) (float16)	float16	100,000	0.2818	0.4741	0.59×	168%
🟡	a * a (square) (float16)	float16	10,000,000	30.1183	46.6249	0.65×	155%
▫	a * a (square) (float32)	float32	1,000	0.0005	0.0017	0.31×	321%
🔴	a * a (square) (float32)	float32	100,000	0.0058	0.0471	0.12×	805%
✅	a * a (square) (float32)	float32	10,000,000	7.6612	4.9707	1.54×	65%
▫	a * a (square) (float64)	float64	1,000	0.0005	0.0020	0.26×	393%
🔴	a * a (square) (float64)	float64	100,000	0.0114	0.0935	0.12×	821%
✅	a * a (square) (float64)	float64	10,000,000	15.3393	13.6029	1.13×	89%
▫	a * a (square) (int16)	int16	1,000	0.0009	0.0017	0.51×	196%
🟡	a * a (square) (int16)	int16	100,000	0.0273	0.0276	0.99×	101%
✅	a * a (square) (int16)	int16	10,000,000	4.7133	2.4548	1.92×	52%
▫	a * a (square) (int32)	int32	1,000	0.0008	0.0020	0.39×	256%
🟡	a * a (square) (int32)	int32	100,000	0.0275	0.0482	0.57×	175%
✅	a * a (square) (int32)	int32	10,000,000	8.0304	5.0264	1.60×	63%
▫	a * a (square) (int64)	int64	1,000	0.0007	0.0017	0.45×	224%
🟠	a * a (square) (int64)	int64	100,000	0.0287	0.0963	0.30×	336%
✅	a * a (square) (int64)	int64	10,000,000	15.3630	13.3964	1.15×	87%
▫	a * a (square) (int8)	int8	1,000	0.0006	0.0015	0.42×	236%
✅	a * a (square) (int8)	int8	100,000	0.0282	0.0143	1.97×	51%
✅	a * a (square) (int8)	int8	10,000,000	3.6720	1.2987	2.83×	35%
▫	a * a (square) (uint16)	uint16	1,000	0.0008	0.0019	0.40×	251%
✅	a * a (square) (uint16)	uint16	100,000	0.0387	0.0261	1.49×	67%
✅	a * a (square) (uint16)	uint16	10,000,000	4.8081	2.5775	1.86×	54%
▫	a * a (square) (uint32)	uint32	1,000	0.0008	0.0017	0.45×	223%
🟡	a * a (square) (uint32)	uint32	100,000	0.0290	0.0503	0.58×	174%
✅	a * a (square) (uint32)	uint32	10,000,000	7.9491	5.0896	1.56×	64%
▫	a * a (square) (uint64)	uint64	1,000	0.0007	0.0025	0.28×	354%
🟠	a * a (square) (uint64)	uint64	100,000	0.0282	0.0988	0.29×	350%
✅	a * a (square) (uint64)	uint64	10,000,000	15.0170	13.2023	1.14×	88%
▫	a * a (square) (uint8)	uint8	1,000	0.0006	0.0016	0.39×	257%
✅	a * a (square) (uint8)	uint8	100,000	0.0272	0.0090	3.03×	33%
✅	a * a (square) (uint8)	uint8	10,000,000	3.6667	1.2804	2.86×	35%
▫	a * b (element-wise) (complex128)	complex128	1,000	0.0009	0.0030	0.29×	341%
✅	a * b (element-wise) (complex128)	complex128	100,000	0.2949	0.2291	1.29×	78%
✅	a * b (element-wise) (complex128)	complex128	10,000,000	33.9731	28.5083	1.19×	84%
✅	a * b (element-wise) (float16)	float16	1,000	0.0059	0.0053	1.11×	90%
🟡	a * b (element-wise) (float16)	float16	100,000	0.2799	0.4728	0.59×	169%
🟡	a * b (element-wise) (float16)	float16	10,000,000	30.1434	46.7307	0.65×	155%
▫	a * b (element-wise) (float32)	float32	1,000	0.0005	0.0018	0.28×	350%
🔴	a * b (element-wise) (float32)	float32	100,000	0.0068	0.0495	0.14×	730%
✅	a * b (element-wise) (float32)	float32	10,000,000	8.3804	5.5527	1.51×	66%
▫	a * b (element-wise) (float64)	float64	1,000	0.0006	0.0018	0.36×	277%
🟠	a * b (element-wise) (float64)	float64	100,000	0.0259	0.0982	0.26×	379%
✅	a * b (element-wise) (float64)	float64	10,000,000	16.8272	15.0603	1.12×	90%
▫	a * b (element-wise) (int16)	int16	1,000	0.0008	0.0018	0.44×	228%
✅	a * b (element-wise) (int16)	int16	100,000	0.0274	0.0151	1.81×	55%
✅	a * b (element-wise) (int16)	int16	10,000,000	4.9661	2.8493	1.74×	57%
▫	a * b (element-wise) (int32)	int32	1,000	0.0008	0.0020	0.39×	258%
🟡	a * b (element-wise) (int32)	int32	100,000	0.0282	0.0474	0.59×	168%
✅	a * b (element-wise) (int32)	int32	10,000,000	8.7071	5.6788	1.53×	65%
▫	a * b (element-wise) (int64)	int64	1,000	0.0007	0.0018	0.41×	242%
🟠	a * b (element-wise) (int64)	int64	100,000	0.0314	0.1035	0.30×	329%
✅	a * b (element-wise) (int64)	int64	10,000,000	17.4762	15.2636	1.15×	87%
▫	a * b (element-wise) (int8)	int8	1,000	0.0007	0.0016	0.40×	248%
✅	a * b (element-wise) (int8)	int8	100,000	0.0276	0.0152	1.82×	55%
✅	a * b (element-wise) (int8)	int8	10,000,000	3.7429	1.4944	2.50×	40%
▫	a * b (element-wise) (uint16)	uint16	1,000	0.0008	0.0018	0.42×	236%
✅	a * b (element-wise) (uint16)	uint16	100,000	0.0275	0.0271	1.02×	98%
✅	a * b (element-wise) (uint16)	uint16	10,000,000	4.9546	2.9238	1.70×	59%
▫	a * b (element-wise) (uint32)	uint32	1,000	0.0008	0.0019	0.43×	234%
🟡	a * b (element-wise) (uint32)	uint32	100,000	0.0300	0.0483	0.62×	161%
✅	a * b (element-wise) (uint32)	uint32	10,000,000	8.9206	5.4716	1.63×	61%
▫	a * b (element-wise) (uint64)	uint64	1,000	0.0007	0.0018	0.40×	252%
🟠	a * b (element-wise) (uint64)	uint64	100,000	0.0351	0.1020	0.34×	291%
✅	a * b (element-wise) (uint64)	uint64	10,000,000	16.8707	15.5586	1.08×	92%
▫	a * b (element-wise) (uint8)	uint8	1,000	0.0007	0.0015	0.44×	228%
✅	a * b (element-wise) (uint8)	uint8	100,000	0.0272	0.0144	1.90×	53%
✅	a * b (element-wise) (uint8)	uint8	10,000,000	3.8159	1.4474	2.64×	38%
▫	a * scalar (complex128)	complex128	1,000	0.0009	0.0026	0.36×	280%
✅	a * scalar (complex128)	complex128	100,000	0.2846	0.2201	1.29×	77%
✅	a * scalar (complex128)	complex128	10,000,000	30.8011	25.2644	1.22×	82%
✅	a * scalar (float16)	float16	1,000	0.0064	0.0053	1.21×	82%
🟡	a * scalar (float16)	float16	100,000	0.2797	0.4704	0.59×	168%
🟡	a * scalar (float16)	float16	10,000,000	30.2302	46.2873	0.65×	153%
▫	a * scalar (float32)	float32	1,000	0.0007	0.0012	0.54×	184%
🟠	a * scalar (float32)	float32	100,000	0.0062	0.0274	0.23×	441%
✅	a * scalar (float32)	float32	10,000,000	7.8170	5.1097	1.53×	65%
▫	a * scalar (float64)	float64	1,000	0.0007	0.0016	0.46×	217%
🔴	a * scalar (float64)	float64	100,000	0.0116	0.0658	0.18×	566%
✅	a * scalar (float64)	float64	10,000,000	15.9832	13.7184	1.17×	86%
▫	a * scalar (int16)	int16	1,000	0.0009	0.0011	0.82×	122%
✅	a * scalar (int16)	int16	100,000	0.0215	0.0162	1.33×	75%
✅	a * scalar (int16)	int16	10,000,000	4.1983	2.5429	1.65×	61%
▫	a * scalar (int32)	int32	1,000	0.0009	0.0013	0.67×	148%
🟡	a * scalar (int32)	int32	100,000	0.0224	0.0310	0.72×	139%
✅	a * scalar (int32)	int32	10,000,000	7.6670	5.1149	1.50×	67%
▫	a * scalar (int64)	int64	1,000	0.0008	0.0017	0.48×	208%
🟠	a * scalar (int64)	int64	100,000	0.0219	0.0622	0.35×	284%
✅	a * scalar (int64)	int64	10,000,000	14.9706	13.1378	1.14×	88%
▫	a * scalar (int8)	int8	1,000	0.0007	0.0012	0.62×	161%
✅	a * scalar (int8)	int8	100,000	0.0215	0.0081	2.66×	38%
✅	a * scalar (int8)	int8	10,000,000	3.0113	1.2891	2.34×	43%
▫	a * scalar (uint16)	uint16	1,000	0.0009	0.0015	0.58×	174%
✅	a * scalar (uint16)	uint16	100,000	0.0231	0.0143	1.62×	62%
✅	a * scalar (uint16)	uint16	10,000,000	4.2996	2.5670	1.68×	60%
▫	a * scalar (uint32)	uint32	1,000	0.0009	0.0012	0.72×	138%
🟡	a * scalar (uint32)	uint32	100,000	0.0218	0.0307	0.71×	140%
✅	a * scalar (uint32)	uint32	10,000,000	7.6963	5.1056	1.51×	66%
▫	a * scalar (uint64)	uint64	1,000	0.0008	0.0018	0.46×	219%
🟠	a * scalar (uint64)	uint64	100,000	0.0270	0.0573	0.47×	212%
✅	a * scalar (uint64)	uint64	10,000,000	14.8864	13.1397	1.13×	88%
▫	a * scalar (uint8)	uint8	1,000	0.0007	0.0009	0.84×	119%
✅	a * scalar (uint8)	uint8	100,000	0.0225	0.0078	2.87×	35%
✅	a * scalar (uint8)	uint8	10,000,000	3.1220	1.2945	2.41×	42%
🔴	a + 5 (literal) (complex128)	complex128	1,000	0.0011	0.0059	0.19×	532%
🟡	a + 5 (literal) (complex128)	complex128	100,000	0.2877	0.3143	0.92×	109%
🟡	a + 5 (literal) (complex128)	complex128	10,000,000	31.2807	40.8716	0.77×	131%
🟡	a + 5 (literal) (float16)	float16	1,000	0.0064	0.0093	0.68×	146%
🟠	a + 5 (literal) (float16)	float16	100,000	0.2865	0.8094	0.35×	282%
🟠	a + 5 (literal) (float16)	float16	10,000,000	30.8894	88.5978	0.35×	287%
▫	a + 5 (literal) (float32)	float32	1,000	0.0008	0.0063	0.13×	783%
🔴	a + 5 (literal) (float32)	float32	100,000	0.0062	0.0531	0.12×	851%
🟡	a + 5 (literal) (float32)	float32	10,000,000	7.8256	8.3656	0.94×	107%
▫	a + 5 (literal) (float64)	float64	1,000	0.0008	0.0061	0.13×	770%
🔴	a + 5 (literal) (float64)	float64	100,000	0.0118	0.0979	0.12×	830%
🟡	a + 5 (literal) (float64)	float64	10,000,000	15.5405	19.1910	0.81×	124%
🟠	a + 5 (literal) (int16)	int16	1,000	0.0010	0.0039	0.26×	382%
🟡	a + 5 (literal) (int16)	int16	100,000	0.0239	0.0301	0.79×	126%
✅	a + 5 (literal) (int16)	int16	10,000,000	4.4762	4.4458	1.01×	99%
🟠	a + 5 (literal) (int32)	int32	1,000	0.0010	0.0035	0.29×	344%
🟠	a + 5 (literal) (int32)	int32	100,000	0.0234	0.0505	0.46×	216%
🟡	a + 5 (literal) (int32)	int32	10,000,000	7.8319	8.2820	0.95×	106%
▫	a + 5 (literal) (int64)	int64	1,000	0.0009	0.0056	0.17×	588%
🟠	a + 5 (literal) (int64)	int64	100,000	0.0252	0.1021	0.25×	406%
🟡	a + 5 (literal) (int64)	int64	10,000,000	15.0804	19.9053	0.76×	132%
▫	a + 5 (literal) (int8)	int8	1,000	0.0009	0.0033	0.26×	382%
🟡	a + 5 (literal) (int8)	int8	100,000	0.0238	0.0242	0.98×	102%
✅	a + 5 (literal) (int8)	int8	10,000,000	3.3623	1.9502	1.72×	58%
🟠	a + 5 (literal) (uint16)	uint16	1,000	0.0010	0.0049	0.21×	476%
🟡	a + 5 (literal) (uint16)	uint16	100,000	0.0247	0.0284	0.87×	115%
✅	a + 5 (literal) (uint16)	uint16	10,000,000	4.4740	4.2326	1.06×	95%
🔴	a + 5 (literal) (uint32)	uint32	1,000	0.0010	0.0051	0.20×	502%
🟠	a + 5 (literal) (uint32)	uint32	100,000	0.0234	0.0502	0.47×	214%
🟡	a + 5 (literal) (uint32)	uint32	10,000,000	7.8656	8.5342	0.92×	108%
▫	a + 5 (literal) (uint64)	uint64	1,000	0.0010	0.0063	0.15×	646%
🟠	a + 5 (literal) (uint64)	uint64	100,000	0.0234	0.0954	0.24×	408%
🟡	a + 5 (literal) (uint64)	uint64	10,000,000	15.0958	19.4444	0.78×	129%
▫	a + 5 (literal) (uint8)	uint8	1,000	0.0009	0.0034	0.25×	395%
✅	a + 5 (literal) (uint8)	uint8	100,000	0.0253	0.0192	1.31×	76%
✅	a + 5 (literal) (uint8)	uint8	10,000,000	3.4076	1.9372	1.76×	57%
🟠	a + b (element-wise) (complex128)	complex128	1,000	0.0011	0.0044	0.26×	393%
🟡	a + b (element-wise) (complex128)	complex128	100,000	0.3142	0.3445	0.91×	110%
🟡	a + b (element-wise) (complex128)	complex128	10,000,000	33.8363	54.0273	0.63×	160%
🟡	a + b (element-wise) (float16)	float16	1,000	0.0055	0.0095	0.58×	174%
🟠	a + b (element-wise) (float16)	float16	100,000	0.2823	0.9001	0.31×	319%
🟠	a + b (element-wise) (float16)	float16	10,000,000	30.3275	87.5732	0.35×	289%
▫	a + b (element-wise) (float32)	float32	1,000	0.0007	0.0019	0.37×	270%
🔴	a + b (element-wise) (float32)	float32	100,000	0.0082	0.0537	0.15×	651%
🟡	a + b (element-wise) (float32)	float32	10,000,000	8.4264	10.8929	0.77×	129%
▫	a + b (element-wise) (float64)	float64	1,000	0.0005	0.0025	0.20×	492%
🟠	a + b (element-wise) (float64)	float64	100,000	0.0277	0.1133	0.24×	409%
🟡	a + b (element-wise) (float64)	float64	10,000,000	16.7263	26.0989	0.64×	156%
▫	a + b (element-wise) (int16)	int16	1,000	0.0010	0.0016	0.59×	169%
✅	a + b (element-wise) (int16)	int16	100,000	0.0310	0.0284	1.09×	91%
🟡	a + b (element-wise) (int16)	int16	10,000,000	5.0603	6.1401	0.82×	121%
▫	a + b (element-wise) (int32)	int32	1,000	0.0008	0.0017	0.45×	222%
🟡	a + b (element-wise) (int32)	int32	100,000	0.0297	0.0548	0.54×	185%
🟡	a + b (element-wise) (int32)	int32	10,000,000	8.4215	10.8873	0.77×	129%
▫	a + b (element-wise) (int64)	int64	1,000	0.0010	0.0038	0.25×	398%
🟠	a + b (element-wise) (int64)	int64	100,000	0.0306	0.1154	0.27×	377%
🟡	a + b (element-wise) (int64)	int64	10,000,000	16.7804	25.2327	0.67×	150%
▫	a + b (element-wise) (int8)	int8	1,000	0.0007	0.0012	0.53×	188%
✅	a + b (element-wise) (int8)	int8	100,000	0.0296	0.0159	1.86×	54%
✅	a + b (element-wise) (int8)	int8	10,000,000	3.8279	2.7881	1.37×	73%
▫	a + b (element-wise) (uint16)	uint16	1,000	0.0008	0.0014	0.57×	175%
✅	a + b (element-wise) (uint16)	uint16	100,000	0.0299	0.0270	1.11×	90%
🟡	a + b (element-wise) (uint16)	uint16	10,000,000	5.0917	6.1902	0.82×	122%
🟡	a + b (element-wise) (uint32)	uint32	1,000	0.0014	0.0016	0.87×	115%
🟡	a + b (element-wise) (uint32)	uint32	100,000	0.0285	0.0511	0.56×	180%
🟡	a + b (element-wise) (uint32)	uint32	10,000,000	8.6066	10.7026	0.80×	124%
▫	a + b (element-wise) (uint64)	uint64	1,000	0.0008	0.0029	0.26×	380%
🟠	a + b (element-wise) (uint64)	uint64	100,000	0.0327	0.1082	0.30×	331%
🟡	a + b (element-wise) (uint64)	uint64	10,000,000	18.1412	26.0889	0.69×	144%
▫	a + b (element-wise) (uint8)	uint8	1,000	0.0007	0.0012	0.55×	181%
✅	a + b (element-wise) (uint8)	uint8	100,000	0.0297	0.0153	1.94×	52%
✅	a + b (element-wise) (uint8)	uint8	10,000,000	3.8081	2.7749	1.37×	73%
▫	a + scalar (complex128)	complex128	1,000	0.0009	0.0039	0.24×	410%
🟡	a + scalar (complex128)	complex128	100,000	0.2866	0.3178	0.90×	111%
🟡	a + scalar (complex128)	complex128	10,000,000	31.3992	41.0864	0.76×	131%
🟡	a + scalar (float16)	float16	1,000	0.0061	0.0093	0.65×	154%
🟠	a + scalar (float16)	float16	100,000	0.2825	0.8408	0.34×	298%
🟠	a + scalar (float16)	float16	10,000,000	30.6155	85.2390	0.36×	278%
▫	a + scalar (float32)	float32	1,000	0.0007	0.0019	0.35×	282%
🔴	a + scalar (float32)	float32	100,000	0.0062	0.0512	0.12×	824%
🟡	a + scalar (float32)	float32	10,000,000	7.8223	8.2505	0.95×	106%
▫	a + scalar (float64)	float64	1,000	0.0007	0.0023	0.28×	358%
🔴	a + scalar (float64)	float64	100,000	0.0115	0.0998	0.12×	865%
🟡	a + scalar (float64)	float64	10,000,000	15.6255	19.5551	0.80×	125%
▫	a + scalar (int16)	int16	1,000	0.0009	0.0018	0.51×	196%
🟡	a + scalar (int16)	int16	100,000	0.0238	0.0264	0.90×	111%
✅	a + scalar (int16)	int16	10,000,000	4.3864	4.1556	1.06×	95%
▫	a + scalar (int32)	int32	1,000	0.0009	0.0018	0.50×	200%
🟠	a + scalar (int32)	int32	100,000	0.0232	0.0523	0.44×	225%
🟡	a + scalar (int32)	int32	10,000,000	7.8124	8.3847	0.93×	107%
▫	a + scalar (int64)	int64	1,000	0.0009	0.0026	0.34×	296%
🟠	a + scalar (int64)	int64	100,000	0.0395	0.1005	0.39×	255%
🟡	a + scalar (int64)	int64	10,000,000	15.3427	20.6485	0.74×	135%
▫	a + scalar (int8)	int8	1,000	0.0010	0.0015	0.64×	156%
✅	a + scalar (int8)	int8	100,000	0.0259	0.0144	1.80×	56%
✅	a + scalar (int8)	int8	10,000,000	3.3690	2.0078	1.68×	60%
▫	a + scalar (uint16)	uint16	1,000	0.0009	0.0017	0.54×	185%
🟡	a + scalar (uint16)	uint16	100,000	0.0240	0.0257	0.93×	107%
✅	a + scalar (uint16)	uint16	10,000,000	4.5159	4.3325	1.04×	96%
🟡	a + scalar (uint32)	uint32	1,000	0.0013	0.0018	0.70×	142%
🟠	a + scalar (uint32)	uint32	100,000	0.0233	0.0494	0.47×	212%
🟡	a + scalar (uint32)	uint32	10,000,000	7.7179	8.4788	0.91×	110%
▫	a + scalar (uint64)	uint64	1,000	0.0009	0.0029	0.29×	345%
🟠	a + scalar (uint64)	uint64	100,000	0.0233	0.1007	0.23×	432%
🟡	a + scalar (uint64)	uint64	10,000,000	15.6794	19.7857	0.79×	126%
▫	a + scalar (uint8)	uint8	1,000	0.0008	0.0017	0.45×	221%
✅	a + scalar (uint8)	uint8	100,000	0.0264	0.0143	1.85×	54%
✅	a + scalar (uint8)	uint8	10,000,000	3.3843	1.9032	1.78×	56%
▫	a - b (element-wise) (complex128)	complex128	1,000	0.0009	0.0032	0.27×	369%
✅	a - b (element-wise) (complex128)	complex128	100,000	0.3175	0.2343	1.35×	74%
✅	a - b (element-wise) (complex128)	complex128	10,000,000	34.2472	30.3482	1.13×	89%
🟡	a - b (element-wise) (float16)	float16	1,000	0.0045	0.0050	0.90×	111%
🟡	a - b (element-wise) (float16)	float16	100,000	0.2794	0.4692	0.60×	168%
🟠	a - b (element-wise) (float16)	float16	10,000,000	30.4358	65.6914	0.46×	216%
▫	a - b (element-wise) (float32)	float32	1,000	0.0005	0.0013	0.41×	241%
🟠	a - b (element-wise) (float32)	float32	100,000	0.0070	0.0275	0.26×	391%
✅	a - b (element-wise) (float32)	float32	10,000,000	8.4147	5.3696	1.57×	64%
▫	a - b (element-wise) (float64)	float64	1,000	0.0007	0.0022	0.31×	319%
🟠	a - b (element-wise) (float64)	float64	100,000	0.0263	0.0614	0.43×	233%
✅	a - b (element-wise) (float64)	float64	10,000,000	16.5820	14.8489	1.12×	90%
▫	a - b (element-wise) (int16)	int16	1,000	0.0008	0.0013	0.64×	155%
✅	a - b (element-wise) (int16)	int16	100,000	0.0288	0.0152	1.89×	53%
✅	a - b (element-wise) (int16)	int16	10,000,000	5.0343	2.8963	1.74×	58%
▫	a - b (element-wise) (int32)	int32	1,000	0.0008	0.0012	0.68×	147%
🟡	a - b (element-wise) (int32)	int32	100,000	0.0286	0.0296	0.97×	104%
✅	a - b (element-wise) (int32)	int32	10,000,000	8.8063	5.5819	1.58×	63%
▫	a - b (element-wise) (int64)	int64	1,000	0.0008	0.0021	0.37×	272%
🟠	a - b (element-wise) (int64)	int64	100,000	0.0329	0.0668	0.49×	203%
✅	a - b (element-wise) (int64)	int64	10,000,000	17.0835	14.9251	1.15×	87%
▫	a - b (element-wise) (int8)	int8	1,000	0.0007	0.0011	0.62×	162%
✅	a - b (element-wise) (int8)	int8	100,000	0.0285	0.0083	3.43×	29%
✅	a - b (element-wise) (int8)	int8	10,000,000	3.8695	1.4622	2.65×	38%
▫	a - b (element-wise) (uint16)	uint16	1,000	0.0008	0.0011	0.72×	139%
✅	a - b (element-wise) (uint16)	uint16	100,000	0.0296	0.0150	1.98×	51%
✅	a - b (element-wise) (uint16)	uint16	10,000,000	5.0948	2.9174	1.75×	57%
▫	a - b (element-wise) (uint32)	uint32	1,000	0.0008	0.0014	0.53×	189%
✅	a - b (element-wise) (uint32)	uint32	100,000	0.0285	0.0280	1.02×	98%
✅	a - b (element-wise) (uint32)	uint32	10,000,000	8.7412	5.4282	1.61×	62%
▫	a - b (element-wise) (uint64)	uint64	1,000	0.0007	0.0018	0.41×	244%
🟡	a - b (element-wise) (uint64)	uint64	100,000	0.0358	0.0653	0.55×	183%
✅	a - b (element-wise) (uint64)	uint64	10,000,000	16.8067	14.7610	1.14×	88%
▫	a - b (element-wise) (uint8)	uint8	1,000	0.0006	0.0009	0.75×	134%
✅	a - b (element-wise) (uint8)	uint8	100,000	0.0300	0.0086	3.50×	29%
✅	a - b (element-wise) (uint8)	uint8	10,000,000	3.8491	1.4835	2.60×	38%
▫	a - scalar (complex128)	complex128	1,000	0.0009	0.0028	0.34×	298%
✅	a - scalar (complex128)	complex128	100,000	0.2994	0.2283	1.31×	76%
✅	a - scalar (complex128)	complex128	10,000,000	32.8674	25.2962	1.30×	77%
✅	a - scalar (float16)	float16	1,000	0.0060	0.0049	1.23×	82%
🟡	a - scalar (float16)	float16	100,000	0.2796	0.4687	0.60×	168%
🟡	a - scalar (float16)	float16	10,000,000	30.3791	46.1701	0.66×	152%
▫	a - scalar (float32)	float32	1,000	0.0008	0.0014	0.57×	174%
🟠	a - scalar (float32)	float32	100,000	0.0061	0.0270	0.23×	439%
✅	a - scalar (float32)	float32	10,000,000	7.8119	5.1477	1.52×	66%
▫	a - scalar (float64)	float64	1,000	0.0006	0.0021	0.30×	335%
🔴	a - scalar (float64)	float64	100,000	0.0117	0.0614	0.19×	524%
✅	a - scalar (float64)	float64	10,000,000	15.5805	13.7960	1.13×	88%
🟡	a - scalar (int16)	int16	1,000	0.0011	0.0012	0.94×	107%
✅	a - scalar (int16)	int16	100,000	0.0232	0.0139	1.67×	60%
✅	a - scalar (int16)	int16	10,000,000	4.3717	2.6212	1.67×	60%
▫	a - scalar (int32)	int32	1,000	0.0009	0.0015	0.60×	165%
🟡	a - scalar (int32)	int32	100,000	0.0245	0.0261	0.94×	107%
✅	a - scalar (int32)	int32	10,000,000	7.8246	5.1023	1.53×	65%
▫	a - scalar (int64)	int64	1,000	0.0009	0.0020	0.43×	233%
🟠	a - scalar (int64)	int64	100,000	0.0257	0.0580	0.44×	226%
✅	a - scalar (int64)	int64	10,000,000	15.0036	13.7351	1.09×	92%
▫	a - scalar (int8)	int8	1,000	0.0009	0.0012	0.73×	137%
✅	a - scalar (int8)	int8	100,000	0.0234	0.0079	2.96×	34%
✅	a - scalar (int8)	int8	10,000,000	3.3051	1.3891	2.38×	42%
▫	a - scalar (uint16)	uint16	1,000	0.0009	0.0010	0.90×	111%
✅	a - scalar (uint16)	uint16	100,000	0.0235	0.0140	1.68×	60%
✅	a - scalar (uint16)	uint16	10,000,000	4.5055	2.5875	1.74×	57%
▫	a - scalar (uint32)	uint32	1,000	0.0009	0.0012	0.73×	138%
✅	a - scalar (uint32)	uint32	100,000	0.0270	0.0266	1.02×	98%
✅	a - scalar (uint32)	uint32	10,000,000	7.9393	5.0601	1.57×	64%
▫	a - scalar (uint64)	uint64	1,000	0.0009	0.0017	0.49×	203%
🟠	a - scalar (uint64)	uint64	100,000	0.0257	0.0557	0.46×	216%
✅	a - scalar (uint64)	uint64	10,000,000	15.0786	13.6412	1.10×	90%
▫	a - scalar (uint8)	uint8	1,000	0.0008	0.0009	0.90×	111%
✅	a - scalar (uint8)	uint8	100,000	0.0252	0.0081	3.11×	32%
✅	a - scalar (uint8)	uint8	10,000,000	3.3366	1.3483	2.48×	40%
▫	a / b (element-wise) (float32)	float32	1,000	0.0005	0.0020	0.25×	401%
🟠	a / b (element-wise) (float32)	float32	100,000	0.0123	0.0563	0.22×	458%
🟡	a / b (element-wise) (float32)	float32	10,000,000	8.4746	10.4479	0.81×	123%
▫	a / b (element-wise) (float64)	float64	1,000	0.0008	0.0033	0.23×	436%
🟠	a / b (element-wise) (float64)	float64	100,000	0.0382	0.1504	0.25×	393%
🟡	a / b (element-wise) (float64)	float64	10,000,000	16.5123	24.6973	0.67×	150%
🟠	a / b (element-wise) (int32)	int32	1,000	0.0019	0.0056	0.34×	297%
🟠	a / b (element-wise) (int32)	int32	100,000	0.0827	0.1883	0.44×	228%
🟡	a / b (element-wise) (int32)	int32	10,000,000	20.2642	23.3858	0.87×	115%
🟠	a / b (element-wise) (int64)	int64	1,000	0.0018	0.0048	0.39×	259%
🟠	a / b (element-wise) (int64)	int64	100,000	0.0821	0.1914	0.43×	233%
🟡	a / b (element-wise) (int64)	int64	10,000,000	23.2035	27.5732	0.84×	119%
▫	a / scalar (float32)	float32	1,000	0.0006	0.0021	0.30×	336%
🟠	a / scalar (float32)	float32	100,000	0.0120	0.0591	0.20×	492%
🟡	a / scalar (float32)	float32	10,000,000	7.9059	8.4903	0.93×	107%
▫	a / scalar (float64)	float64	1,000	0.0009	0.0037	0.24×	412%
🟠	a / scalar (float64)	float64	100,000	0.0372	0.1545	0.24×	416%
🟡	a / scalar (float64)	float64	10,000,000	15.4651	21.6902	0.71×	140%
🟠	a / scalar (int32)	int32	1,000	0.0022	0.0073	0.30×	332%
🟠	a / scalar (int32)	int32	100,000	0.0616	0.1934	0.32×	314%
🟡	a / scalar (int32)	int32	10,000,000	17.1824	23.0455	0.75×	134%
🟠	a / scalar (int64)	int64	1,000	0.0017	0.0069	0.25×	404%
🟠	a / scalar (int64)	int64	100,000	0.0571	0.1868	0.31×	327%
🟡	a / scalar (int64)	int64	10,000,000	18.4227	23.5786	0.78×	128%
🟠	np.add(a, b) (complex128)	complex128	1,000	0.0011	0.0042	0.25×	398%
🟡	np.add(a, b) (complex128)	complex128	100,000	0.3045	0.3432	0.89×	113%
🟡	np.add(a, b) (complex128)	complex128	10,000,000	33.3065	56.7710	0.59×	170%
🟡	np.add(a, b) (float16)	float16	1,000	0.0054	0.0096	0.56×	180%
🟠	np.add(a, b) (float16)	float16	100,000	0.2880	0.8665	0.33×	301%
🟠	np.add(a, b) (float16)	float16	10,000,000	30.2918	84.4809	0.36×	279%
▫	np.add(a, b) (float32)	float32	1,000	0.0005	0.0019	0.29×	346%
🔴	np.add(a, b) (float32)	float32	100,000	0.0069	0.0511	0.14×	743%
🟡	np.add(a, b) (float32)	float32	10,000,000	8.4121	11.6595	0.72×	139%
▫	np.add(a, b) (float64)	float64	1,000	0.0005	0.0027	0.20×	514%
🟠	np.add(a, b) (float64)	float64	100,000	0.0274	0.1083	0.25×	396%
🟡	np.add(a, b) (float64)	float64	10,000,000	16.6312	24.9414	0.67×	150%
▫	np.add(a, b) (int16)	int16	1,000	0.0008	0.0015	0.52×	192%
✅	np.add(a, b) (int16)	int16	100,000	0.0289	0.0283	1.02×	98%
🟡	np.add(a, b) (int16)	int16	10,000,000	5.0436	6.3374	0.80×	126%
▫	np.add(a, b) (int32)	int32	1,000	0.0008	0.0018	0.43×	233%
🟡	np.add(a, b) (int32)	int32	100,000	0.0286	0.0523	0.55×	183%
🟡	np.add(a, b) (int32)	int32	10,000,000	8.5431	10.9704	0.78×	128%
▫	np.add(a, b) (int64)	int64	1,000	0.0009	0.0025	0.38×	267%
🟠	np.add(a, b) (int64)	int64	100,000	0.0307	0.1070	0.29×	349%
🟡	np.add(a, b) (int64)	int64	10,000,000	16.9611	25.6104	0.66×	151%
▫	np.add(a, b) (int8)	int8	1,000	0.0008	0.0011	0.72×	139%
✅	np.add(a, b) (int8)	int8	100,000	0.0285	0.0154	1.85×	54%
✅	np.add(a, b) (int8)	int8	10,000,000	3.8480	2.7190	1.42×	71%
▫	np.add(a, b) (uint16)	uint16	1,000	0.0008	0.0016	0.49×	205%
✅	np.add(a, b) (uint16)	uint16	100,000	0.0292	0.0271	1.07×	93%
🟡	np.add(a, b) (uint16)	uint16	10,000,000	5.0613	6.0800	0.83×	120%
▫	np.add(a, b) (uint32)	uint32	1,000	0.0010	0.0014	0.68×	147%
🟡	np.add(a, b) (uint32)	uint32	100,000	0.0285	0.0534	0.53×	187%
🟡	np.add(a, b) (uint32)	uint32	10,000,000	8.5822	10.6338	0.81×	124%
▫	np.add(a, b) (uint64)	uint64	1,000	0.0008	0.0017	0.44×	228%
🟠	np.add(a, b) (uint64)	uint64	100,000	0.0355	0.1051	0.34×	296%
🟡	np.add(a, b) (uint64)	uint64	10,000,000	17.4766	26.0047	0.67×	149%
▫	np.add(a, b) (uint8)	uint8	1,000	0.0007	0.0013	0.53×	188%
✅	np.add(a, b) (uint8)	uint8	100,000	0.0293	0.0155	1.89×	53%
✅	np.add(a, b) (uint8)	uint8	10,000,000	3.8443	3.0809	1.25×	80%
▫	scalar - a (complex128)	complex128	1,000	0.0010	0.0027	0.36×	279%
✅	scalar - a (complex128)	complex128	100,000	0.3082	0.2238	1.38×	73%
✅	scalar - a (complex128)	complex128	10,000,000	32.3795	25.2975	1.28×	78%
✅	scalar - a (float16)	float16	1,000	0.0056	0.0049	1.15×	87%
🟡	scalar - a (float16)	float16	100,000	0.2910	0.4656	0.62×	160%
🟡	scalar - a (float16)	float16	10,000,000	30.2778	46.0030	0.66×	152%
▫	scalar - a (float32)	float32	1,000	0.0007	0.0014	0.49×	202%
🟠	scalar - a (float32)	float32	100,000	0.0062	0.0265	0.23×	427%
✅	scalar - a (float32)	float32	10,000,000	7.7928	5.1631	1.51×	66%
▫	scalar - a (float64)	float64	1,000	0.0007	0.0020	0.34×	297%
🟠	scalar - a (float64)	float64	100,000	0.0115	0.0568	0.20×	493%
✅	scalar - a (float64)	float64	10,000,000	15.7789	13.8734	1.14×	88%
▫	scalar - a (int16)	int16	1,000	0.0009	0.0011	0.86×	116%
✅	scalar - a (int16)	int16	100,000	0.0246	0.0147	1.68×	60%
✅	scalar - a (int16)	int16	10,000,000	4.4218	2.5703	1.72×	58%
▫	scalar - a (int32)	int32	1,000	0.0009	0.0012	0.78×	128%
🟡	scalar - a (int32)	int32	100,000	0.0237	0.0275	0.86×	116%
✅	scalar - a (int32)	int32	10,000,000	7.8237	5.1041	1.53×	65%
🟡	scalar - a (int64)	int64	1,000	0.0011	0.0016	0.66×	151%
🟠	scalar - a (int64)	int64	100,000	0.0241	0.0657	0.37×	273%
✅	scalar - a (int64)	int64	10,000,000	14.9127	13.4584	1.11×	90%
▫	scalar - a (int8)	int8	1,000	0.0008	0.0010	0.77×	130%
✅	scalar - a (int8)	int8	100,000	0.0237	0.0079	3.01×	33%
✅	scalar - a (int8)	int8	10,000,000	3.2754	1.3503	2.43×	41%
✅	scalar - a (uint16)	uint16	1,000	0.0016	0.0012	1.41×	71%
✅	scalar - a (uint16)	uint16	100,000	0.0240	0.0143	1.68×	60%
✅	scalar - a (uint16)	uint16	10,000,000	4.4048	2.4891	1.77×	56%
▫	scalar - a (uint32)	uint32	1,000	0.0009	0.0014	0.66×	153%
✅	scalar - a (uint32)	uint32	100,000	0.0287	0.0275	1.04×	96%
✅	scalar - a (uint32)	uint32	10,000,000	7.7897	5.0724	1.54×	65%
▫	scalar - a (uint64)	uint64	1,000	0.0010	0.0017	0.56×	178%
🟠	scalar - a (uint64)	uint64	100,000	0.0236	0.0589	0.40×	250%
✅	scalar - a (uint64)	uint64	10,000,000	15.0333	13.5035	1.11×	90%
▫	scalar - a (uint8)	uint8	1,000	0.0008	0.0010	0.79×	126%
✅	scalar - a (uint8)	uint8	100,000	0.0245	0.0078	3.13×	32%
✅	scalar - a (uint8)	uint8	10,000,000	3.3284	1.3375	2.49×	40%
▫	scalar / a (float32)	float32	1,000	0.0007	0.0019	0.34×	294%
🟠	scalar / a (float32)	float32	100,000	0.0149	0.0582	0.26×	391%
🟡	scalar / a (float32)	float32	10,000,000	7.9318	8.0737	0.98×	102%
▫	scalar / a (float64)	float64	1,000	0.0009	0.0033	0.28×	356%
🟠	scalar / a (float64)	float64	100,000	0.0374	0.1398	0.27×	374%
🟡	scalar / a (float64)	float64	10,000,000	15.4337	22.3529	0.69×	145%
🟠	scalar / a (int32)	int32	1,000	0.0018	0.0063	0.29×	349%
🟠	scalar / a (int32)	int32	100,000	0.0618	0.1726	0.36×	279%
🟡	scalar / a (int32)	int32	10,000,000	17.0772	22.8310	0.75×	134%
🟠	scalar / a (int64)	int64	1,000	0.0022	0.0060	0.36×	274%
🟠	scalar / a (int64)	int64	100,000	0.0575	0.1799	0.32×	313%
🟡	scalar / a (int64)	int64	10,000,000	18.5249	24.6415	0.75×	133%

Unary

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
▫	np.abs (float16)	float16	1,000	0.0008	0.0014	0.58×	172%
✅	np.abs (float16)	float16	100,000	0.0261	0.0219	1.19×	84%
✅	np.abs (float16)	float16	10,000,000	7.7905	2.7758	2.81×	36%
▫	np.abs (float32)	float32	1,000	0.0006	0.0016	0.35×	286%
🔴	np.abs (float32)	float32	100,000	0.0061	0.0376	0.16×	617%
✅	np.abs (float32)	float32	10,000,000	7.3196	4.2367	1.73×	58%
▫	np.abs (float64)	float64	1,000	0.0006	0.0050	0.11×	904%
🔴	np.abs (float64)	float64	100,000	0.0113	0.0656	0.17×	581%
✅	np.abs (float64)	float64	10,000,000	14.5867	14.0433	1.04×	96%
🟡	np.cbrt(a) (float16)	float16	1,000	0.0104	0.0111	0.93×	107%
🟡	np.cbrt(a) (float16)	float16	100,000	1.1653	1.3881	0.84×	119%
🟡	np.cbrt(a) (float16)	float16	10,000,000	123.1163	137.5717	0.90×	112%
✅	np.cbrt(a) (float32)	float32	1,000	0.0062	0.0060	1.02×	98%
🟡	np.cbrt(a) (float32)	float32	100,000	0.8801	0.8926	0.99×	101%
✅	np.cbrt(a) (float32)	float32	10,000,000	93.3862	87.0798	1.07×	93%
🟡	np.cbrt(a) (float64)	float64	1,000	0.0092	0.0096	0.96×	104%
🟡	np.cbrt(a) (float64)	float64	100,000	1.0901	1.0964	0.99×	101%
✅	np.cbrt(a) (float64)	float64	10,000,000	115.3223	113.1029	1.02×	98%
✅	np.ceil (float16)	float16	1,000	0.0051	0.0039	1.33×	75%
✅	np.ceil (float16)	float16	100,000	0.4009	0.3367	1.19×	84%
✅	np.ceil (float16)	float16	10,000,000	41.2225	33.5011	1.23×	81%
▫	np.ceil (float32)	float32	1,000	0.0005	0.0015	0.36×	276%
🔴	np.ceil (float32)	float32	100,000	0.0057	0.0285	0.20×	501%
✅	np.ceil (float32)	float32	10,000,000	7.4340	4.1609	1.79×	56%
▫	np.ceil (float64)	float64	1,000	0.0006	0.0036	0.15×	653%
🟠	np.ceil (float64)	float64	100,000	0.0112	0.0552	0.20×	495%
✅	np.ceil (float64)	float64	10,000,000	14.8375	14.0530	1.06×	95%
✅	np.clip(a, -10, 10) (float16)	float16	1,000	0.0099	0.0060	1.66×	60%
✅	np.clip(a, -10, 10) (float16)	float16	100,000	0.9202	0.7256	1.27×	79%
✅	np.clip(a, -10, 10) (float16)	float16	10,000,000	92.7997	71.2042	1.30×	77%
🟠	np.clip(a, -10, 10) (float32)	float32	1,000	0.0020	0.0063	0.32×	311%
🟠	np.clip(a, -10, 10) (float32)	float32	100,000	0.0083	0.0345	0.24×	415%
✅	np.clip(a, -10, 10) (float32)	float32	10,000,000	7.4072	4.1688	1.78×	56%
🟠	np.clip(a, -10, 10) (float64)	float64	1,000	0.0018	0.0061	0.30×	332%
🟠	np.clip(a, -10, 10) (float64)	float64	100,000	0.0131	0.0640	0.20×	487%
✅	np.clip(a, -10, 10) (float64)	float64	10,000,000	14.7613	13.3322	1.11×	90%
🟡	np.cos (float16)	float16	1,000	0.0050	0.0084	0.60×	168%
🟡	np.cos (float16)	float16	100,000	0.6956	1.1041	0.63×	159%
🟡	np.cos (float16)	float16	10,000,000	79.1733	110.5111	0.72×	140%
✅	np.cos (float32)	float32	1,000	0.0049	0.0038	1.30×	77%
🟡	np.cos (float32)	float32	100,000	0.7072	0.7109	0.99×	100%
✅	np.cos (float32)	float32	10,000,000	80.0272	69.8170	1.15×	87%
✅	np.cos (float64)	float64	1,000	0.0049	0.0042	1.18×	85%
🟡	np.cos (float64)	float64	100,000	0.7039	0.7283	0.97×	104%
✅	np.cos (float64)	float64	10,000,000	79.0328	77.0677	1.02×	98%
🟡	np.exp (float16)	float16	1,000	0.0054	0.0063	0.86×	116%
🟡	np.exp (float16)	float16	100,000	0.4124	0.5903	0.70×	143%
✅	np.exp (float16)	float16	10,000,000	63.7886	58.5180	1.09×	92%
🟠	np.exp (float32)	float32	1,000	0.0010	0.0034	0.29×	339%
🟠	np.exp (float32)	float32	100,000	0.0544	0.1753	0.31×	322%
🟡	np.exp (float32)	float32	10,000,000	10.5143	16.5467	0.64×	157%
🟡	np.exp (float64)	float64	1,000	0.0030	0.0038	0.78×	128%
🟡	np.exp (float64)	float64	100,000	0.2543	0.2691	0.94×	106%
✅	np.exp (float64)	float64	10,000,000	32.9892	30.7385	1.07×	93%
🟡	np.exp2 (float16)	float16	1,000	0.0052	0.0098	0.54×	187%
🟠	np.exp2 (float16)	float16	100,000	0.4402	0.9688	0.45×	220%
🟠	np.exp2 (float16)	float16	10,000,000	47.4052	97.6500	0.48×	206%
🟠	np.exp2 (float32)	float32	1,000	0.0022	0.0097	0.23×	435%
🔴	np.exp2 (float32)	float32	100,000	0.1723	0.8886	0.19×	516%
🟠	np.exp2 (float32)	float32	10,000,000	23.4637	87.7856	0.27×	374%
🟠	np.exp2 (float64)	float64	1,000	0.0025	0.0096	0.26×	386%
🟠	np.exp2 (float64)	float64	100,000	0.2067	0.8452	0.24×	409%
🟠	np.exp2 (float64)	float64	10,000,000	28.4119	87.4368	0.33×	308%
🟡	np.expm1 (float16)	float16	1,000	0.0059	0.0091	0.65×	154%
🟡	np.expm1 (float16)	float16	100,000	0.5256	0.8595	0.61×	164%
🟡	np.expm1 (float16)	float16	10,000,000	54.8518	86.3626	0.64×	157%
🟡	np.expm1 (float32)	float32	1,000	0.0032	0.0039	0.83×	120%
✅	np.expm1 (float32)	float32	100,000	0.2667	0.1878	1.42×	70%
✅	np.expm1 (float32)	float32	10,000,000	31.6479	17.6348	1.79×	56%
🟡	np.expm1 (float64)	float64	1,000	0.0038	0.0039	0.98×	102%
✅	np.expm1 (float64)	float64	100,000	0.3380	0.2746	1.23×	81%
✅	np.expm1 (float64)	float64	10,000,000	42.0588	31.9769	1.31×	76%
✅	np.floor (float16)	float16	1,000	0.0051	0.0039	1.32×	76%
✅	np.floor (float16)	float16	100,000	0.4141	0.3381	1.23×	82%
✅	np.floor (float16)	float16	10,000,000	43.2932	32.6165	1.33×	75%
▫	np.floor (float32)	float32	1,000	0.0005	0.0019	0.29×	350%
🟠	np.floor (float32)	float32	100,000	0.0063	0.0309	0.20×	488%
✅	np.floor (float32)	float32	10,000,000	7.6079	4.1823	1.82×	55%
▫	np.floor (float64)	float64	1,000	0.0006	0.0048	0.12×	833%
🔴	np.floor (float64)	float64	100,000	0.0117	0.0586	0.20×	502%
✅	np.floor (float64)	float64	10,000,000	14.9548	13.8842	1.08×	93%
🟡	np.log (float16)	float16	1,000	0.0050	0.0066	0.75×	133%
🟡	np.log (float16)	float16	100,000	0.4253	0.6276	0.68×	148%
✅	np.log (float16)	float16	10,000,000	84.3523	62.5962	1.35×	74%
🟠	np.log (float32)	float32	1,000	0.0013	0.0039	0.34×	290%
🟠	np.log (float32)	float32	100,000	0.0917	0.2125	0.43×	232%
🟡	np.log (float32)	float32	10,000,000	13.6695	20.7475	0.66×	152%
🟡	np.log (float64)	float64	1,000	0.0028	0.0031	0.89×	112%
🟡	np.log (float64)	float64	100,000	0.2338	0.2548	0.92×	109%
✅	np.log (float64)	float64	10,000,000	31.4221	29.8544	1.05×	95%
🟡	np.log10 (float16)	float16	1,000	0.0055	0.0067	0.81×	123%
🟡	np.log10 (float16)	float16	100,000	0.4443	0.6431	0.69×	145%
✅	np.log10 (float16)	float16	10,000,000	69.8188	63.1013	1.11×	90%
🟡	np.log10 (float32)	float32	1,000	0.0024	0.0038	0.64×	157%
🟡	np.log10 (float32)	float32	100,000	0.1944	0.2121	0.92×	109%
✅	np.log10 (float32)	float32	10,000,000	23.1019	20.3369	1.14×	88%
🟡	np.log10 (float64)	float64	1,000	0.0029	0.0031	0.94×	107%
🟡	np.log10 (float64)	float64	100,000	0.2459	0.2616	0.94×	106%
✅	np.log10 (float64)	float64	10,000,000	32.7819	30.4759	1.08×	93%
🟡	np.log1p (float16)	float16	1,000	0.0063	0.0082	0.77×	130%
🟡	np.log1p (float16)	float16	100,000	0.5635	0.7911	0.71×	140%
🟡	np.log1p (float16)	float16	10,000,000	58.8048	77.9264	0.76×	132%
✅	np.log1p (float32)	float32	1,000	0.0034	0.0028	1.24×	81%
✅	np.log1p (float32)	float32	100,000	0.2895	0.2324	1.25×	80%
✅	np.log1p (float32)	float32	10,000,000	31.9094	21.9765	1.45×	69%
✅	np.log1p (float64)	float64	1,000	0.0037	0.0032	1.14×	87%
✅	np.log1p (float64)	float64	100,000	0.3215	0.2717	1.18×	84%
✅	np.log1p (float64)	float64	10,000,000	39.8056	31.3997	1.27×	79%
🟡	np.log2 (float16)	float16	1,000	0.0050	0.0067	0.74×	134%
🟡	np.log2 (float16)	float16	100,000	0.4571	0.6374	0.72×	140%
🟡	np.log2 (float16)	float16	10,000,000	48.6171	62.9314	0.77×	129%
🟡	np.log2 (float32)	float32	1,000	0.0026	0.0042	0.61×	163%
🟡	np.log2 (float32)	float32	100,000	0.1889	0.1979	0.95×	105%
✅	np.log2 (float32)	float32	10,000,000	22.7833	18.9040	1.21×	83%
🟡	np.log2 (float64)	float64	1,000	0.0041	0.0044	0.93×	107%
🟡	np.log2 (float64)	float64	100,000	0.3738	0.3897	0.96×	104%
✅	np.log2 (float64)	float64	10,000,000	45.1058	42.4500	1.06×	94%
▫	np.negative(a) (float16)	float16	1,000	0.0008	0.0015	0.51×	197%
✅	np.negative(a) (float16)	float16	100,000	0.0320	0.0234	1.37×	73%
✅	np.negative(a) (float16)	float16	10,000,000	4.7401	3.0972	1.53×	65%
▫	np.negative(a) (float32)	float32	1,000	0.0005	0.0020	0.26×	391%
🟠	np.negative(a) (float32)	float32	100,000	0.0065	0.0264	0.25×	403%
✅	np.negative(a) (float32)	float32	10,000,000	7.8325	4.2918	1.82×	55%
▫	np.negative(a) (float64)	float64	1,000	0.0005	0.0032	0.16×	622%
🟠	np.negative(a) (float64)	float64	100,000	0.0136	0.0544	0.25×	399%
✅	np.negative(a) (float64)	float64	10,000,000	16.3329	16.1866	1.01×	99%
▫	np.positive(a) (float16)	float16	1,000	0.0007	0.0011	0.63×	160%
✅	np.positive(a) (float16)	float16	100,000	0.0209	0.0132	1.59×	63%
✅	np.positive(a) (float16)	float16	10,000,000	4.2717	1.6411	2.60×	38%
▫	np.positive(a) (float32)	float32	1,000	0.0007	0.0016	0.41×	243%
🟡	np.positive(a) (float32)	float32	100,000	0.0192	0.0244	0.78×	128%
✅	np.positive(a) (float32)	float32	10,000,000	7.8097	3.6030	2.17×	46%
▫	np.positive(a) (float64)	float64	1,000	0.0006	0.0022	0.29×	349%
🟠	np.positive(a) (float64)	float64	100,000	0.0191	0.0504	0.38×	265%
✅	np.positive(a) (float64)	float64	10,000,000	15.2613	13.7699	1.11×	90%
✅	np.power(a, 0.5) (float16)	float16	1,000	0.0091	0.0057	1.59×	63%
✅	np.power(a, 0.5) (float16)	float16	100,000	0.8082	0.3429	2.36×	42%
✅	np.power(a, 0.5) (float16)	float16	10,000,000	85.4485	33.5902	2.54×	39%
🟡	np.power(a, 0.5) (float32)	float32	1,000	0.0020	0.0028	0.70×	143%
✅	np.power(a, 0.5) (float32)	float32	100,000	0.1204	0.0268	4.50×	22%
✅	np.power(a, 0.5) (float32)	float32	10,000,000	15.8291	4.1517	3.81×	26%
🟡	np.power(a, 0.5) (float64)	float64	1,000	0.0018	0.0027	0.67×	150%
✅	np.power(a, 0.5) (float64)	float64	100,000	0.1208	0.0624	1.94×	52%
✅	np.power(a, 0.5) (float64)	float64	10,000,000	20.4169	13.6772	1.49×	67%
✅	np.power(a, 2) (float16)	float16	1,000	0.0102	0.0057	1.78×	56%
✅	np.power(a, 2) (float16)	float16	100,000	1.0479	0.4785	2.19×	46%
✅	np.power(a, 2) (float16)	float16	10,000,000	106.1243	47.3970	2.24×	45%
🟡	np.power(a, 2) (float32)	float32	1,000	0.0023	0.0029	0.80×	125%
✅	np.power(a, 2) (float32)	float32	100,000	0.1497	0.0268	5.59×	18%
✅	np.power(a, 2) (float32)	float32	10,000,000	18.8415	4.1425	4.55×	22%
🟡	np.power(a, 2) (float64)	float64	1,000	0.0022	0.0035	0.65×	155%
✅	np.power(a, 2) (float64)	float64	100,000	0.1534	0.0578	2.65×	38%
✅	np.power(a, 2) (float64)	float64	10,000,000	22.8226	13.5837	1.68×	60%
🟡	np.power(a, 3) (float16)	float16	1,000	0.0134	0.0172	0.78×	128%
🟡	np.power(a, 3) (float16)	float16	100,000	1.4800	2.4845	0.60×	168%
🟡	np.power(a, 3) (float16)	float16	10,000,000	162.6844	251.6184	0.65×	155%
🟡	np.power(a, 3) (float32)	float32	1,000	0.0058	0.0091	0.64×	157%
🟡	np.power(a, 3) (float32)	float32	100,000	0.6605	0.6694	0.99×	101%
✅	np.power(a, 3) (float32)	float32	10,000,000	71.1467	66.4474	1.07×	93%
🟡	np.power(a, 3) (float64)	float64	1,000	0.0097	0.0110	0.88×	113%
🟡	np.power(a, 3) (float64)	float64	100,000	1.0647	1.0958	0.97×	103%
✅	np.power(a, 3) (float64)	float64	10,000,000	116.0376	111.0662	1.04×	96%
🟡	np.reciprocal(a) (float16)	float16	1,000	0.0034	0.0045	0.74×	134%
🟡	np.reciprocal(a) (float16)	float16	100,000	0.2055	0.4096	0.50×	199%
🟡	np.reciprocal(a) (float16)	float16	10,000,000	22.5069	40.3090	0.56×	179%
▫	np.reciprocal(a) (float32)	float32	1,000	0.0006	0.0016	0.36×	275%
🟡	np.reciprocal(a) (float32)	float32	100,000	0.0142	0.0259	0.55×	182%
✅	np.reciprocal(a) (float32)	float32	10,000,000	7.2180	4.1823	1.73×	58%
▫	np.reciprocal(a) (float64)	float64	1,000	0.0008	0.0026	0.31×	322%
🟡	np.reciprocal(a) (float64)	float64	100,000	0.0376	0.0582	0.65×	154%
🟡	np.reciprocal(a) (float64)	float64	10,000,000	14.8973	16.0878	0.93×	108%
✅	np.round (float16)	float16	1,000	0.0058	0.0046	1.26×	80%
✅	np.round (float16)	float16	100,000	0.4702	0.4047	1.16×	86%
✅	np.round (float16)	float16	10,000,000	41.1908	39.4955	1.04×	96%
🟡	np.round (float32)	float32	1,000	0.0011	0.0016	0.74×	136%
🟠	np.round (float32)	float32	100,000	0.0065	0.0269	0.24×	411%
✅	np.round (float32)	float32	10,000,000	7.6748	4.1299	1.86×	54%
🟠	np.round (float64)	float64	1,000	0.0012	0.0054	0.22×	458%
🟠	np.round (float64)	float64	100,000	0.0124	0.0549	0.23×	441%
✅	np.round (float64)	float64	10,000,000	14.9249	13.9922	1.07×	94%
🟠	np.sign (float16)	float16	1,000	0.0014	0.0041	0.34×	292%
🔴	np.sign (float16)	float16	100,000	0.0922	0.6486	0.14×	704%
🟠	np.sign (float16)	float16	10,000,000	14.1494	63.7746	0.22×	451%
🟠	np.sign (float32)	float32	1,000	0.0011	0.0042	0.26×	379%
🟡	np.sign (float32)	float32	100,000	0.2912	0.3816	0.76×	131%
🟡	np.sign (float32)	float32	10,000,000	36.3663	38.1486	0.95×	105%
🔴	np.sign (float64)	float64	1,000	0.0011	0.0055	0.20×	504%
🟡	np.sign (float64)	float64	100,000	0.3016	0.3884	0.78×	129%
🟡	np.sign (float64)	float64	10,000,000	40.3152	44.8085	0.90×	111%
🟡	np.sin (float16)	float16	1,000	0.0053	0.0079	0.67×	149%
🟡	np.sin (float16)	float16	100,000	0.7007	1.1071	0.63×	158%
🟡	np.sin (float16)	float16	10,000,000	78.9906	111.0622	0.71×	141%
✅	np.sin (float32)	float32	1,000	0.0047	0.0038	1.24×	80%
🟡	np.sin (float32)	float32	100,000	0.7041	0.7070	1.00×	100%
✅	np.sin (float32)	float32	10,000,000	79.5476	70.5422	1.13×	89%
✅	np.sin (float64)	float64	1,000	0.0051	0.0041	1.25×	80%
🟡	np.sin (float64)	float64	100,000	0.6997	0.7363	0.95×	105%
✅	np.sin (float64)	float64	10,000,000	78.9810	78.7186	1.00×	100%
✅	np.sqrt (float16)	float16	1,000	0.0046	0.0040	1.15×	87%
✅	np.sqrt (float16)	float16	100,000	0.3887	0.3403	1.14×	88%
✅	np.sqrt (float16)	float16	10,000,000	47.6898	32.7937	1.45×	69%
▫	np.sqrt (float32)	float32	1,000	0.0007	0.0015	0.44×	227%
🟡	np.sqrt (float32)	float32	100,000	0.0151	0.0276	0.55×	182%
✅	np.sqrt (float32)	float32	10,000,000	7.3481	4.2392	1.73×	58%
▫	np.sqrt (float64)	float64	1,000	0.0010	0.0044	0.23×	444%
🟡	np.sqrt (float64)	float64	100,000	0.0558	0.0642	0.87×	115%
✅	np.sqrt (float64)	float64	10,000,000	15.0151	13.7258	1.09×	91%
🟡	np.square(a) (float16)	float16	1,000	0.0035	0.0049	0.72×	138%
🟠	np.square(a) (float16)	float16	100,000	0.2064	0.4497	0.46×	218%
🟡	np.square(a) (float16)	float16	10,000,000	22.6650	43.4725	0.52×	192%
▫	np.square(a) (float32)	float32	1,000	0.0005	0.0015	0.34×	298%
🟠	np.square(a) (float32)	float32	100,000	0.0058	0.0268	0.21×	465%
✅	np.square(a) (float32)	float32	10,000,000	7.3211	4.2896	1.71×	59%
▫	np.square(a) (float64)	float64	1,000	0.0005	0.0025	0.21×	484%
🟠	np.square(a) (float64)	float64	100,000	0.0123	0.0544	0.23×	442%
🟡	np.square(a) (float64)	float64	10,000,000	15.1366	16.4735	0.92×	109%
🟡	np.tan (float16)	float16	1,000	0.0048	0.0083	0.58×	173%
🟡	np.tan (float16)	float16	100,000	0.8034	1.1034	0.73×	137%
🟡	np.tan (float16)	float16	10,000,000	89.8512	110.0293	0.82×	122%
✅	np.tan (float32)	float32	1,000	0.0046	0.0037	1.23×	81%
✅	np.tan (float32)	float32	100,000	0.8164	0.6873	1.19×	84%
✅	np.tan (float32)	float32	10,000,000	90.0943	67.8999	1.33×	75%
🟡	np.tan (float64)	float64	1,000	0.0046	0.0050	0.93×	108%
🟡	np.tan (float64)	float64	100,000	0.8098	0.8479	0.95×	105%
✅	np.tan (float64)	float64	10,000,000	90.9533	89.5086	1.02×	98%
✅	np.trunc(a) (float16)	float16	1,000	0.0051	0.0038	1.34×	75%
✅	np.trunc(a) (float16)	float16	100,000	0.4499	0.3360	1.34×	75%
✅	np.trunc(a) (float16)	float16	10,000,000	42.5258	32.7977	1.30×	77%
▫	np.trunc(a) (float32)	float32	1,000	0.0005	0.0014	0.38×	262%
🟠	np.trunc(a) (float32)	float32	100,000	0.0058	0.0248	0.23×	429%
✅	np.trunc(a) (float32)	float32	10,000,000	7.3663	4.0853	1.80×	56%
▫	np.trunc(a) (float64)	float64	1,000	0.0005	0.0019	0.28×	359%
🟠	np.trunc(a) (float64)	float64	100,000	0.0124	0.0524	0.24×	422%
🟡	np.trunc(a) (float64)	float64	10,000,000	15.0096	16.0305	0.94×	107%

Reduction

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
✅	np.amax (complex128)	complex128	1,000	0.0030	0.0019	1.62×	62%
✅	np.amax (complex128)	complex128	100,000	0.1566	0.1153	1.36×	74%
✅	np.amax (complex128)	complex128	10,000,000	16.6373	13.6040	1.22×	82%
✅	np.amax (float16)	float16	1,000	0.0039	0.0012	3.16×	32%
✅	np.amax (float16)	float16	100,000	0.5006	0.3155	1.59×	63%
✅	np.amax (float16)	float16	10,000,000	50.1383	33.0696	1.52×	66%
▫	np.amax (float32)	float32	1,000	0.0016	0.0007	2.32×	43%
🟡	np.amax (float32)	float32	100,000	0.0059	0.0085	0.70×	144%
🟡	np.amax (float32)	float32	10,000,000	1.4178	1.6223	0.87×	114%
▫	np.amax (float64)	float64	1,000	0.0016	0.0008	2.14×	47%
🟡	np.amax (float64)	float64	100,000	0.0105	0.0181	0.58×	173%
🟡	np.amax (float64)	float64	10,000,000	3.2715	3.9602	0.83×	121%
▫	np.amax (int16)	int16	1,000	0.0015	0.0008	2.01×	50%
✅	np.amax (int16)	int16	100,000	0.0030	0.0015	1.99×	50%
🟡	np.amax (int16)	int16	10,000,000	0.2827	0.3374	0.84×	119%
▫	np.amax (int32)	int32	1,000	0.0016	0.0008	2.02×	50%
✅	np.amax (int32)	int32	100,000	0.0043	0.0023	1.87×	54%
🟡	np.amax (int32)	int32	10,000,000	1.0127	1.1192	0.91×	110%
▫	np.amax (int64)	int64	1,000	0.0016	0.0008	2.07×	48%
✅	np.amax (int64)	int64	100,000	0.0088	0.0079	1.12×	89%
✅	np.amax (int64)	int64	10,000,000	3.8239	3.5708	1.07×	93%
✅	np.amax (int8)	int8	1,000	0.0016	0.0011	1.41×	71%
✅	np.amax (int8)	int8	100,000	0.0023	0.0012	1.94×	52%
🟡	np.amax (int8)	int8	10,000,000	0.1343	0.1496	0.90×	111%
▫	np.amax (uint16)	uint16	1,000	0.0015	0.0007	2.08×	48%
✅	np.amax (uint16)	uint16	100,000	0.0034	0.0015	2.20×	45%
🟡	np.amax (uint16)	uint16	10,000,000	0.2964	0.3173	0.93×	107%
▫	np.amax (uint32)	uint32	1,000	0.0019	0.0007	2.57×	39%
✅	np.amax (uint32)	uint32	100,000	0.0055	0.0032	1.72×	58%
🟡	np.amax (uint32)	uint32	10,000,000	1.0003	1.0486	0.95×	105%
▫	np.amax (uint64)	uint64	1,000	0.0017	0.0007	2.54×	39%
✅	np.amax (uint64)	uint64	100,000	0.0119	0.0103	1.15×	87%
✅	np.amax (uint64)	uint64	10,000,000	3.8010	3.6843	1.03×	97%
✅	np.amax (uint8)	uint8	1,000	0.0016	0.0012	1.38×	72%
✅	np.amax (uint8)	uint8	100,000	0.0024	0.0012	1.97×	51%
✅	np.amax (uint8)	uint8	10,000,000	0.1984	0.1471	1.35×	74%
✅	np.amax axis=0 (complex128)	complex128	1,000	0.0029	0.0029	1.02×	98%
✅	np.amax axis=0 (complex128)	complex128	100,000	0.1417	0.1202	1.18×	85%
✅	np.amax axis=0 (complex128)	complex128	10,000,000	15.7452	13.1310	1.20×	83%
✅	np.amax axis=0 (float16)	float16	1,000	0.0039	0.0021	1.92×	52%
✅	np.amax axis=0 (float16)	float16	100,000	0.5054	0.5030	1.00×	100%
🟡	np.amax axis=0 (float16)	float16	10,000,000	49.4449	75.7723	0.65×	153%
▫	np.amax axis=0 (float32)	float32	1,000	0.0020	0.0008	2.47×	40%
🟡	np.amax axis=0 (float32)	float32	100,000	0.0097	0.0112	0.87×	115%
🟡	np.amax axis=0 (float32)	float32	10,000,000	1.7638	1.9930	0.89×	113%
▫	np.amax axis=0 (float64)	float64	1,000	0.0020	0.0009	2.18×	46%
🟡	np.amax axis=0 (float64)	float64	100,000	0.0165	0.0175	0.94×	106%
🟡	np.amax axis=0 (float64)	float64	10,000,000	4.1500	4.2356	0.98×	102%
▫	np.amax axis=0 (int16)	int16	1,000	0.0019	0.0007	2.81×	36%
✅	np.amax axis=0 (int16)	int16	100,000	0.0062	0.0037	1.68×	60%
✅	np.amax axis=0 (int16)	int16	10,000,000	0.4174	0.3993	1.04×	96%
▫	np.amax axis=0 (int32)	int32	1,000	0.0019	0.0008	2.51×	40%
✅	np.amax axis=0 (int32)	int32	100,000	0.0099	0.0055	1.81×	55%
✅	np.amax axis=0 (int32)	int32	10,000,000	1.5302	1.4232	1.07×	93%
▫	np.amax axis=0 (int64)	int64	1,000	0.0020	0.0008	2.46×	41%
✅	np.amax axis=0 (int64)	int64	100,000	0.0139	0.0129	1.07×	93%
✅	np.amax axis=0 (int64)	int64	10,000,000	4.5156	3.7700	1.20×	84%
✅	np.amax axis=0 (int8)	int8	1,000	0.0019	0.0014	1.44×	70%
✅	np.amax axis=0 (int8)	int8	100,000	0.0075	0.0038	2.00×	50%
✅	np.amax axis=0 (int8)	int8	10,000,000	0.1960	0.1810	1.08×	92%
▫	np.amax axis=0 (uint16)	uint16	1,000	0.0019	0.0007	2.79×	36%
✅	np.amax axis=0 (uint16)	uint16	100,000	0.0062	0.0037	1.71×	58%
✅	np.amax axis=0 (uint16)	uint16	10,000,000	0.4066	0.4009	1.01×	99%
▫	np.amax axis=0 (uint32)	uint32	1,000	0.0019	0.0008	2.39×	42%
✅	np.amax axis=0 (uint32)	uint32	100,000	0.0105	0.0055	1.90×	53%
✅	np.amax axis=0 (uint32)	uint32	10,000,000	1.5582	1.3678	1.14×	88%
▫	np.amax axis=0 (uint64)	uint64	1,000	0.0020	0.0009	2.19×	46%
✅	np.amax axis=0 (uint64)	uint64	100,000	0.0165	0.0149	1.10×	90%
✅	np.amax axis=0 (uint64)	uint64	10,000,000	4.8129	3.8642	1.25×	80%
▫	np.amax axis=0 (uint8)	uint8	1,000	0.0019	0.0007	2.90×	34%
✅	np.amax axis=0 (uint8)	uint8	100,000	0.0079	0.0031	2.60×	38%
✅	np.amax axis=0 (uint8)	uint8	10,000,000	0.1980	0.1853	1.07×	94%
✅	np.amin (complex128)	complex128	1,000	0.0030	0.0018	1.65×	61%
✅	np.amin (complex128)	complex128	100,000	0.1631	0.1144	1.43×	70%
✅	np.amin (complex128)	complex128	10,000,000	16.4507	13.7923	1.19×	84%
✅	np.amin (float16)	float16	1,000	0.0039	0.0011	3.40×	29%
✅	np.amin (float16)	float16	100,000	0.5184	0.2957	1.75×	57%
✅	np.amin (float16)	float16	10,000,000	52.2634	30.6378	1.71×	59%
▫	np.amin (float32)	float32	1,000	0.0016	0.0008	1.96×	51%
🟡	np.amin (float32)	float32	100,000	0.0059	0.0085	0.70×	144%
🟡	np.amin (float32)	float32	10,000,000	1.4309	1.6079	0.89×	112%
▫	np.amin (float64)	float64	1,000	0.0016	0.0008	2.13×	47%
🟡	np.amin (float64)	float64	100,000	0.0102	0.0160	0.64×	157%
🟡	np.amin (float64)	float64	10,000,000	3.4121	3.9668	0.86×	116%
▫	np.amin (int16)	int16	1,000	0.0016	0.0007	2.18×	46%
✅	np.amin (int16)	int16	100,000	0.0034	0.0015	2.24×	45%
🟡	np.amin (int16)	int16	10,000,000	0.3086	0.3322	0.93×	108%
▫	np.amin (int32)	int32	1,000	0.0016	0.0007	2.23×	45%
✅	np.amin (int32)	int32	100,000	0.0043	0.0023	1.90×	53%
✅	np.amin (int32)	int32	10,000,000	1.1001	1.0492	1.05×	95%
▫	np.amin (int64)	int64	1,000	0.0016	0.0007	2.32×	43%
✅	np.amin (int64)	int64	100,000	0.0105	0.0078	1.34×	75%
🟡	np.amin (int64)	int64	10,000,000	3.3743	3.5906	0.94×	106%
▫	np.amin (int8)	int8	1,000	0.0016	0.0007	2.21×	45%
✅	np.amin (int8)	int8	100,000	0.0027	0.0012	2.21×	45%
🟡	np.amin (int8)	int8	10,000,000	0.1287	0.1462	0.88×	114%
▫	np.amin (uint16)	uint16	1,000	0.0016	0.0007	2.21×	45%
✅	np.amin (uint16)	uint16	100,000	0.0039	0.0015	2.62×	38%
✅	np.amin (uint16)	uint16	10,000,000	0.3188	0.3184	1.00×	100%
▫	np.amin (uint32)	uint32	1,000	0.0016	0.0006	2.49×	40%
✅	np.amin (uint32)	uint32	100,000	0.0044	0.0032	1.35×	74%
✅	np.amin (uint32)	uint32	10,000,000	1.0969	1.0524	1.04×	96%
▫	np.amin (uint64)	uint64	1,000	0.0017	0.0008	2.01×	50%
✅	np.amin (uint64)	uint64	100,000	0.0118	0.0102	1.16×	86%
✅	np.amin (uint64)	uint64	10,000,000	3.7562	3.7107	1.01×	99%
▫	np.amin (uint8)	uint8	1,000	0.0016	0.0007	2.20×	45%
✅	np.amin (uint8)	uint8	100,000	0.0028	0.0012	2.34×	43%
🟡	np.amin (uint8)	uint8	10,000,000	0.1207	0.1490	0.81×	124%
🟡	np.amin axis=0 (complex128)	complex128	1,000	0.0029	0.0032	0.93×	107%
🟡	np.amin axis=0 (complex128)	complex128	100,000	0.1390	0.1482	0.94×	107%
✅	np.amin axis=0 (complex128)	complex128	10,000,000	15.7175	15.3632	1.02×	98%
✅	np.amin axis=0 (float16)	float16	1,000	0.0040	0.0021	1.94×	52%
🟡	np.amin axis=0 (float16)	float16	100,000	0.4748	0.5203	0.91×	110%
🟡	np.amin axis=0 (float16)	float16	10,000,000	47.0860	78.8804	0.60×	168%
▫	np.amin axis=0 (float32)	float32	1,000	0.0020	0.0008	2.60×	38%
✅	np.amin axis=0 (float32)	float32	100,000	0.0100	0.0098	1.01×	99%
🟡	np.amin axis=0 (float32)	float32	10,000,000	1.6982	1.8897	0.90×	111%
▫	np.amin axis=0 (float64)	float64	1,000	0.0020	0.0009	2.38×	42%
✅	np.amin axis=0 (float64)	float64	100,000	0.0170	0.0168	1.01×	99%
🟡	np.amin axis=0 (float64)	float64	10,000,000	4.0838	4.2063	0.97×	103%
▫	np.amin axis=0 (int16)	int16	1,000	0.0019	0.0006	3.03×	33%
✅	np.amin axis=0 (int16)	int16	100,000	0.0072	0.0036	1.98×	50%
✅	np.amin axis=0 (int16)	int16	10,000,000	0.4065	0.3871	1.05×	95%
▫	np.amin axis=0 (int32)	int32	1,000	0.0019	0.0007	2.88×	35%
✅	np.amin axis=0 (int32)	int32	100,000	0.0099	0.0055	1.82×	55%
✅	np.amin axis=0 (int32)	int32	10,000,000	1.4950	1.3257	1.13×	89%
▫	np.amin axis=0 (int64)	int64	1,000	0.0020	0.0008	2.60×	38%
✅	np.amin axis=0 (int64)	int64	100,000	0.0151	0.0130	1.15×	87%
✅	np.amin axis=0 (int64)	int64	10,000,000	4.2095	3.6711	1.15×	87%
▫	np.amin axis=0 (int8)	int8	1,000	0.0021	0.0006	3.36×	30%
✅	np.amin axis=0 (int8)	int8	100,000	0.0070	0.0042	1.67×	60%
✅	np.amin axis=0 (int8)	int8	10,000,000	0.1946	0.1865	1.04×	96%
▫	np.amin axis=0 (uint16)	uint16	1,000	0.0024	0.0007	3.58×	28%
✅	np.amin axis=0 (uint16)	uint16	100,000	0.0062	0.0037	1.69×	59%
✅	np.amin axis=0 (uint16)	uint16	10,000,000	0.4283	0.3837	1.12×	90%
▫	np.amin axis=0 (uint32)	uint32	1,000	0.0019	0.0007	2.68×	37%
✅	np.amin axis=0 (uint32)	uint32	100,000	0.0101	0.0055	1.84×	54%
✅	np.amin axis=0 (uint32)	uint32	10,000,000	1.4473	1.4195	1.02×	98%
▫	np.amin axis=0 (uint64)	uint64	1,000	0.0020	0.0008	2.51×	40%
✅	np.amin axis=0 (uint64)	uint64	100,000	0.0162	0.0149	1.08×	92%
✅	np.amin axis=0 (uint64)	uint64	10,000,000	6.5201	3.9728	1.64×	61%
▫	np.amin axis=0 (uint8)	uint8	1,000	0.0031	0.0006	4.95×	20%
✅	np.amin axis=0 (uint8)	uint8	100,000	0.0068	0.0050	1.36×	74%
✅	np.amin axis=0 (uint8)	uint8	10,000,000	0.1993	0.1898	1.05×	95%
🟡	np.argmax (complex128)	complex128	1,000	0.0019	0.0022	0.87×	115%
🟡	np.argmax (complex128)	complex128	100,000	0.1266	0.1481	0.85×	117%
✅	np.argmax (complex128)	complex128	10,000,000	13.9015	13.8404	1.00×	100%
🟡	np.argmax (float16)	float16	1,000	0.0029	0.0031	0.94×	106%
✅	np.argmax (float16)	float16	100,000	0.4335	0.2184	1.98×	50%
✅	np.argmax (float16)	float16	10,000,000	43.8671	14.1525	3.10×	32%
▫	np.argmax (float32)	float32	1,000	0.0009	0.0008	1.05×	95%
🔴	np.argmax (float32)	float32	100,000	0.0087	0.0580	0.15×	669%
🟠	np.argmax (float32)	float32	10,000,000	1.9137	5.7625	0.33×	301%
▫	np.argmax (float64)	float64	1,000	0.0010	0.0012	0.78×	128%
🟠	np.argmax (float64)	float64	100,000	0.0167	0.0592	0.28×	355%
🟡	np.argmax (float64)	float64	10,000,000	4.2645	6.8295	0.62×	160%
▫	np.argmax (int16)	int16	1,000	0.0008	0.0007	1.13×	89%
✅	np.argmax (int16)	int16	100,000	0.0035	0.0032	1.07×	93%
✅	np.argmax (int16)	int16	10,000,000	0.4148	0.3569	1.16×	86%
▫	np.argmax (int32)	int32	1,000	0.0009	0.0007	1.17×	85%
✅	np.argmax (int32)	int32	100,000	0.0060	0.0057	1.05×	95%
✅	np.argmax (int32)	int32	10,000,000	1.6383	1.1982	1.37×	73%
▫	np.argmax (int64)	int64	1,000	0.0011	0.0009	1.21×	83%
🟠	np.argmax (int64)	int64	100,000	0.0156	0.0524	0.30×	335%
🟡	np.argmax (int64)	int64	10,000,000	4.3721	4.6726	0.94×	107%
▫	np.argmax (int8)	int8	1,000	0.0009	0.0007	1.23×	82%
🟡	np.argmax (int8)	int8	100,000	0.0023	0.0023	1.00×	100%
🟡	np.argmax (int8)	int8	10,000,000	0.1639	0.2730	0.60×	167%
▫	np.argmax (uint16)	uint16	1,000	0.0010	0.0007	1.41×	71%
✅	np.argmax (uint16)	uint16	100,000	0.0057	0.0033	1.74×	58%
✅	np.argmax (uint16)	uint16	10,000,000	0.5121	0.3437	1.49×	67%
▫	np.argmax (uint32)	uint32	1,000	0.0009	0.0007	1.23×	81%
✅	np.argmax (uint32)	uint32	100,000	0.0101	0.0057	1.76×	57%
✅	np.argmax (uint32)	uint32	10,000,000	1.8813	1.2228	1.54×	65%
▫	np.argmax (uint64)	uint64	1,000	0.0010	0.0010	0.97×	103%
🟠	np.argmax (uint64)	uint64	100,000	0.0173	0.0601	0.29×	347%
🟡	np.argmax (uint64)	uint64	10,000,000	4.6673	4.9980	0.93×	107%
▫	np.argmax (uint8)	uint8	1,000	0.0009	0.0007	1.27×	79%
✅	np.argmax (uint8)	uint8	100,000	0.0034	0.0023	1.47×	68%
✅	np.argmax (uint8)	uint8	10,000,000	0.2183	0.1747	1.25×	80%
✅	np.argmin (complex128)	complex128	1,000	0.0021	0.0017	1.21×	83%
✅	np.argmin (complex128)	complex128	100,000	0.1271	0.1146	1.11×	90%
🟡	np.argmin (complex128)	complex128	10,000,000	14.2050	20.0184	0.71×	141%
✅	np.argmin (float16)	float16	1,000	0.0030	0.0021	1.42×	70%
✅	np.argmin (float16)	float16	100,000	0.4183	0.1428	2.93×	34%
✅	np.argmin (float16)	float16	10,000,000	42.0779	21.9963	1.91×	52%
▫	np.argmin (float32)	float32	1,000	0.0009	0.0012	0.74×	136%
🔴	np.argmin (float32)	float32	100,000	0.0085	0.0566	0.15×	666%
🟠	np.argmin (float32)	float32	10,000,000	1.9936	6.5124	0.31×	327%
▫	np.argmin (float64)	float64	1,000	0.0010	0.0012	0.81×	124%
🟠	np.argmin (float64)	float64	100,000	0.0172	0.0571	0.30×	332%
🟠	np.argmin (float64)	float64	10,000,000	4.2683	9.2928	0.46×	218%
▫	np.argmin (int16)	int16	1,000	0.0009	0.0007	1.22×	82%
✅	np.argmin (int16)	int16	100,000	0.0041	0.0017	2.43×	41%
🟠	np.argmin (int16)	int16	10,000,000	0.3710	0.7659	0.48×	206%
▫	np.argmin (int32)	int32	1,000	0.0009	0.0007	1.18×	85%
✅	np.argmin (int32)	int32	100,000	0.0064	0.0027	2.42×	41%
🟠	np.argmin (int32)	int32	10,000,000	1.5661	3.8037	0.41×	243%
▫	np.argmin (int64)	int64	1,000	0.0009	0.0009	1.05×	95%
🟠	np.argmin (int64)	int64	100,000	0.0141	0.0285	0.49×	202%
🟠	np.argmin (int64)	int64	10,000,000	4.6382	10.1031	0.46×	218%
▫	np.argmin (int8)	int8	1,000	0.0009	0.0007	1.23×	82%
▫	np.argmin (int8)	int8	100,000	0.0025	0.0010	2.51×	40%
🟡	np.argmin (int8)	int8	10,000,000	0.1575	0.1631	0.97×	104%
▫	np.argmin (uint16)	uint16	1,000	0.0009	0.0007	1.26×	80%
✅	np.argmin (uint16)	uint16	100,000	0.0057	0.0017	3.38×	30%
🟡	np.argmin (uint16)	uint16	10,000,000	0.5604	0.7560	0.74×	135%
▫	np.argmin (uint32)	uint32	1,000	0.0009	0.0007	1.17×	86%
✅	np.argmin (uint32)	uint32	100,000	0.0104	0.0036	2.85×	35%
🟠	np.argmin (uint32)	uint32	10,000,000	1.8309	4.1115	0.45×	225%
▫	np.argmin (uint64)	uint64	1,000	0.0010	0.0009	1.06×	94%
🟡	np.argmin (uint64)	uint64	100,000	0.0172	0.0334	0.52×	194%
🟠	np.argmin (uint64)	uint64	10,000,000	4.5163	9.1975	0.49×	204%
▫	np.argmin (uint8)	uint8	1,000	0.0009	0.0007	1.22×	82%
▫	np.argmin (uint8)	uint8	100,000	0.0031	0.0010	3.17×	32%
✅	np.argmin (uint8)	uint8	10,000,000	0.2245	0.1651	1.36×	74%
🟡	np.cumprod(a) (float16)	float16	1,000	0.0063	0.0099	0.64×	157%
🟠	np.cumprod(a) (float16)	float16	100,000	0.4134	0.9650	0.43×	233%
🟠	np.cumprod(a) (float16)	float16	10,000,000	44.2839	94.7772	0.47×	214%
✅	np.cumprod(a) (float32)	float32	1,000	0.0038	0.0031	1.23×	81%
✅	np.cumprod(a) (float32)	float32	100,000	0.1696	0.1138	1.49×	67%
✅	np.cumprod(a) (float32)	float32	10,000,000	20.7899	10.2126	2.04×	49%
🟡	np.cumprod(a) (float64)	float64	1,000	0.0039	0.0046	0.84×	119%
✅	np.cumprod(a) (float64)	float64	100,000	0.1674	0.1473	1.14×	88%
✅	np.cumprod(a) (float64)	float64	10,000,000	25.0159	14.1834	1.76×	57%
🟡	np.cumsum (complex128)	complex128	1,000	0.0030	0.0032	0.95×	105%
✅	np.cumsum (complex128)	complex128	100,000	0.3630	0.2362	1.54×	65%
✅	np.cumsum (complex128)	complex128	10,000,000	52.8389	25.0336	2.11×	47%
🟡	np.cumsum (float16)	float16	1,000	0.0072	0.0095	0.76×	131%
🟡	np.cumsum (float16)	float16	100,000	0.4668	0.9169	0.51×	196%
🟡	np.cumsum (float16)	float16	10,000,000	49.2891	91.6228	0.54×	186%
✅	np.cumsum (float32)	float32	1,000	0.0028	0.0017	1.60×	62%
✅	np.cumsum (float32)	float32	100,000	0.1619	0.0784	2.06×	48%
✅	np.cumsum (float32)	float32	10,000,000	19.8910	7.4357	2.67×	37%
✅	np.cumsum (float64)	float64	1,000	0.0029	0.0021	1.39×	72%
✅	np.cumsum (float64)	float64	100,000	0.1686	0.1272	1.33×	75%
✅	np.cumsum (float64)	float64	10,000,000	24.4835	14.3123	1.71×	58%
✅	np.cumsum (int16)	int16	1,000	0.0025	0.0019	1.30×	77%
✅	np.cumsum (int16)	int16	100,000	0.3268	0.1215	2.69×	37%
✅	np.cumsum (int16)	int16	10,000,000	28.8643	11.0684	2.61×	38%
✅	np.cumsum (int32)	int32	1,000	0.0025	0.0017	1.48×	67%
✅	np.cumsum (int32)	int32	100,000	0.3144	0.1209	2.60×	38%
✅	np.cumsum (int32)	int32	10,000,000	29.3769	11.6781	2.52×	40%
🟡	np.cumsum (int64)	int64	1,000	0.0017	0.0020	0.87×	115%
🟠	np.cumsum (int64)	int64	100,000	0.0298	0.1205	0.25×	404%
✅	np.cumsum (int64)	int64	10,000,000	15.7029	15.3993	1.02×	98%
✅	np.cumsum (int8)	int8	1,000	0.0033	0.0019	1.71×	58%
✅	np.cumsum (int8)	int8	100,000	0.3408	0.1194	2.85×	35%
✅	np.cumsum (int8)	int8	10,000,000	28.6022	10.6443	2.69×	37%
✅	np.cumsum (uint16)	uint16	1,000	0.0025	0.0019	1.28×	78%
✅	np.cumsum (uint16)	uint16	100,000	0.3213	0.1183	2.72×	37%
✅	np.cumsum (uint16)	uint16	10,000,000	29.1560	11.1585	2.61×	38%
✅	np.cumsum (uint32)	uint32	1,000	0.0025	0.0021	1.17×	86%
✅	np.cumsum (uint32)	uint32	100,000	0.3202	0.1199	2.67×	38%
✅	np.cumsum (uint32)	uint32	10,000,000	29.2400	12.9004	2.27×	44%
🟡	np.cumsum (uint64)	uint64	1,000	0.0017	0.0019	0.93×	108%
🟠	np.cumsum (uint64)	uint64	100,000	0.0335	0.1206	0.28×	359%
✅	np.cumsum (uint64)	uint64	10,000,000	16.3669	14.9772	1.09×	92%
✅	np.cumsum (uint8)	uint8	1,000	0.0024	0.0021	1.15×	87%
✅	np.cumsum (uint8)	uint8	100,000	0.3392	0.1173	2.89×	35%
✅	np.cumsum (uint8)	uint8	10,000,000	29.4047	10.6918	2.75×	36%
✅	np.mean (complex128)	complex128	1,000	0.0026	0.0010	2.58×	39%
✅	np.mean (complex128)	complex128	100,000	0.0303	0.0116	2.62×	38%
✅	np.mean (complex128)	complex128	10,000,000	8.5271	6.8972	1.24×	81%
✅	np.mean (float16)	float16	1,000	0.0047	0.0012	3.86×	26%
✅	np.mean (float16)	float16	100,000	0.1029	0.0804	1.28×	78%
✅	np.mean (float16)	float16	10,000,000	10.3777	8.0110	1.29×	77%
▫	np.mean (float32)	float32	1,000	0.0037	0.0007	5.29×	19%
✅	np.mean (float32)	float32	100,000	0.0170	0.0032	5.22×	19%
✅	np.mean (float32)	float32	10,000,000	2.8795	1.1770	2.45×	41%
▫	np.mean (float64)	float64	1,000	0.0024	0.0008	2.98×	34%
✅	np.mean (float64)	float64	100,000	0.0167	0.0062	2.70×	37%
✅	np.mean (float64)	float64	10,000,000	4.8035	3.0818	1.56×	64%
▫	np.mean (int16)	int16	1,000	0.0030	0.0008	3.63×	28%
✅	np.mean (int16)	int16	100,000	0.0520	0.0191	2.73×	37%
✅	np.mean (int16)	int16	10,000,000	5.0434	3.6523	1.38×	72%
▫	np.mean (int32)	int32	1,000	0.0031	0.0008	3.70×	27%
✅	np.mean (int32)	int32	100,000	0.0384	0.0192	2.00×	50%
✅	np.mean (int32)	int32	10,000,000	4.5473	2.8394	1.60×	62%
▫	np.mean (int64)	int64	1,000	0.0029	0.0007	4.32×	23%
✅	np.mean (int64)	int64	100,000	0.0342	0.0064	5.37×	19%
✅	np.mean (int64)	int64	10,000,000	6.1407	3.0443	2.02×	50%
▫	np.mean (int8)	int8	1,000	0.0044	0.0009	5.05×	20%
✅	np.mean (int8)	int8	100,000	0.0521	0.0188	2.78×	36%
✅	np.mean (int8)	int8	10,000,000	5.0129	1.8465	2.71×	37%
▫	np.mean (uint16)	uint16	1,000	0.0029	0.0008	3.55×	28%
✅	np.mean (uint16)	uint16	100,000	0.0542	0.0191	2.84×	35%
✅	np.mean (uint16)	uint16	10,000,000	5.1089	2.2867	2.23×	45%
▫	np.mean (uint32)	uint32	1,000	0.0030	0.0008	3.59×	28%
✅	np.mean (uint32)	uint32	100,000	0.0399	0.0192	2.08×	48%
✅	np.mean (uint32)	uint32	10,000,000	4.6300	2.8166	1.64×	61%
▫	np.mean (uint64)	uint64	1,000	0.0030	0.0008	3.81×	26%
✅	np.mean (uint64)	uint64	100,000	0.0521	0.0064	8.16×	12%
✅	np.mean (uint64)	uint64	10,000,000	7.8297	3.0240	2.59×	39%
▫	np.mean (uint8)	uint8	1,000	0.0031	0.0009	3.54×	28%
✅	np.mean (uint8)	uint8	100,000	0.0570	0.0190	3.01×	33%
✅	np.mean (uint8)	uint8	10,000,000	5.2869	1.8522	2.85×	35%
✅	np.mean axis=0 (complex128)	complex128	1,000	0.0031	0.0025	1.23×	81%
🟡	np.mean axis=0 (complex128)	complex128	100,000	0.0174	0.0243	0.71×	140%
✅	np.mean axis=0 (complex128)	complex128	10,000,000	7.4300	7.1318	1.04×	96%
✅	np.mean axis=0 (float16)	float16	1,000	0.0056	0.0035	1.59×	63%
🟡	np.mean axis=0 (float16)	float16	100,000	0.0793	0.1507	0.53×	190%
🟠	np.mean axis=0 (float16)	float16	10,000,000	7.0247	14.1582	0.50×	202%
✅	np.mean axis=0 (float32)	float32	1,000	0.0036	0.0021	1.71×	59%
🟡	np.mean axis=0 (float32)	float32	100,000	0.0098	0.0101	0.97×	103%
🟡	np.mean axis=0 (float32)	float32	10,000,000	1.3927	1.4838	0.94×	106%
✅	np.mean axis=0 (float64)	float64	1,000	0.0029	0.0022	1.34×	75%
✅	np.mean axis=0 (float64)	float64	100,000	0.0155	0.0150	1.03×	97%
✅	np.mean axis=0 (float64)	float64	10,000,000	3.7262	3.5836	1.04×	96%
▫	np.mean axis=0 (int16)	int16	1,000	0.0035	0.0008	4.58×	22%
✅	np.mean axis=0 (int16)	int16	100,000	0.0573	0.0084	6.79×	15%
✅	np.mean axis=0 (int16)	int16	10,000,000	5.1418	0.9907	5.19×	19%
▫	np.mean axis=0 (int32)	int32	1,000	0.0036	0.0008	4.45×	22%
✅	np.mean axis=0 (int32)	int32	100,000	0.0399	0.0078	5.11×	20%
✅	np.mean axis=0 (int32)	int32	10,000,000	4.4363	1.9084	2.33×	43%
✅	np.mean axis=0 (int64)	int64	1,000	0.0034	0.0013	2.61×	38%
🟠	np.mean axis=0 (int64)	int64	100,000	0.0298	0.0620	0.48×	208%
🔴	np.mean axis=0 (int64)	int64	10,000,000	6.0028	36.4496	0.17×	607%
▫	np.mean axis=0 (int8)	int8	1,000	0.0040	0.0008	5.10×	20%
✅	np.mean axis=0 (int8)	int8	100,000	0.0481	0.0107	4.49×	22%
✅	np.mean axis=0 (int8)	int8	10,000,000	5.1002	0.8293	6.15×	16%
▫	np.mean axis=0 (uint16)	uint16	1,000	0.0036	0.0008	4.56×	22%
✅	np.mean axis=0 (uint16)	uint16	100,000	0.0487	0.0085	5.73×	18%
✅	np.mean axis=0 (uint16)	uint16	10,000,000	5.1212	0.9833	5.21×	19%
▫	np.mean axis=0 (uint32)	uint32	1,000	0.0035	0.0008	4.29×	23%
✅	np.mean axis=0 (uint32)	uint32	100,000	0.0362	0.0094	3.85×	26%
✅	np.mean axis=0 (uint32)	uint32	10,000,000	4.6000	2.1895	2.10×	48%
✅	np.mean axis=0 (uint64)	uint64	1,000	0.0036	0.0017	2.09×	48%
🟡	np.mean axis=0 (uint64)	uint64	100,000	0.0463	0.0898	0.52×	194%
🔴	np.mean axis=0 (uint64)	uint64	10,000,000	7.2856	41.5410	0.17×	570%
▫	np.mean axis=0 (uint8)	uint8	1,000	0.0038	0.0008	4.73×	21%
✅	np.mean axis=0 (uint8)	uint8	100,000	0.0497	0.0082	6.03×	17%
✅	np.mean axis=0 (uint8)	uint8	10,000,000	5.1578	0.8219	6.28×	16%
✅	np.mean axis=1 (complex128)	complex128	1,000	0.0031	0.0026	1.21×	83%
🟡	np.mean axis=1 (complex128)	complex128	100,000	0.0348	0.0349	1.00×	100%
✅	np.mean axis=1 (complex128)	complex128	10,000,000	8.6206	8.5984	1.00×	100%
✅	np.mean axis=1 (float16)	float16	1,000	0.0049	0.0040	1.23×	82%
🟡	np.mean axis=1 (float16)	float16	100,000	0.0957	0.1374	0.70×	144%
🟡	np.mean axis=1 (float16)	float16	10,000,000	8.1108	13.0257	0.62×	161%
✅	np.mean axis=1 (float32)	float32	1,000	0.0035	0.0021	1.69×	59%
✅	np.mean axis=1 (float32)	float32	100,000	0.0178	0.0143	1.25×	80%
✅	np.mean axis=1 (float32)	float32	10,000,000	3.1620	1.9854	1.59×	63%
✅	np.mean axis=1 (float64)	float64	1,000	0.0031	0.0022	1.43×	70%
✅	np.mean axis=1 (float64)	float64	100,000	0.0210	0.0152	1.38×	72%
✅	np.mean axis=1 (float64)	float64	10,000,000	5.5001	3.8569	1.43×	70%
▫	np.mean axis=1 (int16)	int16	1,000	0.0035	0.0008	4.26×	24%
✅	np.mean axis=1 (int16)	int16	100,000	0.0579	0.0080	7.25×	14%
✅	np.mean axis=1 (int16)	int16	10,000,000	5.2057	0.8685	5.99×	17%
▫	np.mean axis=1 (int32)	int32	1,000	0.0035	0.0008	4.47×	22%
✅	np.mean axis=1 (int32)	int32	100,000	0.0424	0.0049	8.69×	12%
✅	np.mean axis=1 (int32)	int32	10,000,000	4.6015	1.5143	3.04×	33%
✅	np.mean axis=1 (int64)	int64	1,000	0.0034	0.0013	2.60×	38%
🟡	np.mean axis=1 (int64)	int64	100,000	0.0412	0.0600	0.69×	146%
🟡	np.mean axis=1 (int64)	int64	10,000,000	6.5756	7.1615	0.92×	109%
▫	np.mean axis=1 (int8)	int8	1,000	0.0035	0.0009	4.11×	24%
✅	np.mean axis=1 (int8)	int8	100,000	0.0560	0.0089	6.29×	16%
✅	np.mean axis=1 (int8)	int8	10,000,000	5.1060	0.7330	6.97×	14%
▫	np.mean axis=1 (uint16)	uint16	1,000	0.0035	0.0009	4.00×	25%
✅	np.mean axis=1 (uint16)	uint16	100,000	0.0571	0.0079	7.18×	14%
✅	np.mean axis=1 (uint16)	uint16	10,000,000	5.2099	0.8763	5.95×	17%
▫	np.mean axis=1 (uint32)	uint32	1,000	0.0034	0.0008	4.22×	24%
✅	np.mean axis=1 (uint32)	uint32	100,000	0.0462	0.0092	5.01×	20%
✅	np.mean axis=1 (uint32)	uint32	10,000,000	4.8969	1.9956	2.45×	41%
✅	np.mean axis=1 (uint64)	uint64	1,000	0.0037	0.0017	2.14×	47%
🟡	np.mean axis=1 (uint64)	uint64	100,000	0.0536	0.0873	0.61×	163%
✅	np.mean axis=1 (uint64)	uint64	10,000,000	11.1462	9.3389	1.19×	84%
▫	np.mean axis=1 (uint8)	uint8	1,000	0.0035	0.0008	4.44×	22%
✅	np.mean axis=1 (uint8)	uint8	100,000	0.0617	0.0079	7.80×	13%
✅	np.mean axis=1 (uint8)	uint8	10,000,000	5.1481	0.7363	6.99×	14%
✅	np.nanmax(a) (float16)	float16	1,000	0.0053	0.0011	4.74×	21%
✅	np.nanmax(a) (float16)	float16	100,000	0.5135	0.3094	1.66×	60%
✅	np.nanmax(a) (float16)	float16	10,000,000	50.3872	31.6489	1.59×	63%
▫	np.nanmax(a) (float32)	float32	1,000	0.0029	0.0008	3.50×	29%
🟠	np.nanmax(a) (float32)	float32	100,000	0.0071	0.0288	0.25×	407%
🟠	np.nanmax(a) (float32)	float32	10,000,000	1.4848	3.2658	0.46×	220%
✅	np.nanmax(a) (float64)	float64	1,000	0.0037	0.0012	3.02×	33%
🟠	np.nanmax(a) (float64)	float64	100,000	0.0155	0.0603	0.26×	390%
🟠	np.nanmax(a) (float64)	float64	10,000,000	3.4599	7.0157	0.49×	203%
✅	np.nanmean(a) (float16)	float16	1,000	0.0128	0.0017	7.46×	13%
✅	np.nanmean(a) (float16)	float16	100,000	0.3311	0.1059	3.12×	32%
✅	np.nanmean(a) (float16)	float16	10,000,000	37.1950	10.5785	3.52×	28%
✅	np.nanmean(a) (float32)	float32	1,000	0.0096	0.0012	7.87×	13%
✅	np.nanmean(a) (float32)	float32	100,000	0.0749	0.0383	1.96×	51%
✅	np.nanmean(a) (float32)	float32	10,000,000	19.4404	4.1632	4.67×	21%
✅	np.nanmean(a) (float64)	float64	1,000	0.0097	0.0012	7.97×	12%
✅	np.nanmean(a) (float64)	float64	100,000	0.3257	0.0387	8.42×	12%
✅	np.nanmean(a) (float64)	float64	10,000,000	31.3597	5.6141	5.59×	18%
✅	np.nanmedian(a) (float16)	float16	1,000	0.0183	0.0044	4.15×	24%
🟡	np.nanmedian(a) (float16)	float16	100,000	0.9708	1.3140	0.74×	135%
✅	np.nanmedian(a) (float16)	float16	10,000,000	116.3105	93.3718	1.25×	80%
✅	np.nanmedian(a) (float32)	float32	1,000	0.0137	0.0023	5.84×	17%
🟡	np.nanmedian(a) (float32)	float32	100,000	0.4951	0.7126	0.69×	144%
🟡	np.nanmedian(a) (float32)	float32	10,000,000	76.8994	80.3683	0.96×	104%
✅	np.nanmedian(a) (float64)	float64	1,000	0.0116	0.0026	4.42×	23%
🟡	np.nanmedian(a) (float64)	float64	100,000	0.5300	0.7595	0.70×	143%
🟡	np.nanmedian(a) (float64)	float64	10,000,000	91.1907	92.5204	0.99×	102%
✅	np.nanmin(a) (float16)	float16	1,000	0.0054	0.0011	4.89×	20%
✅	np.nanmin(a) (float16)	float16	100,000	0.5116	0.3033	1.69×	59%
✅	np.nanmin(a) (float16)	float16	10,000,000	60.5488	31.1541	1.94×	52%
▫	np.nanmin(a) (float32)	float32	1,000	0.0029	0.0009	3.15×	32%
🟠	np.nanmin(a) (float32)	float32	100,000	0.0070	0.0287	0.24×	408%
🟠	np.nanmin(a) (float32)	float32	10,000,000	1.5149	3.2889	0.46×	217%
✅	np.nanmin(a) (float64)	float64	1,000	0.0030	0.0012	2.43×	41%
🔴	np.nanmin(a) (float64)	float64	100,000	0.0112	0.0589	0.19×	525%
🟡	np.nanmin(a) (float64)	float64	10,000,000	3.5942	6.8799	0.52×	191%
✅	np.nanpercentile(a, 50) (float16)	float16	1,000	0.0316	0.0044	7.16×	14%
✅	np.nanpercentile(a, 50) (float16)	float16	100,000	1.8767	1.3135	1.43×	70%
✅	np.nanpercentile(a, 50) (float16)	float16	10,000,000	122.7941	94.3214	1.30×	77%
✅	np.nanpercentile(a, 50) (float32)	float32	1,000	0.0269	0.0023	11.51×	9%
✅	np.nanpercentile(a, 50) (float32)	float32	100,000	0.7245	0.7038	1.03×	97%
🟡	np.nanpercentile(a, 50) (float32)	float32	10,000,000	51.3261	80.6873	0.64×	157%
✅	np.nanpercentile(a, 50) (float64)	float64	1,000	0.0303	0.0027	11.42×	9%
✅	np.nanpercentile(a, 50) (float64)	float64	100,000	0.7650	0.7593	1.01×	99%
🟡	np.nanpercentile(a, 50) (float64)	float64	10,000,000	63.5936	93.0204	0.68×	146%
✅	np.nanprod(a) (float16)	float16	1,000	0.0057	0.0013	4.38×	23%
✅	np.nanprod(a) (float16)	float16	100,000	0.1646	0.0888	1.85×	54%
✅	np.nanprod(a) (float16)	float16	10,000,000	21.9118	9.1189	2.40×	42%
▫	np.nanprod(a) (float32)	float32	1,000	0.0050	0.0007	7.58×	13%
✅	np.nanprod(a) (float32)	float32	100,000	0.0981	0.0120	8.18×	12%
✅	np.nanprod(a) (float32)	float32	10,000,000	17.9167	1.8087	9.91×	10%
▫	np.nanprod(a) (float64)	float64	1,000	0.0050	0.0009	5.45×	18%
✅	np.nanprod(a) (float64)	float64	100,000	0.1075	0.0235	4.57×	22%
✅	np.nanprod(a) (float64)	float64	10,000,000	29.1353	4.0320	7.23×	14%
✅	np.nanquantile(a, 0.5) (float16)	float16	1,000	0.0317	0.0044	7.18×	14%
✅	np.nanquantile(a, 0.5) (float16)	float16	100,000	1.8705	1.3153	1.42×	70%
✅	np.nanquantile(a, 0.5) (float16)	float16	10,000,000	123.5395	92.3417	1.34×	75%
✅	np.nanquantile(a, 0.5) (float32)	float32	1,000	0.0277	0.0023	11.86×	8%
✅	np.nanquantile(a, 0.5) (float32)	float32	100,000	0.7317	0.7122	1.03×	97%
🟡	np.nanquantile(a, 0.5) (float32)	float32	10,000,000	51.3567	80.5913	0.64×	157%
✅	np.nanquantile(a, 0.5) (float64)	float64	1,000	0.0256	0.0027	9.59×	10%
🟡	np.nanquantile(a, 0.5) (float64)	float64	100,000	0.7457	0.7589	0.98×	102%
🟡	np.nanquantile(a, 0.5) (float64)	float64	10,000,000	64.0411	92.7650	0.69×	145%
✅	np.nanstd(a) (float16)	float16	1,000	0.0342	0.0027	12.50×	8%
✅	np.nanstd(a) (float16)	float16	100,000	1.1469	0.2160	5.31×	19%
✅	np.nanstd(a) (float16)	float16	10,000,000	156.8616	21.7440	7.21×	14%
✅	np.nanstd(a) (float32)	float32	1,000	0.0195	0.0017	11.39×	9%
✅	np.nanstd(a) (float32)	float32	100,000	0.1736	0.0865	2.01×	50%
✅	np.nanstd(a) (float32)	float32	10,000,000	32.1553	9.2600	3.47×	29%
✅	np.nanstd(a) (float64)	float64	1,000	0.0202	0.0015	13.33×	8%
✅	np.nanstd(a) (float64)	float64	100,000	0.4571	0.0760	6.01×	17%
✅	np.nanstd(a) (float64)	float64	10,000,000	50.9740	11.3108	4.51×	22%
✅	np.nansum(a) (float16)	float16	1,000	0.0063	0.0013	4.79×	21%
✅	np.nansum(a) (float16)	float16	100,000	0.2764	0.0898	3.08×	32%
✅	np.nansum(a) (float16)	float16	10,000,000	31.6873	8.9186	3.55×	28%
▫	np.nansum(a) (float32)	float32	1,000	0.0036	0.0007	5.42×	18%
✅	np.nansum(a) (float32)	float32	100,000	0.0337	0.0049	6.81×	15%
✅	np.nansum(a) (float32)	float32	10,000,000	13.4916	1.4504	9.30×	11%
▫	np.nansum(a) (float64)	float64	1,000	0.0036	0.0007	5.52×	18%
✅	np.nansum(a) (float64)	float64	100,000	0.0425	0.0098	4.36×	23%
✅	np.nansum(a) (float64)	float64	10,000,000	24.4520	3.4763	7.03×	14%
✅	np.nanvar(a) (float16)	float16	1,000	0.0320	0.0027	11.67×	9%
✅	np.nanvar(a) (float16)	float16	100,000	1.1778	0.2157	5.46×	18%
✅	np.nanvar(a) (float16)	float16	10,000,000	121.9127	21.5319	5.66×	18%
✅	np.nanvar(a) (float32)	float32	1,000	0.0189	0.0017	11.19×	9%
✅	np.nanvar(a) (float32)	float32	100,000	0.1775	0.0878	2.02×	50%
✅	np.nanvar(a) (float32)	float32	10,000,000	32.2343	9.2642	3.48×	29%
✅	np.nanvar(a) (float64)	float64	1,000	0.0173	0.0015	11.42×	9%
✅	np.nanvar(a) (float64)	float64	100,000	0.4650	0.0759	6.13×	16%
✅	np.nanvar(a) (float64)	float64	10,000,000	51.7630	11.4041	4.54×	22%
▫	np.prod (float64)	float64	1,000	0.0022	0.0008	2.84×	35%
✅	np.prod (float64)	float64	100,000	2.3362	0.1699	13.75×	7%
✅	np.prod (float64)	float64	10,000,000	240.6877	60.9344	3.95×	25%
▫	np.prod (int64)	int64	1,000	0.0023	0.0008	3.04×	33%
✅	np.prod (int64)	int64	100,000	0.0655	0.0144	4.54×	22%
✅	np.prod (int64)	int64	10,000,000	6.4666	3.8559	1.68×	60%
▫	np.prod axis=0 (float64)	float64	1,000	0.0019	0.0007	2.75×	36%
✅	np.prod axis=0 (float64)	float64	100,000	0.0140	0.0099	1.41×	71%
✅	np.prod axis=0 (float64)	float64	10,000,000	22.2109	19.6546	1.13×	88%
▫	np.prod axis=0 (int64)	int64	1,000	0.0019	0.0008	2.35×	43%
✅	np.prod axis=0 (int64)	int64	100,000	0.0285	0.0149	1.91×	52%
✅	np.prod axis=0 (int64)	int64	10,000,000	5.8931	4.2660	1.38×	72%
▫	np.prod axis=1 (float64)	float64	1,000	0.0019	0.0008	2.41×	42%
✅	np.prod axis=1 (float64)	float64	100,000	0.0576	0.0071	8.14×	12%
▫	np.prod axis=1 (float64)	float64	10,000,000	70.8781	2.9565	23.97×	4%
▫	np.prod axis=1 (int64)	int64	1,000	0.0019	0.0010	1.98×	50%
✅	np.prod axis=1 (int64)	int64	100,000	0.0457	0.0171	2.67×	37%
✅	np.prod axis=1 (int64)	int64	10,000,000	6.2300	3.8578	1.61×	62%
✅	np.std (float16)	float16	1,000	0.0198	0.0021	9.46×	11%
✅	np.std (float16)	float16	100,000	0.9087	0.1873	4.85×	21%
✅	np.std (float16)	float16	10,000,000	98.8955	18.9743	5.21×	19%
▫	np.std (float32)	float32	1,000	0.0107	0.0008	12.79×	8%
✅	np.std (float32)	float32	100,000	0.0453	0.0100	4.54×	22%
✅	np.std (float32)	float32	10,000,000	16.0146	3.3593	4.77×	21%
▫	np.std (float64)	float64	1,000	0.0066	0.0010	6.74×	15%
✅	np.std (float64)	float64	100,000	0.0575	0.0202	2.84×	35%
✅	np.std (float64)	float64	10,000,000	30.5191	7.2652	4.20×	24%
✅	np.std axis=0 (float16)	float16	1,000	0.0196	0.0047	4.14×	24%
✅	np.std axis=0 (float16)	float16	100,000	1.0975	0.3754	2.92×	34%
✅	np.std axis=0 (float16)	float16	10,000,000	107.7057	88.6112	1.22×	82%
✅	np.std axis=0 (float32)	float32	1,000	0.0085	0.0017	4.90×	20%
✅	np.std axis=0 (float32)	float32	100,000	0.0373	0.0237	1.57×	64%
✅	np.std axis=0 (float32)	float32	10,000,000	14.4059	5.5122	2.61×	38%
▫	np.std axis=0 (float64)	float64	1,000	0.0074	0.0010	7.55×	13%
✅	np.std axis=0 (float64)	float64	100,000	0.0685	0.0221	3.10×	32%
✅	np.std axis=0 (float64)	float64	10,000,000	39.8234	8.1253	4.90×	20%
▫	np.sum (complex128)	complex128	1,000	0.0018	0.0010	1.84×	54%
✅	np.sum (complex128)	complex128	100,000	0.0306	0.0104	2.93×	34%
✅	np.sum (complex128)	complex128	10,000,000	8.5843	7.2562	1.18×	84%
✅	np.sum (float16)	float16	1,000	0.0036	0.0012	3.02×	33%
✅	np.sum (float16)	float16	100,000	0.2020	0.0835	2.42×	41%
✅	np.sum (float16)	float16	10,000,000	19.9349	8.2364	2.42×	41%
▫	np.sum (float32)	float32	1,000	0.0016	0.0008	2.04×	49%
✅	np.sum (float32)	float32	100,000	0.0152	0.0032	4.72×	21%
✅	np.sum (float32)	float32	10,000,000	2.8487	1.3964	2.04×	49%
▫	np.sum (float64)	float64	1,000	0.0017	0.0008	2.12×	47%
🔴	np.sum (float64)	float64	100,000	0.0159	0.2139	0.074×	1345%
✅	np.sum (float64)	float64	10,000,000	4.8472	3.6648	1.32×	76%
▫	np.sum (int16)	int16	1,000	0.0020	0.0009	2.21×	45%
✅	np.sum (int16)	int16	100,000	0.0328	0.0193	1.70×	59%
✅	np.sum (int16)	int16	10,000,000	3.2851	2.1615	1.52×	66%
▫	np.sum (int32)	int32	1,000	0.0022	0.0009	2.61×	38%
✅	np.sum (int32)	int32	100,000	0.0377	0.0193	1.96×	51%
✅	np.sum (int32)	int32	10,000,000	3.9883	2.8904	1.38×	72%
▫	np.sum (int64)	int64	1,000	0.0017	0.0007	2.48×	40%
✅	np.sum (int64)	int64	100,000	0.0181	0.0065	2.79×	36%
✅	np.sum (int64)	int64	10,000,000	4.3268	3.2874	1.32×	76%
▫	np.sum (int8)	int8	1,000	0.0021	0.0008	2.51×	40%
✅	np.sum (int8)	int8	100,000	0.0333	0.0188	1.77×	56%
✅	np.sum (int8)	int8	10,000,000	3.1769	1.8950	1.68×	60%
▫	np.sum (uint16)	uint16	1,000	0.0020	0.0010	2.09×	48%
✅	np.sum (uint16)	uint16	100,000	0.0334	0.0193	1.73×	58%
✅	np.sum (uint16)	uint16	10,000,000	3.3411	2.0295	1.65×	61%
▫	np.sum (uint32)	uint32	1,000	0.0021	0.0008	2.47×	40%
✅	np.sum (uint32)	uint32	100,000	0.0328	0.0194	1.69×	59%
✅	np.sum (uint32)	uint32	10,000,000	4.0355	2.9673	1.36×	74%
▫	np.sum (uint64)	uint64	1,000	0.0017	0.0008	2.29×	44%
✅	np.sum (uint64)	uint64	100,000	0.0200	0.0064	3.12×	32%
✅	np.sum (uint64)	uint64	10,000,000	4.8125	3.4080	1.41×	71%
▫	np.sum (uint8)	uint8	1,000	0.0023	0.0009	2.56×	39%
✅	np.sum (uint8)	uint8	100,000	0.0349	0.0189	1.85×	54%
✅	np.sum (uint8)	uint8	10,000,000	3.1844	1.9225	1.66×	60%
✅	np.sum axis=0 (complex128)	complex128	1,000	0.0020	0.0017	1.19×	84%
🟡	np.sum axis=0 (complex128)	complex128	100,000	0.0174	0.0207	0.84×	119%
🟡	np.sum axis=0 (complex128)	complex128	10,000,000	7.4801	7.6616	0.98×	102%
✅	np.sum axis=0 (float16)	float16	1,000	0.0049	0.0040	1.22×	82%
✅	np.sum axis=0 (float16)	float16	100,000	0.2901	0.1489	1.95×	51%
✅	np.sum axis=0 (float16)	float16	10,000,000	29.7526	14.4612	2.06×	49%
🟡	np.sum axis=0 (float32)	float32	1,000	0.0019	0.0019	0.98×	102%
✅	np.sum axis=0 (float32)	float32	100,000	0.0081	0.0079	1.02×	98%
🟡	np.sum axis=0 (float32)	float32	10,000,000	1.3909	1.4413	0.96×	104%
🟡	np.sum axis=0 (float64)	float64	1,000	0.0019	0.0020	0.97×	103%
🟡	np.sum axis=0 (float64)	float64	100,000	0.0122	0.0129	0.95×	106%
✅	np.sum axis=0 (float64)	float64	10,000,000	3.6033	3.5571	1.01×	99%
✅	np.sum axis=0 (int16)	int16	1,000	0.0024	0.0010	2.33×	43%
✅	np.sum axis=0 (int16)	int16	100,000	0.0484	0.0047	10.34×	10%
✅	np.sum axis=0 (int16)	int16	10,000,000	4.6103	0.7373	6.25×	16%
▫	np.sum axis=0 (int32)	int32	1,000	0.0025	0.0007	3.51×	28%
✅	np.sum axis=0 (int32)	int32	100,000	0.0479	0.0086	5.59×	18%
✅	np.sum axis=0 (int32)	int32	10,000,000	5.3488	1.9895	2.69×	37%
▫	np.sum axis=0 (int64)	int64	1,000	0.0020	0.0007	2.72×	37%
✅	np.sum axis=0 (int64)	int64	100,000	0.0294	0.0104	2.84×	35%
✅	np.sum axis=0 (int64)	int64	10,000,000	5.9812	3.4043	1.76×	57%
▫	np.sum axis=0 (int8)	int8	1,000	0.0024	0.0009	2.72×	37%
✅	np.sum axis=0 (int8)	int8	100,000	0.0467	0.0043	10.78×	9%
✅	np.sum axis=0 (int8)	int8	10,000,000	4.4559	0.3992	11.16×	9%
▫	np.sum axis=0 (uint16)	uint16	1,000	0.0024	0.0010	2.48×	40%
✅	np.sum axis=0 (uint16)	uint16	100,000	0.0471	0.0047	10.03×	10%
✅	np.sum axis=0 (uint16)	uint16	10,000,000	4.6567	0.7216	6.45×	16%
▫	np.sum axis=0 (uint32)	uint32	1,000	0.0024	0.0007	3.63×	28%
✅	np.sum axis=0 (uint32)	uint32	100,000	0.0475	0.0086	5.52×	18%
✅	np.sum axis=0 (uint32)	uint32	10,000,000	5.3266	1.9748	2.70×	37%
▫	np.sum axis=0 (uint64)	uint64	1,000	0.0020	0.0007	2.88×	35%
✅	np.sum axis=0 (uint64)	uint64	100,000	0.0277	0.0104	2.67×	37%
✅	np.sum axis=0 (uint64)	uint64	10,000,000	5.3910	3.4393	1.57×	64%
▫	np.sum axis=0 (uint8)	uint8	1,000	0.0026	0.0010	2.63×	38%
✅	np.sum axis=0 (uint8)	uint8	100,000	0.0474	0.0050	9.40×	11%
✅	np.sum axis=0 (uint8)	uint8	10,000,000	4.4480	0.5649	7.87×	13%
✅	np.sum axis=1 (complex128)	complex128	1,000	0.0021	0.0018	1.11×	90%
✅	np.sum axis=1 (complex128)	complex128	100,000	0.0324	0.0313	1.03×	97%
🟡	np.sum axis=1 (complex128)	complex128	10,000,000	8.5166	8.9144	0.95×	105%
✅	np.sum axis=1 (float16)	float16	1,000	0.0038	0.0038	1.02×	98%
✅	np.sum axis=1 (float16)	float16	100,000	0.2099	0.1355	1.55×	64%
✅	np.sum axis=1 (float16)	float16	10,000,000	19.3738	13.2482	1.46×	68%
🟡	np.sum axis=1 (float32)	float32	1,000	0.0018	0.0020	0.94×	106%
✅	np.sum axis=1 (float32)	float32	100,000	0.0168	0.0128	1.32×	76%
✅	np.sum axis=1 (float32)	float32	10,000,000	3.1793	2.0144	1.58×	63%
🟡	np.sum axis=1 (float64)	float64	1,000	0.0019	0.0019	0.96×	104%
✅	np.sum axis=1 (float64)	float64	100,000	0.0175	0.0132	1.33×	75%
✅	np.sum axis=1 (float64)	float64	10,000,000	5.1383	3.9398	1.30×	77%
▫	np.sum axis=1 (int16)	int16	1,000	0.0023	0.0007	3.34×	30%
✅	np.sum axis=1 (int16)	int16	100,000	0.0372	0.0038	9.75×	10%
✅	np.sum axis=1 (int16)	int16	10,000,000	3.3329	0.6803	4.90×	20%
▫	np.sum axis=1 (int32)	int32	1,000	0.0025	0.0007	3.60×	28%
✅	np.sum axis=1 (int32)	int32	100,000	0.0364	0.0053	6.86×	15%
✅	np.sum axis=1 (int32)	int32	10,000,000	4.0800	1.7611	2.32×	43%
▫	np.sum axis=1 (int64)	int64	1,000	0.0019	0.0007	2.60×	38%
✅	np.sum axis=1 (int64)	int64	100,000	0.0182	0.0075	2.41×	42%
✅	np.sum axis=1 (int64)	int64	10,000,000	4.5921	3.0301	1.52×	66%
▫	np.sum axis=1 (int8)	int8	1,000	0.0028	0.0008	3.60×	28%
✅	np.sum axis=1 (int8)	int8	100,000	0.0367	0.0038	9.66×	10%
✅	np.sum axis=1 (int8)	int8	10,000,000	3.1418	0.3053	10.29×	10%
▫	np.sum axis=1 (uint16)	uint16	1,000	0.0023	0.0007	3.49×	29%
✅	np.sum axis=1 (uint16)	uint16	100,000	0.0378	0.0037	10.17×	10%
✅	np.sum axis=1 (uint16)	uint16	10,000,000	3.3093	0.4828	6.85×	15%
▫	np.sum axis=1 (uint32)	uint32	1,000	0.0023	0.0007	3.52×	28%
✅	np.sum axis=1 (uint32)	uint32	100,000	0.0363	0.0053	6.84×	15%
✅	np.sum axis=1 (uint32)	uint32	10,000,000	4.0964	1.7182	2.38×	42%
▫	np.sum axis=1 (uint64)	uint64	1,000	0.0019	0.0008	2.51×	40%
✅	np.sum axis=1 (uint64)	uint64	100,000	0.0182	0.0076	2.40×	42%
✅	np.sum axis=1 (uint64)	uint64	10,000,000	5.0124	2.9323	1.71×	58%
▫	np.sum axis=1 (uint8)	uint8	1,000	0.0026	0.0007	3.91×	26%
✅	np.sum axis=1 (uint8)	uint8	100,000	0.0377	0.0037	10.22×	10%
✅	np.sum axis=1 (uint8)	uint8	10,000,000	3.1519	0.3047	10.34×	10%
✅	np.var (float16)	float16	1,000	0.0196	0.0022	9.03×	11%
✅	np.var (float16)	float16	100,000	0.8945	0.1898	4.71×	21%
✅	np.var (float16)	float16	10,000,000	90.2053	18.7450	4.81×	21%
▫	np.var (float32)	float32	1,000	0.0077	0.0010	7.83×	13%
✅	np.var (float32)	float32	100,000	0.0460	0.0122	3.77×	26%
✅	np.var (float32)	float32	10,000,000	16.3933	3.3367	4.91×	20%
▫	np.var (float64)	float64	1,000	0.0085	0.0010	8.62×	12%
✅	np.var (float64)	float64	100,000	0.0651	0.0197	3.30×	30%
✅	np.var (float64)	float64	10,000,000	30.9039	10.2952	3.00×	33%
✅	np.var axis=0 (float16)	float16	1,000	0.0191	0.0047	4.09×	24%
✅	np.var axis=0 (float16)	float16	100,000	1.0938	0.3838	2.85×	35%
✅	np.var axis=0 (float16)	float16	10,000,000	107.4462	86.2534	1.25×	80%
✅	np.var axis=0 (float32)	float32	1,000	0.0082	0.0019	4.18×	24%
✅	np.var axis=0 (float32)	float32	100,000	0.0367	0.0235	1.56×	64%
✅	np.var axis=0 (float32)	float32	10,000,000	13.9379	5.6308	2.48×	40%
▫	np.var axis=0 (float64)	float64	1,000	0.0071	0.0010	7.21×	14%
✅	np.var axis=0 (float64)	float64	100,000	0.0665	0.0227	2.93×	34%
✅	np.var axis=0 (float64)	float64	10,000,000	44.1983	8.6817	5.09×	20%

Broadcasting

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
⚪	matrix + col_vector (N,M)+(N,1)	float64	1,000	0.0012	-	-	-
⚪	matrix + col_vector (N,M)+(N,1)	float64	100,000	0.0282	-	-	-
✅	matrix + col_vector (N,M)+(N,1)	float64	10,000,000	16.1367	14.9780	1.08×	93%
⚪	matrix + row_vector (N,M)+(M,)	float64	1,000	0.0012	-	-	-
⚪	matrix + row_vector (N,M)+(M,)	float64	100,000	0.0268	-	-	-
✅	matrix + row_vector (N,M)+(M,)	float64	10,000,000	16.5907	14.7614	1.12×	89%
⚪	matrix + scalar	float64	1,000	0.0007	-	-	-
⚪	matrix + scalar	float64	100,000	0.0127	-	-	-
✅	matrix + scalar	float64	10,000,000	16.0746	14.6726	1.10×	91%
⚪	np.broadcast_to(row, (N,M))	float64	1,000	0.0019	-	-	-
⚪	np.broadcast_to(row, (N,M))	float64	100,000	0.0018	-	-	-
▫	np.broadcast_to(row, (N,M))	float64	10,000,000	0.0018	0.0007	2.68×	37%

Creation

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
▫	np.copy (float32)	float32	1,000	0.0006	0.0107	0.056×	1785%
🟡	np.copy (float32)	float32	100,000	0.0060	0.0072	0.84×	119%
✅	np.copy (float32)	float32	10,000,000	6.3236	2.8506	2.22×	45%
▫	np.copy (float64)	float64	1,000	0.0006	0.0146	0.041×	2444%
🟡	np.copy (float64)	float64	100,000	0.0115	0.0133	0.86×	116%
🟡	np.copy (float64)	float64	10,000,000	13.1481	14.2102	0.93×	108%
▫	np.copy (int32)	int32	1,000	0.0006	0.0101	0.057×	1765%
🟡	np.copy (int32)	int32	100,000	0.0068	0.0070	0.97×	103%
✅	np.copy (int32)	int32	10,000,000	6.4479	2.3947	2.69×	37%
▫	np.copy (int64)	int64	1,000	0.0006	0.0155	0.040×	2479%
🟡	np.copy (int64)	int64	100,000	0.0116	0.0133	0.87×	114%
🟡	np.copy (int64)	int64	10,000,000	13.0440	13.5955	0.96×	104%
▫	np.empty (float32)	float32	1,000	0.0003	0.0079	0.041×	2410%
▫	np.empty (float32)	float32	100,000	0.0003	0.0123	0.026×	3788%
🟡	np.empty (float32)	float32	10,000,000	0.0136	0.0154	0.89×	113%
▫	np.empty (float64)	float64	1,000	0.0003	0.0141	0.021×	4785%
▫	np.empty (float64)	float64	100,000	0.0003	0.0118	0.024×	4137%
🟡	np.empty (float64)	float64	10,000,000	0.0102	0.0143	0.72×	139%
▫	np.empty (int32)	int32	1,000	0.0003	0.0104	0.031×	3239%
▫	np.empty (int32)	int32	100,000	0.0003	0.0141	0.021×	4659%
✅	np.empty (int32)	int32	10,000,000	0.0167	0.0132	1.26×	79%
▫	np.empty (int64)	int64	1,000	0.0003	0.0121	0.026×	3888%
▫	np.empty (int64)	int64	100,000	0.0003	0.0139	0.023×	4389%
🟡	np.empty (int64)	int64	10,000,000	0.0108	0.0174	0.62×	162%
▫	np.full (float32)	float32	1,000	0.0009	0.0106	0.083×	1199%
🟠	np.full (float32)	float32	100,000	0.0057	0.0129	0.44×	228%
✅	np.full (float32)	float32	10,000,000	7.2846	2.6587	2.74×	36%
▫	np.full (float64)	float64	1,000	0.0009	0.0106	0.082×	1218%
🟡	np.full (float64)	float64	100,000	0.0100	0.0144	0.69×	145%
✅	np.full (float64)	float64	10,000,000	14.8069	13.2111	1.12×	89%
▫	np.full (int32)	int32	1,000	0.0009	0.0088	0.11×	925%
🟠	np.full (int32)	int32	100,000	0.0054	0.0127	0.43×	235%
✅	np.full (int32)	int32	10,000,000	7.2671	2.6612	2.73×	37%
▫	np.full (int64)	int64	1,000	0.0009	0.0124	0.069×	1448%
🟡	np.full (int64)	int64	100,000	0.0099	0.0152	0.65×	154%
✅	np.full (int64)	int64	10,000,000	14.7618	13.5495	1.09×	92%
▫	np.ones (float32)	float32	1,000	0.0009	0.0097	0.093×	1080%
🟠	np.ones (float32)	float32	100,000	0.0053	0.0125	0.42×	236%
✅	np.ones (float32)	float32	10,000,000	7.4168	2.5871	2.87×	35%
▫	np.ones (float64)	float64	1,000	0.0009	0.0140	0.062×	1605%
🟡	np.ones (float64)	float64	100,000	0.0098	0.0153	0.64×	156%
✅	np.ones (float64)	float64	10,000,000	14.7708	13.0423	1.13×	88%
▫	np.ones (int32)	int32	1,000	0.0009	0.0088	0.10×	1004%
🟡	np.ones (int32)	int32	100,000	0.0076	0.0124	0.61×	164%
✅	np.ones (int32)	int32	10,000,000	7.3873	2.6333	2.81×	36%
▫	np.ones (int64)	int64	1,000	0.0008	0.0139	0.061×	1638%
🟡	np.ones (int64)	int64	100,000	0.0098	0.0149	0.66×	152%
✅	np.ones (int64)	int64	10,000,000	14.7014	13.3927	1.10×	91%
▫	np.zeros (float32)	float32	1,000	0.0005	0.0105	0.051×	1958%
✅	np.zeros (float32)	float32	100,000	0.0048	0.0021	2.31×	43%
✅	np.zeros (float32)	float32	10,000,000	0.0110	0.0068	1.62×	62%
▫	np.zeros (float64)	float64	1,000	0.0004	0.0130	0.028×	3535%
✅	np.zeros (float64)	float64	100,000	0.0093	0.0026	3.57×	28%
✅	np.zeros (float64)	float64	10,000,000	0.0120	0.0068	1.76×	57%
▫	np.zeros (int32)	int32	1,000	0.0004	0.0114	0.035×	2881%
✅	np.zeros (int32)	int32	100,000	0.0048	0.0020	2.44×	41%
✅	np.zeros (int32)	int32	10,000,000	0.0139	0.0058	2.39×	42%
▫	np.zeros (int64)	int64	1,000	0.0004	0.0084	0.046×	2187%
✅	np.zeros (int64)	int64	100,000	0.0096	0.0026	3.63×	28%
✅	np.zeros (int64)	int64	10,000,000	0.0112	0.0091	1.23×	81%
🔴	np.zeros_like (float32)	float32	1,000	0.0011	0.0088	0.12×	826%
✅	np.zeros_like (float32)	float32	100,000	0.0056	0.0022	2.59×	39%
▫	np.zeros_like (float32)	float32	10,000,000	7.3581	0.0069	1061.51×	0%
🔴	np.zeros_like (float64)	float64	1,000	0.0010	0.0148	0.068×	1471%
✅	np.zeros_like (float64)	float64	100,000	0.0101	0.0027	3.69×	27%
▫	np.zeros_like (float64)	float64	10,000,000	14.7410	0.0069	2150.69×	0%
🔴	np.zeros_like (int32)	int32	1,000	0.0011	0.0111	0.095×	1052%
✅	np.zeros_like (int32)	int32	100,000	0.0054	0.0021	2.58×	39%
▫	np.zeros_like (int32)	int32	10,000,000	7.4489	0.0061	1230.61×	0%
🔴	np.zeros_like (int64)	int64	1,000	0.0011	0.0118	0.095×	1056%
✅	np.zeros_like (int64)	int64	100,000	0.0100	0.0028	3.55×	28%
▫	np.zeros_like (int64)	int64	10,000,000	14.7656	0.0093	1585.88×	0%

Manipulation

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
⚪	a.T (2D)	float64	1,000	0.0001	-	-	-
⚪	a.T (2D)	float64	100,000	0.0001	-	-	-
⚪	a.T (2D)	float64	10,000,000	0.0001	-	-	-
⚪	a.flatten	float64	1,000	0.0005	-	-	-
🔴	a.flatten	float64	100,000	0.0152	0.0997	0.15×	657%
✅	a.flatten	float64	10,000,000	13.1072	12.5501	1.04×	96%
⚪	np.concatenate	float64	1,000	0.0010	-	-	-
⚪	np.concatenate	float64	100,000	0.3267	-	-	-
⚪	np.concatenate	float64	10,000,000	34.0246	-	-	-
⚪	np.ravel	float64	1,000	0.0003	-	-	-
▫	np.ravel	float64	100,000	0.0003	0.0006	0.55×	181%
▫	np.ravel	float64	10,000,000	0.0004	0.0006	0.59×	168%
⚪	np.stack	float64	1,000	0.0021	-	-	-
⚪	np.stack	float64	100,000	0.3333	-	-	-
⚪	np.stack	float64	10,000,000	33.5715	-	-	-
⚪	np.transpose (2D)	float64	1,000	0.0004	-	-	-
⚪	np.transpose (2D)	float64	100,000	0.0004	-	-	-
⚪	np.transpose (2D)	float64	10,000,000	0.0004	-	-	-
⚪	reshape 1D->2D	float64	1,000	0.0002	-	-	-
⚪	reshape 1D->2D	float64	100,000	0.0002	-	-	-
⚪	reshape 1D->2D	float64	10,000,000	0.0002	-	-	-
⚪	reshape 2D->1D	float64	1,000	0.0002	-	-	-
▫	reshape 2D->1D	float64	100,000	0.0002	0.0006	0.29×	349%
▫	reshape 2D->1D	float64	10,000,000	0.0002	0.0007	0.25×	405%

Slicing

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
⚪	a[100:1000] (contiguous)	float64	1,000	0.0002	-	-	-
⚪	a[100:1000] (contiguous)	float64	100,000	0.0002	-	-	-
⚪	a[100:1000] (contiguous)	float64	10,000,000	0.0002	-	-	-
⚪	a[::-1] (reversed)	float64	1,000	0.0001	-	-	-
▫	a[::-1] (reversed)	float64	100,000	0.0002	0.0015	0.11×	937%
▫	a[::-1] (reversed)	float64	10,000,000	0.0001	0.0013	0.092×	1091%
⚪	a[::2] (strided)	float64	1,000	0.0001	-	-	-
⚪	a[::2] (strided)	float64	100,000	0.0001	-	-	-
⚪	a[::2] (strided)	float64	10,000,000	0.0002	-	-	-
⚪	np.sum(contiguous_slice)	float64	900	0.0016	-	-	-
⚪	np.sum(contiguous_slice)	float64	900	0.0016	-	-	-
⚪	np.sum(contiguous_slice)	float64	900	0.0017	-	-	-
⚪	np.sum(strided_slice)	float64	500	0.0016	-	-	-
⚪	np.sum(strided_slice)	float64	50,000	0.0097	-	-	-
⚪	np.sum(strided_slice)	float64	5,000,000	4.3559	-	-	-

Comparison

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
▫	a != b (float32)	float32	1,000	0.0005	0.0008	0.66×	151%
🟠	a != b (float32)	float32	100,000	0.0055	0.0210	0.26×	385%
✅	a != b (float32)	float32	10,000,000	4.0035	3.8343	1.04×	96%
▫	a != b (float64)	float64	1,000	0.0004	0.0008	0.53×	188%
🟠	a != b (float64)	float64	100,000	0.0099	0.0261	0.38×	264%
🟡	a != b (float64)	float64	10,000,000	6.8612	6.8679	1.00×	100%
▫	a != b (int32)	int32	1,000	0.0004	0.0008	0.54×	184%
🟠	a != b (int32)	int32	100,000	0.0070	0.0195	0.36×	280%
✅	a != b (int32)	int32	10,000,000	4.4415	3.8892	1.14×	88%
▫	a != b (int64)	int64	1,000	0.0005	0.0009	0.56×	177%
🟠	a != b (int64)	int64	100,000	0.0126	0.0280	0.45×	222%
✅	a != b (int64)	int64	10,000,000	7.4973	6.9054	1.09×	92%
▫	a < b (float32)	float32	1,000	0.0005	0.0008	0.62×	160%
🟠	a < b (float32)	float32	100,000	0.0054	0.0215	0.25×	396%
🟡	a < b (float32)	float32	10,000,000	3.9556	3.9752	0.99×	100%
▫	a < b (float64)	float64	1,000	0.0004	0.0008	0.55×	183%
🟠	a < b (float64)	float64	100,000	0.0102	0.0287	0.36×	280%
🟡	a < b (float64)	float64	10,000,000	6.7457	6.7981	0.99×	101%
▫	a < b (int32)	int32	1,000	0.0004	0.0008	0.52×	191%
🟠	a < b (int32)	int32	100,000	0.0070	0.0175	0.40×	249%
✅	a < b (int32)	int32	10,000,000	4.2024	3.8654	1.09×	92%
▫	a < b (int64)	int64	1,000	0.0005	0.0010	0.55×	182%
🟡	a < b (int64)	int64	100,000	0.0178	0.0271	0.66×	152%
✅	a < b (int64)	int64	10,000,000	7.2004	6.6980	1.07×	93%
▫	a <= b (float32)	float32	1,000	0.0004	0.0009	0.43×	231%
🟠	a <= b (float32)	float32	100,000	0.0058	0.0206	0.28×	355%
✅	a <= b (float32)	float32	10,000,000	4.0141	3.9178	1.02×	98%
▫	a <= b (float64)	float64	1,000	0.0005	0.0008	0.56×	180%
🟠	a <= b (float64)	float64	100,000	0.0102	0.0279	0.37×	274%
🟡	a <= b (float64)	float64	10,000,000	6.9314	7.5527	0.92×	109%
▫	a <= b (int32)	int32	1,000	0.0004	0.0008	0.53×	190%
🟠	a <= b (int32)	int32	100,000	0.0070	0.0183	0.39×	260%
✅	a <= b (int32)	int32	10,000,000	4.3206	3.9855	1.08×	92%
▫	a <= b (int64)	int64	1,000	0.0033	0.0008	4.37×	23%
🟡	a <= b (int64)	int64	100,000	0.0179	0.0277	0.65×	155%
✅	a <= b (int64)	int64	10,000,000	7.3167	6.8152	1.07×	93%
▫	a == b (float32)	float32	1,000	0.0005	0.0008	0.60×	167%
🟠	a == b (float32)	float32	100,000	0.0057	0.0222	0.26×	391%
✅	a == b (float32)	float32	10,000,000	4.2784	3.8917	1.10×	91%
▫	a == b (float64)	float64	1,000	0.0004	0.0008	0.53×	190%
🟠	a == b (float64)	float64	100,000	0.0102	0.0256	0.40×	250%
✅	a == b (float64)	float64	10,000,000	6.7360	6.6513	1.01×	99%
▫	a == b (int32)	int32	1,000	0.0005	0.0008	0.65×	153%
🟠	a == b (int32)	int32	100,000	0.0070	0.0179	0.39×	257%
✅	a == b (int32)	int32	10,000,000	4.3115	3.8389	1.12×	89%
▫	a == b (int64)	int64	1,000	0.0004	0.0008	0.53×	189%
🟠	a == b (int64)	int64	100,000	0.0124	0.0277	0.45×	223%
✅	a == b (int64)	int64	10,000,000	7.1056	6.8700	1.03×	97%
▫	a > b (float32)	float32	1,000	0.0004	0.0008	0.54×	184%
🟠	a > b (float32)	float32	100,000	0.0057	0.0211	0.27×	369%
✅	a > b (float32)	float32	10,000,000	4.0557	4.0290	1.01×	99%
▫	a > b (float64)	float64	1,000	0.0004	0.0008	0.53×	189%
🟠	a > b (float64)	float64	100,000	0.0100	0.0257	0.39×	256%
🟡	a > b (float64)	float64	10,000,000	6.7723	6.8430	0.99×	101%
▫	a > b (int32)	int32	1,000	0.0004	0.0008	0.52×	192%
🟠	a > b (int32)	int32	100,000	0.0070	0.0199	0.35×	284%
✅	a > b (int32)	int32	10,000,000	4.3282	3.9012	1.11×	90%
▫	a > b (int64)	int64	1,000	0.0005	0.0008	0.66×	151%
🟡	a > b (int64)	int64	100,000	0.0189	0.0269	0.70×	142%
✅	a > b (int64)	int64	10,000,000	7.3191	6.5042	1.12×	89%
▫	a >= b (float32)	float32	1,000	0.0004	0.0008	0.50×	200%
🟠	a >= b (float32)	float32	100,000	0.0059	0.0205	0.29×	349%
🟡	a >= b (float32)	float32	10,000,000	3.9175	3.9675	0.99×	101%
▫	a >= b (float64)	float64	1,000	0.0004	0.0008	0.53×	190%
🟠	a >= b (float64)	float64	100,000	0.0103	0.0262	0.39×	256%
🟡	a >= b (float64)	float64	10,000,000	6.7369	7.2300	0.93×	107%
▫	a >= b (int32)	int32	1,000	0.0005	0.0008	0.56×	179%
🟠	a >= b (int32)	int32	100,000	0.0069	0.0191	0.36×	275%
✅	a >= b (int32)	int32	10,000,000	4.4423	3.9289	1.13×	88%
▫	a >= b (int64)	int64	1,000	0.0005	0.0008	0.68×	148%
🟡	a >= b (int64)	int64	100,000	0.0178	0.0284	0.63×	160%
✅	a >= b (int64)	int64	10,000,000	7.5761	6.8095	1.11×	90%

Bitwise

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
▫	a & b (bool)	bool	1,000	0.0004	0.0016	0.24×	418%
🔴	a & b (bool)	bool	100,000	0.0029	0.0240	0.12×	815%
🟡	a & b (bool)	bool	10,000,000	1.9362	2.3708	0.82×	122%
▫	a & b (int16)	int16	1,000	0.0008	0.0021	0.36×	275%
✅	a & b (int16)	int16	100,000	0.0369	0.0131	2.81×	36%
✅	a & b (int16)	int16	10,000,000	5.1340	3.0763	1.67×	60%
▫	a & b (int32)	int32	1,000	0.0008	0.0069	0.11×	876%
🟡	a & b (int32)	int32	100,000	0.0291	0.0311	0.94×	107%
✅	a & b (int32)	int32	10,000,000	9.2134	6.2718	1.47×	68%
▫	a & b (int64)	int64	1,000	0.0008	0.0120	0.065×	1544%
🟡	a & b (int64)	int64	100,000	0.0328	0.0569	0.57×	174%
🟡	a & b (int64)	int64	10,000,000	18.5987	19.4528	0.96×	105%
▫	a & b (int8)	int8	1,000	0.0007	0.0013	0.58×	172%
✅	a & b (int8)	int8	100,000	0.0288	0.0085	3.39×	30%
✅	a & b (int8)	int8	10,000,000	3.8601	1.5868	2.43×	41%
▫	a & b (uint16)	uint16	1,000	0.0008	0.0022	0.35×	283%
✅	a & b (uint16)	uint16	100,000	0.0291	0.0138	2.11×	48%
✅	a & b (uint16)	uint16	10,000,000	7.4077	2.9658	2.50×	40%
▫	a & b (uint32)	uint32	1,000	0.0008	0.0023	0.37×	270%
✅	a & b (uint32)	uint32	100,000	0.0337	0.0278	1.21×	82%
✅	a & b (uint32)	uint32	10,000,000	9.0297	5.8148	1.55×	64%
▫	a & b (uint64)	uint64	1,000	0.0008	0.0066	0.12×	856%
🟡	a & b (uint64)	uint64	100,000	0.0353	0.0608	0.58×	172%
🟡	a & b (uint64)	uint64	10,000,000	17.0949	18.1468	0.94×	106%
▫	a & b (uint8)	uint8	1,000	0.0006	0.0013	0.50×	201%
✅	a & b (uint8)	uint8	100,000	0.0285	0.0080	3.58×	28%
✅	a & b (uint8)	uint8	10,000,000	3.8145	1.5470	2.47×	41%
▫	a ^ b (bool)	bool	1,000	0.0004	0.0015	0.25×	401%
🔴	a ^ b (bool)	bool	100,000	0.0030	0.0228	0.13×	752%
🟡	a ^ b (bool)	bool	10,000,000	1.9149	2.4520	0.78×	128%
▫	a ^ b (int16)	int16	1,000	0.0008	0.0022	0.35×	281%
✅	a ^ b (int16)	int16	100,000	0.0285	0.0144	1.98×	50%
✅	a ^ b (int16)	int16	10,000,000	5.2473	2.9006	1.81×	55%
🟠	a ^ b (int32)	int32	1,000	0.0019	0.0073	0.26×	381%
🟡	a ^ b (int32)	int32	100,000	0.0289	0.0304	0.95×	105%
✅	a ^ b (int32)	int32	10,000,000	8.9648	6.1135	1.47×	68%
▫	a ^ b (int64)	int64	1,000	0.0008	0.0123	0.064×	1554%
🟡	a ^ b (int64)	int64	100,000	0.0311	0.0617	0.50×	198%
✅	a ^ b (int64)	int64	10,000,000	20.4191	19.7104	1.04×	96%
▫	a ^ b (int8)	int8	1,000	0.0006	0.0014	0.47×	215%
✅	a ^ b (int8)	int8	100,000	0.0285	0.0083	3.43×	29%
✅	a ^ b (int8)	int8	10,000,000	3.8174	1.6025	2.38×	42%
▫	a ^ b (uint16)	uint16	1,000	0.0008	0.0023	0.33×	302%
✅	a ^ b (uint16)	uint16	100,000	0.0287	0.0146	1.97×	51%
✅	a ^ b (uint16)	uint16	10,000,000	5.8436	2.9363	1.99×	50%
▫	a ^ b (uint32)	uint32	1,000	0.0008	0.0035	0.22×	446%
✅	a ^ b (uint32)	uint32	100,000	0.0286	0.0274	1.04×	96%
✅	a ^ b (uint32)	uint32	10,000,000	8.8120	5.8908	1.50×	67%
▫	a ^ b (uint64)	uint64	1,000	0.0009	0.0128	0.069×	1457%
🟡	a ^ b (uint64)	uint64	100,000	0.0300	0.0587	0.51×	196%
🟡	a ^ b (uint64)	uint64	10,000,000	17.2203	17.4055	0.99×	101%
▫	a ^ b (uint8)	uint8	1,000	0.0007	0.0013	0.50×	200%
✅	a ^ b (uint8)	uint8	100,000	0.0286	0.0097	2.94×	34%
✅	a ^ b (uint8)	uint8	10,000,000	4.0447	1.4824	2.73×	37%
▫	a	b (bool)	bool	1,000	0.0004	0.0014	0.27×	377%
🔴	a	b (bool)	bool	100,000	0.0029	0.0244	0.12×	852%
🟡	a	b (bool)	bool	10,000,000	2.0040	2.5681	0.78×	128%
▫	a	b (int16)	int16	1,000	0.0009	0.0022	0.40×	251%
✅	a	b (int16)	int16	100,000	0.0286	0.0138	2.08×	48%
✅	a	b (int16)	int16	10,000,000	5.2591	2.9088	1.81×	55%
▫	a	b (int32)	int32	1,000	0.0008	0.0052	0.15×	654%
🟡	a	b (int32)	int32	100,000	0.0287	0.0301	0.95×	105%
✅	a	b (int32)	int32	10,000,000	10.1933	6.1209	1.67×	60%
▫	a	b (int64)	int64	1,000	0.0008	0.0116	0.069×	1454%
🟡	a	b (int64)	int64	100,000	0.0325	0.0643	0.51×	198%
🟡	a	b (int64)	int64	10,000,000	17.4904	19.2407	0.91×	110%
▫	a	b (int8)	int8	1,000	0.0007	0.0013	0.53×	188%
✅	a	b (int8)	int8	100,000	0.0298	0.0093	3.20×	31%
✅	a	b (int8)	int8	10,000,000	4.0815	1.7639	2.31×	43%
▫	a	b (uint16)	uint16	1,000	0.0008	0.0026	0.30×	332%
✅	a	b (uint16)	uint16	100,000	0.0300	0.0151	1.98×	50%
✅	a	b (uint16)	uint16	10,000,000	5.8621	2.8445	2.06×	48%
▫	a	b (uint32)	uint32	1,000	0.0009	0.0040	0.22×	461%
🟡	a	b (uint32)	uint32	100,000	0.0287	0.0292	0.98×	102%
✅	a	b (uint32)	uint32	10,000,000	8.7585	5.7854	1.51×	66%
▫	a	b (uint64)	uint64	1,000	0.0008	0.0087	0.091×	1094%
🟡	a	b (uint64)	uint64	100,000	0.0383	0.0625	0.61×	163%
✅	a	b (uint64)	uint64	10,000,000	17.6590	17.4118	1.01×	99%
▫	a	b (uint8)	uint8	1,000	0.0007	0.0012	0.57×	176%
✅	a	b (uint8)	uint8	100,000	0.0292	0.0107	2.73×	37%
✅	a	b (uint8)	uint8	10,000,000	4.0708	1.5442	2.64×	38%
▫	np.invert(a) (bool)	bool	1,000	0.0004	0.0015	0.24×	412%
🔴	np.invert(a) (bool)	bool	100,000	0.0022	0.0237	0.094×	1068%
🟡	np.invert(a) (bool)	bool	10,000,000	1.7472	2.4556	0.71×	140%
▫	np.invert(a) (int16)	int16	1,000	0.0009	0.0021	0.43×	230%
✅	np.invert(a) (int16)	int16	100,000	0.0257	0.0133	1.94×	52%
✅	np.invert(a) (int16)	int16	10,000,000	4.6982	2.3993	1.96×	51%
▫	np.invert(a) (int32)	int32	1,000	0.0008	0.0024	0.32×	309%
🟡	np.invert(a) (int32)	int32	100,000	0.0261	0.0327	0.80×	125%
✅	np.invert(a) (int32)	int32	10,000,000	8.1259	5.3159	1.53×	65%
▫	np.invert(a) (int64)	int64	1,000	0.0007	0.0071	0.10×	969%
🟠	np.invert(a) (int64)	int64	100,000	0.0269	0.0565	0.48×	210%
🟡	np.invert(a) (int64)	int64	10,000,000	15.5655	20.8043	0.75×	134%
▫	np.invert(a) (int8)	int8	1,000	0.0006	0.0010	0.60×	165%
✅	np.invert(a) (int8)	int8	100,000	0.0257	0.0086	2.98×	34%
✅	np.invert(a) (int8)	int8	10,000,000	3.5401	1.3515	2.62×	38%
▫	np.invert(a) (uint16)	uint16	1,000	0.0007	0.0026	0.28×	354%
✅	np.invert(a) (uint16)	uint16	100,000	0.0258	0.0152	1.70×	59%
✅	np.invert(a) (uint16)	uint16	10,000,000	4.7607	2.5025	1.90×	53%
▫	np.invert(a) (uint32)	uint32	1,000	0.0007	0.0052	0.14×	699%
✅	np.invert(a) (uint32)	uint32	100,000	0.0347	0.0255	1.36×	73%
✅	np.invert(a) (uint32)	uint32	10,000,000	7.9103	4.3619	1.81×	55%
▫	np.invert(a) (uint64)	uint64	1,000	0.0007	0.0084	0.086×	1162%
🟠	np.invert(a) (uint64)	uint64	100,000	0.0261	0.0561	0.47×	215%
🟡	np.invert(a) (uint64)	uint64	10,000,000	15.3698	16.1587	0.95×	105%
▫	np.invert(a) (uint8)	uint8	1,000	0.0006	0.0012	0.52×	193%
✅	np.invert(a) (uint8)	uint8	100,000	0.0268	0.0072	3.73×	27%
✅	np.invert(a) (uint8)	uint8	10,000,000	3.5368	1.2344	2.87×	35%
⚪	np.left_shift(a, 2) (bool)	bool	1,000	0.0015	-	-	-
⚪	np.left_shift(a, 2) (bool)	bool	100,000	0.0449	-	-	-
⚪	np.left_shift(a, 2) (bool)	bool	10,000,000	15.2171	-	-	-
🔴	np.left_shift(a, 2) (int16)	int16	1,000	0.0010	0.0053	0.20×	510%
🔴	np.left_shift(a, 2) (int16)	int16	100,000	0.0282	0.3813	0.074×	1350%
🔴	np.left_shift(a, 2) (int16)	int16	10,000,000	4.9430	37.1258	0.13×	751%
▫	np.left_shift(a, 2) (int32)	int32	1,000	0.0010	0.0089	0.11×	897%
🔴	np.left_shift(a, 2) (int32)	int32	100,000	0.0192	0.3904	0.049×	2035%
🟠	np.left_shift(a, 2) (int32)	int32	10,000,000	7.7457	37.0641	0.21×	478%
▫	np.left_shift(a, 2) (int64)	int64	1,000	0.0010	0.0133	0.075×	1342%
🔴	np.left_shift(a, 2) (int64)	int64	100,000	0.0202	0.3924	0.051×	1945%
🟠	np.left_shift(a, 2) (int64)	int64	10,000,000	15.1483	48.2592	0.31×	319%
▫	np.left_shift(a, 2) (int8)	int8	1,000	0.0009	0.0054	0.17×	584%
🔴	np.left_shift(a, 2) (int8)	int8	100,000	0.0305	0.3768	0.081×	1236%
🔴	np.left_shift(a, 2) (int8)	int8	10,000,000	3.7550	37.7355	0.10×	1005%
🔴	np.left_shift(a, 2) (uint16)	uint16	1,000	0.0011	0.0053	0.20×	503%
🔴	np.left_shift(a, 2) (uint16)	uint16	100,000	0.0293	0.3879	0.076×	1322%
🔴	np.left_shift(a, 2) (uint16)	uint16	10,000,000	5.3824	37.4437	0.14×	696%
🔴	np.left_shift(a, 2) (uint32)	uint32	1,000	0.0014	0.0072	0.20×	503%
🔴	np.left_shift(a, 2) (uint32)	uint32	100,000	0.0201	0.3908	0.051×	1944%
🟠	np.left_shift(a, 2) (uint32)	uint32	10,000,000	7.7136	37.4067	0.21×	485%
▫	np.left_shift(a, 2) (uint64)	uint64	1,000	0.0010	0.0122	0.079×	1264%
🔴	np.left_shift(a, 2) (uint64)	uint64	100,000	0.0197	0.3923	0.050×	1992%
🟠	np.left_shift(a, 2) (uint64)	uint64	10,000,000	15.1562	43.8575	0.35×	289%
▫	np.left_shift(a, 2) (uint8)	uint8	1,000	0.0009	0.0053	0.17×	579%
🔴	np.left_shift(a, 2) (uint8)	uint8	100,000	0.0282	0.3753	0.075×	1330%
🔴	np.left_shift(a, 2) (uint8)	uint8	10,000,000	3.7382	37.0483	0.10×	991%
⚪	np.right_shift(a, 2) (bool)	bool	1,000	0.0016	-	-	-
⚪	np.right_shift(a, 2) (bool)	bool	100,000	0.0562	-	-	-
⚪	np.right_shift(a, 2) (bool)	bool	10,000,000	15.4174	-	-	-
🟠	np.right_shift(a, 2) (int16)	int16	1,000	0.0012	0.0054	0.22×	460%
🔴	np.right_shift(a, 2) (int16)	int16	100,000	0.0374	0.3824	0.098×	1021%
🔴	np.right_shift(a, 2) (int16)	int16	10,000,000	5.7902	37.1819	0.16×	642%
🔴	np.right_shift(a, 2) (int32)	int32	1,000	0.0013	0.0090	0.15×	676%
🔴	np.right_shift(a, 2) (int32)	int32	100,000	0.0288	0.3903	0.074×	1353%
🟠	np.right_shift(a, 2) (int32)	int32	10,000,000	7.9852	37.4325	0.21×	469%
🔴	np.right_shift(a, 2) (int64)	int64	1,000	0.0010	0.0127	0.080×	1249%
🔴	np.right_shift(a, 2) (int64)	int64	100,000	0.0289	0.3926	0.074×	1357%
🟠	np.right_shift(a, 2) (int64)	int64	10,000,000	15.2694	46.0316	0.33×	302%
🟠	np.right_shift(a, 2) (int8)	int8	1,000	0.0011	0.0054	0.20×	487%
🔴	np.right_shift(a, 2) (int8)	int8	100,000	0.0383	0.3764	0.10×	982%
🔴	np.right_shift(a, 2) (int8)	int8	10,000,000	4.6221	37.4222	0.12×	810%
🔴	np.right_shift(a, 2) (uint16)	uint16	1,000	0.0011	0.0054	0.20×	512%
🔴	np.right_shift(a, 2) (uint16)	uint16	100,000	0.0285	0.3868	0.074×	1355%
🔴	np.right_shift(a, 2) (uint16)	uint16	10,000,000	5.2827	37.5630	0.14×	711%
▫	np.right_shift(a, 2) (uint32)	uint32	1,000	0.0010	0.0135	0.073×	1366%
🔴	np.right_shift(a, 2) (uint32)	uint32	100,000	0.0202	0.3900	0.052×	1930%
🟠	np.right_shift(a, 2) (uint32)	uint32	10,000,000	7.8598	37.2613	0.21×	474%
▫	np.right_shift(a, 2) (uint64)	uint64	1,000	0.0010	0.0136	0.072×	1384%
🔴	np.right_shift(a, 2) (uint64)	uint64	100,000	0.0206	0.3933	0.052×	1908%
🟠	np.right_shift(a, 2) (uint64)	uint64	10,000,000	15.2120	44.4632	0.34×	292%
▫	np.right_shift(a, 2) (uint8)	uint8	1,000	0.0009	0.0054	0.17×	583%
🔴	np.right_shift(a, 2) (uint8)	uint8	100,000	0.0286	0.3756	0.076×	1315%
🔴	np.right_shift(a, 2) (uint8)	uint8	10,000,000	3.7457	37.0296	0.10×	989%

Logic

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
⚪	np.all(a) (bool)	bool	1,000	0.0015	-	-	-
⚪	np.all(a) (bool)	bool	100,000	0.0015	-	-	-
⚪	np.all(a) (bool)	bool	10,000,000	0.0014	-	-	-
⚪	np.allclose(a, b) (float16)	float16	1,000	0.0332	-	-	-
⚪	np.allclose(a, b) (float16)	float16	100,000	1.7625	-	-	-
⚪	np.allclose(a, b) (float16)	float16	10,000,000	192.9437	-	-	-
⚪	np.allclose(a, b) (float32)	float32	1,000	0.0130	-	-	-
⚪	np.allclose(a, b) (float32)	float32	100,000	0.3409	-	-	-
⚪	np.allclose(a, b) (float32)	float32	10,000,000	54.6204	-	-	-
⚪	np.allclose(a, b) (float64)	float64	1,000	0.0132	-	-	-
⚪	np.allclose(a, b) (float64)	float64	100,000	0.6240	-	-	-
⚪	np.allclose(a, b) (float64)	float64	10,000,000	107.6998	-	-	-
⚪	np.any(a) (bool)	bool	1,000	0.0016	-	-	-
⚪	np.any(a) (bool)	bool	100,000	0.0014	-	-	-
⚪	np.any(a) (bool)	bool	10,000,000	0.0014	-	-	-
✅	np.array_equal(a, b) (float16)	float16	1,000	0.0025	0.0011	2.26×	44%
✅	np.array_equal(a, b) (float16)	float16	100,000	0.0956	0.0710	1.35×	74%
✅	np.array_equal(a, b) (float16)	float16	10,000,000	9.4225	6.3415	1.49×	67%
▫	np.array_equal(a, b) (float32)	float32	1,000	0.0015	0.0007	2.14×	47%
🟡	np.array_equal(a, b) (float32)	float32	100,000	0.0087	0.0166	0.52×	191%
🟡	np.array_equal(a, b) (float32)	float32	10,000,000	3.8713	3.8855	1.00×	100%
▫	np.array_equal(a, b) (float64)	float64	1,000	0.0016	0.0008	2.01×	50%
🟠	np.array_equal(a, b) (float64)	float64	100,000	0.0121	0.0297	0.41×	245%
✅	np.array_equal(a, b) (float64)	float64	10,000,000	7.0010	6.4820	1.08×	93%
⚪	np.isclose(a, b) (float16)	float16	1,000	0.0296	-	-	-
⚪	np.isclose(a, b) (float16)	float16	100,000	1.7611	-	-	-
⚪	np.isclose(a, b) (float16)	float16	10,000,000	199.5655	-	-	-
⚪	np.isclose(a, b) (float32)	float32	1,000	0.0116	-	-	-
⚪	np.isclose(a, b) (float32)	float32	100,000	0.3355	-	-	-
⚪	np.isclose(a, b) (float32)	float32	10,000,000	55.8382	-	-	-
⚪	np.isclose(a, b) (float64)	float64	1,000	0.0116	-	-	-
⚪	np.isclose(a, b) (float64)	float64	100,000	0.6394	-	-	-
⚪	np.isclose(a, b) (float64)	float64	10,000,000	102.1851	-	-	-
▫	np.isfinite(a) (float16)	float16	1,000	0.0009	0.0010	0.86×	116%
🟡	np.isfinite(a) (float16)	float16	100,000	0.0482	0.0528	0.91×	110%
✅	np.isfinite(a) (float16)	float16	10,000,000	5.7788	3.3303	1.74×	58%
▫	np.isfinite(a) (float32)	float32	1,000	0.0004	0.0011	0.36×	281%
🔴	np.isfinite(a) (float32)	float32	100,000	0.0053	0.0362	0.14×	688%
🟡	np.isfinite(a) (float32)	float32	10,000,000	3.2475	4.1421	0.78×	128%
▫	np.isfinite(a) (float64)	float64	1,000	0.0004	0.0011	0.39×	256%
🟠	np.isfinite(a) (float64)	float64	100,000	0.0098	0.0395	0.25×	405%
🟡	np.isfinite(a) (float64)	float64	10,000,000	5.1256	6.2088	0.83×	121%
▫	np.isinf(a) (float16)	float16	1,000	0.0009	0.0011	0.85×	118%
🟡	np.isinf(a) (float16)	float16	100,000	0.0498	0.0543	0.92×	109%
✅	np.isinf(a) (float16)	float16	10,000,000	5.9810	3.2027	1.87×	54%
▫	np.isinf(a) (float32)	float32	1,000	0.0005	0.0012	0.46×	219%
🔴	np.isinf(a) (float32)	float32	100,000	0.0054	0.0421	0.13×	780%
🟡	np.isinf(a) (float32)	float32	10,000,000	3.4097	4.4158	0.77×	130%
▫	np.isinf(a) (float64)	float64	1,000	0.0005	0.0012	0.39×	259%
🟠	np.isinf(a) (float64)	float64	100,000	0.0101	0.0483	0.21×	480%
🟡	np.isinf(a) (float64)	float64	10,000,000	4.9636	6.7550	0.73×	136%
▫	np.isnan(a) (float16)	float16	1,000	0.0012	0.0010	1.18×	85%
✅	np.isnan(a) (float16)	float16	100,000	0.0678	0.0500	1.36×	74%
✅	np.isnan(a) (float16)	float16	10,000,000	7.7367	3.2338	2.39×	42%
▫	np.isnan(a) (float32)	float32	1,000	0.0005	0.0010	0.51×	197%
🔴	np.isnan(a) (float32)	float32	100,000	0.0041	0.0486	0.085×	1177%
🟡	np.isnan(a) (float32)	float32	10,000,000	3.1759	4.6187	0.69×	145%
▫	np.isnan(a) (float64)	float64	1,000	0.0004	0.0013	0.33×	304%
🔴	np.isnan(a) (float64)	float64	100,000	0.0086	0.0490	0.18×	566%
🟡	np.isnan(a) (float64)	float64	10,000,000	4.9428	6.3496	0.78×	128%
🟡	np.maximum(a, b) (float16)	float16	1,000	0.0031	0.0040	0.79×	127%
✅	np.maximum(a, b) (float16)	float16	100,000	0.7598	0.6773	1.12×	89%
✅	np.maximum(a, b) (float16)	float16	10,000,000	80.6049	65.8783	1.22×	82%
▫	np.maximum(a, b) (float32)	float32	1,000	0.0006	0.0027	0.21×	478%
🟠	np.maximum(a, b) (float32)	float32	100,000	0.0085	0.0375	0.23×	439%
✅	np.maximum(a, b) (float32)	float32	10,000,000	8.4970	5.1052	1.66×	60%
▫	np.maximum(a, b) (float64)	float64	1,000	0.0006	0.0033	0.18×	557%
🟠	np.maximum(a, b) (float64)	float64	100,000	0.0291	0.0937	0.31×	322%
🟡	np.maximum(a, b) (float64)	float64	10,000,000	16.6866	21.8878	0.76×	131%
🟡	np.minimum(a, b) (float16)	float16	1,000	0.0034	0.0039	0.87×	116%
✅	np.minimum(a, b) (float16)	float16	100,000	0.7651	0.6905	1.11×	90%
✅	np.minimum(a, b) (float16)	float16	10,000,000	81.5912	66.2103	1.23×	81%
▫	np.minimum(a, b) (float32)	float32	1,000	0.0006	0.0026	0.21×	468%
🟠	np.minimum(a, b) (float32)	float32	100,000	0.0084	0.0380	0.22×	450%
✅	np.minimum(a, b) (float32)	float32	10,000,000	8.4896	4.9888	1.70×	59%
▫	np.minimum(a, b) (float64)	float64	1,000	0.0006	0.0027	0.22×	454%
🟠	np.minimum(a, b) (float64)	float64	100,000	0.0294	0.0879	0.33×	300%
🟡	np.minimum(a, b) (float64)	float64	10,000,000	16.7333	22.1221	0.76×	132%

Statistics

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
✅	np.average(a) (float16)	float16	1,000	0.0055	0.0013	4.13×	24%
✅	np.average(a) (float16)	float16	100,000	0.1051	0.0820	1.28×	78%
✅	np.average(a) (float16)	float16	10,000,000	17.2176	8.1660	2.11×	47%
▫	np.average(a) (float32)	float32	1,000	0.0050	0.0007	6.67×	15%
✅	np.average(a) (float32)	float32	100,000	0.0174	0.0022	7.92×	13%
✅	np.average(a) (float32)	float32	10,000,000	10.2401	1.2354	8.29×	12%
▫	np.average(a) (float64)	float64	1,000	0.0035	0.0009	3.81×	26%
✅	np.average(a) (float64)	float64	100,000	0.0171	0.0064	2.69×	37%
✅	np.average(a) (float64)	float64	10,000,000	15.3117	3.1971	4.79×	21%
▫	np.count_nonzero(a) (float16)	float16	1,000	0.0018	0.0005	3.72×	27%
✅	np.count_nonzero(a) (float16)	float16	100,000	0.1526	0.0451	3.39×	30%
✅	np.count_nonzero(a) (float16)	float16	10,000,000	25.1066	4.3725	5.74×	17%
▫	np.count_nonzero(a) (float32)	float32	1,000	0.0008	0.0001	9.41×	11%
✅	np.count_nonzero(a) (float32)	float32	100,000	0.0376	0.0048	7.77×	13%
✅	np.count_nonzero(a) (float32)	float32	10,000,000	8.0489	2.0107	4.00×	25%
▫	np.count_nonzero(a) (float64)	float64	1,000	0.0010	0.0001	7.20×	14%
✅	np.count_nonzero(a) (float64)	float64	100,000	0.0405	0.0102	3.98×	25%
✅	np.count_nonzero(a) (float64)	float64	10,000,000	10.1563	4.2387	2.40×	42%
✅	np.median(a) (float16)	float16	1,000	0.0136	0.0042	3.26×	31%
🟡	np.median(a) (float16)	float16	100,000	0.9048	1.2881	0.70×	142%
✅	np.median(a) (float16)	float16	10,000,000	134.8925	92.0448	1.47×	68%
✅	np.median(a) (float32)	float32	1,000	0.0109	0.0023	4.77×	21%
🟡	np.median(a) (float32)	float32	100,000	0.4875	0.7182	0.68×	147%
✅	np.median(a) (float32)	float32	10,000,000	96.5370	82.6295	1.17×	86%
✅	np.median(a) (float64)	float64	1,000	0.0110	0.0024	4.53×	22%
🟡	np.median(a) (float64)	float64	100,000	0.4789	0.7222	0.66×	151%
✅	np.median(a) (float64)	float64	10,000,000	112.1137	92.2792	1.22×	82%
✅	np.percentile(a, 50) (float16)	float16	1,000	0.0323	0.0042	7.69×	13%
✅	np.percentile(a, 50) (float16)	float16	100,000	1.8092	1.2858	1.41×	71%
✅	np.percentile(a, 50) (float16)	float16	10,000,000	156.5275	91.5503	1.71×	58%
✅	np.percentile(a, 50) (float32)	float32	1,000	0.0241	0.0023	10.51×	10%
✅	np.percentile(a, 50) (float32)	float32	100,000	0.7427	0.7156	1.04×	96%
🟡	np.percentile(a, 50) (float32)	float32	10,000,000	63.9717	81.0735	0.79×	127%
✅	np.percentile(a, 50) (float64)	float64	1,000	0.0300	0.0025	12.18×	8%
✅	np.percentile(a, 50) (float64)	float64	100,000	0.7387	0.7299	1.01×	99%
🟡	np.percentile(a, 50) (float64)	float64	10,000,000	80.6078	93.3931	0.86×	116%
✅	np.ptp(a) (float16)	float16	1,000	0.0073	0.0032	2.28×	44%
✅	np.ptp(a) (float16)	float16	100,000	1.0217	0.6418	1.59×	63%
✅	np.ptp(a) (float16)	float16	10,000,000	130.8630	65.0541	2.01×	50%
✅	np.ptp(a) (float32)	float32	1,000	0.0034	0.0024	1.45×	69%
🟡	np.ptp(a) (float32)	float32	100,000	0.0119	0.0176	0.68×	147%
✅	np.ptp(a) (float32)	float32	10,000,000	8.0532	3.5153	2.29×	44%
✅	np.ptp(a) (float64)	float64	1,000	0.0041	0.0027	1.50×	67%
🟡	np.ptp(a) (float64)	float64	100,000	0.0194	0.0330	0.59×	170%
✅	np.ptp(a) (float64)	float64	10,000,000	17.0859	8.6509	1.98×	51%
✅	np.quantile(a, 0.5) (float16)	float16	1,000	0.0287	0.0042	6.76×	15%
✅	np.quantile(a, 0.5) (float16)	float16	100,000	1.7839	1.3025	1.37×	73%
✅	np.quantile(a, 0.5) (float16)	float16	10,000,000	156.4810	91.1789	1.72×	58%
✅	np.quantile(a, 0.5) (float32)	float32	1,000	0.0234	0.0023	10.31×	10%
✅	np.quantile(a, 0.5) (float32)	float32	100,000	0.7177	0.7119	1.01×	99%
🟡	np.quantile(a, 0.5) (float32)	float32	10,000,000	63.5667	80.9988	0.79×	127%
✅	np.quantile(a, 0.5) (float64)	float64	1,000	0.0233	0.0025	9.44×	11%
🟡	np.quantile(a, 0.5) (float64)	float64	100,000	0.7353	0.7477	0.98×	102%
🟡	np.quantile(a, 0.5) (float64)	float64	10,000,000	81.6003	91.1410	0.90×	112%

Sorting

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
🟡	np.argsort(a) (float32)	float32	1,000	0.0121	0.0163	0.74×	135%
✅	np.argsort(a) (float32)	float32	100,000	1.5773	1.3462	1.17×	85%
✅	np.argsort(a) (float32)	float32	10,000,000	657.2035	164.2182	4.00×	25%
🟠	np.argsort(a) (float64)	float64	1,000	0.0101	0.0229	0.44×	228%
🟡	np.argsort(a) (float64)	float64	100,000	1.4552	2.6803	0.54×	184%
✅	np.argsort(a) (float64)	float64	10,000,000	612.9057	305.7646	2.00×	50%
🟡	np.argsort(a) (int32)	int32	1,000	0.0122	0.0150	0.81×	123%
🟠	np.argsort(a) (int32)	int32	100,000	0.4357	1.1883	0.37×	273%
✅	np.argsort(a) (int32)	int32	10,000,000	306.9013	130.5309	2.35×	42%
🟡	np.argsort(a) (int64)	int64	1,000	0.0133	0.0204	0.65×	154%
🔴	np.argsort(a) (int64)	int64	100,000	0.5113	2.9221	0.17×	572%
✅	np.argsort(a) (int64)	int64	10,000,000	390.5333	240.1491	1.63×	62%
✅	np.nonzero(a) (float32)	float32	1,000	0.0025	0.0021	1.20×	84%
🟡	np.nonzero(a) (float32)	float32	100,000	0.1872	0.2217	0.84×	118%
✅	np.nonzero(a) (float32)	float32	10,000,000	25.5561	15.7379	1.62×	62%
✅	np.nonzero(a) (float64)	float64	1,000	0.0028	0.0019	1.50×	66%
🟡	np.nonzero(a) (float64)	float64	100,000	0.1789	0.2447	0.73×	137%
✅	np.nonzero(a) (float64)	float64	10,000,000	32.2888	18.0774	1.79×	56%
🟡	np.nonzero(a) (int32)	int32	1,000	0.0017	0.0030	0.56×	178%
🟠	np.nonzero(a) (int32)	int32	100,000	0.1019	0.2350	0.43×	231%
✅	np.nonzero(a) (int32)	int32	10,000,000	29.9222	27.4282	1.09×	92%
🟡	np.nonzero(a) (int64)	int64	1,000	0.0018	0.0031	0.57×	176%
🟠	np.nonzero(a) (int64)	int64	100,000	0.1143	0.2499	0.46×	219%
✅	np.nonzero(a) (int64)	int64	10,000,000	29.8745	19.8804	1.50×	66%
✅	np.searchsorted(a, v) (float32)	float32	1,000	0.0074	0.0056	1.31×	76%
✅	np.searchsorted(a, v) (float32)	float32	100,000	2.0207	1.7645	1.15×	87%
✅	np.searchsorted(a, v) (float32)	float32	10,000,000	239.6437	195.4530	1.23×	82%
✅	np.searchsorted(a, v) (float64)	float64	1,000	0.0079	0.0055	1.45×	69%
✅	np.searchsorted(a, v) (float64)	float64	100,000	2.0950	1.7708	1.18×	84%
✅	np.searchsorted(a, v) (float64)	float64	10,000,000	249.7088	192.5328	1.30×	77%
✅	np.searchsorted(a, v) (int32)	int32	1,000	0.0204	0.0077	2.65×	38%
✅	np.searchsorted(a, v) (int32)	int32	100,000	2.8565	2.2922	1.25×	80%
✅	np.searchsorted(a, v) (int32)	int32	10,000,000	578.2002	253.6528	2.28×	44%
✅	np.searchsorted(a, v) (int64)	int64	1,000	0.0202	0.0073	2.77×	36%
✅	np.searchsorted(a, v) (int64)	int64	100,000	2.8969	2.2836	1.27×	79%
✅	np.searchsorted(a, v) (int64)	int64	10,000,000	559.5927	247.0748	2.27×	44%

LinearAlgebra

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
▫	np.dot(a, b) (float64)	float64	1,000	0.0007	0.0006	1.13×	89%
✅	np.dot(a, b) (float64)	float64	100,000	0.0994	0.0070	14.17×	7%
🟠	np.dot(a, b) (float64)	float64	10,000,000	0.9192	3.1020	0.30×	338%
🟠	np.matmul(A, B) (float64)	float64	1,000	0.0027	0.0062	0.43×	234%
🔴	np.matmul(A, B) (float64)	float64	100,000	0.5265	3.0608	0.17×	581%
🔴	np.matmul(A, B) (float64)	float64	10,000,000	0.7113	4.2590	0.17×	599%
🟠	np.outer(a, b) (float64)	float64	1,000	0.0022	0.0057	0.38×	262%
🟠	np.outer(a, b) (float64)	float64	100,000	0.0365	0.0742	0.49×	204%
✅	np.outer(a, b) (float64)	float64	10,000,000	13.5041	11.9438	1.13×	88%

Selection

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
🟡	np.where(cond) (float64)	float64	1,000	0.0010	0.0014	0.74×	134%
🟠	np.where(cond) (float64)	float64	100,000	0.0309	0.1016	0.30×	329%
✅	np.where(cond) (float64)	float64	10,000,000	7.9232	7.3884	1.07×	93%
🟡	np.where(cond, a, b) (float64)	float64	1,000	0.0017	0.0020	0.84×	119%
🟡	np.where(cond, a, b) (float64)	float64	100,000	0.0542	0.0678	0.80×	125%
✅	np.where(cond, a, b) (float64)	float64	10,000,000	17.9453	15.2212	1.18×	85%

---

NDIter iterator benchmark

Complementary harness: measures the iterator machinery itself (construction, traversal, reductions, selection, dtypes, pathologies, dividends) across cache tiers — not part of the op/dtype/N matrix above. speedup = NumPy / NumSharp; NA = section ignored due to a known intermittent NumSharp AccessViolation.

NumSharp NDIter — canonical benchmark · 2026-06-23 · speedup = NumPy ÷ NumSharp (>1.0× = NumSharp faster)
198 measured pairs (35 NA) · best-of-rounds, Release · matched kernels/ids
%NumPy🕐 = NumSharp ÷ NumPy × 100 = share of NumPy's time NumSharp uses (8% = takes only 8% as long; <100% = faster)

AV POLICY — a NumSharp section that crashes all retries (known intermittent
AccessViolation, an unmanaged-storage lifetime bug) is reported NA / IGNORED
and excluded from every geomean below.  THIS RUN: NA across selection.

HEADLINE — operation matrix: 1.18× geomean · 85%🕐 of NumPy's time · 72 win / 58 lose over 130 cells

OPERATIONS — BY SIZE TIER  (geomean over all families)
        slower ◄───────── 1.0 (parity) ─────────► faster
scalar     ██████████▉ ........   1.10×    91%🕐  ( 12 win / 14 lose)
1K         ███████████▊ .......   1.19×    84%🕐  ( 15 win / 11 lose)
100K       ██████████▊ ........   1.08×    93%🕐  ( 12 win / 14 lose)
1M         █████████████ ......   1.31×    77%🕐  ( 17 win /  9 lose)
10M        ████████████▎ ......   1.23×    81%🕐  ( 16 win / 10 lose)
ALL        ███████████▊ .......   1.18×    85%🕐  ( 72 win / 58 lose)

OPERATIONS — BY CATEGORY  (geomean over its families, all sizes)
        slower ◄───────── 1.0 (parity) ─────────► faster
elementwise███████████▊ .......   1.18×    85%🕐  ( 28 win / 12 lose)
reductions █████████████████▍     1.75×    57%🕐  ( 28 win / 12 lose)
selection  (no data)
copy/cast  ███████▎ ...........   0.73×   137%🕐  (  8 win / 17 lose)  ◄ SLOWER
index-math ███████▌ ...........   0.75×   133%🕐  (  3 win /  7 lose)  ◄ SLOWER
dtypes     ████████████▏ ......   1.22×    82%🕐  (  5 win / 10 lose)

CATEGORY × TIER geomean
category       scalar       1K     100K       1M      10M
elementwise     1.05×    1.54×    1.18×    1.09×    1.11×
reductions      2.67×    1.99×    1.51×    1.44×    1.42×
selection           -        -        -        -        -
copy/cast       0.61×    0.59×    0.40×    1.39×    1.06×
index-math      0.32×    0.51×    0.97×    1.22×    1.22×
dtypes          0.71×    0.85×    1.97×    1.54×    1.47×

PER-FAMILY × TIER  (NumPy ÷ NumSharp; >1.0 = NumSharp faster)
family        scalar       1K     100K       1M      10M    geomean
-- elementwise
  add          1.01×    1.48×    1.03×    0.88×    1.01×     1.06×
  sqrt         0.85×    1.15×    1.00×    1.01×    1.02×     1.00×
  copy         0.88×    2.59×    1.78×    1.33×    1.72×     1.56×
  strided      0.89×    1.12×    1.00×    1.02×    0.99×     1.00×
  bcast        0.89×    1.13×    1.02×    0.98×    1.03×     1.01×
  reversed     0.85×    1.28×    0.90×    0.99×    1.00×     0.99×
  castbuf      1.98×    2.29×    1.65×    1.35×    1.16×     1.64×
  mixbuf       1.49×    1.94×    1.40×    1.24×    1.09×     1.40×
-- reductions
  sum          1.84×    1.78×    2.79×    2.21×    1.76×     2.04×
  sum ax0      1.90×    0.86×    0.96×    1.00×    0.94×     1.08×
  sum ax1      1.85×    0.86×    1.51×    1.83×    1.57×     1.47×
  sum dt=      1.97×    1.47×    0.49×    0.47×    0.55×     0.82×
  amin         1.70×    1.61×    0.71×    0.70×    0.82×     1.02×
  cumsum       1.47×    1.09×    1.06×    1.80×    1.68×     1.39×
  any(F)       8.89×    8.41×    2.12×    0.98×    1.00×     2.74×
  any(hit)     9.01×    8.50×    8.50×    7.87×    8.22×     8.41×
-- selection
  where           NA       NA       NA       NA       NA
  a[mask]         NA       NA       NA       NA       NA
  a[mask]=        NA       NA       NA       NA       NA
  count_nz        NA       NA       NA       NA       NA
  argwhere        NA       NA       NA       NA       NA
  a[idx]          NA       NA       NA       NA       NA
  a[idx]=         NA       NA       NA       NA       NA
-- copy/cast
  flatten      0.43×    0.44×    0.17×    2.17×    0.90×     0.57×
  astype       0.30×    0.53×    0.59×    1.97×    1.90×     0.81×
  ravel.T      0.45×    0.73×    0.48×    2.11×    1.01×     0.80×
  in-place     1.77×    0.81×    0.81×    1.06×    1.02×     1.05×
  less->b      0.81×    0.52×    0.26×    0.54×    0.76×     0.54×
-- index-math
  unravel      0.33×    0.50×    0.95×    1.01×    0.97×     0.68×
  ravel_mi     0.32×    0.52×    0.99×    1.49×    1.53×     0.82×
-- dtypes
  complex      0.74×    0.63×    1.01×    0.76×    0.89×     0.80×
  float16      0.72×    0.65×    0.62×    0.62×    0.62×     0.65×
  int8         0.67×    1.47×   12.09×    7.70×    5.78×     3.51×

CONSTRUCTION — iterator build+dispose vs np.nditer (size-invariant, 1K)
        slower ◄───────── 1.0 (parity) ─────────► faster
1op          ██████████████████▋    1.86×    54%🕐  (  1 win /  0 lose)
3op_exl      ███████████████████▶   4.43×    23%🕐  (  1 win /  0 lose)
ufunc        ███████████████████▶   4.98×    20%🕐  (  1 win /  0 lose)
bufcast      ███████████████████▶   3.49×    29%🕐  (  1 win /  0 lose)
multiindex   ███████████████████▶   2.56×    39%🕐  (  1 win /  0 lose)
8op          ███████████████████▶   5.26×    19%🕐  (  1 win /  0 lose)
4d           ███████████████████▶   2.94×    34%🕐  (  1 win /  0 lose)
8d           ███████████████████▶   2.65×    38%🕐  (  1 win /  0 lose)
strided2d    ███████████████████▶   3.35×    30%🕐  (  1 win /  0 lose)
geomean      ███████████████████▶   3.33×    30%🕐  (  9 win /  0 lose)

CHUNK-WIDTH dispatch — strided rows, 2M total, inner width w (NumPy = np.positive)
        slower ◄───────── 1.0 (parity) ─────────► faster
w=4          ███████ ............   0.71×   141%🕐  (  0 win /  1 lose)  ◄ SLOWER
w=16         ██████████▏ ........   1.02×    98%🕐  (  1 win /  0 lose)  ◄ PARITY
w=64         ███████████▍ .......   1.15×    87%🕐  (  1 win /  0 lose)
w=256        █████████████▍ .....   1.34×    75%🕐  (  1 win /  0 lose)
w=1024       ███████████████ ....   1.51×    66%🕐  (  1 win /  0 lose)

PATHOLOGY canaries — known taxes/losses to track (NumPy ÷ NumSharp)
  bcast_reduce    538.56×   (538.6× faster, faster)
  allocate          1.10×   (1.1× faster, faster)
  overlap_copy      1.78×   (1.8× faster, faster)
  forder_out        1.28×   (1.3× faster, faster)
  zerodim           1.26×   (1.3× faster, faster)

DIVIDENDS — NumSharp-only machinery (NumPy baseline = closest it can do)
                scalar       1K     100K       1M      10M   note
fuse7           12.65×    3.80×    1.39×    1.62×    2.01×   vs chained 6× add
reuse            5.63×    5.30×    0.97×    1.04×    1.06×   vs rebuild each call
par8                 -    0.66×    2.70×    3.09×    4.25×   vs single-thread

biggest NumSharp wins: i8@100K 12.09× · anyeh@1 9.01× · anyff@1 8.89× · anyeh@100K 8.50× · anyeh@1K 8.50×
most behind:           flatten@100K 0.17× · lessbool@100K 0.26× · astype@1 0.30× · ravelmi@1 0.32× · unravel@1 0.33×

---

Layout suite — reduction / copy / elementwise × memory layout × dtype

ratio = NumPy_ms / NumSharp_ms — >1.0 = NumSharp faster. ✅≥1.0 🟡≥0.5 🟠≥0.2 🔴<0.2. Layouts (8, harmonized with the cast subsystem): C, F (Fortran), T (transpose), strided [:, ::2], sliced (offset), negrow [::-1,:], negcol [:,::-1], bcast (stride-0). Fills the op-matrix's blind spot (it measures C-contiguous only). 100K + 1M elements, best-of-rounds.

Reduction (sum/min/max/prod, both axes)

Geomean by lay

size	C	F	T	strided	negrow	negcol	sliced	bcast
100K	1.01 ✅	1.05 ✅	1.04 ✅	0.49 🟠	0.61 🟡	0.56 🟡	0.68 🟡	0.59 🟡
1M	0.92 🟡	0.94 🟡	0.94 🟡	0.56 🟡	0.76 🟡	0.58 🟡	0.70 🟡	0.50 🟡

Geomean by dt

size	f64	f32	c128	dec	f16	i32	i64
100K	0.78 🟡	0.85 🟡	1.01 ✅	0.08 🔴	1.04 ✅	0.89 🟡	1.15 ✅
1M	0.88 🟡	1.05 ✅	1.02 ✅	0.07 🔴	1.00 ✅	0.80 🟡	1.02 ✅

Geomean by op

size	sum	min	max	prod
100K	0.72 🟡	0.61 🟡	0.61 🟡	1.06 ✅
1M	0.74 🟡	0.59 🟡	0.58 🟡	1.14 ✅

Worst 15 cells (NumSharp slowest vs NumPy)

key	NumSharp ms	NumPy ms	ratio
1M|dec|bcast|sum|ax0	5.3741	0.0657	0.01 🔴
100K|dec|bcast|sum|ax0	0.5412	0.0101	0.02 🔴
1M|dec|sliced|sum|ax0	5.4381	0.1108	0.02 🔴
100K|dec|C|sum|ax0	0.5494	0.0114	0.02 🔴
1M|dec|negrow|sum|ax0	5.4461	0.1134	0.02 🔴
100K|dec|negrow|sum|ax0	0.5371	0.0114	0.02 🔴
100K|dec|T|sum|ax1	0.5356	0.0114	0.02 🔴
1M|dec|F|sum|ax1	5.3609	0.1202	0.02 🔴
1M|dec|T|sum|ax1	5.5377	0.1270	0.02 🔴
100K|dec|sliced|sum|ax0	0.5332	0.0123	0.02 🔴
100K|dec|F|sum|ax1	0.5381	0.0126	0.02 🔴
1M|dec|C|sum|ax0	5.4777	0.1298	0.02 🔴
1M|i32|bcast|sum|ax1	4.1105	0.1203	0.03 🔴
100K|i32|bcast|sum|ax1	0.4050	0.0168	0.04 🔴
100K|dec|C|max|ax0	0.2871	0.0137	0.05 🔴

Copy / identity-ufunc (np.positive)

Geomean by lay

size	C	F	T	strided	sliced	negrow	negcol	bcast
100K	1.16 ✅	1.47 ✅	1.25 ✅	0.86 🟡	1.56 ✅	1.63 ✅	2.22 ✅	1.57 ✅
1M	2.87 ✅	2.95 ✅	2.89 ✅	1.96 ✅	2.67 ✅	2.62 ✅	3.24 ✅	2.67 ✅

Geomean by dt

size	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	c128
100K	0.93 🟡	1.41 ✅	1.75 ✅	1.80 ✅	0.99 🟡	1.09 ✅	1.66 ✅	1.03 ✅	2.44 ✅	2.15 ✅	1.06 ✅	0.84 🟡	2.60 ✅
1M	4.51 ✅	4.77 ✅	2.15 ✅	2.11 ✅	2.11 ✅	2.22 ✅	2.61 ✅	2.64 ✅	2.15 ✅	2.14 ✅	2.14 ✅	2.57 ✅	5.31 ✅

Worst 15 cells (NumSharp slowest vs NumPy)

key	NumSharp ms	NumPy ms	ratio
100K|i64|strided|pos	0.0257	0.0110	0.43 🟠
100K|f64|strided|pos	0.0232	0.0105	0.45 🟠
100K|u64|strided|pos	0.0240	0.0109	0.45 🟠
100K|i64|C|pos	0.0441	0.0208	0.47 🟠
100K|f32|strided|pos	0.0202	0.0103	0.51 🟡
100K|i32|strided|pos	0.0200	0.0109	0.54 🟡
100K|i64|T|pos	0.0376	0.0208	0.55 🟡
100K|u8|negrow|pos	0.0419	0.0232	0.56 🟡
100K|u8|sliced|pos	0.0410	0.0230	0.56 🟡
100K|u8|bcast|pos	0.0409	0.0231	0.56 🟡
100K|f64|C|pos	0.0418	0.0242	0.58 🟡
100K|f64|F|pos	0.0388	0.0227	0.58 🟡
100K|u32|strided|pos	0.0180	0.0112	0.62 🟡
100K|f64|T|pos	0.0364	0.0230	0.63 🟡
100K|u64|T|pos	0.0358	0.0290	0.81 🟡

Elementwise (add/mul/neg/abs/sqrt/less/copy)

Geomean by lay

size	C	F	T	strided	sliced	negrow	negcol	bcast
100K	0.54 🟡	0.75 🟡	0.68 🟡	0.53 🟡	0.84 🟡	0.81 🟡	1.16 ✅	0.84 🟡
1M	1.57 ✅	1.54 ✅	1.53 ✅	1.15 ✅	1.66 ✅	1.65 ✅	1.80 ✅	1.67 ✅

Geomean by dt

size	f64	f32	c128	f16	i32	i64
100K	0.58 🟡	0.53 🟡	1.18 ✅	0.75 🟡	0.79 🟡	0.81 🟡
1M	1.91 ✅	1.59 ✅	1.74 ✅	0.96 🟡	1.55 ✅	1.82 ✅

Geomean by op

size	add	mul	neg	abs	sqrt	less	copy
100K	0.97 🟡	0.93 🟡	0.71 🟡	0.70 🟡	0.94 🟡	0.61 🟡	0.50 🟡
1M	1.81 ✅	1.80 ✅	2.12 ✅	1.66 ✅	1.55 ✅	0.69 🟡	1.82 ✅

Worst 15 cells (NumSharp slowest vs NumPy)

key	NumSharp ms	NumPy ms	ratio
100K|f64|strided|abs	0.0481	0.0075	0.16 🔴
100K|f64|C|copy	0.0700	0.0112	0.16 🔴
100K|f64|strided|neg	0.0502	0.0082	0.16 🔴
100K|f64|C|abs	0.0653	0.0113	0.17 🔴
100K|f32|C|abs	0.0310	0.0056	0.18 🔴
100K|f16|C|copy	0.0169	0.0031	0.18 🔴
100K|f64|C|mul	0.0690	0.0129	0.19 🔴
100K|f64|C|neg	0.0649	0.0129	0.20 🔴
100K|f64|C|add	0.0638	0.0130	0.20 🟠
100K|f16|negrow|copy	0.0178	0.0038	0.21 🟠
100K|f32|C|mul	0.0316	0.0069	0.22 🟠
100K|i32|bcast|copy	0.0224	0.0050	0.22 🟠
100K|f32|C|add	0.0311	0.0069	0.22 🟠
100K|f32|T|neg	0.0270	0.0060	0.22 🟠
100K|f32|T|add	0.0302	0.0068	0.23 🟠

---

Operand & broadcast layouts — 1-D / scalar / mixed-operand / broadcast

The layout classes the per-operand layout grid (benchmark/layout) can't express. ratio = NumPy_ms / NumSharp_ms — >1.0 = NumSharp faster. ✅≥1.0 🟡≥0.5 🟠≥0.2 🔴<0.2. 1M elements, best-of-3.

case	f64	f32	f16	i32	i64	c128	geomean
1-D contiguous (a+a)	2.55 ✅	2.18 ✅	0.62 🟡	2.04 ✅	2.54 ✅	2.38 ✅	1.87 ✅
1-D strided a[::2]	1.83 ✅	1.36 ✅	0.52 🟡	1.37 ✅	1.77 ✅	1.86 ✅	1.34 ✅
1-D reversed a[::-1]	2.26 ✅	2.09 ✅	0.56 🟡	2.00 ✅	2.14 ✅	2.23 ✅	1.71 ✅
array + scalar	2.63 ✅	2.11 ✅	0.63 🟡	1.80 ✅	2.17 ✅	2.58 ✅	1.81 ✅
scalar + array	2.35 ✅	2.10 ✅	0.64 🟡	1.98 ✅	2.48 ✅	2.59 ✅	1.85 ✅
mixed C + F	2.12 ✅	2.01 ✅	0.62 🟡	1.98 ✅	2.02 ✅	2.26 ✅	1.70 ✅
mixed C + T	2.59 ✅	2.13 ✅	0.62 🟡	2.04 ✅	2.20 ✅	2.51 ✅	1.84 ✅
binary broadcast +row(1,C)	2.72 ✅	2.28 ✅	0.63 🟡	2.00 ✅	2.42 ✅	2.42 ✅	1.89 ✅
binary broadcast +col(R,1)	2.68 ✅	2.14 ✅	0.56 🟡	1.99 ✅	2.45 ✅	2.82 ✅	1.88 ✅
col-broadcast unary (inner stride-0)	2.55 ✅	1.76 ✅	0.86 🟡	1.69 ✅	2.66 ✅	6.09 ✅	2.18 ✅

Worst 12 cells

key	NumSharp ms	NumPy ms	ratio
1d_strided	f16	2.6414	1.3865	0.52 🟡
1d_rev	f16	5.3054	2.9810	0.56 🟡
bcast_col	f16	5.2996	2.9861	0.56 🟡
mix_C_T	f16	5.3156	3.2865	0.62 🟡
1d_C	f16	4.7503	2.9588	0.62 🟡
mix_C_F	f16	5.3110	3.3155	0.62 🟡
bcast_row	f16	4.7682	2.9983	0.63 🟡
scalar_rhs	f16	4.7137	2.9711	0.63 🟡
scalar_lhs	f16	4.6575	2.9643	0.64 🟡
colbcast_unary	f16	0.4898	0.4232	0.86 🟡
1d_strided	f32	0.2652	0.3608	1.36 ✅
1d_strided	i32	0.2798	0.3832	1.37 ✅

60 comparable cells.

---

Cast matrix — astype src→dst × layout × dtype

Full astype(dst, copy:true) sweep over every src→dst dtype pair × 8 memory layouts at 1M elements, best-of-3. ratio = NumPy_ms / NumSharp_ms — >1.0 = NumSharp faster. ✅≥1.0 🟡≥0.5 🟠≥0.2 🔴<0.2 · — = no NumPy counterpart (Decimal has no NumPy dtype).

Summary

• 129 / 1568 comparable cells lag (<1.0); 1439 win (≥1.0).
• 🔴 <0.2 — 5 cells. Top: 3× * → bool; 2× same-type diagonal (copy)
• 🟠 0.2–0.5 — 10 cells. Top: 8× same-type diagonal (copy); 2× * → bool
• 🟡 0.5–1.0 — 114 cells. Top: 29× float/cplx → narrow-int (bool/u8/i8/i16/u16/char); 20× int → sub-word (narrow); 8× f32 → u64

float/complex → narrow-int geomean by src (the historical cliff): f32→narrow 1.95, f64→narrow 1.39, f16→narrow 3.77, c128→narrow 1.01.

Geomean by layout (all src×dst, excl. Decimal)

C	F	T	sliced	negrow	negcol	strided	bcast
1.82 ✅	1.97 ✅	1.88 ✅	1.87 ✅	1.89 ✅	1.81 ✅	1.47 ✅	2.21 ✅

Geomean by src dtype (all layouts×dst)

bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
2.06 ✅	1.99 ✅	2.02 ✅	2.26 ✅	2.21 ✅	1.96 ✅	1.94 ✅	1.64 ✅	1.58 ✅	1.98 ✅	2.41 ✅	1.75 ✅	1.45 ✅	nan ?	1.16 ✅

Geomean by dst dtype (all layouts×src)

bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
1.95 ✅	1.76 ✅	1.80 ✅	1.63 ✅	1.61 ✅	1.82 ✅	1.66 ✅	1.93 ✅	1.76 ✅	1.63 ✅	2.48 ✅	1.63 ✅	2.04 ✅	nan ?	2.55 ✅

Layout: C (rows=src, cols=dst)

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	0.16🔴	1.50✅	1.74✅	2.01✅	1.99✅	1.49✅	1.50✅	2.33✅	2.41✅	1.91✅	3.43✅	1.73✅	2.74✅	—	2.95✅
u8	2.13✅	0.20🟠	2.40✅	1.71✅	1.79✅	1.98✅	2.10✅	2.43✅	2.57✅	1.78✅	4.04✅	1.41✅	2.60✅	—	3.03✅
i8	3.06✅	2.41✅	0.26🟠	1.91✅	1.73✅	2.29✅	1.98✅	2.30✅	2.45✅	1.72✅	3.93✅	1.77✅	2.53✅	—	3.15✅
i16	3.33✅	4.04✅	3.46✅	1.50✅	1.97✅	1.95✅	2.16✅	2.31✅	2.43✅	1.67✅	3.85✅	2.09✅	2.47✅	—	2.95✅
u16	3.02✅	2.65✅	2.69✅	2.15✅	1.36✅	1.90✅	2.08✅	2.38✅	2.43✅	1.06✅	3.75✅	2.10✅	2.45✅	—	2.85✅
i32	1.85✅	1.27✅	1.20✅	1.50✅	1.54✅	1.73✅	2.25✅	2.17✅	2.47✅	1.52✅	3.64✅	1.74✅	2.36✅	—	2.48✅
u32	1.76✅	1.07✅	1.12✅	1.50✅	1.63✅	2.35✅	1.69✅	2.57✅	2.36✅	1.44✅	3.80✅	1.52✅	2.35✅	—	2.73✅
i64	1.10✅	1.10✅	0.94🟡	1.24✅	1.31✅	1.77✅	1.79✅	2.09✅	2.77✅	1.39✅	1.74✅	1.63✅	2.52✅	—	2.42✅
u64	1.29✅	0.90🟡	0.99🟡	1.30✅	1.25✅	1.80✅	1.91✅	2.51✅	2.25✅	1.15✅	1.58✅	1.19✅	1.67✅	—	2.42✅
char	2.05✅	1.96✅	2.13✅	1.59✅	0.98🟡	1.70✅	1.66✅	2.32✅	2.29✅	1.31✅	3.67✅	1.46✅	2.24✅	—	2.74✅
f16	4.79✅	4.88✅	5.20✅	4.18✅	3.90✅	3.79✅	1.99✅	3.33✅	0.97🟡	4.24✅	1.27✅	1.16✅	0.93🟡	—	1.61✅
f32	3.23✅	2.00✅	2.00✅	1.54✅	1.71✅	1.92✅	1.34✅	0.87🟡	0.86🟡	1.67✅	3.61✅	1.76✅	2.38✅	—	2.35✅
f64	1.90✅	0.84🟡	0.90🟡	1.33✅	1.42✅	1.64✅	1.60✅	0.90🟡	0.92🟡	1.35✅	1.05✅	1.73✅	2.13✅	—	2.43✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	0.96🟡	0.98🟡	1.00✅	1.04✅	1.02✅	1.58✅	1.20✅	0.92🟡	0.80🟡	1.04✅	1.41✅	1.26✅	1.40✅	—	3.06✅

Layout: F (rows=src, cols=dst)

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	3.00✅	4.04✅	4.05✅	1.97✅	2.06✅	1.47✅	1.46✅	2.39✅	2.24✅	1.97✅	4.07✅	1.76✅	2.59✅	—	3.12✅
u8	3.49✅	3.15✅	4.05✅	1.81✅	1.98✅	2.04✅	2.08✅	2.24✅	2.37✅	1.90✅	3.86✅	1.47✅	2.42✅	—	3.03✅
i8	3.86✅	4.23✅	3.36✅	2.07✅	1.74✅	2.06✅	2.10✅	2.50✅	2.43✅	1.74✅	3.73✅	1.84✅	2.48✅	—	3.08✅
i16	2.96✅	2.60✅	3.13✅	1.43✅	2.05✅	2.03✅	2.03✅	2.34✅	2.30✅	1.99✅	3.84✅	2.23✅	2.53✅	—	2.61✅
u16	2.98✅	3.38✅	3.06✅	2.27✅	1.52✅	1.97✅	2.26✅	2.50✅	2.44✅	1.27✅	3.50✅	1.67✅	2.47✅	—	2.76✅
i32	1.74✅	1.14✅	1.06✅	1.44✅	1.66✅	1.71✅	2.29✅	2.35✅	2.42✅	1.80✅	3.74✅	1.75✅	2.73✅	—	2.77✅
u32	1.84✅	1.10✅	1.18✅	1.52✅	1.53✅	2.06✅	1.78✅	2.52✅	2.32✅	1.60✅	3.66✅	1.49✅	2.27✅	—	2.72✅
i64	1.21✅	1.11✅	0.95🟡	1.17✅	1.26✅	1.71✅	1.88✅	2.03✅	2.58✅	1.37✅	1.84✅	1.73✅	2.28✅	—	2.68✅
u64	1.13✅	0.92🟡	0.92🟡	1.24✅	1.21✅	1.72✅	1.78✅	2.81✅	2.11✅	1.34✅	2.45✅	1.18✅	1.86✅	—	2.37✅
char	2.14✅	1.99✅	1.91✅	1.93✅	1.34✅	1.61✅	1.61✅	2.42✅	2.37✅	1.34✅	3.61✅	1.50✅	2.19✅	—	2.72✅
f16	4.92✅	5.47✅	6.19✅	4.06✅	4.35✅	3.67✅	2.04✅	3.25✅	1.13✅	4.29✅	1.34✅	2.29✅	0.97🟡	—	1.69✅
f32	3.21✅	2.20✅	2.17✅	1.69✅	1.72✅	1.87✅	1.38✅	0.85🟡	0.88🟡	1.64✅	3.68✅	1.71✅	2.10✅	—	2.28✅
f64	1.87✅	0.99🟡	1.54✅	1.30✅	1.40✅	1.77✅	1.50✅	0.88🟡	0.88🟡	1.46✅	1.61✅	1.68✅	1.97✅	—	2.44✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	0.93🟡	0.85🟡	0.86🟡	1.03✅	1.14✅	1.47✅	1.35✅	0.87🟡	0.82🟡	1.08✅	1.47✅	1.45✅	1.46✅	—	2.98✅

Layout: T (rows=src, cols=dst)

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	0.18🔴	2.40✅	3.93✅	2.10✅	2.10✅	1.52✅	1.47✅	2.49✅	2.41✅	1.98✅	4.20✅	1.74✅	2.57✅	—	3.21✅
u8	2.17✅	0.16🔴	2.00✅	1.94✅	1.88✅	1.96✅	2.15✅	2.26✅	2.66✅	1.72✅	3.89✅	1.49✅	2.54✅	—	2.75✅
i8	2.29✅	3.03✅	0.20🟠	2.03✅	1.63✅	2.00✅	2.20✅	2.43✅	2.29✅	1.76✅	3.61✅	1.68✅	1.79✅	—	2.76✅
i16	2.45✅	3.08✅	2.89✅	1.35✅	2.02✅	2.03✅	1.90✅	2.45✅	2.34✅	2.04✅	3.88✅	2.02✅	2.36✅	—	2.80✅
u16	2.32✅	2.26✅	3.09✅	2.09✅	1.78✅	1.83✅	2.02✅	2.46✅	2.52✅	1.49✅	3.92✅	2.03✅	2.54✅	—	2.87✅
i32	1.90✅	1.23✅	1.27✅	1.58✅	1.56✅	1.81✅	2.16✅	2.42✅	2.41✅	1.55✅	3.89✅	1.84✅	2.24✅	—	2.82✅
u32	2.00✅	1.12✅	1.04✅	1.57✅	1.56✅	2.43✅	1.73✅	2.32✅	2.17✅	1.55✅	3.87✅	1.58✅	2.38✅	—	2.75✅
i64	1.18✅	1.15✅	1.00🟡	1.18✅	1.28✅	1.88✅	1.79✅	2.08✅	2.65✅	1.42✅	1.85✅	1.67✅	2.31✅	—	2.64✅
u64	1.18✅	0.93🟡	0.95🟡	1.14✅	1.26✅	1.73✅	1.71✅	2.68✅	2.11✅	1.40✅	2.51✅	1.20✅	1.74✅	—	2.35✅
char	2.45✅	2.21✅	2.31✅	1.87✅	1.26✅	1.72✅	1.59✅	2.24✅	2.45✅	1.29✅	3.58✅	1.57✅	2.49✅	—	2.28✅
f16	5.96✅	6.20✅	6.19✅	4.19✅	4.48✅	4.05✅	2.09✅	3.27✅	1.15✅	4.22✅	1.22✅	2.84✅	0.99🟡	—	1.66✅
f32	3.16✅	2.19✅	2.28✅	1.73✅	1.71✅	1.87✅	1.40✅	0.84🟡	0.87🟡	1.66✅	3.80✅	1.82✅	2.48✅	—	2.30✅
f64	2.29✅	1.22✅	1.27✅	1.47✅	1.52✅	1.69✅	1.52✅	0.87🟡	0.90🟡	1.43✅	1.64✅	1.80✅	2.15✅	—	2.46✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	1.00✅	0.92🟡	0.89🟡	1.14✅	1.14✅	1.46✅	1.19✅	0.89🟡	0.86🟡	1.16✅	1.50✅	1.29✅	1.45✅	—	3.29✅

Layout: sliced (rows=src, cols=dst)

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	0.20🔴	2.59✅	3.31✅	2.05✅	2.00✅	1.50✅	1.58✅	2.39✅	2.28✅	1.95✅	3.98✅	1.87✅	2.42✅	—	3.28✅
u8	2.61✅	0.22🟠	2.86✅	1.96✅	1.85✅	2.02✅	1.98✅	2.25✅	2.37✅	1.95✅	3.73✅	1.50✅	2.53✅	—	3.04✅
i8	2.69✅	3.27✅	0.29🟠	1.88✅	1.77✅	2.12✅	1.94✅	2.37✅	2.49✅	1.67✅	3.83✅	1.60✅	2.44✅	—	2.79✅
i16	2.61✅	2.75✅	2.62✅	1.47✅	1.56✅	2.09✅	1.91✅	2.22✅	2.38✅	1.66✅	3.56✅	2.05✅	2.08✅	—	2.36✅
u16	2.51✅	3.01✅	2.99✅	1.60✅	1.40✅	2.05✅	2.10✅	2.55✅	2.25✅	1.54✅	3.70✅	2.13✅	2.72✅	—	2.72✅
i32	1.72✅	2.09✅	2.42✅	1.58✅	1.63✅	1.85✅	1.87✅	2.35✅	2.39✅	1.50✅	3.68✅	1.62✅	2.37✅	—	2.87✅
u32	1.91✅	2.15✅	2.19✅	1.55✅	1.47✅	1.88✅	1.99✅	2.01✅	2.13✅	1.62✅	3.67✅	1.55✅	2.22✅	—	2.63✅
i64	1.13✅	1.27✅	1.26✅	1.36✅	1.38✅	1.80✅	1.88✅	2.64✅	2.52✅	1.29✅	1.81✅	1.63✅	2.23✅	—	2.59✅
u64	1.21✅	1.25✅	1.27✅	1.30✅	1.25✅	1.76✅	1.83✅	2.20✅	2.68✅	1.31✅	2.32✅	1.00🟡	1.63✅	—	2.43✅
char	1.45✅	2.45✅	2.83✅	1.61✅	1.48✅	1.64✅	1.68✅	2.03✅	2.39✅	1.40✅	3.38✅	1.49✅	2.17✅	—	2.92✅
f16	5.03✅	5.33✅	5.42✅	3.92✅	3.92✅	3.57✅	2.01✅	3.10✅	1.11✅	4.00✅	1.37✅	2.81✅	1.01✅	—	1.61✅
f32	3.18✅	2.29✅	2.34✅	1.71✅	1.61✅	1.87✅	1.37✅	0.84🟡	0.90🟡	1.54✅	3.54✅	1.82✅	2.32✅	—	2.36✅
f64	1.82✅	1.17✅	1.18✅	1.36✅	1.33✅	0.80🟡	1.34✅	0.86🟡	0.89🟡	1.50✅	1.58✅	1.85✅	2.30✅	—	2.51✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	0.97🟡	0.93🟡	0.92🟡	1.15✅	0.99🟡	1.47✅	1.08✅	0.86🟡	0.77🟡	1.07✅	1.44✅	1.26✅	1.55✅	—	2.15✅

Layout: negrow (rows=src, cols=dst)

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	0.24🟠	3.08✅	3.39✅	1.93✅	2.01✅	1.50✅	1.55✅	2.17✅	2.33✅	1.98✅	3.85✅	1.67✅	2.62✅	—	2.97✅
u8	3.02✅	0.23🟠	2.94✅	1.80✅	1.74✅	2.00✅	2.04✅	2.24✅	2.33✅	1.76✅	3.81✅	1.49✅	2.53✅	—	3.11✅
i8	2.84✅	2.66✅	0.24🟠	1.88✅	1.70✅	2.05✅	2.07✅	2.53✅	2.57✅	1.88✅	3.79✅	1.65✅	2.41✅	—	3.07✅
i16	3.40✅	2.43✅	2.21✅	1.46✅	1.76✅	1.92✅	2.07✅	2.21✅	2.23✅	1.73✅	3.49✅	2.14✅	2.19✅	—	2.63✅
u16	2.52✅	2.65✅	3.08✅	1.60✅	1.44✅	2.04✅	2.07✅	2.60✅	2.42✅	1.44✅	3.65✅	2.03✅	2.49✅	—	2.83✅
i32	2.08✅	2.13✅	2.38✅	1.59✅	1.58✅	1.99✅	1.97✅	2.34✅	2.27✅	1.58✅	3.60✅	1.69✅	2.39✅	—	2.67✅
u32	1.71✅	2.19✅	2.32✅	1.59✅	1.59✅	1.98✅	1.93✅	2.51✅	2.09✅	1.53✅	3.72✅	1.54✅	2.17✅	—	2.77✅
i64	1.18✅	1.26✅	1.25✅	1.36✅	1.38✅	1.82✅	1.84✅	2.39✅	2.23✅	1.44✅	1.79✅	1.55✅	2.23✅	—	2.36✅
u64	1.20✅	1.17✅	1.21✅	1.43✅	1.37✅	1.87✅	1.84✅	2.20✅	2.51✅	1.43✅	2.33✅	0.99🟡	1.48✅	—	2.42✅
char	2.22✅	2.50✅	2.15✅	1.59✅	1.33✅	1.71✅	1.57✅	2.35✅	2.30✅	1.44✅	3.40✅	1.49✅	2.29✅	—	2.68✅
f16	5.36✅	4.77✅	4.63✅	3.79✅	4.08✅	3.86✅	2.03✅	3.19✅	1.07✅	3.86✅	1.38✅	2.80✅	0.98🟡	—	1.62✅
f32	3.48✅	2.27✅	2.31✅	1.60✅	1.54✅	2.01✅	1.37✅	0.87🟡	0.88🟡	1.73✅	3.57✅	1.84✅	2.23✅	—	2.24✅
f64	1.97✅	1.25✅	1.28✅	1.48✅	1.55✅	1.77✅	1.50✅	0.87🟡	0.91🟡	1.64✅	1.60✅	1.87✅	2.36✅	—	2.46✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	0.83🟡	0.77🟡	0.93🟡	1.15✅	1.13✅	1.53✅	1.14✅	0.90🟡	0.81🟡	1.08✅	1.42✅	1.27✅	1.38✅	—	2.33✅

Layout: negcol (rows=src, cols=dst)

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	2.32✅	5.20✅	4.90✅	2.08✅	2.28✅	1.53✅	1.53✅	2.33✅	2.49✅	2.29✅	2.86✅	1.92✅	2.42✅	—	2.91✅
u8	1.20✅	2.65✅	3.15✅	1.96✅	1.85✅	1.90✅	1.84✅	2.21✅	2.35✅	1.86✅	2.55✅	1.48✅	2.46✅	—	2.98✅
i8	1.20✅	2.97✅	3.04✅	1.84✅	1.94✅	1.85✅	1.83✅	2.32✅	2.68✅	1.93✅	2.64✅	1.63✅	2.13✅	—	2.96✅
i16	4.16✅	3.05✅	2.48✅	1.72✅	1.79✅	1.83✅	1.77✅	2.44✅	2.57✅	1.89✅	2.00✅	1.67✅	2.46✅	—	2.72✅
u16	3.53✅	3.04✅	2.95✅	1.70✅	1.68✅	1.74✅	1.69✅	2.39✅	2.23✅	1.70✅	2.04✅	1.46✅	2.56✅	—	2.76✅
i32	1.96✅	1.93✅	1.58✅	1.69✅	1.76✅	1.70✅	1.64✅	2.66✅	2.48✅	1.71✅	2.01✅	1.71✅	2.29✅	—	2.73✅
u32	2.01✅	1.57✅	1.63✅	1.66✅	1.69✅	1.65✅	1.73✅	2.28✅	2.30✅	1.76✅	2.07✅	1.48✅	2.35✅	—	2.81✅
i64	1.23✅	0.95🟡	0.95🟡	1.33✅	1.39✅	1.85✅	1.77✅	2.40✅	2.29✅	1.31✅	1.30✅	1.59✅	2.56✅	—	2.54✅
u64	1.25✅	1.05✅	0.92🟡	1.33✅	1.36✅	1.60✅	1.75✅	2.56✅	2.42✅	1.37✅	1.64✅	1.07✅	1.61✅	—	2.35✅
char	4.04✅	2.53✅	2.58✅	1.62✅	1.65✅	1.70✅	1.69✅	2.12✅	2.26✅	1.66✅	1.94✅	1.56✅	2.41✅	—	2.70✅
f16	5.66✅	1.74✅	1.75✅	1.80✅	1.81✅	2.18✅	1.31✅	2.04✅	0.90🟡	1.79✅	1.77✅	1.57✅	0.99🟡	—	1.58✅
f32	2.29✅	1.70✅	1.66✅	1.77✅	1.82✅	1.93✅	1.10✅	0.88🟡	0.82🟡	1.78✅	1.96✅	1.41✅	1.19✅	—	2.21✅
f64	1.49✅	1.08✅	1.10✅	1.32✅	1.45✅	1.92✅	1.13✅	0.85🟡	0.82🟡	1.36✅	1.15✅	1.45✅	2.37✅	—	2.39✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	0.87🟡	0.89🟡	0.97🟡	1.22✅	1.08✅	1.51✅	0.98🟡	0.86🟡	0.79🟡	1.16✅	0.97🟡	1.10✅	1.53✅	—	2.07✅

Layout: strided (rows=src, cols=dst)

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	1.71✅	3.24✅	3.65✅	1.76✅	1.96✅	1.22✅	1.28✅	1.88✅	1.77✅	2.21✅	2.49✅	1.44✅	1.86✅	—	2.43✅
u8	0.98🟡	2.62✅	2.02✅	1.71✅	1.33✅	1.41✅	1.37✅	2.09✅	2.00✅	1.80✅	2.38✅	1.18✅	2.00✅	—	2.60✅
i8	1.03✅	2.14✅	1.85✅	1.44✅	1.51✅	1.35✅	1.41✅	2.10✅	2.06✅	1.44✅	2.35✅	1.34✅	1.93✅	—	2.58✅
i16	2.48✅	1.61✅	1.68✅	1.65✅	1.77✅	1.43✅	1.33✅	1.93✅	1.92✅	1.62✅	1.96✅	1.34✅	1.98✅	—	2.37✅
u16	2.36✅	1.76✅	2.09✅	1.40✅	1.28✅	1.36✅	1.25✅	2.01✅	1.82✅	1.31✅	1.90✅	1.18✅	1.88✅	—	2.45✅
i32	1.77✅	1.15✅	1.40✅	1.15✅	1.18✅	1.23✅	1.17✅	1.89✅	1.95✅	1.18✅	1.89✅	1.19✅	2.05✅	—	2.53✅
u32	1.77✅	1.41✅	1.46✅	1.27✅	1.25✅	1.28✅	1.23✅	1.90✅	1.83✅	1.22✅	1.88✅	1.20✅	2.09✅	—	2.37✅
i64	1.16✅	1.00🟡	1.00✅	0.93🟡	0.94🟡	1.25✅	1.28✅	1.75✅	1.65✅	1.01✅	1.18✅	1.34✅	1.82✅	—	2.35✅
u64	1.13✅	0.97🟡	1.01✅	0.86🟡	0.98🟡	1.26✅	1.33✅	1.66✅	1.78✅	0.99🟡	1.44✅	0.92🟡	1.43✅	—	2.27✅
char	2.14✅	1.77✅	1.99✅	1.35✅	1.16✅	1.32✅	1.40✅	1.81✅	2.05✅	1.30✅	1.79✅	1.14✅	1.83✅	—	2.19✅
f16	4.00✅	1.51✅	1.50✅	1.60✅	1.60✅	1.77✅	1.14✅	1.95✅	0.90🟡	1.61✅	1.42✅	1.32✅	0.97🟡	—	1.46✅
f32	1.61✅	1.05✅	1.35✅	1.16✅	1.16✅	1.35✅	0.78🟡	0.91🟡	0.80🟡	1.32✅	1.76✅	1.15✅	1.26✅	—	2.34✅
f64	1.21✅	0.83🟡	1.13✅	0.94🟡	0.96🟡	1.28✅	1.03✅	0.96🟡	0.81🟡	0.96🟡	1.06✅	1.21✅	1.73✅	—	2.23✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	0.82🟡	1.17✅	0.95🟡	0.91🟡	0.81🟡	1.14✅	0.87🟡	1.02✅	0.75🟡	0.82🟡	0.84🟡	1.11✅	1.43✅	—	1.56✅

Layout: bcast (rows=src, cols=dst)

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	0.22🟠	4.09✅	4.15✅	2.28✅	2.13✅	1.54✅	1.61✅	2.33✅	2.55✅	2.33✅	4.19✅	1.92✅	2.41✅	—	3.36✅
u8	4.89✅	0.23🟠	3.71✅	1.97✅	1.76✅	2.07✅	2.20✅	2.30✅	2.41✅	1.76✅	3.81✅	2.39✅	2.29✅	—	3.21✅
i8	3.86✅	2.95✅	0.18🔴	1.87✅	1.91✅	2.07✅	2.38✅	2.28✅	2.59✅	1.99✅	3.63✅	2.08✅	2.41✅	—	2.92✅
i16	5.51✅	4.13✅	3.91✅	1.76✅	1.71✅	1.97✅	2.15✅	2.39✅	2.39✅	1.81✅	3.68✅	2.37✅	2.53✅	—	2.96✅
u16	4.78✅	4.90✅	3.58✅	1.70✅	1.58✅	1.99✅	1.95✅	2.14✅	2.47✅	1.85✅	3.76✅	2.16✅	2.11✅	—	2.90✅
i32	3.52✅	3.21✅	2.47✅	1.82✅	1.87✅	2.26✅	2.04✅	2.36✅	2.40✅	1.69✅	3.80✅	1.99✅	2.12✅	—	2.87✅
u32	4.98✅	3.15✅	2.88✅	1.71✅	1.95✅	1.92✅	2.23✅	2.22✅	2.17✅	1.92✅	3.67✅	2.34✅	2.28✅	—	2.78✅
i64	2.38✅	2.10✅	2.21✅	1.79✅	1.75✅	2.08✅	2.02✅	2.49✅	2.38✅	1.86✅	1.81✅	2.01✅	2.30✅	—	2.74✅
u64	2.66✅	2.27✅	2.14✅	1.64✅	1.75✅	2.13✅	2.05✅	2.20✅	2.88✅	1.72✅	2.37✅	2.34✅	2.34✅	—	2.58✅
char	4.06✅	3.83✅	2.84✅	1.64✅	1.56✅	1.73✅	1.77✅	2.42✅	2.08✅	1.78✅	3.52✅	1.59✅	2.27✅	—	2.65✅
f16	5.14✅	5.61✅	5.48✅	4.15✅	3.79✅	3.96✅	2.10✅	2.90✅	1.11✅	3.91✅	1.56✅	2.92✅	0.99🟡	—	1.60✅
f32	5.24✅	2.78✅	3.44✅	1.83✅	1.80✅	2.13✅	1.45✅	2.38✅	0.87🟡	2.05✅	3.59✅	2.29✅	2.39✅	—	2.37✅
f64	2.77✅	2.12✅	1.89✅	1.85✅	1.88✅	2.00✅	1.54✅	2.30✅	0.91🟡	1.85✅	1.59✅	2.07✅	2.65✅	—	2.62✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	1.06✅	1.04✅	1.08✅	1.42✅	1.38✅	1.93✅	1.38✅	0.88🟡	0.79🟡	1.36✅	1.51✅	1.61✅	2.19✅	—	2.93✅

Lagging cells (<1.0) — the worklist (129 cells)

key	NumSharp ms	NumPy ms	ratio
bool|C|bool	0.0930	0.0146	0.16 🔴
u8|T|u8	0.0942	0.0150	0.16 🔴
bool|T|bool	0.0836	0.0148	0.18 🔴
i8|bcast|i8	0.0741	0.0133	0.18 🔴
bool|sliced|bool	0.0866	0.0172	0.20 🔴
i8|T|i8	0.0753	0.0153	0.20 🟠
u8|C|u8	0.0719	0.0147	0.20 🟠
u8|sliced|u8	0.0782	0.0170	0.22 🟠
bool|bcast|bool	0.0601	0.0134	0.22 🟠
u8|bcast|u8	0.0580	0.0133	0.23 🟠
u8|negrow|u8	0.0754	0.0174	0.23 🟠
bool|negrow|bool	0.0731	0.0172	0.24 🟠
i8|negrow|i8	0.0732	0.0175	0.24 🟠
i8|C|i8	0.0556	0.0146	0.26 🟠
i8|sliced|i8	0.0596	0.0173	0.29 🟠
c128|strided|u64	1.0409	0.7793	0.75 🟡
c128|sliced|u64	1.8015	1.3784	0.77 🟡
c128|negrow|u8	0.4046	0.3127	0.77 🟡
f32|strided|u32	0.4345	0.3399	0.78 🟡
c128|negcol|u64	1.7175	1.3574	0.79 🟡
c128|bcast|u64	1.5889	1.2598	0.79 🟡
f32|strided|u64	0.8030	0.6402	0.80 🟡
f64|sliced|i32	0.9055	0.7249	0.80 🟡
c128|C|u64	1.6541	1.3315	0.80 🟡
c128|negrow|u64	1.7336	1.4027	0.81 🟡
f64|strided|u64	0.8082	0.6566	0.81 🟡
c128|strided|u16	0.3140	0.2553	0.81 🟡
f32|negcol|u64	1.5682	1.2821	0.82 🟡
c128|strided|bool	0.3447	0.2829	0.82 🟡
c128|F|u64	1.7086	1.4038	0.82 🟡
f64|negcol|u64	1.5536	1.2785	0.82 🟡
c128|strided|char	0.3088	0.2547	0.82 🟡
c128|negrow|bool	0.5430	0.4512	0.83 🟡
f64|strided|u8	0.1717	0.1430	0.83 🟡
f32|sliced|i64	1.4652	1.2288	0.84 🟡
c128|strided|f16	0.8931	0.7492	0.84 🟡
f64|C|u8	0.2835	0.2387	0.84 🟡
f32|T|i64	1.4811	1.2507	0.84 🟡
f32|F|i64	1.4574	1.2362	0.85 🟡
c128|F|u8	0.3452	0.2939	0.85 🟡
f64|negcol|i64	1.4715	1.2532	0.85 🟡
c128|T|u64	1.6769	1.4340	0.86 🟡
c128|sliced|i64	1.5784	1.3516	0.86 🟡
c128|F|i8	0.3486	0.2987	0.86 🟡
f32|C|u64	1.4853	1.2784	0.86 🟡
c128|negcol|i64	1.6269	1.4042	0.86 🟡
f64|sliced|i64	1.4984	1.2939	0.86 🟡
u64|strided|i16	0.1644	0.1420	0.86 🟡
f32|T|u64	1.4626	1.2668	0.87 🟡
c128|strided|u32	0.5487	0.4762	0.87 🟡
f32|negrow|i64	1.4789	1.2839	0.87 🟡
f64|T|i64	1.4482	1.2586	0.87 🟡
f32|C|i64	1.4536	1.2668	0.87 🟡
c128|F|i64	1.5922	1.3883	0.87 🟡
f32|bcast|u64	1.4674	1.2816	0.87 🟡
f64|negrow|i64	1.4964	1.3079	0.87 🟡
c128|negcol|bool	0.5195	0.4544	0.87 🟡
c128|bcast|i64	1.4481	1.2677	0.88 🟡
f32|F|u64	1.4896	1.3080	0.88 🟡
f32|negrow|u64	1.4970	1.3187	0.88 🟡
f64|F|i64	1.4520	1.2833	0.88 🟡
f32|negcol|i64	1.4142	1.2505	0.88 🟡
f64|F|u64	1.4627	1.2941	0.88 🟡
c128|T|i8	0.3269	0.2902	0.89 🟡
c128|T|i64	1.5379	1.3708	0.89 🟡
c128|negcol|u8	0.3712	0.3314	0.89 🟡
f64|sliced|u64	1.4568	1.3039	0.89 🟡
f32|sliced|u64	1.4956	1.3400	0.90 🟡
f64|T|u64	1.4262	1.2802	0.90 🟡
f16|negcol|u64	2.0974	1.8845	0.90 🟡
f64|C|i8	0.2900	0.2608	0.90 🟡
u64|C|u8	0.2218	0.2000	0.90 🟡
c128|negrow|i64	1.6017	1.4469	0.90 🟡
f16|strided|u64	1.0325	0.9327	0.90 🟡
f64|C|i64	1.4545	1.3151	0.90 🟡
f64|bcast|u64	1.4342	1.3050	0.91 🟡
f64|negrow|u64	1.4679	1.3358	0.91 🟡
c128|strided|i16	0.2931	0.2677	0.91 🟡
f32|strided|i64	0.7058	0.6456	0.91 🟡
u64|strided|f32	0.4321	0.3956	0.92 🟡
u64|F|i8	0.2140	0.1962	0.92 🟡
c128|sliced|i8	0.3210	0.2949	0.92 🟡
u64|negcol|i8	0.2499	0.2296	0.92 🟡
c128|T|u8	0.3420	0.3149	0.92 🟡
c128|C|i64	1.5669	1.4433	0.92 🟡
f64|C|u64	1.4336	1.3246	0.92 🟡
u64|F|u8	0.2147	0.1985	0.92 🟡
c128|F|bool	0.4381	0.4058	0.93 🟡
i64|strided|i16	0.1542	0.1434	0.93 🟡
f16|C|f64	1.5849	1.4744	0.93 🟡
c128|negrow|i8	0.3334	0.3111	0.93 🟡
u64|T|u8	0.2141	0.1998	0.93 🟡
c128|sliced|u8	0.3155	0.2949	0.93 🟡
i64|C|i8	0.2113	0.1976	0.94 🟡
i64|strided|u16	0.1507	0.1417	0.94 🟡
f64|strided|i16	0.1653	0.1562	0.94 🟡
u64|T|i8	0.2094	0.1981	0.95 🟡
c128|strided|i8	0.2675	0.2533	0.95 🟡
i64|negcol|u8	0.2486	0.2356	0.95 🟡
i64|F|i8	0.2086	0.1983	0.95 🟡
i64|negcol|i8	0.2551	0.2430	0.95 🟡
c128|C|bool	0.4338	0.4158	0.96 🟡
f64|strided|u16	0.1591	0.1527	0.96 🟡
f64|strided|char	0.1576	0.1517	0.96 🟡
f64|strided|i64	0.7156	0.6903	0.96 🟡
f16|strided|f64	0.7580	0.7321	0.97 🟡
u64|strided|u8	0.1434	0.1386	0.97 🟡
c128|negcol|i8	0.3582	0.3466	0.97 🟡
c128|sliced|bool	0.4285	0.4147	0.97 🟡
c128|negcol|f16	1.8312	1.7743	0.97 🟡
f16|F|f64	1.4863	1.4453	0.97 🟡
f16|C|u64	1.8897	1.8418	0.97 🟡
c128|C|u8	0.3243	0.3163	0.98 🟡
f16|negrow|f64	1.5172	1.4849	0.98 🟡
u8|strided|bool	0.1541	0.1513	0.98 🟡
c128|negcol|u32	0.7951	0.7816	0.98 🟡
char|C|u16	0.2561	0.2517	0.98 🟡
u64|strided|u16	0.1497	0.1474	0.98 🟡
f64|F|u8	0.2394	0.2366	0.99 🟡
f16|T|f64	1.4960	1.4799	0.99 🟡
u64|negrow|f32	0.7876	0.7794	0.99 🟡
u64|C|i8	0.2056	0.2036	0.99 🟡
c128|sliced|u16	0.5149	0.5101	0.99 🟡
u64|strided|char	0.1500	0.1490	0.99 🟡
f16|bcast|f64	1.4862	1.4782	0.99 🟡
f16|negcol|f64	1.5169	1.5088	0.99 🟡
i64|strided|u8	0.1367	0.1361	1.00 🟡
i64|T|i8	0.2063	0.2055	1.00 🟡
u64|sliced|f32	0.7792	0.7791	1.00 🟡

1568 comparable cells (1800 NumSharp rows; 129 lagging <1.0).

---

Fusion — np.evaluate vs unfused chains

np.evaluate runs a whole expression tree in one NDIter pass (no intermediates). Fixed-expression gate plus an operand-layout sweep of the flagship a*b+c (C/F/T/strided/bcast — does the fused single-pass win survive non-contiguous operands?), not a dtype/layout matrix — so reported as-is.

NumSharp — fused np.evaluate vs unfused np.* chains (4M elements, best-of-9; (Nx) = unfused ÷ fused, >1 = fusion faster):

correctness cross-checks ok

4M float64, best of 9:
  a*b+c       fused    4.48 ms   unfused    6.97 ms   (1.56x)
  (a-b)/(a+b) fused    3.26 ms   unfused   13.54 ms   (4.16x)
  sum(a*b)    fused    2.44 ms   unfused    3.90 ms   (1.60x)
  sum(af*bf)  fused    1.30 ms   unfused    1.68 ms   (1.29x)  [f32]
  a*b+c out=  fused    3.77 ms   [1-pass fused-into-out]
  i4*2+f8     fused    2.93 ms   unfused    4.18 ms   (1.43x)

  a*b+c across operand layouts (2-D 2000x2000, all 3 operands same layout):
    [C      ] fused    3.68 ms   unfused    6.43 ms   (1.75x)
    [F      ] fused    3.60 ms   unfused    6.67 ms   (1.85x)
    [T      ] fused    3.67 ms   unfused    6.37 ms   (1.74x)
    [strided] fused    3.49 ms   unfused    4.75 ms   (1.36x)
    [bcast  ] fused    1.11 ms   unfused    3.99 ms   (3.60x)

NumPy — absolutes on the same box (context for the unfused column):

numpy 2.4.2, 4M float64, best of 9:
  a*b+c         12.93 ms
  (a-b)/(a+b)   19.64 ms
  sum(a*b)       8.45 ms
  sum(af*bf)     4.19 ms  [f32]
  a*b+c out=     4.96 ms  [two-pass with out=]
  i4*2+f8        9.99 ms
  a*b+c across operand layouts (2-D 2000x2000, unfused):
    [C      ]   12.87 ms
    [F      ]   12.76 ms
    [T      ]   12.84 ms
    [strided]    7.87 ms
    [bcast  ]   12.36 ms