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 | ✅ 838 | 🟡 329 | 🟠 183 | 🔴 50 | ▫ 388 | ⚪ 63

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	116	58	35	11	372	23	1.13x	89%
50,000	1	0	0	0	0	0	1	-	-
100,000	615	295	135	124	35	7	19	0.98x	102%
5,000,000	1	0	0	0	0	0	1	-	-
10,000,000	615	427	136	24	4	9	15	1.39x	72%

---

🏆 Top 15 Best (NumSharp fastest vs NumPy)

Ranked over 1400 credible comparisons (both sides ≥1µs, within 20×); 388 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.prod (float64)	float64	100,000	2.331	0.170	13.71×	7%
✅	np.nanprod(a) (float32)	float32	100,000	0.160	0.012	13.53×	7%
✅	np.sum axis=1 (int8)	int8	10,000,000	3.511	0.264	13.30×	8%
✅	np.nanvar(a) (float64)	float64	1,000	0.020	0.002	13.06×	8%
✅	np.nanquantile(a, 0.5) (float32)	float32	1,000	0.028	0.002	12.60×	8%
✅	np.nanstd(a) (float64)	float64	1,000	0.019	0.002	12.52×	8%
✅	np.nanstd(a) (float16)	float16	1,000	0.034	0.003	12.26×	8%
✅	np.prod axis=1 (float64)	float64	100,000	0.060	0.005	12.13×	8%
✅	np.sum axis=1 (uint8)	uint8	10,000,000	3.206	0.265	12.11×	8%
✅	np.mean (uint64)	uint64	100,000	0.054	0.004	12.08×	8%
✅	np.dot(a, b) (float64)	float64	100,000	0.112	0.009	12.05×	8%
✅	np.nanpercentile(a, 50) (float32)	float32	1,000	0.027	0.002	11.99×	8%
✅	np.nanstd(a) (float32)	float32	1,000	0.020	0.002	11.92×	8%
✅	np.nanvar(a) (float16)	float16	1,000	0.032	0.003	11.72×	8%
✅	np.sum axis=0 (uint8)	uint8	100,000	0.051	0.004	11.69×	9%

🔻 Top 15 Worst (Optimization priorities)

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
🔴	np.zeros_like (int64)	int64	1,000	0.001	0.013	0.079×	1261%
🔴	np.sum (float64)	float64	100,000	0.017	0.209	0.079×	1260%
🔴	np.isnan(a) (float32)	float32	100,000	0.004	0.048	0.092×	1091%
🔴	np.invert(a) (bool)	bool	100,000	0.002	0.023	0.092×	1083%
🔴	np.zeros_like (float64)	float64	1,000	0.001	0.013	0.092×	1086%
🔴	a	b (bool)	bool	100,000	0.003	0.023	0.11×	912%
🔴	a + scalar (float64)	float64	100,000	0.012	0.104	0.11×	902%
🔴	a * 2 (literal) (float64)	float64	100,000	0.012	0.106	0.11×	887%
🔴	a + 5 (literal) (float64)	float64	100,000	0.012	0.103	0.11×	884%
🔴	np.zeros_like (float32)	float32	1,000	0.001	0.009	0.12×	861%
🔴	a * a (square) (float64)	float64	100,000	0.011	0.098	0.12×	863%
🔴	a * scalar (float64)	float64	100,000	0.012	0.100	0.12×	857%
🔴	np.right_shift(a, 2) (bool)	bool	1,000	0.002	0.013	0.12×	844%
🔴	np.left_shift(a, 2) (bool)	bool	1,000	0.002	0.013	0.12×	845%
🔴	np.zeros_like (int32)	int32	1,000	0.001	0.009	0.12×	842%

---

Arithmetic

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
🟡	a % 7 (literal) (float32)	float32	1,000	0.0143	0.0167	0.86×	116%
🟡	a % 7 (literal) (float32)	float32	100,000	1.6323	1.8289	0.89×	112%
🟡	a % 7 (literal) (float32)	float32	10,000,000	166.6333	176.1757	0.95×	106%
🟡	a % 7 (literal) (float64)	float64	1,000	0.0112	0.0175	0.64×	156%
🟡	a % 7 (literal) (float64)	float64	100,000	1.4461	1.6302	0.89×	113%
🟡	a % 7 (literal) (float64)	float64	10,000,000	159.2176	162.5277	0.98×	102%
🟡	a % 7 (literal) (int32)	int32	1,000	0.0022	0.0028	0.78×	129%
🟡	a % 7 (literal) (int32)	int32	100,000	0.3957	0.6590	0.60×	166%
🟡	a % 7 (literal) (int32)	int32	10,000,000	49.0203	66.9383	0.73×	137%
🟡	a % 7 (literal) (int64)	int64	1,000	0.0044	0.0069	0.64×	156%
🟡	a % 7 (literal) (int64)	int64	100,000	0.4155	0.6703	0.62×	161%
🟡	a % 7 (literal) (int64)	int64	10,000,000	50.7135	75.8665	0.67×	150%
✅	a % b (element-wise) (float32)	float32	1,000	0.0121	0.0108	1.12×	90%
🟡	a % b (element-wise) (float32)	float32	100,000	1.5318	1.5713	0.97×	103%
✅	a % b (element-wise) (float32)	float32	10,000,000	156.9058	152.7181	1.03×	97%
✅	a % b (element-wise) (float64)	float64	1,000	0.0100	0.0090	1.12×	89%
🟡	a % b (element-wise) (float64)	float64	100,000	1.2891	1.3568	0.95×	105%
🟡	a % b (element-wise) (float64)	float64	10,000,000	143.9662	145.6373	0.99×	101%
🟡	a % b (element-wise) (int32)	int32	1,000	0.0021	0.0028	0.76×	132%
🟡	a % b (element-wise) (int32)	int32	100,000	0.3784	0.6093	0.62×	161%
🟡	a % b (element-wise) (int32)	int32	10,000,000	47.9091	58.8577	0.81×	123%
🟡	a % b (element-wise) (int64)	int64	1,000	0.0035	0.0040	0.88×	114%
🟡	a % b (element-wise) (int64)	int64	100,000	0.3756	0.6058	0.62×	161%
🟡	a % b (element-wise) (int64)	int64	10,000,000	49.5215	66.8191	0.74×	135%
🟠	a * 2 (literal) (complex128)	complex128	1,000	0.0011	0.0045	0.25×	402%
✅	a * 2 (literal) (complex128)	complex128	100,000	0.3633	0.3155	1.15×	87%
🟡	a * 2 (literal) (complex128)	complex128	10,000,000	31.3365	57.0611	0.55×	182%
🟡	a * 2 (literal) (float16)	float16	1,000	0.0066	0.0103	0.63×	158%
🟠	a * 2 (literal) (float16)	float16	100,000	0.3439	0.8963	0.38×	261%
🟠	a * 2 (literal) (float16)	float16	10,000,000	31.2284	86.0293	0.36×	276%
▫	a * 2 (literal) (float32)	float32	1,000	0.0008	0.0053	0.14×	691%
🔴	a * 2 (literal) (float32)	float32	100,000	0.0066	0.0516	0.13×	780%
🟡	a * 2 (literal) (float32)	float32	10,000,000	7.8824	9.4240	0.84×	120%
▫	a * 2 (literal) (float64)	float64	1,000	0.0008	0.0062	0.13×	773%
🔴	a * 2 (literal) (float64)	float64	100,000	0.0119	0.1056	0.11×	887%
🟡	a * 2 (literal) (float64)	float64	10,000,000	20.0350	22.1709	0.90×	111%
▫	a * 2 (literal) (int16)	int16	1,000	0.0010	0.0058	0.17×	589%
🟡	a * 2 (literal) (int16)	int16	100,000	0.0233	0.0306	0.76×	131%
✅	a * 2 (literal) (int16)	int16	10,000,000	6.0238	4.4309	1.36×	74%
🟠	a * 2 (literal) (int32)	int32	1,000	0.0010	0.0034	0.30×	334%
🟠	a * 2 (literal) (int32)	int32	100,000	0.0230	0.0521	0.44×	226%
✅	a * 2 (literal) (int32)	int32	10,000,000	12.3132	7.7215	1.59×	63%
▫	a * 2 (literal) (int64)	int64	1,000	0.0009	0.0056	0.16×	614%
🟠	a * 2 (literal) (int64)	int64	100,000	0.0216	0.1059	0.20×	491%
🟡	a * 2 (literal) (int64)	int64	10,000,000	16.4530	31.0792	0.53×	189%
▫	a * 2 (literal) (int8)	int8	1,000	0.0008	0.0036	0.23×	425%
🟡	a * 2 (literal) (int8)	int8	100,000	0.0226	0.0233	0.97×	103%
✅	a * 2 (literal) (int8)	int8	10,000,000	3.7464	2.1072	1.78×	56%
🟠	a * 2 (literal) (uint16)	uint16	1,000	0.0010	0.0027	0.37×	269%
🟡	a * 2 (literal) (uint16)	uint16	100,000	0.0229	0.0291	0.78×	128%
✅	a * 2 (literal) (uint16)	uint16	10,000,000	6.6073	4.8579	1.36×	74%
🔴	a * 2 (literal) (uint32)	uint32	1,000	0.0010	0.0054	0.19×	520%
🟠	a * 2 (literal) (uint32)	uint32	100,000	0.0225	0.0519	0.43×	231%
✅	a * 2 (literal) (uint32)	uint32	10,000,000	7.8930	7.6778	1.03×	97%
▫	a * 2 (literal) (uint64)	uint64	1,000	0.0009	0.0030	0.31×	323%
🟠	a * 2 (literal) (uint64)	uint64	100,000	0.0222	0.1066	0.21×	481%
🟡	a * 2 (literal) (uint64)	uint64	10,000,000	15.0621	29.8983	0.50×	198%
▫	a * 2 (literal) (uint8)	uint8	1,000	0.0009	0.0038	0.23×	428%
✅	a * 2 (literal) (uint8)	uint8	100,000	0.0229	0.0216	1.06×	95%
✅	a * 2 (literal) (uint8)	uint8	10,000,000	4.1643	2.1224	1.96×	51%
▫	a * a (square) (complex128)	complex128	1,000	0.0008	0.0042	0.19×	520%
🟡	a * a (square) (complex128)	complex128	100,000	0.3485	0.4268	0.82×	122%
🟡	a * a (square) (complex128)	complex128	10,000,000	30.2303	43.0242	0.70×	142%
🟡	a * a (square) (float16)	float16	1,000	0.0057	0.0093	0.61×	162%
🟠	a * a (square) (float16)	float16	100,000	0.2934	0.8294	0.35×	283%
🟠	a * a (square) (float16)	float16	10,000,000	30.7340	84.9605	0.36×	276%
▫	a * a (square) (float32)	float32	1,000	0.0005	0.0019	0.28×	356%
🔴	a * a (square) (float32)	float32	100,000	0.0059	0.0493	0.12×	834%
🟡	a * a (square) (float32)	float32	10,000,000	7.8671	8.1233	0.97×	103%
▫	a * a (square) (float64)	float64	1,000	0.0005	0.0027	0.20×	506%
🔴	a * a (square) (float64)	float64	100,000	0.0113	0.0977	0.12×	863%
🟡	a * a (square) (float64)	float64	10,000,000	19.3973	20.3482	0.95×	105%
▫	a * a (square) (int16)	int16	1,000	0.0008	0.0018	0.41×	242%
✅	a * a (square) (int16)	int16	100,000	0.0287	0.0251	1.14×	88%
✅	a * a (square) (int16)	int16	10,000,000	7.2866	5.2338	1.39×	72%
▫	a * a (square) (int32)	int32	1,000	0.0008	0.0020	0.39×	258%
🟡	a * a (square) (int32)	int32	100,000	0.0300	0.0553	0.54×	184%
✅	a * a (square) (int32)	int32	10,000,000	12.7934	7.8908	1.62×	62%
▫	a * a (square) (int64)	int64	1,000	0.0008	0.0029	0.27×	376%
🟠	a * a (square) (int64)	int64	100,000	0.0289	0.1056	0.27×	366%
🟡	a * a (square) (int64)	int64	10,000,000	15.6967	30.4188	0.52×	194%
▫	a * a (square) (int8)	int8	1,000	0.0006	0.0015	0.42×	239%
✅	a * a (square) (int8)	int8	100,000	0.0280	0.0158	1.77×	57%
✅	a * a (square) (int8)	int8	10,000,000	4.4945	2.8519	1.58×	64%
▫	a * a (square) (uint16)	uint16	1,000	0.0008	0.0017	0.45×	223%
✅	a * a (square) (uint16)	uint16	100,000	0.0347	0.0258	1.34×	74%
✅	a * a (square) (uint16)	uint16	10,000,000	7.9808	5.3188	1.50×	67%
▫	a * a (square) (uint32)	uint32	1,000	0.0008	0.0021	0.37×	269%
🟡	a * a (square) (uint32)	uint32	100,000	0.0285	0.0490	0.58×	172%
🟡	a * a (square) (uint32)	uint32	10,000,000	7.9914	8.4603	0.94×	106%
▫	a * a (square) (uint64)	uint64	1,000	0.0007	0.0028	0.26×	384%
🟠	a * a (square) (uint64)	uint64	100,000	0.0293	0.1078	0.27×	368%
🟡	a * a (square) (uint64)	uint64	10,000,000	15.1757	29.8093	0.51×	196%
▫	a * a (square) (uint8)	uint8	1,000	0.0007	0.0014	0.46×	216%
✅	a * a (square) (uint8)	uint8	100,000	0.0290	0.0155	1.88×	53%
✅	a * a (square) (uint8)	uint8	10,000,000	4.8089	2.8618	1.68×	60%
▫	a * b (element-wise) (complex128)	complex128	1,000	0.0009	0.0043	0.22×	453%
🟡	a * b (element-wise) (complex128)	complex128	100,000	0.3579	0.4442	0.81×	124%
🟠	a * b (element-wise) (complex128)	complex128	10,000,000	34.4053	73.3371	0.47×	213%
🟠	a * b (element-wise) (float16)	float16	1,000	0.0034	0.0090	0.37×	268%
🟠	a * b (element-wise) (float16)	float16	100,000	0.3186	0.8505	0.38×	267%
🟠	a * b (element-wise) (float16)	float16	10,000,000	30.9166	88.9610	0.35×	288%
▫	a * b (element-wise) (float32)	float32	1,000	0.0006	0.0019	0.30×	336%
🔴	a * b (element-wise) (float32)	float32	100,000	0.0071	0.0514	0.14×	722%
🟡	a * b (element-wise) (float32)	float32	10,000,000	8.4965	10.2234	0.83×	120%
▫	a * b (element-wise) (float64)	float64	1,000	0.0005	0.0025	0.20×	489%
🟠	a * b (element-wise) (float64)	float64	100,000	0.0274	0.1030	0.27×	376%
🟡	a * b (element-wise) (float64)	float64	10,000,000	21.0075	33.0143	0.64×	157%
▫	a * b (element-wise) (int16)	int16	1,000	0.0008	0.0019	0.41×	241%
✅	a * b (element-wise) (int16)	int16	100,000	0.0282	0.0266	1.06×	95%
✅	a * b (element-wise) (int16)	int16	10,000,000	7.7338	6.8196	1.13×	88%
▫	a * b (element-wise) (int32)	int32	1,000	0.0008	0.0020	0.39×	257%
🟡	a * b (element-wise) (int32)	int32	100,000	0.0287	0.0519	0.55×	181%
✅	a * b (element-wise) (int32)	int32	10,000,000	13.0207	10.9911	1.19×	84%
▫	a * b (element-wise) (int64)	int64	1,000	0.0008	0.0030	0.26×	386%
🟠	a * b (element-wise) (int64)	int64	100,000	0.0386	0.1068	0.36×	277%
🟠	a * b (element-wise) (int64)	int64	10,000,000	17.0533	38.5984	0.44×	226%
▫	a * b (element-wise) (int8)	int8	1,000	0.0006	0.0016	0.39×	255%
✅	a * b (element-wise) (int8)	int8	100,000	0.0282	0.0162	1.74×	57%
✅	a * b (element-wise) (int8)	int8	10,000,000	5.3373	3.6339	1.47×	68%
▫	a * b (element-wise) (uint16)	uint16	1,000	0.0008	0.0019	0.39×	254%
✅	a * b (element-wise) (uint16)	uint16	100,000	0.0308	0.0267	1.15×	87%
✅	a * b (element-wise) (uint16)	uint16	10,000,000	7.7433	6.7987	1.14×	88%
▫	a * b (element-wise) (uint32)	uint32	1,000	0.0008	0.0020	0.40×	250%
🟡	a * b (element-wise) (uint32)	uint32	100,000	0.0278	0.0486	0.57×	175%
🟡	a * b (element-wise) (uint32)	uint32	10,000,000	9.8085	11.0138	0.89×	112%
▫	a * b (element-wise) (uint64)	uint64	1,000	0.0007	0.0027	0.27×	377%
🟠	a * b (element-wise) (uint64)	uint64	100,000	0.0361	0.1090	0.33×	302%
🟠	a * b (element-wise) (uint64)	uint64	10,000,000	16.9583	37.9021	0.45×	224%
▫	a * b (element-wise) (uint8)	uint8	1,000	0.0007	0.0017	0.39×	257%
✅	a * b (element-wise) (uint8)	uint8	100,000	0.0295	0.0157	1.88×	53%
✅	a * b (element-wise) (uint8)	uint8	10,000,000	4.5011	3.6771	1.22×	82%
▫	a * scalar (complex128)	complex128	1,000	0.0009	0.0043	0.22×	458%
✅	a * scalar (complex128)	complex128	100,000	0.3458	0.3076	1.12×	89%
🟡	a * scalar (complex128)	complex128	10,000,000	30.9297	45.1226	0.69×	146%
🟡	a * scalar (float16)	float16	1,000	0.0062	0.0092	0.68×	148%
🟠	a * scalar (float16)	float16	100,000	0.3472	0.8794	0.40×	253%
🟠	a * scalar (float16)	float16	10,000,000	35.1625	88.3826	0.40×	251%
▫	a * scalar (float32)	float32	1,000	0.0007	0.0020	0.36×	281%
🔴	a * scalar (float32)	float32	100,000	0.0068	0.0488	0.14×	722%
🟡	a * scalar (float32)	float32	10,000,000	8.0629	8.9608	0.90×	111%
▫	a * scalar (float64)	float64	1,000	0.0009	0.0028	0.31×	325%
🔴	a * scalar (float64)	float64	100,000	0.0117	0.0999	0.12×	857%
🟡	a * scalar (float64)	float64	10,000,000	19.9081	22.8588	0.87×	115%
▫	a * scalar (int16)	int16	1,000	0.0009	0.0018	0.50×	201%
🟡	a * scalar (int16)	int16	100,000	0.0233	0.0262	0.89×	112%
✅	a * scalar (int16)	int16	10,000,000	7.0592	4.6609	1.51×	66%
▫	a * scalar (int32)	int32	1,000	0.0009	0.0019	0.46×	217%
🟠	a * scalar (int32)	int32	100,000	0.0231	0.0508	0.46×	220%
✅	a * scalar (int32)	int32	10,000,000	12.6141	9.1360	1.38×	72%
▫	a * scalar (int64)	int64	1,000	0.0009	0.0029	0.30×	332%
🟠	a * scalar (int64)	int64	100,000	0.0226	0.1076	0.21×	476%
🟠	a * scalar (int64)	int64	10,000,000	15.4341	31.3975	0.49×	203%
▫	a * scalar (int8)	int8	1,000	0.0007	0.0016	0.45×	223%
✅	a * scalar (int8)	int8	100,000	0.0223	0.0161	1.39×	72%
✅	a * scalar (int8)	int8	10,000,000	3.7610	2.0651	1.82×	55%
▫	a * scalar (uint16)	uint16	1,000	0.0009	0.0018	0.47×	213%
🟡	a * scalar (uint16)	uint16	100,000	0.0262	0.0269	0.97×	103%
✅	a * scalar (uint16)	uint16	10,000,000	7.0635	4.6785	1.51×	66%
▫	a * scalar (uint32)	uint32	1,000	0.0009	0.0020	0.46×	219%
🟠	a * scalar (uint32)	uint32	100,000	0.0227	0.0507	0.45×	223%
🟡	a * scalar (uint32)	uint32	10,000,000	7.8165	9.2370	0.85×	118%
▫	a * scalar (uint64)	uint64	1,000	0.0008	0.0028	0.28×	351%
🟠	a * scalar (uint64)	uint64	100,000	0.0222	0.1048	0.21×	471%
🟡	a * scalar (uint64)	uint64	10,000,000	15.1079	30.0570	0.50×	199%
▫	a * scalar (uint8)	uint8	1,000	0.0008	0.0016	0.47×	210%
✅	a * scalar (uint8)	uint8	100,000	0.0238	0.0159	1.50×	67%
✅	a * scalar (uint8)	uint8	10,000,000	4.0195	2.0901	1.92×	52%
🔴	a + 5 (literal) (complex128)	complex128	1,000	0.0011	0.0076	0.14×	691%
✅	a + 5 (literal) (complex128)	complex128	100,000	0.3558	0.3115	1.14×	88%
✅	a + 5 (literal) (complex128)	complex128	10,000,000	42.7672	39.9933	1.07×	94%
🟡	a + 5 (literal) (float16)	float16	1,000	0.0064	0.0106	0.60×	166%
🟠	a + 5 (literal) (float16)	float16	100,000	0.3642	0.8592	0.42×	236%
🟠	a + 5 (literal) (float16)	float16	10,000,000	31.0643	84.9236	0.37×	273%
▫	a + 5 (literal) (float32)	float32	1,000	0.0009	0.0049	0.18×	568%
🔴	a + 5 (literal) (float32)	float32	100,000	0.0065	0.0543	0.12×	841%
🟡	a + 5 (literal) (float32)	float32	10,000,000	8.0704	8.3566	0.97×	104%
▫	a + 5 (literal) (float64)	float64	1,000	0.0008	0.0056	0.14×	708%
🔴	a + 5 (literal) (float64)	float64	100,000	0.0117	0.1033	0.11×	884%
✅	a + 5 (literal) (float64)	float64	10,000,000	19.9822	19.3898	1.03×	97%
🟠	a + 5 (literal) (int16)	int16	1,000	0.0010	0.0025	0.41×	245%
🟡	a + 5 (literal) (int16)	int16	100,000	0.0256	0.0297	0.86×	116%
✅	a + 5 (literal) (int16)	int16	10,000,000	6.8921	4.3178	1.60×	63%
🟠	a + 5 (literal) (int32)	int32	1,000	0.0010	0.0033	0.31×	321%
🟠	a + 5 (literal) (int32)	int32	100,000	0.0250	0.0530	0.47×	212%
✅	a + 5 (literal) (int32)	int32	10,000,000	12.6603	8.4146	1.50×	66%
▫	a + 5 (literal) (int64)	int64	1,000	0.0010	0.0058	0.17×	598%
🟠	a + 5 (literal) (int64)	int64	100,000	0.0233	0.1024	0.23×	439%
🟡	a + 5 (literal) (int64)	int64	10,000,000	15.3142	19.3520	0.79×	126%
▫	a + 5 (literal) (int8)	int8	1,000	0.0009	0.0034	0.26×	387%
✅	a + 5 (literal) (int8)	int8	100,000	0.0369	0.0230	1.60×	62%
✅	a + 5 (literal) (int8)	int8	10,000,000	4.1932	1.9965	2.10×	48%
🟠	a + 5 (literal) (uint16)	uint16	1,000	0.0010	0.0048	0.21×	474%
🟡	a + 5 (literal) (uint16)	uint16	100,000	0.0250	0.0308	0.81×	123%
✅	a + 5 (literal) (uint16)	uint16	10,000,000	6.9032	4.2530	1.62×	62%
🔴	a + 5 (literal) (uint32)	uint32	1,000	0.0011	0.0056	0.19×	530%
🟠	a + 5 (literal) (uint32)	uint32	100,000	0.0234	0.0493	0.47×	211%
✅	a + 5 (literal) (uint32)	uint32	10,000,000	10.0916	8.5435	1.18×	85%
🔴	a + 5 (literal) (uint64)	uint64	1,000	0.0010	0.0054	0.19×	526%
🟠	a + 5 (literal) (uint64)	uint64	100,000	0.0236	0.1073	0.22×	454%
🟡	a + 5 (literal) (uint64)	uint64	10,000,000	15.2161	20.0614	0.76×	132%
▫	a + 5 (literal) (uint8)	uint8	1,000	0.0009	0.0036	0.26×	390%
✅	a + 5 (literal) (uint8)	uint8	100,000	0.0248	0.0205	1.21×	83%
✅	a + 5 (literal) (uint8)	uint8	10,000,000	4.1679	1.9455	2.14×	47%
🟠	a + b (element-wise) (complex128)	complex128	1,000	0.0010	0.0046	0.23×	442%
🟡	a + b (element-wise) (complex128)	complex128	100,000	0.3515	0.4716	0.74×	134%
🟡	a + b (element-wise) (complex128)	complex128	10,000,000	42.3859	58.1610	0.73×	137%
🟡	a + b (element-wise) (float16)	float16	1,000	0.0055	0.0091	0.60×	165%
🟠	a + b (element-wise) (float16)	float16	100,000	0.2982	0.8560	0.35×	287%
🟠	a + b (element-wise) (float16)	float16	10,000,000	31.3075	87.5987	0.36×	280%
▫	a + b (element-wise) (float32)	float32	1,000	0.0007	0.0011	0.67×	149%
🔴	a + b (element-wise) (float32)	float32	100,000	0.0069	0.0546	0.13×	792%
🟡	a + b (element-wise) (float32)	float32	10,000,000	8.7877	10.3685	0.85×	118%
▫	a + b (element-wise) (float64)	float64	1,000	0.0005	0.0018	0.28×	358%
🟠	a + b (element-wise) (float64)	float64	100,000	0.0287	0.1183	0.24×	413%
🟡	a + b (element-wise) (float64)	float64	10,000,000	17.1247	32.2672	0.53×	188%
▫	a + b (element-wise) (int16)	int16	1,000	0.0009	0.0018	0.47×	213%
🟡	a + b (element-wise) (int16)	int16	100,000	0.0306	0.0341	0.90×	111%
✅	a + b (element-wise) (int16)	int16	10,000,000	7.6408	7.1288	1.07×	93%
▫	a + b (element-wise) (int32)	int32	1,000	0.0008	0.0022	0.35×	286%
🟡	a + b (element-wise) (int32)	int32	100,000	0.0296	0.0569	0.52×	192%
✅	a + b (element-wise) (int32)	int32	10,000,000	13.4533	10.0724	1.34×	75%
▫	a + b (element-wise) (int64)	int64	1,000	0.0010	0.0032	0.30×	330%
🟠	a + b (element-wise) (int64)	int64	100,000	0.0351	0.1211	0.29×	345%
🟡	a + b (element-wise) (int64)	int64	10,000,000	16.9982	32.1148	0.53×	189%
▫	a + b (element-wise) (int8)	int8	1,000	0.0007	0.0017	0.39×	256%
✅	a + b (element-wise) (int8)	int8	100,000	0.0289	0.0158	1.83×	55%
✅	a + b (element-wise) (int8)	int8	10,000,000	4.7377	3.2841	1.44×	69%
▫	a + b (element-wise) (uint16)	uint16	1,000	0.0008	0.0021	0.39×	256%
✅	a + b (element-wise) (uint16)	uint16	100,000	0.0305	0.0303	1.00×	100%
✅	a + b (element-wise) (uint16)	uint16	10,000,000	7.7579	7.1286	1.09×	92%
🟡	a + b (element-wise) (uint32)	uint32	1,000	0.0011	0.0017	0.68×	148%
🟡	a + b (element-wise) (uint32)	uint32	100,000	0.0292	0.0565	0.52×	194%
✅	a + b (element-wise) (uint32)	uint32	10,000,000	13.4492	9.8607	1.36×	73%
▫	a + b (element-wise) (uint64)	uint64	1,000	0.0008	0.0027	0.29×	348%
🟠	a + b (element-wise) (uint64)	uint64	100,000	0.0529	0.1072	0.49×	203%
🟠	a + b (element-wise) (uint64)	uint64	10,000,000	17.2194	35.4223	0.49×	206%
▫	a + b (element-wise) (uint8)	uint8	1,000	0.0008	0.0019	0.43×	232%
✅	a + b (element-wise) (uint8)	uint8	100,000	0.0305	0.0154	1.98×	50%
✅	a + b (element-wise) (uint8)	uint8	10,000,000	4.9889	3.3759	1.48×	68%
▫	a + scalar (complex128)	complex128	1,000	0.0009	0.0042	0.23×	442%
✅	a + scalar (complex128)	complex128	100,000	0.3392	0.3087	1.10×	91%
🟡	a + scalar (complex128)	complex128	10,000,000	39.4817	41.1306	0.96×	104%
🟡	a + scalar (float16)	float16	1,000	0.0066	0.0091	0.73×	138%
🟠	a + scalar (float16)	float16	100,000	0.3632	0.8631	0.42×	238%
🟠	a + scalar (float16)	float16	10,000,000	30.8505	85.6472	0.36×	278%
▫	a + scalar (float32)	float32	1,000	0.0007	0.0020	0.35×	283%
🔴	a + scalar (float32)	float32	100,000	0.0062	0.0514	0.12×	829%
🟡	a + scalar (float32)	float32	10,000,000	7.9325	8.3761	0.95×	106%
▫	a + scalar (float64)	float64	1,000	0.0007	0.0027	0.24×	416%
🔴	a + scalar (float64)	float64	100,000	0.0116	0.1045	0.11×	902%
🟡	a + scalar (float64)	float64	10,000,000	19.7762	20.4638	0.97×	104%
▫	a + scalar (int16)	int16	1,000	0.0009	0.0017	0.51×	196%
🟡	a + scalar (int16)	int16	100,000	0.0249	0.0262	0.95×	105%
✅	a + scalar (int16)	int16	10,000,000	7.1782	4.4382	1.62×	62%
▫	a + scalar (int32)	int32	1,000	0.0009	0.0019	0.46×	217%
🟠	a + scalar (int32)	int32	100,000	0.0245	0.0532	0.46×	217%
✅	a + scalar (int32)	int32	10,000,000	12.6205	8.3589	1.51×	66%
▫	a + scalar (int64)	int64	1,000	0.0009	0.0027	0.33×	304%
🟠	a + scalar (int64)	int64	100,000	0.0236	0.1014	0.23×	429%
🟡	a + scalar (int64)	int64	10,000,000	14.8466	19.9072	0.75×	134%
▫	a + scalar (int8)	int8	1,000	0.0008	0.0016	0.49×	203%
✅	a + scalar (int8)	int8	100,000	0.0251	0.0149	1.69×	59%
✅	a + scalar (int8)	int8	10,000,000	4.2152	1.9671	2.14×	47%
▫	a + scalar (uint16)	uint16	1,000	0.0009	0.0017	0.54×	187%
🟡	a + scalar (uint16)	uint16	100,000	0.0245	0.0256	0.96×	105%
✅	a + scalar (uint16)	uint16	10,000,000	6.9794	4.3583	1.60×	62%
▫	a + scalar (uint32)	uint32	1,000	0.0009	0.0019	0.49×	205%
🟠	a + scalar (uint32)	uint32	100,000	0.0247	0.0503	0.49×	204%
✅	a + scalar (uint32)	uint32	10,000,000	10.8927	8.4266	1.29×	77%
▫	a + scalar (uint64)	uint64	1,000	0.0009	0.0025	0.37×	273%
🟠	a + scalar (uint64)	uint64	100,000	0.0235	0.1018	0.23×	433%
🟡	a + scalar (uint64)	uint64	10,000,000	15.0579	20.0299	0.75×	133%
▫	a + scalar (uint8)	uint8	1,000	0.0008	0.0015	0.50×	202%
✅	a + scalar (uint8)	uint8	100,000	0.0248	0.0148	1.67×	60%
✅	a + scalar (uint8)	uint8	10,000,000	4.4127	1.9329	2.28×	44%
▫	a - b (element-wise) (complex128)	complex128	1,000	0.0009	0.0040	0.22×	458%
✅	a - b (element-wise) (complex128)	complex128	100,000	0.3505	0.2610	1.34×	74%
✅	a - b (element-wise) (complex128)	complex128	10,000,000	41.6707	35.7057	1.17×	86%
🟠	a - b (element-wise) (float16)	float16	1,000	0.0041	0.0092	0.44×	225%
🟡	a - b (element-wise) (float16)	float16	100,000	0.3042	0.4791	0.64×	158%
🟡	a - b (element-wise) (float16)	float16	10,000,000	31.1711	48.4343	0.64×	155%
▫	a - b (element-wise) (float32)	float32	1,000	0.0006	0.0020	0.28×	359%
🔴	a - b (element-wise) (float32)	float32	100,000	0.0069	0.0482	0.14×	698%
✅	a - b (element-wise) (float32)	float32	10,000,000	8.6157	5.6899	1.51×	66%
▫	a - b (element-wise) (float64)	float64	1,000	0.0005	0.0018	0.29×	340%
🟠	a - b (element-wise) (float64)	float64	100,000	0.0331	0.1072	0.31×	324%
✅	a - b (element-wise) (float64)	float64	10,000,000	21.1427	16.8826	1.25×	80%
▫	a - b (element-wise) (int16)	int16	1,000	0.0008	0.0017	0.45×	222%
✅	a - b (element-wise) (int16)	int16	100,000	0.0293	0.0250	1.17×	85%
✅	a - b (element-wise) (int16)	int16	10,000,000	7.8362	3.1173	2.51×	40%
▫	a - b (element-wise) (int32)	int32	1,000	0.0008	0.0020	0.40×	253%
🟡	a - b (element-wise) (int32)	int32	100,000	0.0287	0.0524	0.55×	182%
✅	a - b (element-wise) (int32)	int32	10,000,000	13.7810	6.3717	2.16×	46%
▫	a - b (element-wise) (int64)	int64	1,000	0.0008	0.0028	0.27×	367%
🟠	a - b (element-wise) (int64)	int64	100,000	0.0352	0.1044	0.34×	297%
🟡	a - b (element-wise) (int64)	int64	10,000,000	16.8594	20.7569	0.81×	123%
▫	a - b (element-wise) (int8)	int8	1,000	0.0007	0.0014	0.46×	219%
✅	a - b (element-wise) (int8)	int8	100,000	0.0355	0.0155	2.29×	44%
✅	a - b (element-wise) (int8)	int8	10,000,000	4.7577	1.7145	2.77×	36%
▫	a - b (element-wise) (uint16)	uint16	1,000	0.0008	0.0018	0.45×	222%
✅	a - b (element-wise) (uint16)	uint16	100,000	0.0299	0.0263	1.14×	88%
✅	a - b (element-wise) (uint16)	uint16	10,000,000	8.2884	3.1096	2.67×	38%
▫	a - b (element-wise) (uint32)	uint32	1,000	0.0008	0.0020	0.41×	242%
🟡	a - b (element-wise) (uint32)	uint32	100,000	0.0294	0.0506	0.58×	172%
✅	a - b (element-wise) (uint32)	uint32	10,000,000	10.8540	6.0006	1.81×	55%
▫	a - b (element-wise) (uint64)	uint64	1,000	0.0008	0.0029	0.26×	385%
🟠	a - b (element-wise) (uint64)	uint64	100,000	0.0385	0.1017	0.38×	264%
🟡	a - b (element-wise) (uint64)	uint64	10,000,000	16.7811	20.9601	0.80×	125%
▫	a - b (element-wise) (uint8)	uint8	1,000	0.0007	0.0015	0.45×	224%
✅	a - b (element-wise) (uint8)	uint8	100,000	0.0288	0.0152	1.90×	53%
✅	a - b (element-wise) (uint8)	uint8	10,000,000	5.0513	1.6363	3.09×	32%
▫	a - scalar (complex128)	complex128	1,000	0.0009	0.0030	0.31×	319%
✅	a - scalar (complex128)	complex128	100,000	0.3509	0.2223	1.58×	63%
✅	a - scalar (complex128)	complex128	10,000,000	39.6368	25.1620	1.57×	64%
✅	a - scalar (float16)	float16	1,000	0.0061	0.0052	1.18×	85%
🟡	a - scalar (float16)	float16	100,000	0.2950	0.4792	0.62×	162%
🟡	a - scalar (float16)	float16	10,000,000	31.0622	48.9935	0.63×	158%
▫	a - scalar (float32)	float32	1,000	0.0007	0.0013	0.53×	190%
🟠	a - scalar (float32)	float32	100,000	0.0070	0.0293	0.24×	417%
✅	a - scalar (float32)	float32	10,000,000	8.0175	5.3684	1.49×	67%
▫	a - scalar (float64)	float64	1,000	0.0006	0.0019	0.33×	302%
🔴	a - scalar (float64)	float64	100,000	0.0118	0.0691	0.17×	586%
✅	a - scalar (float64)	float64	10,000,000	19.9346	14.0728	1.42×	71%
▫	a - scalar (int16)	int16	1,000	0.0009	0.0013	0.70×	142%
✅	a - scalar (int16)	int16	100,000	0.0239	0.0141	1.70×	59%
✅	a - scalar (int16)	int16	10,000,000	7.1495	2.7330	2.62×	38%
▫	a - scalar (int32)	int32	1,000	0.0009	0.0016	0.58×	173%
🟡	a - scalar (int32)	int32	100,000	0.0237	0.0278	0.85×	117%
✅	a - scalar (int32)	int32	10,000,000	13.2645	5.2875	2.51×	40%
▫	a - scalar (int64)	int64	1,000	0.0009	0.0015	0.62×	162%
🟠	a - scalar (int64)	int64	100,000	0.0241	0.0677	0.36×	280%
✅	a - scalar (int64)	int64	10,000,000	15.1015	14.4570	1.04×	96%
▫	a - scalar (int8)	int8	1,000	0.0008	0.0011	0.68×	147%
✅	a - scalar (int8)	int8	100,000	0.0319	0.0079	4.02×	25%
✅	a - scalar (int8)	int8	10,000,000	4.4975	1.3821	3.25×	31%
▫	a - scalar (uint16)	uint16	1,000	0.0009	0.0012	0.77×	130%
✅	a - scalar (uint16)	uint16	100,000	0.0244	0.0148	1.65×	61%
✅	a - scalar (uint16)	uint16	10,000,000	6.7651	2.6065	2.60×	38%
🟡	a - scalar (uint32)	uint32	1,000	0.0011	0.0012	0.88×	114%
🟡	a - scalar (uint32)	uint32	100,000	0.0233	0.0264	0.89×	113%
✅	a - scalar (uint32)	uint32	10,000,000	10.2434	5.3189	1.93×	52%
▫	a - scalar (uint64)	uint64	1,000	0.0009	0.0016	0.56×	177%
🟠	a - scalar (uint64)	uint64	100,000	0.0241	0.0652	0.37×	271%
✅	a - scalar (uint64)	uint64	10,000,000	15.1815	14.5668	1.04×	96%
▫	a - scalar (uint8)	uint8	1,000	0.0008	0.0008	0.95×	105%
✅	a - scalar (uint8)	uint8	100,000	0.0374	0.0079	4.71×	21%
✅	a - scalar (uint8)	uint8	10,000,000	4.1241	1.3972	2.95×	34%
▫	a / b (element-wise) (float32)	float32	1,000	0.0005	0.0023	0.22×	458%
🟠	a / b (element-wise) (float32)	float32	100,000	0.0134	0.0623	0.21×	466%
🟡	a / b (element-wise) (float32)	float32	10,000,000	8.4590	10.2825	0.82×	122%
▫	a / b (element-wise) (float64)	float64	1,000	0.0007	0.0034	0.22×	452%
🟠	a / b (element-wise) (float64)	float64	100,000	0.0382	0.1801	0.21×	472%
🟡	a / b (element-wise) (float64)	float64	10,000,000	20.4780	25.4700	0.80×	124%
🟠	a / b (element-wise) (int32)	int32	1,000	0.0024	0.0053	0.47×	215%
🟠	a / b (element-wise) (int32)	int32	100,000	0.0909	0.1953	0.47×	215%
✅	a / b (element-wise) (int32)	int32	10,000,000	31.1185	23.9718	1.30×	77%
🟠	a / b (element-wise) (int64)	int64	1,000	0.0019	0.0055	0.35×	289%
🟠	a / b (element-wise) (int64)	int64	100,000	0.0785	0.1896	0.41×	242%
🟡	a / b (element-wise) (int64)	int64	10,000,000	24.7535	40.7339	0.61×	165%
▫	a / scalar (float32)	float32	1,000	0.0007	0.0020	0.32×	308%
🟠	a / scalar (float32)	float32	100,000	0.0123	0.0595	0.21×	484%
🟡	a / scalar (float32)	float32	10,000,000	7.8511	8.8399	0.89×	113%
▫	a / scalar (float64)	float64	1,000	0.0009	0.0034	0.27×	376%
🟠	a / scalar (float64)	float64	100,000	0.0372	0.1696	0.22×	456%
🟡	a / scalar (float64)	float64	10,000,000	19.0548	23.8037	0.80×	125%
🟠	a / scalar (int32)	int32	1,000	0.0018	0.0041	0.43×	234%
🟠	a / scalar (int32)	int32	100,000	0.0622	0.1883	0.33×	302%
✅	a / scalar (int32)	int32	10,000,000	26.4799	23.0389	1.15×	87%
🟠	a / scalar (int64)	int64	1,000	0.0017	0.0074	0.23×	436%
🟠	a / scalar (int64)	int64	100,000	0.0575	0.1885	0.30×	328%
🟡	a / scalar (int64)	int64	10,000,000	20.5211	29.8992	0.69×	146%
▫	np.add(a, b) (complex128)	complex128	1,000	0.0008	0.0046	0.17×	572%
🟡	np.add(a, b) (complex128)	complex128	100,000	0.3569	0.4892	0.73×	137%
🟡	np.add(a, b) (complex128)	complex128	10,000,000	41.8396	58.6023	0.71×	140%
🟡	np.add(a, b) (float16)	float16	1,000	0.0057	0.0088	0.65×	155%
🟠	np.add(a, b) (float16)	float16	100,000	0.2995	0.8369	0.36×	280%
🟠	np.add(a, b) (float16)	float16	10,000,000	31.2511	85.9844	0.36×	275%
▫	np.add(a, b) (float32)	float32	1,000	0.0008	0.0019	0.41×	245%
🔴	np.add(a, b) (float32)	float32	100,000	0.0068	0.0542	0.12×	798%
🟡	np.add(a, b) (float32)	float32	10,000,000	8.6159	10.2348	0.84×	119%
▫	np.add(a, b) (float64)	float64	1,000	0.0005	0.0025	0.21×	475%
🟠	np.add(a, b) (float64)	float64	100,000	0.0287	0.1135	0.25×	396%
🟡	np.add(a, b) (float64)	float64	10,000,000	23.3169	25.7561	0.91×	110%
▫	np.add(a, b) (int16)	int16	1,000	0.0009	0.0017	0.51×	196%
✅	np.add(a, b) (int16)	int16	100,000	0.0312	0.0273	1.14×	87%
✅	np.add(a, b) (int16)	int16	10,000,000	7.8320	7.1303	1.10×	91%
▫	np.add(a, b) (int32)	int32	1,000	0.0008	0.0019	0.42×	238%
🟡	np.add(a, b) (int32)	int32	100,000	0.0299	0.0546	0.55×	183%
✅	np.add(a, b) (int32)	int32	10,000,000	14.4326	12.7485	1.13×	88%
▫	np.add(a, b) (int64)	int64	1,000	0.0008	0.0028	0.29×	341%
🟠	np.add(a, b) (int64)	int64	100,000	0.0359	0.1337	0.27×	372%
🟠	np.add(a, b) (int64)	int64	10,000,000	17.0171	34.3239	0.50×	202%
▫	np.add(a, b) (int8)	int8	1,000	0.0007	0.0017	0.39×	257%
✅	np.add(a, b) (int8)	int8	100,000	0.0293	0.0152	1.93×	52%
✅	np.add(a, b) (int8)	int8	10,000,000	4.8360	3.1341	1.54×	65%
▫	np.add(a, b) (uint16)	uint16	1,000	0.0008	0.0018	0.42×	235%
🟡	np.add(a, b) (uint16)	uint16	100,000	0.0294	0.0296	0.99×	101%
✅	np.add(a, b) (uint16)	uint16	10,000,000	8.1075	6.8350	1.19×	84%
▫	np.add(a, b) (uint32)	uint32	1,000	0.0010	0.0019	0.51×	195%
🟡	np.add(a, b) (uint32)	uint32	100,000	0.0324	0.0542	0.60×	167%
✅	np.add(a, b) (uint32)	uint32	10,000,000	10.4639	9.8564	1.06×	94%
▫	np.add(a, b) (uint64)	uint64	1,000	0.0008	0.0028	0.30×	330%
🟠	np.add(a, b) (uint64)	uint64	100,000	0.0405	0.1101	0.37×	272%
🟠	np.add(a, b) (uint64)	uint64	10,000,000	16.7988	34.5621	0.49×	206%
▫	np.add(a, b) (uint8)	uint8	1,000	0.0007	0.0019	0.36×	276%
✅	np.add(a, b) (uint8)	uint8	100,000	0.0287	0.0154	1.86×	54%
✅	np.add(a, b) (uint8)	uint8	10,000,000	4.7543	3.2277	1.47×	68%
▫	scalar - a (complex128)	complex128	1,000	0.0010	0.0027	0.36×	280%
✅	scalar - a (complex128)	complex128	100,000	0.3545	0.2210	1.60×	62%
✅	scalar - a (complex128)	complex128	10,000,000	37.5427	25.1481	1.49×	67%
✅	scalar - a (float16)	float16	1,000	0.0054	0.0051	1.05×	95%
🟡	scalar - a (float16)	float16	100,000	0.3008	0.4746	0.63×	158%
🟡	scalar - a (float16)	float16	10,000,000	31.1065	47.0491	0.66×	151%
▫	scalar - a (float32)	float32	1,000	0.0007	0.0014	0.52×	191%
🟠	scalar - a (float32)	float32	100,000	0.0067	0.0325	0.20×	487%
✅	scalar - a (float32)	float32	10,000,000	7.8766	5.3211	1.48×	68%
▫	scalar - a (float64)	float64	1,000	0.0007	0.0020	0.33×	300%
🟠	scalar - a (float64)	float64	100,000	0.0138	0.0582	0.24×	422%
✅	scalar - a (float64)	float64	10,000,000	20.1742	14.0006	1.44×	69%
▫	scalar - a (int16)	int16	1,000	0.0009	0.0012	0.78×	128%
✅	scalar - a (int16)	int16	100,000	0.0243	0.0148	1.64×	61%
✅	scalar - a (int16)	int16	10,000,000	7.1811	2.7354	2.62×	38%
▫	scalar - a (int32)	int32	1,000	0.0009	0.0013	0.72×	139%
🟡	scalar - a (int32)	int32	100,000	0.0240	0.0290	0.83×	121%
✅	scalar - a (int32)	int32	10,000,000	13.3685	5.4031	2.47×	40%
🟡	scalar - a (int64)	int64	1,000	0.0011	0.0018	0.63×	159%
🟠	scalar - a (int64)	int64	100,000	0.0250	0.0667	0.38×	267%
✅	scalar - a (int64)	int64	10,000,000	15.5954	14.9929	1.04×	96%
▫	scalar - a (int8)	int8	1,000	0.0008	0.0009	0.90×	111%
✅	scalar - a (int8)	int8	100,000	0.0254	0.0080	3.18×	31%
✅	scalar - a (int8)	int8	10,000,000	4.5431	1.3785	3.30×	30%
▫	scalar - a (uint16)	uint16	1,000	0.0009	0.0011	0.85×	118%
✅	scalar - a (uint16)	uint16	100,000	0.0313	0.0147	2.12×	47%
✅	scalar - a (uint16)	uint16	10,000,000	7.1706	2.6431	2.71×	37%
▫	scalar - a (uint32)	uint32	1,000	0.0009	0.0012	0.80×	124%
🟡	scalar - a (uint32)	uint32	100,000	0.0239	0.0299	0.80×	125%
✅	scalar - a (uint32)	uint32	10,000,000	9.9808	5.3724	1.86×	54%
▫	scalar - a (uint64)	uint64	1,000	0.0009	0.0018	0.51×	198%
🟠	scalar - a (uint64)	uint64	100,000	0.0246	0.0594	0.41×	242%
🟡	scalar - a (uint64)	uint64	10,000,000	14.8288	14.8342	1.00×	100%
▫	scalar - a (uint8)	uint8	1,000	0.0008	0.0009	0.84×	119%
✅	scalar - a (uint8)	uint8	100,000	0.0243	0.0082	2.98×	34%
✅	scalar - a (uint8)	uint8	10,000,000	4.0556	1.4050	2.89×	35%
▫	scalar / a (float32)	float32	1,000	0.0007	0.0020	0.33×	301%
🟠	scalar / a (float32)	float32	100,000	0.0127	0.0612	0.21×	483%
✅	scalar / a (float32)	float32	10,000,000	7.9570	7.2244	1.10×	91%
▫	scalar / a (float64)	float64	1,000	0.0009	0.0035	0.26×	385%
🟠	scalar / a (float64)	float64	100,000	0.0372	0.1857	0.20×	499%
🟡	scalar / a (float64)	float64	10,000,000	19.3997	22.5621	0.86×	116%
🟠	scalar / a (int32)	int32	1,000	0.0018	0.0070	0.26×	391%
🟠	scalar / a (int32)	int32	100,000	0.0638	0.1794	0.35×	281%
🟡	scalar / a (int32)	int32	10,000,000	22.0961	25.4827	0.87×	115%
🟠	scalar / a (int64)	int64	1,000	0.0018	0.0069	0.26×	383%
🟠	scalar / a (int64)	int64	100,000	0.0627	0.1881	0.33×	300%
🟡	scalar / a (int64)	int64	10,000,000	19.6435	30.8085	0.64×	157%

Unary

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
▫	np.abs (float16)	float16	1,000	0.0008	0.0015	0.54×	184%
✅	np.abs (float16)	float16	100,000	0.0264	0.0234	1.13×	89%
✅	np.abs (float16)	float16	10,000,000	4.7982	2.9688	1.62×	62%
▫	np.abs (float32)	float32	1,000	0.0005	0.0015	0.34×	291%
🔴	np.abs (float32)	float32	100,000	0.0064	0.0352	0.18×	553%
✅	np.abs (float32)	float32	10,000,000	7.1189	4.2161	1.69×	59%
▫	np.abs (float64)	float64	1,000	0.0006	0.0028	0.20×	503%
🔴	np.abs (float64)	float64	100,000	0.0112	0.0686	0.16×	612%
✅	np.abs (float64)	float64	10,000,000	14.6849	13.9245	1.05×	95%
🟡	np.cbrt(a) (float16)	float16	1,000	0.0101	0.0111	0.91×	110%
🟡	np.cbrt(a) (float16)	float16	100,000	1.1991	1.3766	0.87×	115%
🟡	np.cbrt(a) (float16)	float16	10,000,000	121.4253	136.3973	0.89×	112%
✅	np.cbrt(a) (float32)	float32	1,000	0.0066	0.0060	1.10×	91%
✅	np.cbrt(a) (float32)	float32	100,000	0.8943	0.8882	1.01×	99%
✅	np.cbrt(a) (float32)	float32	10,000,000	94.5195	86.5058	1.09×	92%
✅	np.cbrt(a) (float64)	float64	1,000	0.0098	0.0093	1.05×	95%
✅	np.cbrt(a) (float64)	float64	100,000	1.0970	1.0793	1.02×	98%
✅	np.cbrt(a) (float64)	float64	10,000,000	115.3869	109.5524	1.05×	95%
✅	np.ceil (float16)	float16	1,000	0.0050	0.0040	1.26×	79%
✅	np.ceil (float16)	float16	100,000	0.4660	0.3448	1.35×	74%
✅	np.ceil (float16)	float16	10,000,000	43.5339	33.7644	1.29×	78%
▫	np.ceil (float32)	float32	1,000	0.0005	0.0014	0.38×	263%
🟠	np.ceil (float32)	float32	100,000	0.0066	0.0305	0.22×	460%
✅	np.ceil (float32)	float32	10,000,000	7.2732	4.4002	1.65×	60%
🟠	np.ceil (float64)	float64	1,000	0.0014	0.0036	0.37×	270%
🔴	np.ceil (float64)	float64	100,000	0.0120	0.0606	0.20×	503%
🟡	np.ceil (float64)	float64	10,000,000	14.6298	16.0489	0.91×	110%
✅	np.clip(a, -10, 10) (float16)	float16	1,000	0.0087	0.0059	1.47×	68%
✅	np.clip(a, -10, 10) (float16)	float16	100,000	0.9296	0.7061	1.32×	76%
✅	np.clip(a, -10, 10) (float16)	float16	10,000,000	93.7915	68.7791	1.36×	73%
🟠	np.clip(a, -10, 10) (float32)	float32	1,000	0.0021	0.0064	0.32×	308%
🟠	np.clip(a, -10, 10) (float32)	float32	100,000	0.0082	0.0345	0.24×	421%
✅	np.clip(a, -10, 10) (float32)	float32	10,000,000	7.5158	4.1400	1.81×	55%
🟠	np.clip(a, -10, 10) (float64)	float64	1,000	0.0019	0.0047	0.40×	252%
🟠	np.clip(a, -10, 10) (float64)	float64	100,000	0.0166	0.0700	0.24×	421%
✅	np.clip(a, -10, 10) (float64)	float64	10,000,000	18.6971	13.3810	1.40×	72%
🟡	np.cos (float16)	float16	1,000	0.0051	0.0081	0.63×	158%
🟡	np.cos (float16)	float16	100,000	0.7102	1.1049	0.64×	156%
🟡	np.cos (float16)	float16	10,000,000	80.1757	109.6838	0.73×	137%
✅	np.cos (float32)	float32	1,000	0.0051	0.0038	1.35×	74%
🟡	np.cos (float32)	float32	100,000	0.7030	0.7111	0.99×	101%
✅	np.cos (float32)	float32	10,000,000	82.6791	69.0830	1.20×	84%
✅	np.cos (float64)	float64	1,000	0.0050	0.0040	1.22×	82%
🟡	np.cos (float64)	float64	100,000	0.6990	0.7313	0.96×	105%
✅	np.cos (float64)	float64	10,000,000	81.9906	77.3710	1.06×	94%
🟡	np.exp (float16)	float16	1,000	0.0052	0.0066	0.79×	127%
🟡	np.exp (float16)	float16	100,000	0.4392	0.6077	0.72×	138%
🟡	np.exp (float16)	float16	10,000,000	44.3829	58.6632	0.76×	132%
🔴	np.exp (float32)	float32	1,000	0.0010	0.0056	0.19×	539%
🟠	np.exp (float32)	float32	100,000	0.0553	0.1841	0.30×	333%
🟡	np.exp (float32)	float32	10,000,000	10.4285	17.6747	0.59×	170%
🟡	np.exp (float64)	float64	1,000	0.0030	0.0040	0.75×	134%
🟡	np.exp (float64)	float64	100,000	0.2581	0.2792	0.93×	108%
✅	np.exp (float64)	float64	10,000,000	33.4427	31.7361	1.05×	95%
🟠	np.exp2 (float16)	float16	1,000	0.0047	0.0099	0.48×	210%
🟠	np.exp2 (float16)	float16	100,000	0.4598	0.9896	0.47×	215%
🟠	np.exp2 (float16)	float16	10,000,000	48.1931	97.0656	0.50×	201%
🟠	np.exp2 (float32)	float32	1,000	0.0022	0.0100	0.22×	461%
🔴	np.exp2 (float32)	float32	100,000	0.1760	0.8987	0.20×	511%
🟠	np.exp2 (float32)	float32	10,000,000	22.9673	90.4267	0.25×	394%
🟠	np.exp2 (float64)	float64	1,000	0.0025	0.0096	0.26×	389%
🟠	np.exp2 (float64)	float64	100,000	0.2137	0.8559	0.25×	400%
🟠	np.exp2 (float64)	float64	10,000,000	37.0195	90.0413	0.41×	243%
🟡	np.expm1 (float16)	float16	1,000	0.0058	0.0091	0.64×	157%
🟡	np.expm1 (float16)	float16	100,000	0.5474	0.8722	0.63×	159%
🟡	np.expm1 (float16)	float16	10,000,000	55.0439	85.4215	0.64×	155%
🟡	np.expm1 (float32)	float32	1,000	0.0032	0.0046	0.70×	142%
✅	np.expm1 (float32)	float32	100,000	0.2728	0.1902	1.43×	70%
✅	np.expm1 (float32)	float32	10,000,000	31.7384	18.4160	1.72×	58%
🟡	np.expm1 (float64)	float64	1,000	0.0038	0.0040	0.95×	106%
✅	np.expm1 (float64)	float64	100,000	0.3590	0.2864	1.25×	80%
✅	np.expm1 (float64)	float64	10,000,000	47.0453	33.2374	1.42×	71%
✅	np.floor (float16)	float16	1,000	0.0051	0.0039	1.30×	77%
✅	np.floor (float16)	float16	100,000	0.4407	0.3400	1.30×	77%
✅	np.floor (float16)	float16	10,000,000	43.3912	33.7248	1.29×	78%
▫	np.floor (float32)	float32	1,000	0.0006	0.0015	0.38×	267%
🔴	np.floor (float32)	float32	100,000	0.0064	0.0319	0.20×	501%
✅	np.floor (float32)	float32	10,000,000	7.3030	5.1858	1.41×	71%
▫	np.floor (float64)	float64	1,000	0.0006	0.0032	0.17×	575%
🟠	np.floor (float64)	float64	100,000	0.0151	0.0632	0.24×	419%
🟡	np.floor (float64)	float64	10,000,000	14.8331	19.6220	0.76×	132%
🟡	np.log (float16)	float16	1,000	0.0049	0.0069	0.71×	141%
🟡	np.log (float16)	float16	100,000	0.4263	0.6316	0.68×	148%
🟡	np.log (float16)	float16	10,000,000	46.0282	63.6713	0.72×	138%
🟠	np.log (float32)	float32	1,000	0.0013	0.0051	0.26×	384%
🟠	np.log (float32)	float32	100,000	0.0869	0.2148	0.40×	247%
🟡	np.log (float32)	float32	10,000,000	13.1800	20.9525	0.63×	159%
🟡	np.log (float64)	float64	1,000	0.0028	0.0038	0.73×	136%
🟡	np.log (float64)	float64	100,000	0.2424	0.2668	0.91×	110%
✅	np.log (float64)	float64	10,000,000	31.9128	30.1149	1.06×	94%
🟡	np.log10 (float16)	float16	1,000	0.0052	0.0070	0.74×	135%
🟡	np.log10 (float16)	float16	100,000	0.4465	0.6426	0.69×	144%
🟡	np.log10 (float16)	float16	10,000,000	47.8418	62.9499	0.76×	132%
🟡	np.log10 (float32)	float32	1,000	0.0035	0.0050	0.70×	143%
🟡	np.log10 (float32)	float32	100,000	0.1985	0.2140	0.93×	108%
✅	np.log10 (float32)	float32	10,000,000	23.5444	20.6616	1.14×	88%
🟡	np.log10 (float64)	float64	1,000	0.0029	0.0040	0.73×	138%
🟡	np.log10 (float64)	float64	100,000	0.2625	0.2698	0.97×	103%
✅	np.log10 (float64)	float64	10,000,000	32.9855	30.7610	1.07×	93%
🟡	np.log1p (float16)	float16	1,000	0.0062	0.0086	0.72×	139%
🟡	np.log1p (float16)	float16	100,000	0.5885	0.7878	0.75×	134%
🟡	np.log1p (float16)	float16	10,000,000	60.5869	77.8953	0.78×	129%
🟡	np.log1p (float32)	float32	1,000	0.0039	0.0040	0.98×	102%
✅	np.log1p (float32)	float32	100,000	0.3058	0.2337	1.31×	76%
✅	np.log1p (float32)	float32	10,000,000	33.3514	22.3477	1.49×	67%
✅	np.log1p (float64)	float64	1,000	0.0039	0.0033	1.19×	84%
✅	np.log1p (float64)	float64	100,000	0.3412	0.2752	1.24×	81%
✅	np.log1p (float64)	float64	10,000,000	48.2083	31.5835	1.53×	66%
🟡	np.log2 (float16)	float16	1,000	0.0050	0.0070	0.72×	139%
🟡	np.log2 (float16)	float16	100,000	0.4545	0.6414	0.71×	141%
🟡	np.log2 (float16)	float16	10,000,000	48.9339	62.7084	0.78×	128%
🟡	np.log2 (float32)	float32	1,000	0.0027	0.0052	0.51×	195%
✅	np.log2 (float32)	float32	100,000	0.2008	0.2006	1.00×	100%
✅	np.log2 (float32)	float32	10,000,000	23.4387	19.2540	1.22×	82%
🟡	np.log2 (float64)	float64	1,000	0.0042	0.0044	0.95×	106%
🟡	np.log2 (float64)	float64	100,000	0.3739	0.3882	0.96×	104%
✅	np.log2 (float64)	float64	10,000,000	50.1019	42.1909	1.19×	84%
▫	np.negative(a) (float16)	float16	1,000	0.0007	0.0014	0.54×	185%
✅	np.negative(a) (float16)	float16	100,000	0.0278	0.0234	1.19×	84%
✅	np.negative(a) (float16)	float16	10,000,000	4.7690	2.8837	1.65×	60%
▫	np.negative(a) (float32)	float32	1,000	0.0005	0.0015	0.35×	289%
🟠	np.negative(a) (float32)	float32	100,000	0.0066	0.0261	0.25×	394%
✅	np.negative(a) (float32)	float32	10,000,000	7.7826	4.1048	1.90×	53%
▫	np.negative(a) (float64)	float64	1,000	0.0005	0.0036	0.15×	679%
🟠	np.negative(a) (float64)	float64	100,000	0.0121	0.0539	0.22×	447%
✅	np.negative(a) (float64)	float64	10,000,000	16.0651	13.8831	1.16×	86%
▫	np.positive(a) (float16)	float16	1,000	0.0007	0.0010	0.69×	144%
✅	np.positive(a) (float16)	float16	100,000	0.0217	0.0130	1.67×	60%
✅	np.positive(a) (float16)	float16	10,000,000	4.2319	1.6180	2.62×	38%
▫	np.positive(a) (float32)	float32	1,000	0.0007	0.0020	0.32×	310%
🟡	np.positive(a) (float32)	float32	100,000	0.0194	0.0250	0.78×	129%
✅	np.positive(a) (float32)	float32	10,000,000	7.7620	3.3803	2.30×	44%
▫	np.positive(a) (float64)	float64	1,000	0.0007	0.0028	0.24×	409%
🟠	np.positive(a) (float64)	float64	100,000	0.0206	0.0520	0.40×	252%
✅	np.positive(a) (float64)	float64	10,000,000	15.1241	10.8534	1.39×	72%
✅	np.power(a, 0.5) (float16)	float16	1,000	0.0092	0.0057	1.62×	62%
✅	np.power(a, 0.5) (float16)	float16	100,000	0.8324	0.3398	2.45×	41%
✅	np.power(a, 0.5) (float16)	float16	10,000,000	84.2019	32.9557	2.56×	39%
✅	np.power(a, 0.5) (float32)	float32	1,000	0.0020	0.0019	1.06×	94%
✅	np.power(a, 0.5) (float32)	float32	100,000	0.1267	0.0285	4.45×	22%
✅	np.power(a, 0.5) (float32)	float32	10,000,000	16.0019	4.1327	3.87×	26%
🟡	np.power(a, 0.5) (float64)	float64	1,000	0.0018	0.0032	0.55×	181%
✅	np.power(a, 0.5) (float64)	float64	100,000	0.1231	0.0638	1.93×	52%
✅	np.power(a, 0.5) (float64)	float64	10,000,000	25.4013	13.6356	1.86×	54%
✅	np.power(a, 2) (float16)	float16	1,000	0.0103	0.0054	1.90×	53%
✅	np.power(a, 2) (float16)	float16	100,000	1.0690	0.4762	2.25×	44%
✅	np.power(a, 2) (float16)	float16	10,000,000	106.8632	46.7294	2.29×	44%
✅	np.power(a, 2) (float32)	float32	1,000	0.0024	0.0017	1.36×	73%
✅	np.power(a, 2) (float32)	float32	100,000	0.1544	0.0283	5.46×	18%
✅	np.power(a, 2) (float32)	float32	10,000,000	18.9400	4.1649	4.55×	22%
🟡	np.power(a, 2) (float64)	float64	1,000	0.0022	0.0031	0.71×	141%
✅	np.power(a, 2) (float64)	float64	100,000	0.1542	0.0590	2.62×	38%
✅	np.power(a, 2) (float64)	float64	10,000,000	28.4405	13.5219	2.10×	48%
🟡	np.power(a, 3) (float16)	float16	1,000	0.0126	0.0176	0.72×	140%
🟡	np.power(a, 3) (float16)	float16	100,000	1.5343	2.4828	0.62×	162%
🟡	np.power(a, 3) (float16)	float16	10,000,000	150.3564	250.3069	0.60×	166%
🟡	np.power(a, 3) (float32)	float32	1,000	0.0059	0.0082	0.73×	137%
🟡	np.power(a, 3) (float32)	float32	100,000	0.6578	0.6780	0.97×	103%
✅	np.power(a, 3) (float32)	float32	10,000,000	72.0628	66.4589	1.08×	92%
🟡	np.power(a, 3) (float64)	float64	1,000	0.0098	0.0121	0.81×	123%
🟡	np.power(a, 3) (float64)	float64	100,000	1.0724	1.0959	0.98×	102%
✅	np.power(a, 3) (float64)	float64	10,000,000	124.6532	111.9286	1.11×	90%
🟡	np.reciprocal(a) (float16)	float16	1,000	0.0036	0.0045	0.79×	127%
🟡	np.reciprocal(a) (float16)	float16	100,000	0.2193	0.4080	0.54×	186%
🟡	np.reciprocal(a) (float16)	float16	10,000,000	23.1324	40.0357	0.58×	173%
▫	np.reciprocal(a) (float32)	float32	1,000	0.0006	0.0014	0.44×	225%
🟡	np.reciprocal(a) (float32)	float32	100,000	0.0143	0.0263	0.54×	184%
✅	np.reciprocal(a) (float32)	float32	10,000,000	7.1620	4.0578	1.76×	57%
▫	np.reciprocal(a) (float64)	float64	1,000	0.0008	0.0019	0.42×	237%
🟡	np.reciprocal(a) (float64)	float64	100,000	0.0421	0.0535	0.79×	127%
✅	np.reciprocal(a) (float64)	float64	10,000,000	14.7266	13.7636	1.07×	94%
✅	np.round (float16)	float16	1,000	0.0058	0.0046	1.24×	81%
✅	np.round (float16)	float16	100,000	0.4702	0.4240	1.11×	90%
✅	np.round (float16)	float16	10,000,000	42.8027	40.9331	1.05×	96%
🟡	np.round (float32)	float32	1,000	0.0011	0.0015	0.73×	136%
🟠	np.round (float32)	float32	100,000	0.0070	0.0281	0.25×	403%
✅	np.round (float32)	float32	10,000,000	7.3586	4.6823	1.57×	64%
🟠	np.round (float64)	float64	1,000	0.0012	0.0024	0.49×	204%
🟠	np.round (float64)	float64	100,000	0.0128	0.0572	0.22×	447%
🟡	np.round (float64)	float64	10,000,000	15.0627	15.7393	0.96×	104%
🟠	np.sign (float16)	float16	1,000	0.0014	0.0042	0.33×	304%
🔴	np.sign (float16)	float16	100,000	0.0887	0.6603	0.13×	744%
🔴	np.sign (float16)	float16	10,000,000	10.5588	63.8912	0.17×	605%
🟠	np.sign (float32)	float32	1,000	0.0011	0.0038	0.29×	339%
🟡	np.sign (float32)	float32	100,000	0.2971	0.4006	0.74×	135%
🟡	np.sign (float32)	float32	10,000,000	36.0421	39.7051	0.91×	110%
🟠	np.sign (float64)	float64	1,000	0.0010	0.0047	0.22×	448%
🟡	np.sign (float64)	float64	100,000	0.2936	0.4000	0.73×	136%
🟡	np.sign (float64)	float64	10,000,000	40.6151	45.1700	0.90×	111%
🟡	np.sin (float16)	float16	1,000	0.0057	0.0080	0.72×	139%
🟡	np.sin (float16)	float16	100,000	0.7108	1.1057	0.64×	156%
🟡	np.sin (float16)	float16	10,000,000	79.6291	110.4160	0.72×	139%
✅	np.sin (float32)	float32	1,000	0.0060	0.0038	1.57×	64%
✅	np.sin (float32)	float32	100,000	0.7167	0.7077	1.01×	99%
✅	np.sin (float32)	float32	10,000,000	80.7643	70.4978	1.15×	87%
✅	np.sin (float64)	float64	1,000	0.0049	0.0040	1.22×	82%
🟡	np.sin (float64)	float64	100,000	0.7140	0.7415	0.96×	104%
✅	np.sin (float64)	float64	10,000,000	82.0560	78.2388	1.05×	95%
✅	np.sqrt (float16)	float16	1,000	0.0046	0.0039	1.18×	85%
✅	np.sqrt (float16)	float16	100,000	0.4264	0.3413	1.25×	80%
✅	np.sqrt (float16)	float16	10,000,000	40.8006	33.6967	1.21×	83%
▫	np.sqrt (float32)	float32	1,000	0.0006	0.0015	0.42×	238%
🟡	np.sqrt (float32)	float32	100,000	0.0149	0.0291	0.51×	195%
✅	np.sqrt (float32)	float32	10,000,000	7.0955	4.2557	1.67×	60%
🟠	np.sqrt (float64)	float64	1,000	0.0012	0.0025	0.47×	214%
🟡	np.sqrt (float64)	float64	100,000	0.0557	0.0656	0.85×	118%
✅	np.sqrt (float64)	float64	10,000,000	15.1785	13.7551	1.10×	91%
🟡	np.square(a) (float16)	float16	1,000	0.0034	0.0048	0.71×	141%
🟠	np.square(a) (float16)	float16	100,000	0.2122	0.4399	0.48×	207%
🟡	np.square(a) (float16)	float16	10,000,000	23.1199	42.7721	0.54×	185%
▫	np.square(a) (float32)	float32	1,000	0.0005	0.0013	0.39×	258%
🟠	np.square(a) (float32)	float32	100,000	0.0058	0.0262	0.22×	448%
✅	np.square(a) (float32)	float32	10,000,000	7.1833	4.0587	1.77×	56%
▫	np.square(a) (float64)	float64	1,000	0.0005	0.0030	0.17×	596%
🟠	np.square(a) (float64)	float64	100,000	0.0122	0.0533	0.23×	436%
✅	np.square(a) (float64)	float64	10,000,000	14.9158	13.8405	1.08×	93%
🟡	np.tan (float16)	float16	1,000	0.0045	0.0083	0.55×	183%
🟡	np.tan (float16)	float16	100,000	0.8245	1.1120	0.74×	135%
🟡	np.tan (float16)	float16	10,000,000	92.5062	110.2014	0.84×	119%
✅	np.tan (float32)	float32	1,000	0.0047	0.0038	1.24×	81%
✅	np.tan (float32)	float32	100,000	0.8414	0.6851	1.23×	81%
✅	np.tan (float32)	float32	10,000,000	92.7529	67.5651	1.37×	73%
🟡	np.tan (float64)	float64	1,000	0.0050	0.0050	0.99×	101%
🟡	np.tan (float64)	float64	100,000	0.8055	0.8447	0.95×	105%
✅	np.tan (float64)	float64	10,000,000	94.5311	88.7915	1.06×	94%
✅	np.trunc(a) (float16)	float16	1,000	0.0054	0.0038	1.40×	71%
✅	np.trunc(a) (float16)	float16	100,000	0.4827	0.3346	1.44×	69%
✅	np.trunc(a) (float16)	float16	10,000,000	42.0396	32.4934	1.29×	77%
▫	np.trunc(a) (float32)	float32	1,000	0.0005	0.0016	0.34×	290%
🟠	np.trunc(a) (float32)	float32	100,000	0.0058	0.0257	0.22×	445%
✅	np.trunc(a) (float32)	float32	10,000,000	7.1817	4.0632	1.77×	57%
▫	np.trunc(a) (float64)	float64	1,000	0.0005	0.0020	0.27×	373%
🟠	np.trunc(a) (float64)	float64	100,000	0.0115	0.0513	0.22×	446%
✅	np.trunc(a) (float64)	float64	10,000,000	14.6674	13.6305	1.08×	93%

Reduction

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
✅	np.amax (complex128)	complex128	1,000	0.0030	0.0018	1.64×	61%
✅	np.amax (complex128)	complex128	100,000	0.1573	0.1142	1.38×	73%
✅	np.amax (complex128)	complex128	10,000,000	16.6240	13.6265	1.22×	82%
✅	np.amax (float16)	float16	1,000	0.0037	0.0011	3.48×	29%
✅	np.amax (float16)	float16	100,000	0.5066	0.3200	1.58×	63%
✅	np.amax (float16)	float16	10,000,000	50.6659	33.1861	1.53×	66%
▫	np.amax (float32)	float32	1,000	0.0017	0.0006	2.73×	37%
✅	np.amax (float32)	float32	100,000	0.0059	0.0038	1.54×	65%
✅	np.amax (float32)	float32	10,000,000	1.5947	1.2905	1.24×	81%
▫	np.amax (float64)	float64	1,000	0.0018	0.0008	2.34×	43%
✅	np.amax (float64)	float64	100,000	0.0099	0.0062	1.60×	62%
✅	np.amax (float64)	float64	10,000,000	3.3475	3.2005	1.05×	96%
▫	np.amax (int16)	int16	1,000	0.0015	0.0007	2.14×	47%
✅	np.amax (int16)	int16	100,000	0.0031	0.0015	2.04×	49%
✅	np.amax (int16)	int16	10,000,000	0.4359	0.3359	1.30×	77%
▫	np.amax (int32)	int32	1,000	0.0016	0.0007	2.28×	44%
✅	np.amax (int32)	int32	100,000	0.0044	0.0023	1.94×	52%
✅	np.amax (int32)	int32	10,000,000	1.2908	1.0195	1.27×	79%
▫	np.amax (int64)	int64	1,000	0.0017	0.0006	2.62×	38%
✅	np.amax (int64)	int64	100,000	0.0089	0.0078	1.14×	88%
🟡	np.amax (int64)	int64	10,000,000	3.4074	3.5508	0.96×	104%
▫	np.amax (int8)	int8	1,000	0.0016	0.0007	2.08×	48%
✅	np.amax (int8)	int8	100,000	0.0024	0.0012	2.00×	50%
✅	np.amax (int8)	int8	10,000,000	0.1508	0.1463	1.03×	97%
▫	np.amax (uint16)	uint16	1,000	0.0016	0.0008	2.12×	47%
✅	np.amax (uint16)	uint16	100,000	0.0032	0.0015	2.13×	47%
🟡	np.amax (uint16)	uint16	10,000,000	0.2938	0.3342	0.88×	114%
▫	np.amax (uint32)	uint32	1,000	0.0016	0.0007	2.21×	45%
✅	np.amax (uint32)	uint32	100,000	0.0049	0.0032	1.53×	65%
✅	np.amax (uint32)	uint32	10,000,000	1.4205	1.0043	1.41×	71%
▫	np.amax (uint64)	uint64	1,000	0.0017	0.0008	2.14×	47%
✅	np.amax (uint64)	uint64	100,000	0.0129	0.0100	1.29×	78%
🟡	np.amax (uint64)	uint64	10,000,000	3.6692	3.6868	0.99×	100%
▫	np.amax (uint8)	uint8	1,000	0.0016	0.0008	2.06×	49%
✅	np.amax (uint8)	uint8	100,000	0.0024	0.0012	2.06×	49%
🟡	np.amax (uint8)	uint8	10,000,000	0.1351	0.1468	0.92×	109%
✅	np.amax axis=0 (complex128)	complex128	1,000	0.0030	0.0030	1.00×	100%
✅	np.amax axis=0 (complex128)	complex128	100,000	0.1550	0.1176	1.32×	76%
✅	np.amax axis=0 (complex128)	complex128	10,000,000	16.0042	13.0433	1.23×	82%
✅	np.amax axis=0 (float16)	float16	1,000	0.0042	0.0019	2.18×	46%
✅	np.amax axis=0 (float16)	float16	100,000	0.5075	0.5048	1.00×	100%
🟡	np.amax axis=0 (float16)	float16	10,000,000	49.7420	78.1538	0.64×	157%
▫	np.amax axis=0 (float32)	float32	1,000	0.0021	0.0008	2.66×	38%
🟡	np.amax axis=0 (float32)	float32	100,000	0.0091	0.0100	0.92×	109%
🟡	np.amax axis=0 (float32)	float32	10,000,000	1.6926	1.8598	0.91×	110%
▫	np.amax axis=0 (float64)	float64	1,000	0.0021	0.0009	2.33×	43%
🟡	np.amax axis=0 (float64)	float64	100,000	0.0145	0.0175	0.83×	120%
🟡	np.amax axis=0 (float64)	float64	10,000,000	3.9104	4.2597	0.92×	109%
▫	np.amax axis=0 (int16)	int16	1,000	0.0020	0.0007	2.94×	34%
✅	np.amax axis=0 (int16)	int16	100,000	0.0063	0.0037	1.73×	58%
✅	np.amax axis=0 (int16)	int16	10,000,000	0.5073	0.3767	1.35×	74%
▫	np.amax axis=0 (int32)	int32	1,000	0.0020	0.0007	2.84×	35%
✅	np.amax axis=0 (int32)	int32	100,000	0.0082	0.0055	1.48×	67%
✅	np.amax axis=0 (int32)	int32	10,000,000	1.7469	1.3193	1.32×	76%
▫	np.amax axis=0 (int64)	int64	1,000	0.0021	0.0008	2.62×	38%
✅	np.amax axis=0 (int64)	int64	100,000	0.0153	0.0118	1.30×	77%
✅	np.amax axis=0 (int64)	int64	10,000,000	4.1410	3.6647	1.13×	88%
▫	np.amax axis=0 (int8)	int8	1,000	0.0020	0.0007	2.79×	36%
✅	np.amax axis=0 (int8)	int8	100,000	0.0076	0.0039	1.96×	51%
✅	np.amax axis=0 (int8)	int8	10,000,000	0.3964	0.1724	2.30×	44%
▫	np.amax axis=0 (uint16)	uint16	1,000	0.0020	0.0007	2.97×	34%
✅	np.amax axis=0 (uint16)	uint16	100,000	0.0065	0.0036	1.79×	56%
✅	np.amax axis=0 (uint16)	uint16	10,000,000	0.4804	0.3808	1.26×	79%
▫	np.amax axis=0 (uint32)	uint32	1,000	0.0019	0.0007	2.81×	36%
✅	np.amax axis=0 (uint32)	uint32	100,000	0.0082	0.0055	1.49×	67%
✅	np.amax axis=0 (uint32)	uint32	10,000,000	1.6177	1.2662	1.28×	78%
▫	np.amax axis=0 (uint64)	uint64	1,000	0.0020	0.0009	2.24×	45%
✅	np.amax axis=0 (uint64)	uint64	100,000	0.0185	0.0138	1.34×	74%
✅	np.amax axis=0 (uint64)	uint64	10,000,000	4.3907	3.8229	1.15×	87%
▫	np.amax axis=0 (uint8)	uint8	1,000	0.0019	0.0007	2.85×	35%
✅	np.amax axis=0 (uint8)	uint8	100,000	0.0081	0.0031	2.65×	38%
✅	np.amax axis=0 (uint8)	uint8	10,000,000	0.2207	0.1718	1.28×	78%
✅	np.amin (complex128)	complex128	1,000	0.0031	0.0016	1.93×	52%
✅	np.amin (complex128)	complex128	100,000	0.1527	0.1141	1.34×	75%
✅	np.amin (complex128)	complex128	10,000,000	16.4378	13.5639	1.21×	82%
✅	np.amin (float16)	float16	1,000	0.0041	0.0012	3.53×	28%
✅	np.amin (float16)	float16	100,000	0.5120	0.3020	1.70×	59%
✅	np.amin (float16)	float16	10,000,000	51.8815	31.4161	1.65×	61%
▫	np.amin (float32)	float32	1,000	0.0023	0.0008	2.97×	34%
✅	np.amin (float32)	float32	100,000	0.0058	0.0035	1.68×	60%
✅	np.amin (float32)	float32	10,000,000	1.4447	1.3328	1.08×	92%
▫	np.amin (float64)	float64	1,000	0.0017	0.0008	2.21×	45%
✅	np.amin (float64)	float64	100,000	0.0104	0.0073	1.42×	70%
✅	np.amin (float64)	float64	10,000,000	3.3498	3.2187	1.04×	96%
▫	np.amin (int16)	int16	1,000	0.0016	0.0007	2.27×	44%
✅	np.amin (int16)	int16	100,000	0.0035	0.0015	2.34×	43%
✅	np.amin (int16)	int16	10,000,000	0.7445	0.3330	2.24×	45%
▫	np.amin (int32)	int32	1,000	0.0016	0.0007	2.25×	44%
✅	np.amin (int32)	int32	100,000	0.0045	0.0023	1.98×	50%
✅	np.amin (int32)	int32	10,000,000	1.2150	1.0174	1.19×	84%
▫	np.amin (int64)	int64	1,000	0.0017	0.0008	2.13×	47%
✅	np.amin (int64)	int64	100,000	0.0106	0.0074	1.44×	70%
🟡	np.amin (int64)	int64	10,000,000	3.3282	3.5000	0.95×	105%
▫	np.amin (int8)	int8	1,000	0.0017	0.0007	2.30×	44%
✅	np.amin (int8)	int8	100,000	0.0028	0.0012	2.38×	42%
🟡	np.amin (int8)	int8	10,000,000	0.1435	0.1467	0.98×	102%
▫	np.amin (uint16)	uint16	1,000	0.0016	0.0007	2.16×	46%
✅	np.amin (uint16)	uint16	100,000	0.0033	0.0015	2.21×	45%
🟡	np.amin (uint16)	uint16	10,000,000	0.3225	0.3309	0.97×	103%
▫	np.amin (uint32)	uint32	1,000	0.0016	0.0007	2.30×	44%
✅	np.amin (uint32)	uint32	100,000	0.0044	0.0032	1.36×	74%
✅	np.amin (uint32)	uint32	10,000,000	1.0859	1.0190	1.07×	94%
▫	np.amin (uint64)	uint64	1,000	0.0017	0.0008	2.12×	47%
✅	np.amin (uint64)	uint64	100,000	0.0126	0.0097	1.29×	77%
🟡	np.amin (uint64)	uint64	10,000,000	3.6037	3.7516	0.96×	104%
▫	np.amin (uint8)	uint8	1,000	0.0016	0.0007	2.26×	44%
✅	np.amin (uint8)	uint8	100,000	0.0028	0.0012	2.41×	42%
🟡	np.amin (uint8)	uint8	10,000,000	0.1350	0.1465	0.92×	108%
🟡	np.amin axis=0 (complex128)	complex128	1,000	0.0029	0.0030	0.99×	101%
🟡	np.amin axis=0 (complex128)	complex128	100,000	0.1409	0.1480	0.95×	105%
✅	np.amin axis=0 (complex128)	complex128	10,000,000	15.7182	15.2730	1.03×	97%
✅	np.amin axis=0 (float16)	float16	1,000	0.0040	0.0019	2.11×	47%
🟡	np.amin axis=0 (float16)	float16	100,000	0.4771	0.5006	0.95×	105%
🟡	np.amin axis=0 (float16)	float16	10,000,000	47.3591	77.6081	0.61×	164%
▫	np.amin axis=0 (float32)	float32	1,000	0.0021	0.0008	2.67×	37%
✅	np.amin axis=0 (float32)	float32	100,000	0.0116	0.0098	1.18×	85%
🟡	np.amin axis=0 (float32)	float32	10,000,000	1.7252	1.8255	0.94×	106%
▫	np.amin axis=0 (float64)	float64	1,000	0.0021	0.0009	2.41×	42%
🟡	np.amin axis=0 (float64)	float64	100,000	0.0157	0.0165	0.95×	105%
🟡	np.amin axis=0 (float64)	float64	10,000,000	4.0124	4.1873	0.96×	104%
▫	np.amin axis=0 (int16)	int16	1,000	0.0020	0.0007	2.90×	34%
✅	np.amin axis=0 (int16)	int16	100,000	0.0065	0.0037	1.74×	58%
✅	np.amin axis=0 (int16)	int16	10,000,000	0.5065	0.3754	1.35×	74%
▫	np.amin axis=0 (int32)	int32	1,000	0.0023	0.0007	3.32×	30%
✅	np.amin axis=0 (int32)	int32	100,000	0.0088	0.0055	1.60×	62%
✅	np.amin axis=0 (int32)	int32	10,000,000	2.0366	1.2825	1.59×	63%
▫	np.amin axis=0 (int64)	int64	1,000	0.0027	0.0008	3.32×	30%
✅	np.amin axis=0 (int64)	int64	100,000	0.0193	0.0118	1.63×	61%
✅	np.amin axis=0 (int64)	int64	10,000,000	4.3888	3.6438	1.20×	83%
▫	np.amin axis=0 (int8)	int8	1,000	0.0019	0.0006	2.99×	33%
✅	np.amin axis=0 (int8)	int8	100,000	0.0077	0.0041	1.88×	53%
✅	np.amin axis=0 (int8)	int8	10,000,000	0.2767	0.1726	1.60×	62%
▫	np.amin axis=0 (uint16)	uint16	1,000	0.0020	0.0007	2.98×	34%
✅	np.amin axis=0 (uint16)	uint16	100,000	0.0065	0.0036	1.79×	56%
✅	np.amin axis=0 (uint16)	uint16	10,000,000	0.4421	0.3803	1.16×	86%
▫	np.amin axis=0 (uint32)	uint32	1,000	0.0019	0.0007	2.77×	36%
✅	np.amin axis=0 (uint32)	uint32	100,000	0.0084	0.0055	1.53×	65%
✅	np.amin axis=0 (uint32)	uint32	10,000,000	1.8904	1.2875	1.47×	68%
▫	np.amin axis=0 (uint64)	uint64	1,000	0.0020	0.0008	2.38×	42%
✅	np.amin axis=0 (uint64)	uint64	100,000	0.0177	0.0137	1.29×	77%
✅	np.amin axis=0 (uint64)	uint64	10,000,000	4.4047	3.8707	1.14×	88%
▫	np.amin axis=0 (uint8)	uint8	1,000	0.0019	0.0007	2.86×	35%
✅	np.amin axis=0 (uint8)	uint8	100,000	0.0076	0.0051	1.49×	67%
✅	np.amin axis=0 (uint8)	uint8	10,000,000	0.2090	0.1721	1.22×	82%
✅	np.argmax (complex128)	complex128	1,000	0.0020	0.0018	1.14×	88%
🟡	np.argmax (complex128)	complex128	100,000	0.1132	0.1141	0.99×	101%
✅	np.argmax (complex128)	complex128	10,000,000	14.1968	13.5590	1.05×	96%
✅	np.argmax (float16)	float16	1,000	0.0029	0.0021	1.41×	71%
✅	np.argmax (float16)	float16	100,000	0.4331	0.1412	3.07×	33%
✅	np.argmax (float16)	float16	10,000,000	43.8538	14.1652	3.10×	32%
▫	np.argmax (float32)	float32	1,000	0.0009	0.0012	0.78×	129%
🔴	np.argmax (float32)	float32	100,000	0.0087	0.0564	0.15×	648%
🟠	np.argmax (float32)	float32	10,000,000	2.3137	5.7594	0.40×	249%
▫	np.argmax (float64)	float64	1,000	0.0010	0.0012	0.82×	122%
🟠	np.argmax (float64)	float64	100,000	0.0193	0.0568	0.34×	294%
🟡	np.argmax (float64)	float64	10,000,000	4.1180	6.8003	0.61×	165%
▫	np.argmax (int16)	int16	1,000	0.0009	0.0007	1.23×	82%
✅	np.argmax (int16)	int16	100,000	0.0034	0.0017	2.02×	50%
✅	np.argmax (int16)	int16	10,000,000	0.6951	0.3548	1.96×	51%
▫	np.argmax (int32)	int32	1,000	0.0009	0.0007	1.23×	82%
✅	np.argmax (int32)	int32	100,000	0.0056	0.0027	2.10×	48%
✅	np.argmax (int32)	int32	10,000,000	1.8979	1.2026	1.58×	63%
▫	np.argmax (int64)	int64	1,000	0.0010	0.0009	1.11×	90%
🟡	np.argmax (int64)	int64	100,000	0.0146	0.0284	0.51×	195%
🟡	np.argmax (int64)	int64	10,000,000	4.1056	4.5513	0.90×	111%
▫	np.argmax (int8)	int8	1,000	0.0009	0.0007	1.25×	80%
✅	np.argmax (int8)	int8	100,000	0.0023	0.0012	1.88×	53%
✅	np.argmax (int8)	int8	10,000,000	0.1717	0.1469	1.17×	86%
▫	np.argmax (uint16)	uint16	1,000	0.0009	0.0007	1.27×	79%
✅	np.argmax (uint16)	uint16	100,000	0.0049	0.0017	2.96×	34%
✅	np.argmax (uint16)	uint16	10,000,000	0.5085	0.3549	1.43×	70%
▫	np.argmax (uint32)	uint32	1,000	0.0009	0.0007	1.30×	77%
✅	np.argmax (uint32)	uint32	100,000	0.0104	0.0036	2.91×	34%
✅	np.argmax (uint32)	uint32	10,000,000	1.8851	1.2169	1.55×	65%
▫	np.argmax (uint64)	uint64	1,000	0.0010	0.0009	1.04×	96%
🟡	np.argmax (uint64)	uint64	100,000	0.0171	0.0332	0.52×	194%
🟡	np.argmax (uint64)	uint64	10,000,000	4.3878	4.9463	0.89×	113%
▫	np.argmax (uint8)	uint8	1,000	0.0013	0.0007	1.95×	51%
✅	np.argmax (uint8)	uint8	100,000	0.0032	0.0012	2.60×	38%
✅	np.argmax (uint8)	uint8	10,000,000	0.2246	0.1465	1.53×	65%
✅	np.argmin (complex128)	complex128	1,000	0.0019	0.0015	1.25×	80%
🟡	np.argmin (complex128)	complex128	100,000	0.1139	0.1141	1.00×	100%
✅	np.argmin (complex128)	complex128	10,000,000	13.8711	13.6034	1.02×	98%
✅	np.argmin (float16)	float16	1,000	0.0029	0.0020	1.42×	70%
✅	np.argmin (float16)	float16	100,000	0.4248	0.1413	3.01×	33%
✅	np.argmin (float16)	float16	10,000,000	42.5861	14.1619	3.01×	33%
▫	np.argmin (float32)	float32	1,000	0.0009	0.0012	0.80×	125%
🔴	np.argmin (float32)	float32	100,000	0.0087	0.0564	0.15×	650%
🟠	np.argmin (float32)	float32	10,000,000	2.7401	5.7656	0.47×	210%
▫	np.argmin (float64)	float64	1,000	0.0010	0.0012	0.83×	121%
🟠	np.argmin (float64)	float64	100,000	0.0276	0.0569	0.48×	206%
🟡	np.argmin (float64)	float64	10,000,000	4.2847	6.7686	0.63×	158%
▫	np.argmin (int16)	int16	1,000	0.0011	0.0007	1.52×	66%
✅	np.argmin (int16)	int16	100,000	0.0034	0.0016	2.06×	48%
✅	np.argmin (int16)	int16	10,000,000	0.7167	0.3613	1.98×	50%
▫	np.argmin (int32)	int32	1,000	0.0010	0.0007	1.38×	73%
✅	np.argmin (int32)	int32	100,000	0.0055	0.0026	2.09×	48%
✅	np.argmin (int32)	int32	10,000,000	1.7646	1.1707	1.51×	66%
▫	np.argmin (int64)	int64	1,000	0.0010	0.0009	1.11×	90%
🟡	np.argmin (int64)	int64	100,000	0.0142	0.0283	0.50×	199%
🟡	np.argmin (int64)	int64	10,000,000	4.0644	4.5666	0.89×	112%
▫	np.argmin (int8)	int8	1,000	0.0009	0.0007	1.28×	78%
✅	np.argmin (int8)	int8	100,000	0.0023	0.0012	1.86×	54%
✅	np.argmin (int8)	int8	10,000,000	0.1626	0.1468	1.11×	90%
▫	np.argmin (uint16)	uint16	1,000	0.0009	0.0007	1.32×	76%
✅	np.argmin (uint16)	uint16	100,000	0.0050	0.0016	3.04×	33%
✅	np.argmin (uint16)	uint16	10,000,000	0.5632	0.3583	1.57×	64%
▫	np.argmin (uint32)	uint32	1,000	0.0010	0.0007	1.36×	73%
✅	np.argmin (uint32)	uint32	100,000	0.0101	0.0035	2.86×	35%
✅	np.argmin (uint32)	uint32	10,000,000	1.8480	1.1772	1.57×	64%
▫	np.argmin (uint64)	uint64	1,000	0.0010	0.0009	1.03×	97%
🟡	np.argmin (uint64)	uint64	100,000	0.0180	0.0331	0.54×	184%
🟡	np.argmin (uint64)	uint64	10,000,000	4.2831	4.9246	0.87×	115%
▫	np.argmin (uint8)	uint8	1,000	0.0009	0.0007	1.28×	78%
✅	np.argmin (uint8)	uint8	100,000	0.0033	0.0012	2.70×	37%
✅	np.argmin (uint8)	uint8	10,000,000	0.2237	0.1465	1.53×	66%
🟡	np.cumprod(a) (float16)	float16	1,000	0.0061	0.0097	0.63×	159%
🟠	np.cumprod(a) (float16)	float16	100,000	0.4103	0.9506	0.43×	232%
🟠	np.cumprod(a) (float16)	float16	10,000,000	43.5457	94.2260	0.46×	216%
✅	np.cumprod(a) (float32)	float32	1,000	0.0046	0.0028	1.65×	61%
✅	np.cumprod(a) (float32)	float32	100,000	0.1700	0.1114	1.53×	66%
✅	np.cumprod(a) (float32)	float32	10,000,000	20.8437	10.1707	2.05×	49%
✅	np.cumprod(a) (float64)	float64	1,000	0.0046	0.0034	1.33×	75%
✅	np.cumprod(a) (float64)	float64	100,000	0.1694	0.1446	1.17×	85%
✅	np.cumprod(a) (float64)	float64	10,000,000	25.4983	14.0728	1.81×	55%
🟡	np.cumsum (complex128)	complex128	1,000	0.0030	0.0037	0.82×	122%
✅	np.cumsum (complex128)	complex128	100,000	0.3769	0.2333	1.61×	62%
✅	np.cumsum (complex128)	complex128	10,000,000	41.3487	24.9780	1.66×	60%
🟡	np.cumsum (float16)	float16	1,000	0.0071	0.0094	0.75×	134%
🟡	np.cumsum (float16)	float16	100,000	0.4728	0.9144	0.52×	193%
🟡	np.cumsum (float16)	float16	10,000,000	49.3071	90.7463	0.54×	184%
✅	np.cumsum (float32)	float32	1,000	0.0029	0.0018	1.65×	61%
✅	np.cumsum (float32)	float32	100,000	0.1656	0.0789	2.10×	48%
✅	np.cumsum (float32)	float32	10,000,000	20.1855	7.3471	2.75×	36%
✅	np.cumsum (float64)	float64	1,000	0.0028	0.0022	1.31×	76%
✅	np.cumsum (float64)	float64	100,000	0.1698	0.1249	1.36×	74%
✅	np.cumsum (float64)	float64	10,000,000	24.6822	13.3431	1.85×	54%
✅	np.cumsum (int16)	int16	1,000	0.0025	0.0020	1.23×	81%
✅	np.cumsum (int16)	int16	100,000	0.3253	0.1209	2.69×	37%
✅	np.cumsum (int16)	int16	10,000,000	48.4266	10.6129	4.56×	22%
✅	np.cumsum (int32)	int32	1,000	0.0024	0.0019	1.27×	79%
✅	np.cumsum (int32)	int32	100,000	0.3303	0.1226	2.69×	37%
✅	np.cumsum (int32)	int32	10,000,000	32.3880	11.1306	2.91×	34%
🟡	np.cumsum (int64)	int64	1,000	0.0017	0.0019	0.92×	109%
🟠	np.cumsum (int64)	int64	100,000	0.0315	0.1231	0.26×	391%
✅	np.cumsum (int64)	int64	10,000,000	16.3798	12.7464	1.28×	78%
✅	np.cumsum (int8)	int8	1,000	0.0025	0.0017	1.49×	67%
✅	np.cumsum (int8)	int8	100,000	0.3124	0.1187	2.63×	38%
✅	np.cumsum (int8)	int8	10,000,000	41.0555	10.2543	4.00×	25%
✅	np.cumsum (uint16)	uint16	1,000	0.0026	0.0020	1.26×	80%
✅	np.cumsum (uint16)	uint16	100,000	0.3256	0.1199	2.72×	37%
✅	np.cumsum (uint16)	uint16	10,000,000	34.5917	10.5051	3.29×	30%
✅	np.cumsum (uint32)	uint32	1,000	0.0024	0.0021	1.17×	85%
✅	np.cumsum (uint32)	uint32	100,000	0.3374	0.1227	2.75×	36%
✅	np.cumsum (uint32)	uint32	10,000,000	29.7223	11.0895	2.68×	37%
🟡	np.cumsum (uint64)	uint64	1,000	0.0017	0.0020	0.82×	121%
🟠	np.cumsum (uint64)	uint64	100,000	0.0312	0.1218	0.26×	391%
✅	np.cumsum (uint64)	uint64	10,000,000	16.2415	12.7570	1.27×	78%
✅	np.cumsum (uint8)	uint8	1,000	0.0025	0.0019	1.27×	79%
✅	np.cumsum (uint8)	uint8	100,000	0.3198	0.1205	2.65×	38%
✅	np.cumsum (uint8)	uint8	10,000,000	28.9566	10.2799	2.82×	36%
▫	np.mean (complex128)	complex128	1,000	0.0027	0.0009	2.85×	35%
✅	np.mean (complex128)	complex128	100,000	0.0305	0.0101	3.01×	33%
✅	np.mean (complex128)	complex128	10,000,000	8.5581	6.4565	1.33×	75%
✅	np.mean (float16)	float16	1,000	0.0047	0.0012	3.86×	26%
✅	np.mean (float16)	float16	100,000	0.1088	0.0802	1.36×	74%
✅	np.mean (float16)	float16	10,000,000	10.4935	8.0190	1.31×	76%
▫	np.mean (float32)	float32	1,000	0.0040	0.0007	5.42×	18%
✅	np.mean (float32)	float32	100,000	0.0178	0.0032	5.55×	18%
✅	np.mean (float32)	float32	10,000,000	3.6083	1.0039	3.59×	28%
▫	np.mean (float64)	float64	1,000	0.0024	0.0007	3.25×	31%
✅	np.mean (float64)	float64	100,000	0.0169	0.0040	4.21×	24%
✅	np.mean (float64)	float64	10,000,000	4.6544	2.7943	1.67×	60%
▫	np.mean (int16)	int16	1,000	0.0031	0.0008	3.92×	26%
✅	np.mean (int16)	int16	100,000	0.0532	0.0189	2.81×	36%
✅	np.mean (int16)	int16	10,000,000	6.3750	1.9609	3.25×	31%
▫	np.mean (int32)	int32	1,000	0.0030	0.0008	3.71×	27%
✅	np.mean (int32)	int32	100,000	0.0429	0.0191	2.24×	45%
✅	np.mean (int32)	int32	10,000,000	4.9575	2.6752	1.85×	54%
▫	np.mean (int64)	int64	1,000	0.0029	0.0008	3.71×	27%
✅	np.mean (int64)	int64	100,000	0.0344	0.0045	7.72×	13%
✅	np.mean (int64)	int64	10,000,000	6.3414	2.7730	2.29×	44%
▫	np.mean (int8)	int8	1,000	0.0030	0.0008	3.58×	28%
✅	np.mean (int8)	int8	100,000	0.0567	0.0186	3.04×	33%
✅	np.mean (int8)	int8	10,000,000	5.6945	1.8461	3.08×	32%
▫	np.mean (uint16)	uint16	1,000	0.0031	0.0008	3.90×	26%
✅	np.mean (uint16)	uint16	100,000	0.0526	0.0189	2.78×	36%
✅	np.mean (uint16)	uint16	10,000,000	5.1914	1.9498	2.66×	38%
▫	np.mean (uint32)	uint32	1,000	0.0030	0.0008	3.70×	27%
✅	np.mean (uint32)	uint32	100,000	0.0402	0.0191	2.11×	47%
✅	np.mean (uint32)	uint32	10,000,000	4.6035	2.6686	1.73×	58%
▫	np.mean (uint64)	uint64	1,000	0.0032	0.0008	4.16×	24%
✅	np.mean (uint64)	uint64	100,000	0.0539	0.0045	12.08×	8%
✅	np.mean (uint64)	uint64	10,000,000	7.3769	2.7725	2.66×	38%
▫	np.mean (uint8)	uint8	1,000	0.0031	0.0008	3.81×	26%
✅	np.mean (uint8)	uint8	100,000	0.0541	0.0187	2.90×	34%
✅	np.mean (uint8)	uint8	10,000,000	5.0561	1.8459	2.74×	36%
✅	np.mean axis=0 (complex128)	complex128	1,000	0.0033	0.0025	1.30×	77%
✅	np.mean axis=0 (complex128)	complex128	100,000	0.0286	0.0241	1.19×	84%
✅	np.mean axis=0 (complex128)	complex128	10,000,000	7.5298	7.0381	1.07×	94%
✅	np.mean axis=0 (float16)	float16	1,000	0.0061	0.0035	1.75×	57%
🟡	np.mean axis=0 (float16)	float16	100,000	0.0790	0.1492	0.53×	189%
🟡	np.mean axis=0 (float16)	float16	10,000,000	7.3133	14.1963	0.52×	194%
✅	np.mean axis=0 (float32)	float32	1,000	0.0039	0.0022	1.82×	55%
🟡	np.mean axis=0 (float32)	float32	100,000	0.0086	0.0099	0.87×	115%
✅	np.mean axis=0 (float32)	float32	10,000,000	1.4901	1.3911	1.07×	93%
✅	np.mean axis=0 (float64)	float64	1,000	0.0030	0.0023	1.29×	78%
✅	np.mean axis=0 (float64)	float64	100,000	0.0166	0.0148	1.12×	89%
🟡	np.mean axis=0 (float64)	float64	10,000,000	3.3836	3.4775	0.97×	103%
▫	np.mean axis=0 (int16)	int16	1,000	0.0038	0.0008	4.83×	21%
✅	np.mean axis=0 (int16)	int16	100,000	0.0550	0.0084	6.53×	15%
✅	np.mean axis=0 (int16)	int16	10,000,000	5.3822	0.9630	5.59×	18%
▫	np.mean axis=0 (int32)	int32	1,000	0.0044	0.0008	5.78×	17%
✅	np.mean axis=0 (int32)	int32	100,000	0.0359	0.0078	4.60×	22%
✅	np.mean axis=0 (int32)	int32	10,000,000	4.5299	1.7225	2.63×	38%
✅	np.mean axis=0 (int64)	int64	1,000	0.0043	0.0013	3.25×	31%
🟡	np.mean axis=0 (int64)	int64	100,000	0.0320	0.0609	0.53×	190%
🔴	np.mean axis=0 (int64)	int64	10,000,000	5.9854	37.4022	0.16×	625%
▫	np.mean axis=0 (int8)	int8	1,000	0.0038	0.0008	4.56×	22%
✅	np.mean axis=0 (int8)	int8	100,000	0.0534	0.0082	6.49×	15%
✅	np.mean axis=0 (int8)	int8	10,000,000	6.4497	0.8079	7.98×	12%
▫	np.mean axis=0 (uint16)	uint16	1,000	0.0037	0.0007	5.00×	20%
✅	np.mean axis=0 (uint16)	uint16	100,000	0.0516	0.0084	6.10×	16%
✅	np.mean axis=0 (uint16)	uint16	10,000,000	5.8879	0.9392	6.27×	16%
▫	np.mean axis=0 (uint32)	uint32	1,000	0.0044	0.0008	5.64×	18%
✅	np.mean axis=0 (uint32)	uint32	100,000	0.0471	0.0093	5.04×	20%
✅	np.mean axis=0 (uint32)	uint32	10,000,000	4.9815	2.0165	2.47×	40%
✅	np.mean axis=0 (uint64)	uint64	1,000	0.0037	0.0017	2.20×	46%
🟡	np.mean axis=0 (uint64)	uint64	100,000	0.0479	0.0887	0.54×	185%
🔴	np.mean axis=0 (uint64)	uint64	10,000,000	7.1495	43.0435	0.17×	602%
▫	np.mean axis=0 (uint8)	uint8	1,000	0.0039	0.0007	5.20×	19%
✅	np.mean axis=0 (uint8)	uint8	100,000	0.0545	0.0082	6.63×	15%
✅	np.mean axis=0 (uint8)	uint8	10,000,000	5.3637	0.7883	6.80×	15%
✅	np.mean axis=1 (complex128)	complex128	1,000	0.0032	0.0025	1.24×	81%
✅	np.mean axis=1 (complex128)	complex128	100,000	0.0443	0.0348	1.27×	79%
✅	np.mean axis=1 (complex128)	complex128	10,000,000	8.4055	8.0660	1.04×	96%
✅	np.mean axis=1 (float16)	float16	1,000	0.0052	0.0039	1.31×	76%
🟡	np.mean axis=1 (float16)	float16	100,000	0.0952	0.1325	0.72×	139%
🟡	np.mean axis=1 (float16)	float16	10,000,000	7.9626	12.5326	0.64×	157%
✅	np.mean axis=1 (float32)	float32	1,000	0.0036	0.0022	1.67×	60%
✅	np.mean axis=1 (float32)	float32	100,000	0.0183	0.0127	1.45×	69%
✅	np.mean axis=1 (float32)	float32	10,000,000	2.9697	1.9066	1.56×	64%
✅	np.mean axis=1 (float64)	float64	1,000	0.0029	0.0022	1.33×	75%
✅	np.mean axis=1 (float64)	float64	100,000	0.0198	0.0144	1.37×	73%
✅	np.mean axis=1 (float64)	float64	10,000,000	5.1086	3.6854	1.39×	72%
▫	np.mean axis=1 (int16)	int16	1,000	0.0037	0.0008	4.55×	22%
✅	np.mean axis=1 (int16)	int16	100,000	0.0573	0.0080	7.19×	14%
✅	np.mean axis=1 (int16)	int16	10,000,000	6.0592	0.8322	7.28×	14%
▫	np.mean axis=1 (int32)	int32	1,000	0.0037	0.0007	5.00×	20%
✅	np.mean axis=1 (int32)	int32	100,000	0.0428	0.0049	8.79×	11%
✅	np.mean axis=1 (int32)	int32	10,000,000	4.8185	1.4394	3.35×	30%
✅	np.mean axis=1 (int64)	int64	1,000	0.0034	0.0013	2.55×	39%
🟡	np.mean axis=1 (int64)	int64	100,000	0.0394	0.0596	0.66×	151%
🟡	np.mean axis=1 (int64)	int64	10,000,000	6.3625	6.9185	0.92×	109%
▫	np.mean axis=1 (int8)	int8	1,000	0.0036	0.0008	4.50×	22%
✅	np.mean axis=1 (int8)	int8	100,000	0.0571	0.0079	7.21×	14%
✅	np.mean axis=1 (int8)	int8	10,000,000	5.5023	0.7110	7.74×	13%
▫	np.mean axis=1 (uint16)	uint16	1,000	0.0038	0.0008	4.68×	21%
✅	np.mean axis=1 (uint16)	uint16	100,000	0.0629	0.0080	7.90×	13%
✅	np.mean axis=1 (uint16)	uint16	10,000,000	5.4615	0.8406	6.50×	15%
▫	np.mean axis=1 (uint32)	uint32	1,000	0.0034	0.0008	4.12×	24%
✅	np.mean axis=1 (uint32)	uint32	100,000	0.0467	0.0091	5.12×	20%
✅	np.mean axis=1 (uint32)	uint32	10,000,000	4.9555	1.8041	2.75×	36%
✅	np.mean axis=1 (uint64)	uint64	1,000	0.0037	0.0016	2.23×	45%
🟡	np.mean axis=1 (uint64)	uint64	100,000	0.0569	0.0860	0.66×	151%
🟡	np.mean axis=1 (uint64)	uint64	10,000,000	7.3817	9.0110	0.82×	122%
▫	np.mean axis=1 (uint8)	uint8	1,000	0.0035	0.0008	4.50×	22%
✅	np.mean axis=1 (uint8)	uint8	100,000	0.0587	0.0079	7.42×	14%
✅	np.mean axis=1 (uint8)	uint8	10,000,000	5.2924	0.7077	7.48×	13%
✅	np.nanmax(a) (float16)	float16	1,000	0.0054	0.0011	4.87×	21%
✅	np.nanmax(a) (float16)	float16	100,000	0.5409	0.3172	1.71×	59%
✅	np.nanmax(a) (float16)	float16	10,000,000	51.2440	32.5673	1.57×	64%
▫	np.nanmax(a) (float32)	float32	1,000	0.0030	0.0009	3.29×	30%
🟠	np.nanmax(a) (float32)	float32	100,000	0.0081	0.0287	0.28×	356%
🟠	np.nanmax(a) (float32)	float32	10,000,000	1.5124	3.2798	0.46×	217%
✅	np.nanmax(a) (float64)	float64	1,000	0.0030	0.0012	2.52×	40%
🔴	np.nanmax(a) (float64)	float64	100,000	0.0115	0.0590	0.20×	512%
🟡	np.nanmax(a) (float64)	float64	10,000,000	3.5081	6.8740	0.51×	196%
✅	np.nanmean(a) (float16)	float16	1,000	0.0127	0.0017	7.37×	14%
✅	np.nanmean(a) (float16)	float16	100,000	0.3723	0.1054	3.53×	28%
✅	np.nanmean(a) (float16)	float16	10,000,000	37.8624	10.5382	3.59×	28%
▫	np.nanmean(a) (float32)	float32	1,000	0.0102	0.0008	12.61×	8%
✅	np.nanmean(a) (float32)	float32	100,000	0.0751	0.0383	1.96×	51%
✅	np.nanmean(a) (float32)	float32	10,000,000	19.3182	4.1701	4.63×	22%
✅	np.nanmean(a) (float64)	float64	1,000	0.0088	0.0012	7.49×	13%
✅	np.nanmean(a) (float64)	float64	100,000	0.3101	0.0378	8.21×	12%
✅	np.nanmean(a) (float64)	float64	10,000,000	29.7719	5.5602	5.35×	19%
✅	np.nanmedian(a) (float16)	float16	1,000	0.0171	0.0043	3.93×	26%
🟡	np.nanmedian(a) (float16)	float16	100,000	0.9889	1.3085	0.76×	132%
✅	np.nanmedian(a) (float16)	float16	10,000,000	114.7082	92.8901	1.24×	81%
✅	np.nanmedian(a) (float32)	float32	1,000	0.0132	0.0022	5.94×	17%
🟡	np.nanmedian(a) (float32)	float32	100,000	0.4888	0.6965	0.70×	142%
🟡	np.nanmedian(a) (float32)	float32	10,000,000	77.3793	80.5553	0.96×	104%
✅	np.nanmedian(a) (float64)	float64	1,000	0.0127	0.0023	5.54×	18%
🟡	np.nanmedian(a) (float64)	float64	100,000	0.5210	0.7022	0.74×	135%
✅	np.nanmedian(a) (float64)	float64	10,000,000	92.4864	89.4458	1.03×	97%
✅	np.nanmin(a) (float16)	float16	1,000	0.0053	0.0011	4.77×	21%
✅	np.nanmin(a) (float16)	float16	100,000	0.5322	0.3019	1.76×	57%
✅	np.nanmin(a) (float16)	float16	10,000,000	51.4324	31.1142	1.65×	60%
▫	np.nanmin(a) (float32)	float32	1,000	0.0030	0.0009	3.24×	31%
🟠	np.nanmin(a) (float32)	float32	100,000	0.0072	0.0287	0.25×	400%
🟠	np.nanmin(a) (float32)	float32	10,000,000	1.5001	3.3155	0.45×	221%
▫	np.nanmin(a) (float64)	float64	1,000	0.0042	0.0009	4.51×	22%
🔴	np.nanmin(a) (float64)	float64	100,000	0.0114	0.0589	0.19×	519%
🟡	np.nanmin(a) (float64)	float64	10,000,000	3.6863	6.8141	0.54×	185%
✅	np.nanpercentile(a, 50) (float16)	float16	1,000	0.0365	0.0043	8.45×	12%
✅	np.nanpercentile(a, 50) (float16)	float16	100,000	1.8857	1.3044	1.45×	69%
✅	np.nanpercentile(a, 50) (float16)	float16	10,000,000	120.9498	92.9097	1.30×	77%
✅	np.nanpercentile(a, 50) (float32)	float32	1,000	0.0267	0.0022	11.99×	8%
✅	np.nanpercentile(a, 50) (float32)	float32	100,000	0.7602	0.6960	1.09×	92%
🟡	np.nanpercentile(a, 50) (float32)	float32	10,000,000	51.8789	80.6571	0.64×	156%
✅	np.nanpercentile(a, 50) (float64)	float64	1,000	0.0265	0.0023	11.56×	9%
✅	np.nanpercentile(a, 50) (float64)	float64	100,000	0.7628	0.7034	1.08×	92%
🟡	np.nanpercentile(a, 50) (float64)	float64	10,000,000	63.5626	89.5666	0.71×	141%
✅	np.nanprod(a) (float16)	float16	1,000	0.0061	0.0013	4.73×	21%
✅	np.nanprod(a) (float16)	float16	100,000	0.1701	0.0886	1.92×	52%
✅	np.nanprod(a) (float16)	float16	10,000,000	20.5179	8.9271	2.30×	44%
▫	np.nanprod(a) (float32)	float32	1,000	0.0052	0.0008	6.31×	16%
✅	np.nanprod(a) (float32)	float32	100,000	0.1604	0.0119	13.53×	7%
✅	np.nanprod(a) (float32)	float32	10,000,000	18.0353	1.7540	10.28×	10%
▫	np.nanprod(a) (float64)	float64	1,000	0.0055	0.0008	6.96×	14%
✅	np.nanprod(a) (float64)	float64	100,000	0.1079	0.0235	4.60×	22%
✅	np.nanprod(a) (float64)	float64	10,000,000	28.6688	3.9531	7.25×	14%
✅	np.nanquantile(a, 0.5) (float16)	float16	1,000	0.0336	0.0043	7.73×	13%
✅	np.nanquantile(a, 0.5) (float16)	float16	100,000	1.8626	1.3071	1.43×	70%
✅	np.nanquantile(a, 0.5) (float16)	float16	10,000,000	121.1817	92.8534	1.30×	77%
✅	np.nanquantile(a, 0.5) (float32)	float32	1,000	0.0280	0.0022	12.60×	8%
✅	np.nanquantile(a, 0.5) (float32)	float32	100,000	0.7231	0.6973	1.04×	96%
🟡	np.nanquantile(a, 0.5) (float32)	float32	10,000,000	51.1057	80.6773	0.63×	158%
✅	np.nanquantile(a, 0.5) (float64)	float64	1,000	0.0257	0.0023	11.24×	9%
✅	np.nanquantile(a, 0.5) (float64)	float64	100,000	0.7484	0.7037	1.06×	94%
🟡	np.nanquantile(a, 0.5) (float64)	float64	10,000,000	64.0584	89.4386	0.72×	140%
✅	np.nanstd(a) (float16)	float16	1,000	0.0341	0.0028	12.26×	8%
✅	np.nanstd(a) (float16)	float16	100,000	1.2279	0.2159	5.69×	18%
✅	np.nanstd(a) (float16)	float16	10,000,000	119.9407	21.6231	5.55×	18%
✅	np.nanstd(a) (float32)	float32	1,000	0.0202	0.0017	11.92×	8%
✅	np.nanstd(a) (float32)	float32	100,000	0.1683	0.0864	1.95×	51%
✅	np.nanstd(a) (float32)	float32	10,000,000	31.9536	9.2060	3.47×	29%
✅	np.nanstd(a) (float64)	float64	1,000	0.0190	0.0015	12.52×	8%
✅	np.nanstd(a) (float64)	float64	100,000	0.4497	0.0761	5.91×	17%
✅	np.nanstd(a) (float64)	float64	10,000,000	49.6062	11.3264	4.38×	23%
✅	np.nansum(a) (float16)	float16	1,000	0.0063	0.0013	4.84×	21%
✅	np.nansum(a) (float16)	float16	100,000	0.2885	0.0901	3.20×	31%
✅	np.nansum(a) (float16)	float16	10,000,000	31.6077	8.9086	3.55×	28%
▫	np.nansum(a) (float32)	float32	1,000	0.0037	0.0008	4.83×	21%
✅	np.nansum(a) (float32)	float32	100,000	0.0321	0.0049	6.51×	15%
✅	np.nansum(a) (float32)	float32	10,000,000	13.3987	1.4131	9.48×	10%
▫	np.nansum(a) (float64)	float64	1,000	0.0037	0.0008	4.61×	22%
✅	np.nansum(a) (float64)	float64	100,000	0.0471	0.0097	4.88×	20%
✅	np.nansum(a) (float64)	float64	10,000,000	23.8754	3.4851	6.85×	15%
✅	np.nanvar(a) (float16)	float16	1,000	0.0324	0.0028	11.72×	8%
✅	np.nanvar(a) (float16)	float16	100,000	1.2270	0.2160	5.68×	18%
✅	np.nanvar(a) (float16)	float16	10,000,000	120.0573	21.5187	5.58×	18%
✅	np.nanvar(a) (float32)	float32	1,000	0.0195	0.0017	11.49×	9%
✅	np.nanvar(a) (float32)	float32	100,000	0.1645	0.0864	1.90×	52%
✅	np.nanvar(a) (float32)	float32	10,000,000	32.0612	9.2119	3.48×	29%
✅	np.nanvar(a) (float64)	float64	1,000	0.0198	0.0015	13.06×	8%
✅	np.nanvar(a) (float64)	float64	100,000	0.4356	0.0762	5.72×	18%
✅	np.nanvar(a) (float64)	float64	10,000,000	51.1759	11.2532	4.55×	22%
▫	np.prod (float64)	float64	1,000	0.0022	0.0008	2.89×	35%
✅	np.prod (float64)	float64	100,000	2.3310	0.1700	13.71×	7%
✅	np.prod (float64)	float64	10,000,000	239.6474	60.4092	3.97×	25%
▫	np.prod (int64)	int64	1,000	0.0021	0.0007	2.87×	35%
✅	np.prod (int64)	int64	100,000	0.0572	0.0143	4.00×	25%
✅	np.prod (int64)	int64	10,000,000	6.3161	3.8044	1.66×	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.0136	0.0089	1.54×	65%
🟡	np.prod axis=0 (float64)	float64	10,000,000	19.8072	19.8419	1.00×	100%
▫	np.prod axis=0 (int64)	int64	1,000	0.0020	0.0009	2.24×	45%
✅	np.prod axis=0 (int64)	int64	100,000	0.0272	0.0152	1.79×	56%
✅	np.prod axis=0 (int64)	int64	10,000,000	5.0107	4.1147	1.22×	82%
▫	np.prod axis=1 (float64)	float64	1,000	0.0019	0.0008	2.47×	40%
✅	np.prod axis=1 (float64)	float64	100,000	0.0601	0.0050	12.13×	8%
▫	np.prod axis=1 (float64)	float64	10,000,000	69.9249	3.0274	23.10×	4%
▫	np.prod axis=1 (int64)	int64	1,000	0.0019	0.0010	1.96×	51%
✅	np.prod axis=1 (int64)	int64	100,000	0.0458	0.0171	2.68×	37%
✅	np.prod axis=1 (int64)	int64	10,000,000	6.2759	3.9188	1.60×	62%
✅	np.std (float16)	float16	1,000	0.0203	0.0021	9.63×	10%
✅	np.std (float16)	float16	100,000	0.9085	0.1830	4.96×	20%
✅	np.std (float16)	float16	10,000,000	90.8149	18.0508	5.03×	20%
▫	np.std (float32)	float32	1,000	0.0086	0.0007	12.74×	8%
✅	np.std (float32)	float32	100,000	0.0450	0.0096	4.67×	21%
✅	np.std (float32)	float32	10,000,000	17.8322	2.6281	6.79×	15%
▫	np.std (float64)	float64	1,000	0.0068	0.0004	15.61×	6%
✅	np.std (float64)	float64	100,000	0.0570	0.0190	3.00×	33%
✅	np.std (float64)	float64	10,000,000	30.3403	6.6087	4.59×	22%
✅	np.std axis=0 (float16)	float16	1,000	0.0214	0.0045	4.78×	21%
✅	np.std axis=0 (float16)	float16	100,000	1.1043	0.3567	3.10×	32%
✅	np.std axis=0 (float16)	float16	10,000,000	110.0006	83.8826	1.31×	76%
✅	np.std axis=0 (float32)	float32	1,000	0.0087	0.0016	5.57×	18%
✅	np.std axis=0 (float32)	float32	100,000	0.0377	0.0231	1.63×	61%
✅	np.std axis=0 (float32)	float32	10,000,000	14.2545	4.6258	3.08×	32%
▫	np.std axis=0 (float64)	float64	1,000	0.0076	0.0009	8.36×	12%
✅	np.std axis=0 (float64)	float64	100,000	0.0637	0.0263	2.42×	41%
✅	np.std axis=0 (float64)	float64	10,000,000	30.0409	7.5189	4.00×	25%
▫	np.sum (complex128)	complex128	1,000	0.0018	0.0009	2.02×	50%
✅	np.sum (complex128)	complex128	100,000	0.0294	0.0101	2.91×	34%
✅	np.sum (complex128)	complex128	10,000,000	8.9925	6.4940	1.39×	72%
✅	np.sum (float16)	float16	1,000	0.0040	0.0012	3.33×	30%
✅	np.sum (float16)	float16	100,000	0.1981	0.0802	2.47×	40%
✅	np.sum (float16)	float16	10,000,000	19.9449	8.0365	2.48×	40%
▫	np.sum (float32)	float32	1,000	0.0017	0.0008	2.26×	44%
✅	np.sum (float32)	float32	100,000	0.0171	0.0032	5.40×	18%
✅	np.sum (float32)	float32	10,000,000	3.0579	1.0257	2.98×	34%
▫	np.sum (float64)	float64	1,000	0.0017	0.0008	2.24×	45%
🔴	np.sum (float64)	float64	100,000	0.0166	0.2090	0.079×	1260%
✅	np.sum (float64)	float64	10,000,000	4.8117	2.8908	1.66×	60%
▫	np.sum (int16)	int16	1,000	0.0020	0.0008	2.55×	39%
✅	np.sum (int16)	int16	100,000	0.0339	0.0189	1.79×	56%
✅	np.sum (int16)	int16	10,000,000	3.5547	1.9468	1.83×	55%
▫	np.sum (int32)	int32	1,000	0.0023	0.0008	2.85×	35%
✅	np.sum (int32)	int32	100,000	0.0345	0.0190	1.82×	55%
✅	np.sum (int32)	int32	10,000,000	4.7348	2.6909	1.76×	57%
▫	np.sum (int64)	int64	1,000	0.0018	0.0008	2.27×	44%
✅	np.sum (int64)	int64	100,000	0.0153	0.0045	3.42×	29%
✅	np.sum (int64)	int64	10,000,000	4.1490	2.8310	1.47×	68%
▫	np.sum (int8)	int8	1,000	0.0022	0.0008	2.77×	36%
✅	np.sum (int8)	int8	100,000	0.0342	0.0186	1.84×	54%
✅	np.sum (int8)	int8	10,000,000	3.2333	1.8404	1.76×	57%
▫	np.sum (uint16)	uint16	1,000	0.0022	0.0008	2.84×	35%
✅	np.sum (uint16)	uint16	100,000	0.0334	0.0189	1.77×	57%
✅	np.sum (uint16)	uint16	10,000,000	3.7579	1.9368	1.94×	52%
▫	np.sum (uint32)	uint32	1,000	0.0023	0.0008	2.83×	35%
✅	np.sum (uint32)	uint32	100,000	0.0332	0.0190	1.75×	57%
✅	np.sum (uint32)	uint32	10,000,000	4.0560	2.6922	1.51×	66%
▫	np.sum (uint64)	uint64	1,000	0.0018	0.0008	2.28×	44%
✅	np.sum (uint64)	uint64	100,000	0.0200	0.0044	4.52×	22%
✅	np.sum (uint64)	uint64	10,000,000	4.2549	2.9226	1.46×	69%
▫	np.sum (uint8)	uint8	1,000	0.0024	0.0008	3.07×	32%
✅	np.sum (uint8)	uint8	100,000	0.0348	0.0186	1.87×	54%
✅	np.sum (uint8)	uint8	10,000,000	3.2589	1.8460	1.76×	57%
✅	np.sum axis=0 (complex128)	complex128	1,000	0.0020	0.0017	1.16×	86%
✅	np.sum axis=0 (complex128)	complex128	100,000	0.0309	0.0204	1.51×	66%
✅	np.sum axis=0 (complex128)	complex128	10,000,000	7.4501	7.3478	1.01×	99%
✅	np.sum axis=0 (float16)	float16	1,000	0.0053	0.0040	1.32×	76%
✅	np.sum axis=0 (float16)	float16	100,000	0.2950	0.1473	2.00×	50%
✅	np.sum axis=0 (float16)	float16	10,000,000	29.0440	14.1979	2.05×	49%
✅	np.sum axis=0 (float32)	float32	1,000	0.0022	0.0019	1.18×	85%
✅	np.sum axis=0 (float32)	float32	100,000	0.0083	0.0080	1.04×	96%
✅	np.sum axis=0 (float32)	float32	10,000,000	1.8895	1.3370	1.41×	71%
✅	np.sum axis=0 (float64)	float64	1,000	0.0020	0.0019	1.03×	97%
✅	np.sum axis=0 (float64)	float64	100,000	0.0142	0.0115	1.23×	81%
✅	np.sum axis=0 (float64)	float64	10,000,000	3.4762	3.4200	1.02×	98%
▫	np.sum axis=0 (int16)	int16	1,000	0.0025	0.0009	2.70×	37%
✅	np.sum axis=0 (int16)	int16	100,000	0.0474	0.0047	10.08×	10%
✅	np.sum axis=0 (int16)	int16	10,000,000	5.0614	0.5369	9.43×	11%
▫	np.sum axis=0 (int32)	int32	1,000	0.0028	0.0007	3.80×	26%
✅	np.sum axis=0 (int32)	int32	100,000	0.0485	0.0086	5.62×	18%
✅	np.sum axis=0 (int32)	int32	10,000,000	5.6694	1.8929	3.00×	33%
▫	np.sum axis=0 (int64)	int64	1,000	0.0020	0.0007	2.74×	36%
✅	np.sum axis=0 (int64)	int64	100,000	0.0278	0.0104	2.67×	37%
✅	np.sum axis=0 (int64)	int64	10,000,000	5.6011	3.2402	1.73×	58%
▫	np.sum axis=0 (int8)	int8	1,000	0.0024	0.0009	2.52×	40%
✅	np.sum axis=0 (int8)	int8	100,000	0.0474	0.0044	10.75×	9%
✅	np.sum axis=0 (int8)	int8	10,000,000	4.6440	0.5247	8.85×	11%
▫	np.sum axis=0 (uint16)	uint16	1,000	0.0025	0.0009	2.71×	37%
✅	np.sum axis=0 (uint16)	uint16	100,000	0.0479	0.0053	9.02×	11%
✅	np.sum axis=0 (uint16)	uint16	10,000,000	4.7415	0.6972	6.80×	15%
▫	np.sum axis=0 (uint32)	uint32	1,000	0.0028	0.0007	3.86×	26%
✅	np.sum axis=0 (uint32)	uint32	100,000	0.0506	0.0086	5.87×	17%
✅	np.sum axis=0 (uint32)	uint32	10,000,000	5.5471	1.7971	3.09×	32%
▫	np.sum axis=0 (uint64)	uint64	1,000	0.0020	0.0007	2.73×	37%
✅	np.sum axis=0 (uint64)	uint64	100,000	0.0274	0.0104	2.64×	38%
✅	np.sum axis=0 (uint64)	uint64	10,000,000	5.1406	3.2350	1.59×	63%
▫	np.sum axis=0 (uint8)	uint8	1,000	0.0026	0.0009	2.85×	35%
✅	np.sum axis=0 (uint8)	uint8	100,000	0.0513	0.0044	11.69×	9%
✅	np.sum axis=0 (uint8)	uint8	10,000,000	4.5577	0.5260	8.66×	12%
✅	np.sum axis=1 (complex128)	complex128	1,000	0.0021	0.0018	1.17×	86%
✅	np.sum axis=1 (complex128)	complex128	100,000	0.0340	0.0306	1.11×	90%
✅	np.sum axis=1 (complex128)	complex128	10,000,000	9.2453	8.6134	1.07×	93%
✅	np.sum axis=1 (float16)	float16	1,000	0.0039	0.0038	1.04×	96%
✅	np.sum axis=1 (float16)	float16	100,000	0.1987	0.1303	1.52×	66%
✅	np.sum axis=1 (float16)	float16	10,000,000	19.7912	12.4799	1.59×	63%
✅	np.sum axis=1 (float32)	float32	1,000	0.0030	0.0019	1.53×	65%
✅	np.sum axis=1 (float32)	float32	100,000	0.0162	0.0104	1.55×	64%
✅	np.sum axis=1 (float32)	float32	10,000,000	3.3850	1.8916	1.79×	56%
✅	np.sum axis=1 (float64)	float64	1,000	0.0019	0.0016	1.21×	83%
✅	np.sum axis=1 (float64)	float64	100,000	0.0200	0.0127	1.58×	63%
✅	np.sum axis=1 (float64)	float64	10,000,000	5.1036	3.6624	1.39×	72%
▫	np.sum axis=1 (int16)	int16	1,000	0.0023	0.0007	3.51×	28%
✅	np.sum axis=1 (int16)	int16	100,000	0.0376	0.0038	9.79×	10%
✅	np.sum axis=1 (int16)	int16	10,000,000	3.6422	0.4546	8.01×	12%
▫	np.sum axis=1 (int32)	int32	1,000	0.0025	0.0007	3.66×	27%
✅	np.sum axis=1 (int32)	int32	100,000	0.0396	0.0053	7.49×	13%
✅	np.sum axis=1 (int32)	int32	10,000,000	4.2337	1.6246	2.61×	38%
▫	np.sum axis=1 (int64)	int64	1,000	0.0019	0.0007	2.60×	38%
✅	np.sum axis=1 (int64)	int64	100,000	0.0175	0.0075	2.33×	43%
✅	np.sum axis=1 (int64)	int64	10,000,000	4.7220	2.8722	1.64×	61%
▫	np.sum axis=1 (int8)	int8	1,000	0.0023	0.0007	3.54×	28%
✅	np.sum axis=1 (int8)	int8	100,000	0.0379	0.0039	9.63×	10%
✅	np.sum axis=1 (int8)	int8	10,000,000	3.5111	0.2640	13.30×	8%
▫	np.sum axis=1 (uint16)	uint16	1,000	0.0027	0.0008	3.44×	29%
✅	np.sum axis=1 (uint16)	uint16	100,000	0.0375	0.0037	10.00×	10%
✅	np.sum axis=1 (uint16)	uint16	10,000,000	3.8775	0.4583	8.46×	12%
▫	np.sum axis=1 (uint32)	uint32	1,000	0.0026	0.0007	3.63×	28%
✅	np.sum axis=1 (uint32)	uint32	100,000	0.0413	0.0053	7.79×	13%
✅	np.sum axis=1 (uint32)	uint32	10,000,000	4.2817	1.6385	2.61×	38%
▫	np.sum axis=1 (uint64)	uint64	1,000	0.0019	0.0007	2.69×	37%
✅	np.sum axis=1 (uint64)	uint64	100,000	0.0173	0.0075	2.30×	44%
✅	np.sum axis=1 (uint64)	uint64	10,000,000	4.6457	2.8809	1.61×	62%
▫	np.sum axis=1 (uint8)	uint8	1,000	0.0025	0.0007	3.81×	26%
✅	np.sum axis=1 (uint8)	uint8	100,000	0.0402	0.0038	10.47×	10%
✅	np.sum axis=1 (uint8)	uint8	10,000,000	3.2063	0.2647	12.11×	8%
✅	np.var (float16)	float16	1,000	0.0200	0.0021	9.51×	10%
✅	np.var (float16)	float16	100,000	0.9060	0.1822	4.97×	20%
✅	np.var (float16)	float16	10,000,000	91.4660	18.1038	5.05×	20%
▫	np.var (float32)	float32	1,000	0.0083	0.0007	11.92×	8%
✅	np.var (float32)	float32	100,000	0.0451	0.0096	4.69×	21%
✅	np.var (float32)	float32	10,000,000	17.1259	2.6208	6.54×	15%
▫	np.var (float64)	float64	1,000	0.0067	0.0008	8.40×	12%
✅	np.var (float64)	float64	100,000	0.0573	0.0191	3.00×	33%
✅	np.var (float64)	float64	10,000,000	30.5902	6.6728	4.58×	22%
✅	np.var axis=0 (float16)	float16	1,000	0.0200	0.0044	4.51×	22%
✅	np.var axis=0 (float16)	float16	100,000	1.1366	0.3566	3.19×	31%
✅	np.var axis=0 (float16)	float16	10,000,000	109.8825	83.9268	1.31×	76%
✅	np.var axis=0 (float32)	float32	1,000	0.0086	0.0017	5.19×	19%
✅	np.var axis=0 (float32)	float32	100,000	0.0371	0.0226	1.64×	61%
✅	np.var axis=0 (float32)	float32	10,000,000	14.0847	4.7475	2.97×	34%
▫	np.var axis=0 (float64)	float64	1,000	0.0075	0.0009	7.97×	12%
✅	np.var axis=0 (float64)	float64	100,000	0.0680	0.0252	2.70×	37%
✅	np.var axis=0 (float64)	float64	10,000,000	28.5127	7.5344	3.78×	26%

Broadcasting

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
⚪	matrix + col_vector (N,M)+(N,1)	float64	1,000	0.0013	-	-	-
⚪	matrix + col_vector (N,M)+(N,1)	float64	100,000	0.1968	-	-	-
✅	matrix + col_vector (N,M)+(N,1)	float64	10,000,000	16.0261	13.9778	1.15×	87%
⚪	matrix + row_vector (N,M)+(M,)	float64	1,000	0.0012	-	-	-
⚪	matrix + row_vector (N,M)+(M,)	float64	100,000	0.1942	-	-	-
✅	matrix + row_vector (N,M)+(M,)	float64	10,000,000	16.3420	13.3161	1.23×	82%
⚪	matrix + scalar	float64	1,000	0.0007	-	-	-
⚪	matrix + scalar	float64	100,000	0.0142	-	-	-
✅	matrix + scalar	float64	10,000,000	15.6849	13.5809	1.16×	87%
⚪	np.broadcast_to(row, (N,M))	float64	1,000	0.0018	-	-	-
⚪	np.broadcast_to(row, (N,M))	float64	100,000	0.0021	-	-	-
▫	np.broadcast_to(row, (N,M))	float64	10,000,000	0.0018	0.0006	3.22×	31%

Creation

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
▫	np.copy (float32)	float32	1,000	0.0006	0.0117	0.050×	1983%
🟡	np.copy (float32)	float32	100,000	0.0061	0.0071	0.86×	117%
✅	np.copy (float32)	float32	10,000,000	6.4782	1.8708	3.46×	29%
▫	np.copy (float64)	float64	1,000	0.0006	0.0198	0.031×	3272%
🟡	np.copy (float64)	float64	100,000	0.0113	0.0135	0.83×	120%
✅	np.copy (float64)	float64	10,000,000	13.0404	12.7447	1.02×	98%
▫	np.copy (int32)	int32	1,000	0.0006	0.0116	0.051×	1958%
🟡	np.copy (int32)	int32	100,000	0.0060	0.0069	0.88×	114%
✅	np.copy (int32)	int32	10,000,000	6.3440	1.8390	3.45×	29%
▫	np.copy (int64)	int64	1,000	0.0006	0.0133	0.046×	2177%
🟡	np.copy (int64)	int64	100,000	0.0115	0.0140	0.82×	122%
✅	np.copy (int64)	int64	10,000,000	13.2030	12.7437	1.04×	96%
▫	np.empty (float32)	float32	1,000	0.0003	0.0085	0.039×	2532%
▫	np.empty (float32)	float32	100,000	0.0003	0.0141	0.024×	4090%
🟡	np.empty (float32)	float32	10,000,000	0.0087	0.0143	0.61×	165%
▫	np.empty (float64)	float64	1,000	0.0005	0.0139	0.038×	2598%
▫	np.empty (float64)	float64	100,000	0.0003	0.0140	0.021×	4722%
🟡	np.empty (float64)	float64	10,000,000	0.0080	0.0138	0.58×	172%
▫	np.empty (int32)	int32	1,000	0.0003	0.0089	0.038×	2635%
▫	np.empty (int32)	int32	100,000	0.0003	0.0133	0.026×	3857%
🟡	np.empty (int32)	int32	10,000,000	0.0108	0.0140	0.77×	130%
▫	np.empty (int64)	int64	1,000	0.0003	0.0150	0.021×	4695%
▫	np.empty (int64)	int64	100,000	0.0003	0.0152	0.022×	4622%
🟡	np.empty (int64)	int64	10,000,000	0.0119	0.0141	0.85×	118%
▫	np.full (float32)	float32	1,000	0.0010	0.0117	0.084×	1196%
🟠	np.full (float32)	float32	100,000	0.0053	0.0126	0.42×	239%
✅	np.full (float32)	float32	10,000,000	7.3482	1.8309	4.01×	25%
▫	np.full (float64)	float64	1,000	0.0010	0.0142	0.068×	1466%
🟡	np.full (float64)	float64	100,000	0.0098	0.0148	0.66×	151%
✅	np.full (float64)	float64	10,000,000	14.6927	12.3279	1.19×	84%
▫	np.full (int32)	int32	1,000	0.0009	0.0104	0.088×	1138%
🟠	np.full (int32)	int32	100,000	0.0054	0.0123	0.44×	228%
✅	np.full (int32)	int32	10,000,000	7.3322	1.9121	3.83×	26%
▫	np.full (int64)	int64	1,000	0.0009	0.0135	0.064×	1571%
🟡	np.full (int64)	int64	100,000	0.0098	0.0150	0.65×	153%
✅	np.full (int64)	int64	10,000,000	14.7304	12.3185	1.20×	84%
▫	np.ones (float32)	float32	1,000	0.0010	0.0094	0.10×	953%
🟠	np.ones (float32)	float32	100,000	0.0054	0.0124	0.43×	232%
✅	np.ones (float32)	float32	10,000,000	7.3143	1.8034	4.06×	25%
▫	np.ones (float64)	float64	1,000	0.0009	0.0119	0.073×	1370%
🟡	np.ones (float64)	float64	100,000	0.0098	0.0150	0.66×	152%
✅	np.ones (float64)	float64	10,000,000	14.5911	12.4361	1.17×	85%
▫	np.ones (int32)	int32	1,000	0.0009	0.0111	0.080×	1257%
🟠	np.ones (int32)	int32	100,000	0.0053	0.0124	0.43×	234%
✅	np.ones (int32)	int32	10,000,000	7.1344	2.0772	3.44×	29%
▫	np.ones (int64)	int64	1,000	0.0009	0.0145	0.059×	1685%
🟡	np.ones (int64)	int64	100,000	0.0099	0.0148	0.67×	149%
✅	np.ones (int64)	int64	10,000,000	14.7038	12.3182	1.19×	84%
▫	np.zeros (float32)	float32	1,000	0.0004	0.0107	0.039×	2555%
✅	np.zeros (float32)	float32	100,000	0.0048	0.0020	2.37×	42%
✅	np.zeros (float32)	float32	10,000,000	0.0090	0.0020	4.51×	22%
▫	np.zeros (float64)	float64	1,000	0.0004	0.0137	0.026×	3875%
✅	np.zeros (float64)	float64	100,000	0.0093	0.0026	3.62×	28%
✅	np.zeros (float64)	float64	10,000,000	0.0083	0.0022	3.70×	27%
▫	np.zeros (int32)	int32	1,000	0.0004	0.0107	0.036×	2816%
✅	np.zeros (int32)	int32	100,000	0.0049	0.0020	2.45×	41%
✅	np.zeros (int32)	int32	10,000,000	0.0111	0.0065	1.71×	58%
▫	np.zeros (int64)	int64	1,000	0.0004	0.0140	0.027×	3638%
✅	np.zeros (int64)	int64	100,000	0.0094	0.0026	3.70×	27%
✅	np.zeros (int64)	int64	10,000,000	0.0114	0.0057	1.99×	50%
🔴	np.zeros_like (float32)	float32	1,000	0.0011	0.0091	0.12×	861%
✅	np.zeros_like (float32)	float32	100,000	0.0055	0.0021	2.63×	38%
▫	np.zeros_like (float32)	float32	10,000,000	7.1806	0.0021	3422.48×	0%
🔴	np.zeros_like (float64)	float64	1,000	0.0012	0.0135	0.092×	1086%
✅	np.zeros_like (float64)	float64	100,000	0.0099	0.0027	3.70×	27%
▫	np.zeros_like (float64)	float64	10,000,000	14.8132	0.0023	6363.47×	0%
🔴	np.zeros_like (int32)	int32	1,000	0.0011	0.0089	0.12×	842%
✅	np.zeros_like (int32)	int32	100,000	0.0057	0.0020	2.78×	36%
▫	np.zeros_like (int32)	int32	10,000,000	7.2566	0.0066	1091.90×	0%
🔴	np.zeros_like (int64)	int64	1,000	0.0010	0.0132	0.079×	1261%
✅	np.zeros_like (int64)	int64	100,000	0.0100	0.0026	3.79×	26%
▫	np.zeros_like (int64)	int64	10,000,000	14.7069	0.0056	2623.48×	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.0113	0.0883	0.13×	782%
✅	a.flatten	float64	10,000,000	13.0852	11.4613	1.14×	88%
⚪	np.concatenate	float64	1,000	0.0010	-	-	-
⚪	np.concatenate	float64	100,000	0.3154	-	-	-
⚪	np.concatenate	float64	10,000,000	32.8142	-	-	-
⚪	np.ravel	float64	1,000	0.0004	-	-	-
▫	np.ravel	float64	100,000	0.0003	0.0005	0.69×	145%
▫	np.ravel	float64	10,000,000	0.0003	0.0005	0.62×	162%
⚪	np.stack	float64	1,000	0.0022	-	-	-
⚪	np.stack	float64	100,000	0.3130	-	-	-
⚪	np.stack	float64	10,000,000	33.9601	-	-	-
⚪	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.0005	0.33×	304%
▫	reshape 2D->1D	float64	10,000,000	0.0002	0.0006	0.32×	317%

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.0001	-	-	-
⚪	a[100:1000] (contiguous)	float64	10,000,000	0.0001	-	-	-
⚪	a[::-1] (reversed)	float64	1,000	0.0001	-	-	-
▫	a[::-1] (reversed)	float64	100,000	0.0002	0.0012	0.13×	781%
▫	a[::-1] (reversed)	float64	10,000,000	0.0002	0.0012	0.13×	789%
⚪	a[::2] (strided)	float64	1,000	0.0002	-	-	-
⚪	a[::2] (strided)	float64	100,000	0.0001	-	-	-
⚪	a[::2] (strided)	float64	10,000,000	0.0001	-	-	-
⚪	np.sum(contiguous_slice)	float64	900	0.0017	-	-	-
⚪	np.sum(contiguous_slice)	float64	900	0.0017	-	-	-
⚪	np.sum(contiguous_slice)	float64	900	0.0016	-	-	-
⚪	np.sum(strided_slice)	float64	500	0.0016	-	-	-
⚪	np.sum(strided_slice)	float64	50,000	0.0096	-	-	-
⚪	np.sum(strided_slice)	float64	5,000,000	4.6738	-	-	-

Comparison

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
▫	a != b (float32)	float32	1,000	0.0004	0.0007	0.60×	166%
🟠	a != b (float32)	float32	100,000	0.0059	0.0188	0.31×	321%
✅	a != b (float32)	float32	10,000,000	3.9247	3.3366	1.18×	85%
▫	a != b (float64)	float64	1,000	0.0005	0.0008	0.62×	162%
🟠	a != b (float64)	float64	100,000	0.0110	0.0263	0.42×	239%
✅	a != b (float64)	float64	10,000,000	6.7684	5.8470	1.16×	86%
▫	a != b (int32)	int32	1,000	0.0004	0.0008	0.54×	186%
🟠	a != b (int32)	int32	100,000	0.0069	0.0201	0.34×	291%
✅	a != b (int32)	int32	10,000,000	4.2916	3.4612	1.24×	81%
▫	a != b (int64)	int64	1,000	0.0005	0.0008	0.60×	166%
🟡	a != b (int64)	int64	100,000	0.0140	0.0260	0.54×	186%
✅	a != b (int64)	int64	10,000,000	7.2974	5.8513	1.25×	80%
▫	a < b (float32)	float32	1,000	0.0004	0.0007	0.56×	179%
🟠	a < b (float32)	float32	100,000	0.0056	0.0189	0.29×	339%
✅	a < b (float32)	float32	10,000,000	3.8362	3.2974	1.16×	86%
▫	a < b (float64)	float64	1,000	0.0005	0.0008	0.62×	162%
🟠	a < b (float64)	float64	100,000	0.0106	0.0279	0.38×	264%
✅	a < b (float64)	float64	10,000,000	6.5961	5.7503	1.15×	87%
▫	a < b (int32)	int32	1,000	0.0004	0.0007	0.62×	162%
🟠	a < b (int32)	int32	100,000	0.0071	0.0187	0.38×	265%
✅	a < b (int32)	int32	10,000,000	4.3674	3.2941	1.33×	75%
▫	a < b (int64)	int64	1,000	0.0005	0.0007	0.73×	137%
🟡	a < b (int64)	int64	100,000	0.0182	0.0250	0.73×	137%
✅	a < b (int64)	int64	10,000,000	7.0769	5.6821	1.25×	80%
▫	a <= b (float32)	float32	1,000	0.0006	0.0007	0.80×	126%
🟠	a <= b (float32)	float32	100,000	0.0063	0.0181	0.35×	289%
✅	a <= b (float32)	float32	10,000,000	3.8528	3.2691	1.18×	85%
▫	a <= b (float64)	float64	1,000	0.0004	0.0007	0.60×	167%
🟠	a <= b (float64)	float64	100,000	0.0104	0.0283	0.37×	272%
✅	a <= b (float64)	float64	10,000,000	6.4781	5.7355	1.13×	88%
▫	a <= b (int32)	int32	1,000	0.0004	0.0007	0.58×	173%
🟠	a <= b (int32)	int32	100,000	0.0070	0.0192	0.37×	273%
✅	a <= b (int32)	int32	10,000,000	4.2354	3.3183	1.28×	78%
▫	a <= b (int64)	int64	1,000	0.0005	0.0007	0.72×	138%
🟡	a <= b (int64)	int64	100,000	0.0186	0.0268	0.69×	144%
✅	a <= b (int64)	int64	10,000,000	8.2513	5.9870	1.38×	73%
▫	a == b (float32)	float32	1,000	0.0005	0.0007	0.61×	163%
🟠	a == b (float32)	float32	100,000	0.0059	0.0199	0.29×	339%
✅	a == b (float32)	float32	10,000,000	3.9574	3.2149	1.23×	81%
▫	a == b (float64)	float64	1,000	0.0004	0.0007	0.58×	172%
🟠	a == b (float64)	float64	100,000	0.0114	0.0279	0.41×	244%
✅	a == b (float64)	float64	10,000,000	7.1028	5.6882	1.25×	80%
▫	a == b (int32)	int32	1,000	0.0004	0.0007	0.60×	167%
🟠	a == b (int32)	int32	100,000	0.0072	0.0183	0.40×	253%
✅	a == b (int32)	int32	10,000,000	4.1736	3.3406	1.25×	80%
▫	a == b (int64)	int64	1,000	0.0004	0.0008	0.58×	172%
🟡	a == b (int64)	int64	100,000	0.0131	0.0248	0.53×	189%
✅	a == b (int64)	int64	10,000,000	7.1546	5.7300	1.25×	80%
▫	a > b (float32)	float32	1,000	0.0004	0.0007	0.56×	178%
🟠	a > b (float32)	float32	100,000	0.0056	0.0185	0.31×	327%
✅	a > b (float32)	float32	10,000,000	3.8956	3.3476	1.16×	86%
▫	a > b (float64)	float64	1,000	0.0004	0.0008	0.58×	171%
🟠	a > b (float64)	float64	100,000	0.0105	0.0262	0.40×	248%
✅	a > b (float64)	float64	10,000,000	6.6876	5.7415	1.17×	86%
▫	a > b (int32)	int32	1,000	0.0004	0.0008	0.54×	186%
🟠	a > b (int32)	int32	100,000	0.0070	0.0195	0.36×	280%
✅	a > b (int32)	int32	10,000,000	4.1882	3.3117	1.26×	79%
▫	a > b (int64)	int64	1,000	0.0005	0.0007	0.74×	134%
🟡	a > b (int64)	int64	100,000	0.0231	0.0256	0.90×	111%
✅	a > b (int64)	int64	10,000,000	7.6396	5.7329	1.33×	75%
▫	a >= b (float32)	float32	1,000	0.0004	0.0007	0.61×	165%
🟠	a >= b (float32)	float32	100,000	0.0063	0.0186	0.34×	295%
✅	a >= b (float32)	float32	10,000,000	3.8402	3.2664	1.18×	85%
▫	a >= b (float64)	float64	1,000	0.0005	0.0007	0.60×	166%
🟠	a >= b (float64)	float64	100,000	0.0118	0.0241	0.49×	203%
✅	a >= b (float64)	float64	10,000,000	7.1505	5.6739	1.26×	79%
▫	a >= b (int32)	int32	1,000	0.0004	0.0008	0.56×	177%
🟠	a >= b (int32)	int32	100,000	0.0069	0.0191	0.36×	277%
✅	a >= b (int32)	int32	10,000,000	4.5128	3.3235	1.36×	74%
▫	a >= b (int64)	int64	1,000	0.0008	0.0008	1.00×	100%
🟡	a >= b (int64)	int64	100,000	0.0188	0.0266	0.71×	142%
✅	a >= b (int64)	int64	10,000,000	7.8543	5.9554	1.32×	76%

Bitwise

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
▫	a & b (bool)	bool	1,000	0.0004	0.0016	0.24×	409%
🔴	a & b (bool)	bool	100,000	0.0028	0.0215	0.13×	763%
🟡	a & b (bool)	bool	10,000,000	1.8589	3.0929	0.60×	166%
▫	a & b (int16)	int16	1,000	0.0008	0.0027	0.29×	349%
✅	a & b (int16)	int16	100,000	0.0290	0.0169	1.72×	58%
✅	a & b (int16)	int16	10,000,000	5.2942	2.9661	1.78×	56%
▫	a & b (int32)	int32	1,000	0.0008	0.0060	0.13×	779%
🟡	a & b (int32)	int32	100,000	0.0286	0.0342	0.84×	120%
✅	a & b (int32)	int32	10,000,000	9.1881	5.3408	1.72×	58%
▫	a & b (int64)	int64	1,000	0.0008	0.0069	0.11×	891%
🟡	a & b (int64)	int64	100,000	0.0338	0.0634	0.53×	188%
✅	a & b (int64)	int64	10,000,000	17.1008	16.6525	1.03×	97%
▫	a & b (int8)	int8	1,000	0.0007	0.0013	0.49×	204%
✅	a & b (int8)	int8	100,000	0.0286	0.0100	2.86×	35%
✅	a & b (int8)	int8	10,000,000	3.8854	1.5338	2.53×	40%
▫	a & b (uint16)	uint16	1,000	0.0008	0.0034	0.23×	440%
✅	a & b (uint16)	uint16	100,000	0.0301	0.0180	1.68×	60%
✅	a & b (uint16)	uint16	10,000,000	5.2834	3.0212	1.75×	57%
▫	a & b (uint32)	uint32	1,000	0.0008	0.0039	0.20×	492%
🟡	a & b (uint32)	uint32	100,000	0.0339	0.0400	0.85×	118%
✅	a & b (uint32)	uint32	10,000,000	8.5821	6.0168	1.43×	70%
▫	a & b (uint64)	uint64	1,000	0.0008	0.0024	0.32×	310%
🟠	a & b (uint64)	uint64	100,000	0.0356	0.0739	0.48×	207%
✅	a & b (uint64)	uint64	10,000,000	17.0644	16.1487	1.06×	95%
▫	a & b (uint8)	uint8	1,000	0.0006	0.0010	0.62×	162%
✅	a & b (uint8)	uint8	100,000	0.0296	0.0103	2.88×	35%
✅	a & b (uint8)	uint8	10,000,000	3.8191	1.5272	2.50×	40%
▫	a ^ b (bool)	bool	1,000	0.0004	0.0017	0.22×	447%
🔴	a ^ b (bool)	bool	100,000	0.0026	0.0214	0.12×	822%
🟡	a ^ b (bool)	bool	10,000,000	1.8620	3.0807	0.60×	166%
▫	a ^ b (int16)	int16	1,000	0.0008	0.0026	0.30×	328%
✅	a ^ b (int16)	int16	100,000	0.0285	0.0149	1.92×	52%
✅	a ^ b (int16)	int16	10,000,000	5.2041	2.9252	1.78×	56%
▫	a ^ b (int32)	int32	1,000	0.0008	0.0047	0.16×	615%
🟡	a ^ b (int32)	int32	100,000	0.0288	0.0321	0.90×	111%
✅	a ^ b (int32)	int32	10,000,000	8.9067	5.3599	1.66×	60%
▫	a ^ b (int64)	int64	1,000	0.0008	0.0040	0.20×	511%
🟡	a ^ b (int64)	int64	100,000	0.0337	0.0666	0.51×	198%
✅	a ^ b (int64)	int64	10,000,000	17.2489	15.6910	1.10×	91%
▫	a ^ b (int8)	int8	1,000	0.0007	0.0012	0.52×	191%
✅	a ^ b (int8)	int8	100,000	0.0295	0.0102	2.90×	34%
✅	a ^ b (int8)	int8	10,000,000	3.8764	1.5503	2.50×	40%
▫	a ^ b (uint16)	uint16	1,000	0.0008	0.0028	0.28×	361%
✅	a ^ b (uint16)	uint16	100,000	0.0287	0.0163	1.77×	57%
✅	a ^ b (uint16)	uint16	10,000,000	5.2129	2.9215	1.78×	56%
▫	a ^ b (uint32)	uint32	1,000	0.0008	0.0048	0.16×	610%
🟡	a ^ b (uint32)	uint32	100,000	0.0285	0.0315	0.91×	110%
✅	a ^ b (uint32)	uint32	10,000,000	8.4267	5.7479	1.47×	68%
▫	a ^ b (uint64)	uint64	1,000	0.0009	0.0111	0.078×	1287%
🟡	a ^ b (uint64)	uint64	100,000	0.0341	0.0681	0.50×	200%
✅	a ^ b (uint64)	uint64	10,000,000	16.9004	16.6136	1.02×	98%
▫	a ^ b (uint8)	uint8	1,000	0.0006	0.0012	0.53×	187%
✅	a ^ b (uint8)	uint8	100,000	0.0288	0.0119	2.42×	41%
✅	a ^ b (uint8)	uint8	10,000,000	3.8171	1.4591	2.62×	38%
▫	a	b (bool)	bool	1,000	0.0004	0.0015	0.31×	326%
🔴	a	b (bool)	bool	100,000	0.0025	0.0232	0.11×	912%
🟡	a	b (bool)	bool	10,000,000	1.8887	2.8568	0.66×	151%
▫	a	b (int16)	int16	1,000	0.0008	0.0023	0.35×	288%
✅	a	b (int16)	int16	100,000	0.0285	0.0178	1.60×	62%
✅	a	b (int16)	int16	10,000,000	5.2268	2.9832	1.75×	57%
▫	a	b (int32)	int32	1,000	0.0008	0.0074	0.10×	950%
🟡	a	b (int32)	int32	100,000	0.0286	0.0380	0.75×	133%
✅	a	b (int32)	int32	10,000,000	9.0217	5.4574	1.65×	60%
▫	a	b (int64)	int64	1,000	0.0008	0.0079	0.10×	1003%
🟠	a	b (int64)	int64	100,000	0.0339	0.0707	0.48×	209%
✅	a	b (int64)	int64	10,000,000	17.1245	15.6955	1.09×	92%
▫	a	b (int8)	int8	1,000	0.0007	0.0014	0.48×	210%
✅	a	b (int8)	int8	100,000	0.0300	0.0116	2.58×	39%
✅	a	b (int8)	int8	10,000,000	4.1649	1.5132	2.75×	36%
▫	a	b (uint16)	uint16	1,000	0.0008	0.0019	0.43×	234%
✅	a	b (uint16)	uint16	100,000	0.0291	0.0168	1.73×	58%
✅	a	b (uint16)	uint16	10,000,000	5.1942	2.8924	1.80×	56%
▫	a	b (uint32)	uint32	1,000	0.0008	0.0035	0.22×	446%
🟡	a	b (uint32)	uint32	100,000	0.0285	0.0334	0.85×	117%
✅	a	b (uint32)	uint32	10,000,000	8.5824	5.4787	1.57×	64%
▫	a	b (uint64)	uint64	1,000	0.0008	0.0022	0.35×	282%
🟡	a	b (uint64)	uint64	100,000	0.0353	0.0677	0.52×	192%
✅	a	b (uint64)	uint64	10,000,000	16.8283	16.1102	1.04×	96%
▫	a	b (uint8)	uint8	1,000	0.0007	0.0012	0.56×	177%
✅	a	b (uint8)	uint8	100,000	0.0296	0.0105	2.83×	35%
✅	a	b (uint8)	uint8	10,000,000	4.1042	1.4855	2.76×	36%
▫	np.invert(a) (bool)	bool	1,000	0.0004	0.0015	0.24×	409%
🔴	np.invert(a) (bool)	bool	100,000	0.0021	0.0230	0.092×	1083%
🟡	np.invert(a) (bool)	bool	10,000,000	1.6689	2.5576	0.65×	153%
▫	np.invert(a) (int16)	int16	1,000	0.0007	0.0018	0.40×	247%
✅	np.invert(a) (int16)	int16	100,000	0.0257	0.0140	1.83×	55%
✅	np.invert(a) (int16)	int16	10,000,000	4.7670	2.5132	1.90×	53%
▫	np.invert(a) (int32)	int32	1,000	0.0008	0.0058	0.13×	758%
🟡	np.invert(a) (int32)	int32	100,000	0.0264	0.0305	0.86×	116%
✅	np.invert(a) (int32)	int32	10,000,000	8.1792	4.7721	1.71×	58%
▫	np.invert(a) (int64)	int64	1,000	0.0007	0.0059	0.13×	796%
🟠	np.invert(a) (int64)	int64	100,000	0.0263	0.0661	0.40×	251%
✅	np.invert(a) (int64)	int64	10,000,000	15.1634	14.2955	1.06×	94%
▫	np.invert(a) (int8)	int8	1,000	0.0006	0.0014	0.46×	218%
✅	np.invert(a) (int8)	int8	100,000	0.0293	0.0108	2.72×	37%
✅	np.invert(a) (int8)	int8	10,000,000	3.5390	1.3133	2.69×	37%
▫	np.invert(a) (uint16)	uint16	1,000	0.0007	0.0022	0.33×	302%
✅	np.invert(a) (uint16)	uint16	100,000	0.0258	0.0206	1.25×	80%
✅	np.invert(a) (uint16)	uint16	10,000,000	4.7281	2.4541	1.93×	52%
▫	np.invert(a) (uint32)	uint32	1,000	0.0008	0.0036	0.22×	459%
✅	np.invert(a) (uint32)	uint32	100,000	0.0332	0.0290	1.15×	87%
✅	np.invert(a) (uint32)	uint32	10,000,000	7.8329	4.8460	1.62×	62%
▫	np.invert(a) (uint64)	uint64	1,000	0.0007	0.0035	0.21×	484%
🟠	np.invert(a) (uint64)	uint64	100,000	0.0263	0.0652	0.40×	248%
🟡	np.invert(a) (uint64)	uint64	10,000,000	15.2896	15.3374	1.00×	100%
▫	np.invert(a) (uint8)	uint8	1,000	0.0006	0.0014	0.46×	216%
✅	np.invert(a) (uint8)	uint8	100,000	0.0268	0.0110	2.45×	41%
✅	np.invert(a) (uint8)	uint8	10,000,000	3.5162	1.3311	2.64×	38%
🔴	np.left_shift(a, 2) (bool)	bool	1,000	0.0015	0.0125	0.12×	845%
🟡	np.left_shift(a, 2) (bool)	bool	100,000	0.0430	0.0779	0.55×	181%
✅	np.left_shift(a, 2) (bool)	bool	10,000,000	15.2024	10.3241	1.47×	68%
🟠	np.left_shift(a, 2) (int16)	int16	1,000	0.0010	0.0031	0.33×	302%
✅	np.left_shift(a, 2) (int16)	int16	100,000	0.0285	0.0150	1.90×	53%
✅	np.left_shift(a, 2) (int16)	int16	10,000,000	4.9855	2.6983	1.85×	54%
▫	np.left_shift(a, 2) (int32)	int32	1,000	0.0010	0.0057	0.18×	569%
🟡	np.left_shift(a, 2) (int32)	int32	100,000	0.0190	0.0373	0.51×	196%
✅	np.left_shift(a, 2) (int32)	int32	10,000,000	7.6421	4.5654	1.67×	60%
▫	np.left_shift(a, 2) (int64)	int64	1,000	0.0009	0.0038	0.24×	420%
🟠	np.left_shift(a, 2) (int64)	int64	100,000	0.0190	0.0672	0.28×	353%
✅	np.left_shift(a, 2) (int64)	int64	10,000,000	15.2053	14.9107	1.02×	98%
▫	np.left_shift(a, 2) (int8)	int8	1,000	0.0009	0.0019	0.49×	204%
✅	np.left_shift(a, 2) (int8)	int8	100,000	0.0305	0.0085	3.58×	28%
✅	np.left_shift(a, 2) (int8)	int8	10,000,000	3.7477	1.2738	2.94×	34%
🟠	np.left_shift(a, 2) (uint16)	uint16	1,000	0.0011	0.0023	0.45×	222%
✅	np.left_shift(a, 2) (uint16)	uint16	100,000	0.0290	0.0163	1.78×	56%
✅	np.left_shift(a, 2) (uint16)	uint16	10,000,000	5.3571	2.5057	2.14×	47%
▫	np.left_shift(a, 2) (uint32)	uint32	1,000	0.0010	0.0045	0.22×	456%
🟡	np.left_shift(a, 2) (uint32)	uint32	100,000	0.0192	0.0272	0.70×	142%
✅	np.left_shift(a, 2) (uint32)	uint32	10,000,000	7.9134	5.0757	1.56×	64%
▫	np.left_shift(a, 2) (uint64)	uint64	1,000	0.0010	0.0096	0.10×	1000%
🟠	np.left_shift(a, 2) (uint64)	uint64	100,000	0.0194	0.0697	0.28×	359%
🟡	np.left_shift(a, 2) (uint64)	uint64	10,000,000	15.2926	15.7026	0.97×	103%
▫	np.left_shift(a, 2) (uint8)	uint8	1,000	0.0009	0.0023	0.40×	250%
✅	np.left_shift(a, 2) (uint8)	uint8	100,000	0.0292	0.0131	2.22×	45%
✅	np.left_shift(a, 2) (uint8)	uint8	10,000,000	3.6979	1.2844	2.88×	35%
🔴	np.right_shift(a, 2) (bool)	bool	1,000	0.0016	0.0135	0.12×	844%
🟡	np.right_shift(a, 2) (bool)	bool	100,000	0.0529	0.0750	0.71×	142%
✅	np.right_shift(a, 2) (bool)	bool	10,000,000	15.2744	9.3866	1.63×	62%
🟠	np.right_shift(a, 2) (int16)	int16	1,000	0.0011	0.0026	0.44×	226%
✅	np.right_shift(a, 2) (int16)	int16	100,000	0.0377	0.0158	2.38×	42%
✅	np.right_shift(a, 2) (int16)	int16	10,000,000	5.7282	2.6585	2.15×	46%
🟠	np.right_shift(a, 2) (int32)	int32	1,000	0.0011	0.0038	0.28×	354%
🟡	np.right_shift(a, 2) (int32)	int32	100,000	0.0288	0.0378	0.76×	131%
✅	np.right_shift(a, 2) (int32)	int32	10,000,000	7.8870	4.3972	1.79×	56%
🟠	np.right_shift(a, 2) (int64)	int64	1,000	0.0013	0.0039	0.32×	309%
🟠	np.right_shift(a, 2) (int64)	int64	100,000	0.0287	0.0702	0.41×	244%
✅	np.right_shift(a, 2) (int64)	int64	10,000,000	15.0917	14.2202	1.06×	94%
🟡	np.right_shift(a, 2) (int8)	int8	1,000	0.0010	0.0019	0.54×	185%
✅	np.right_shift(a, 2) (int8)	int8	100,000	0.0436	0.0108	4.02×	25%
✅	np.right_shift(a, 2) (int8)	int8	10,000,000	4.7856	1.2716	3.76×	27%
🟠	np.right_shift(a, 2) (uint16)	uint16	1,000	0.0011	0.0029	0.36×	275%
✅	np.right_shift(a, 2) (uint16)	uint16	100,000	0.0283	0.0170	1.67×	60%
✅	np.right_shift(a, 2) (uint16)	uint16	10,000,000	5.1786	2.5878	2.00×	50%
▫	np.right_shift(a, 2) (uint32)	uint32	1,000	0.0010	0.0036	0.27×	368%
🟡	np.right_shift(a, 2) (uint32)	uint32	100,000	0.0205	0.0284	0.72×	138%
✅	np.right_shift(a, 2) (uint32)	uint32	10,000,000	7.7130	4.7119	1.64×	61%
▫	np.right_shift(a, 2) (uint64)	uint64	1,000	0.0010	0.0108	0.091×	1100%
🟠	np.right_shift(a, 2) (uint64)	uint64	100,000	0.0212	0.0750	0.28×	354%
🟡	np.right_shift(a, 2) (uint64)	uint64	10,000,000	14.9083	16.6474	0.90×	112%
▫	np.right_shift(a, 2) (uint8)	uint8	1,000	0.0009	0.0021	0.44×	227%
✅	np.right_shift(a, 2) (uint8)	uint8	100,000	0.0296	0.0095	3.12×	32%
✅	np.right_shift(a, 2) (uint8)	uint8	10,000,000	3.7353	1.2943	2.89×	35%

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.0014	-	-	-
⚪	np.all(a) (bool)	bool	10,000,000	0.0014	-	-	-
⚪	np.allclose(a, b) (float16)	float16	1,000	0.0305	-	-	-
⚪	np.allclose(a, b) (float16)	float16	100,000	1.7794	-	-	-
⚪	np.allclose(a, b) (float16)	float16	10,000,000	192.9692	-	-	-
⚪	np.allclose(a, b) (float32)	float32	1,000	0.0132	-	-	-
⚪	np.allclose(a, b) (float32)	float32	100,000	0.3660	-	-	-
⚪	np.allclose(a, b) (float32)	float32	10,000,000	55.8239	-	-	-
⚪	np.allclose(a, b) (float64)	float64	1,000	0.0165	-	-	-
⚪	np.allclose(a, b) (float64)	float64	100,000	0.6299	-	-	-
⚪	np.allclose(a, b) (float64)	float64	10,000,000	107.5215	-	-	-
⚪	np.any(a) (bool)	bool	1,000	0.0015	-	-	-
⚪	np.any(a) (bool)	bool	100,000	0.0017	-	-	-
⚪	np.any(a) (bool)	bool	10,000,000	0.0014	-	-	-
✅	np.array_equal(a, b) (float16)	float16	1,000	0.0025	0.0013	1.90×	53%
✅	np.array_equal(a, b) (float16)	float16	100,000	0.0873	0.0697	1.25×	80%
✅	np.array_equal(a, b) (float16)	float16	10,000,000	9.5077	6.1828	1.54×	65%
▫	np.array_equal(a, b) (float32)	float32	1,000	0.0016	0.0008	1.95×	51%
🟠	np.array_equal(a, b) (float32)	float32	100,000	0.0067	0.0186	0.36×	276%
✅	np.array_equal(a, b) (float32)	float32	10,000,000	3.9686	3.4029	1.17×	86%
▫	np.array_equal(a, b) (float64)	float64	1,000	0.0018	0.0007	2.36×	42%
🟠	np.array_equal(a, b) (float64)	float64	100,000	0.0121	0.0248	0.49×	204%
✅	np.array_equal(a, b) (float64)	float64	10,000,000	6.8297	5.8386	1.17×	86%
⚪	np.isclose(a, b) (float16)	float16	1,000	0.0300	-	-	-
⚪	np.isclose(a, b) (float16)	float16	100,000	1.7764	-	-	-
⚪	np.isclose(a, b) (float16)	float16	10,000,000	195.6207	-	-	-
⚪	np.isclose(a, b) (float32)	float32	1,000	0.0113	-	-	-
⚪	np.isclose(a, b) (float32)	float32	100,000	0.3666	-	-	-
⚪	np.isclose(a, b) (float32)	float32	10,000,000	55.1472	-	-	-
⚪	np.isclose(a, b) (float64)	float64	1,000	0.0116	-	-	-
⚪	np.isclose(a, b) (float64)	float64	100,000	0.6275	-	-	-
⚪	np.isclose(a, b) (float64)	float64	10,000,000	104.7217	-	-	-
▫	np.isfinite(a) (float16)	float16	1,000	0.0008	0.0015	0.57×	175%
✅	np.isfinite(a) (float16)	float16	100,000	0.0496	0.0388	1.28×	78%
✅	np.isfinite(a) (float16)	float16	10,000,000	5.8734	3.1098	1.89×	53%
▫	np.isfinite(a) (float32)	float32	1,000	0.0004	0.0012	0.33×	302%
🔴	np.isfinite(a) (float32)	float32	100,000	0.0059	0.0364	0.16×	617%
🟡	np.isfinite(a) (float32)	float32	10,000,000	3.3272	3.8128	0.87×	115%
▫	np.isfinite(a) (float64)	float64	1,000	0.0005	0.0014	0.32×	314%
🟠	np.isfinite(a) (float64)	float64	100,000	0.0098	0.0365	0.27×	374%
🟡	np.isfinite(a) (float64)	float64	10,000,000	5.3098	5.6920	0.93×	107%
▫	np.isinf(a) (float16)	float16	1,000	0.0009	0.0012	0.76×	132%
✅	np.isinf(a) (float16)	float16	100,000	0.0506	0.0386	1.31×	76%
✅	np.isinf(a) (float16)	float16	10,000,000	6.0644	3.1035	1.95×	51%
▫	np.isinf(a) (float32)	float32	1,000	0.0006	0.0013	0.41×	241%
🔴	np.isinf(a) (float32)	float32	100,000	0.0058	0.0416	0.14×	721%
🟡	np.isinf(a) (float32)	float32	10,000,000	3.0154	3.9983	0.75×	133%
▫	np.isinf(a) (float64)	float64	1,000	0.0005	0.0015	0.32×	312%
🟠	np.isinf(a) (float64)	float64	100,000	0.0101	0.0433	0.23×	429%
🟡	np.isinf(a) (float64)	float64	10,000,000	5.2606	5.9503	0.88×	113%
✅	np.isnan(a) (float16)	float16	1,000	0.0014	0.0012	1.12×	89%
✅	np.isnan(a) (float16)	float16	100,000	0.0692	0.0397	1.74×	57%
✅	np.isnan(a) (float16)	float16	10,000,000	7.7981	3.1130	2.50×	40%
▫	np.isnan(a) (float32)	float32	1,000	0.0005	0.0016	0.34×	298%
🔴	np.isnan(a) (float32)	float32	100,000	0.0044	0.0482	0.092×	1091%
🟡	np.isnan(a) (float32)	float32	10,000,000	2.9244	4.7104	0.62×	161%
▫	np.isnan(a) (float64)	float64	1,000	0.0004	0.0013	0.33×	300%
🔴	np.isnan(a) (float64)	float64	100,000	0.0085	0.0483	0.18×	569%
🟡	np.isnan(a) (float64)	float64	10,000,000	4.9310	6.0302	0.82×	122%
✅	np.maximum(a, b) (float16)	float16	1,000	0.0031	0.0030	1.02×	98%
✅	np.maximum(a, b) (float16)	float16	100,000	0.7598	0.6663	1.14×	88%
✅	np.maximum(a, b) (float16)	float16	10,000,000	80.9858	66.1452	1.22×	82%
▫	np.maximum(a, b) (float32)	float32	1,000	0.0006	0.0013	0.45×	223%
🟠	np.maximum(a, b) (float32)	float32	100,000	0.0084	0.0343	0.25×	407%
✅	np.maximum(a, b) (float32)	float32	10,000,000	8.3101	4.3746	1.90×	53%
▫	np.maximum(a, b) (float64)	float64	1,000	0.0006	0.0018	0.31×	323%
🟠	np.maximum(a, b) (float64)	float64	100,000	0.0293	0.0803	0.36×	274%
🟡	np.maximum(a, b) (float64)	float64	10,000,000	16.5750	17.2376	0.96×	104%
✅	np.minimum(a, b) (float16)	float16	1,000	0.0032	0.0031	1.03×	97%
✅	np.minimum(a, b) (float16)	float16	100,000	0.7620	0.6658	1.14×	87%
✅	np.minimum(a, b) (float16)	float16	10,000,000	81.4032	65.4062	1.25×	80%
▫	np.minimum(a, b) (float32)	float32	1,000	0.0005	0.0013	0.42×	240%
🟠	np.minimum(a, b) (float32)	float32	100,000	0.0084	0.0345	0.24×	411%
✅	np.minimum(a, b) (float32)	float32	10,000,000	8.4413	4.4356	1.90×	52%
▫	np.minimum(a, b) (float64)	float64	1,000	0.0006	0.0013	0.44×	228%
🟠	np.minimum(a, b) (float64)	float64	100,000	0.0290	0.0866	0.34×	298%
🟡	np.minimum(a, b) (float64)	float64	10,000,000	16.8958	20.5756	0.82×	122%

Statistics

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
✅	np.average(a) (float16)	float16	1,000	0.0054	0.0012	4.48×	22%
✅	np.average(a) (float16)	float16	100,000	0.1147	0.0798	1.44×	70%
✅	np.average(a) (float16)	float16	10,000,000	10.5817	8.0311	1.32×	76%
▫	np.average(a) (float32)	float32	1,000	0.0042	0.0007	5.80×	17%
✅	np.average(a) (float32)	float32	100,000	0.0177	0.0032	5.57×	18%
✅	np.average(a) (float32)	float32	10,000,000	2.8186	0.9734	2.90×	34%
▫	np.average(a) (float64)	float64	1,000	0.0029	0.0007	3.89×	26%
✅	np.average(a) (float64)	float64	100,000	0.0171	0.0040	4.26×	23%
✅	np.average(a) (float64)	float64	10,000,000	4.6529	2.8474	1.63×	61%
▫	np.count_nonzero(a) (float16)	float16	1,000	0.0018	0.0008	2.29×	44%
✅	np.count_nonzero(a) (float16)	float16	100,000	0.1447	0.0436	3.32×	30%
✅	np.count_nonzero(a) (float16)	float16	10,000,000	15.7587	4.3062	3.66×	27%
▫	np.count_nonzero(a) (float32)	float32	1,000	0.0006	0.0003	1.87×	53%
✅	np.count_nonzero(a) (float32)	float32	100,000	0.0438	0.0050	8.69×	12%
✅	np.count_nonzero(a) (float32)	float32	10,000,000	4.2117	1.6445	2.56×	39%
▫	np.count_nonzero(a) (float64)	float64	1,000	0.0007	0.0004	1.82×	55%
✅	np.count_nonzero(a) (float64)	float64	100,000	0.0376	0.0090	4.19×	24%
✅	np.count_nonzero(a) (float64)	float64	10,000,000	5.6444	3.9133	1.44×	69%
✅	np.median(a) (float16)	float16	1,000	0.0144	0.0041	3.52×	28%
🟡	np.median(a) (float16)	float16	100,000	0.8796	1.2503	0.70×	142%
✅	np.median(a) (float16)	float16	10,000,000	105.7899	88.7294	1.19×	84%
✅	np.median(a) (float32)	float32	1,000	0.0110	0.0023	4.80×	21%
🟡	np.median(a) (float32)	float32	100,000	0.4686	0.6988	0.67×	149%
🟡	np.median(a) (float32)	float32	10,000,000	73.7480	79.7326	0.93×	108%
✅	np.median(a) (float64)	float64	1,000	0.0098	0.0023	4.23×	24%
🟡	np.median(a) (float64)	float64	100,000	0.4653	0.7089	0.66×	152%
🟡	np.median(a) (float64)	float64	10,000,000	86.4309	88.8375	0.97×	103%
✅	np.percentile(a, 50) (float16)	float16	1,000	0.0288	0.0041	6.97×	14%
✅	np.percentile(a, 50) (float16)	float16	100,000	1.7825	1.2489	1.43×	70%
✅	np.percentile(a, 50) (float16)	float16	10,000,000	113.4806	88.7652	1.28×	78%
✅	np.percentile(a, 50) (float32)	float32	1,000	0.0243	0.0023	10.61×	9%
✅	np.percentile(a, 50) (float32)	float32	100,000	0.7026	0.7007	1.00×	100%
🟡	np.percentile(a, 50) (float32)	float32	10,000,000	47.5374	79.7748	0.60×	168%
✅	np.percentile(a, 50) (float64)	float64	1,000	0.0258	0.0023	11.00×	9%
🟡	np.percentile(a, 50) (float64)	float64	100,000	0.7045	0.7086	0.99×	101%
🟡	np.percentile(a, 50) (float64)	float64	10,000,000	58.5689	88.9709	0.66×	152%
✅	np.ptp(a) (float16)	float16	1,000	0.0077	0.0037	2.10×	48%
✅	np.ptp(a) (float16)	float16	100,000	1.0004	0.6489	1.54×	65%
✅	np.ptp(a) (float16)	float16	10,000,000	103.1114	67.0357	1.54×	65%
✅	np.ptp(a) (float32)	float32	1,000	0.0035	0.0022	1.59×	63%
✅	np.ptp(a) (float32)	float32	100,000	0.0114	0.0080	1.44×	70%
✅	np.ptp(a) (float32)	float32	10,000,000	2.6949	2.4569	1.10×	91%
✅	np.ptp(a) (float64)	float64	1,000	0.0037	0.0020	1.88×	53%
✅	np.ptp(a) (float64)	float64	100,000	0.0200	0.0134	1.49×	67%
✅	np.ptp(a) (float64)	float64	10,000,000	6.9463	6.2250	1.12×	90%
✅	np.quantile(a, 0.5) (float16)	float16	1,000	0.0283	0.0041	6.89×	14%
✅	np.quantile(a, 0.5) (float16)	float16	100,000	1.7668	1.2481	1.42×	71%
✅	np.quantile(a, 0.5) (float16)	float16	10,000,000	112.7790	88.6407	1.27×	79%
✅	np.quantile(a, 0.5) (float32)	float32	1,000	0.0237	0.0023	10.32×	10%
🟡	np.quantile(a, 0.5) (float32)	float32	100,000	0.6938	0.7016	0.99×	101%
🟡	np.quantile(a, 0.5) (float32)	float32	10,000,000	47.6198	79.7894	0.60×	168%
✅	np.quantile(a, 0.5) (float64)	float64	1,000	0.0239	0.0023	10.21×	10%
🟡	np.quantile(a, 0.5) (float64)	float64	100,000	0.7004	0.7083	0.99×	101%
🟡	np.quantile(a, 0.5) (float64)	float64	10,000,000	58.1853	89.0162	0.65×	153%

Sorting

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
🟡	np.argsort(a) (float32)	float32	1,000	0.0120	0.0223	0.54×	186%
✅	np.argsort(a) (float32)	float32	100,000	1.5922	1.0142	1.57×	64%
✅	np.argsort(a) (float32)	float32	10,000,000	1348.2730	132.4664	10.18×	10%
🟡	np.argsort(a) (float64)	float64	1,000	0.0104	0.0177	0.59×	171%
🟡	np.argsort(a) (float64)	float64	100,000	1.4280	2.5193	0.57×	176%
✅	np.argsort(a) (float64)	float64	10,000,000	1768.7035	251.4880	7.03×	14%
🟡	np.argsort(a) (int32)	int32	1,000	0.0113	0.0221	0.51×	196%
🟠	np.argsort(a) (int32)	int32	100,000	0.4031	0.8504	0.47×	211%
✅	np.argsort(a) (int32)	int32	10,000,000	174.0979	107.5057	1.62×	62%
🟡	np.argsort(a) (int64)	int64	1,000	0.0131	0.0167	0.78×	128%
🟠	np.argsort(a) (int64)	int64	100,000	0.4917	2.2549	0.22×	459%
✅	np.argsort(a) (int64)	int64	10,000,000	310.5208	188.5734	1.65×	61%
✅	np.nonzero(a) (float32)	float32	1,000	0.0027	0.0021	1.25×	80%
✅	np.nonzero(a) (float32)	float32	100,000	0.1988	0.1946	1.02×	98%
✅	np.nonzero(a) (float32)	float32	10,000,000	39.8712	14.1945	2.81×	36%
✅	np.nonzero(a) (float64)	float64	1,000	0.0029	0.0020	1.44×	70%
🟡	np.nonzero(a) (float64)	float64	100,000	0.1923	0.2002	0.96×	104%
✅	np.nonzero(a) (float64)	float64	10,000,000	42.6329	17.6206	2.42×	41%
🟡	np.nonzero(a) (int32)	int32	1,000	0.0017	0.0028	0.61×	164%
🟡	np.nonzero(a) (int32)	int32	100,000	0.1051	0.1932	0.54×	184%
✅	np.nonzero(a) (int32)	int32	10,000,000	20.1149	14.3503	1.40×	71%
🟡	np.nonzero(a) (int64)	int64	1,000	0.0018	0.0026	0.69×	144%
🟡	np.nonzero(a) (int64)	int64	100,000	0.1073	0.2034	0.53×	190%
✅	np.nonzero(a) (int64)	int64	10,000,000	23.7474	18.2560	1.30×	77%
✅	np.searchsorted(a, v) (float32)	float32	1,000	0.0083	0.0053	1.56×	64%
✅	np.searchsorted(a, v) (float32)	float32	100,000	2.0222	1.7299	1.17×	86%
✅	np.searchsorted(a, v) (float32)	float32	10,000,000	312.1823	191.5647	1.63×	61%
✅	np.searchsorted(a, v) (float64)	float64	1,000	0.0083	0.0053	1.56×	64%
✅	np.searchsorted(a, v) (float64)	float64	100,000	2.0961	1.7424	1.20×	83%
✅	np.searchsorted(a, v) (float64)	float64	10,000,000	310.2307	192.5449	1.61×	62%
✅	np.searchsorted(a, v) (int32)	int32	1,000	0.0190	0.0075	2.54×	39%
✅	np.searchsorted(a, v) (int32)	int32	100,000	2.8983	2.2559	1.28×	78%
✅	np.searchsorted(a, v) (int32)	int32	10,000,000	390.1343	243.3194	1.60×	62%
✅	np.searchsorted(a, v) (int64)	int64	1,000	0.0186	0.0071	2.61×	38%
✅	np.searchsorted(a, v) (int64)	int64	100,000	2.9016	2.2381	1.30×	77%
✅	np.searchsorted(a, v) (int64)	int64	10,000,000	568.2151	243.9343	2.33×	43%

LinearAlgebra

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
▫	np.dot(a, b) (float64)	float64	1,000	0.0007	0.0007	1.06×	94%
✅	np.dot(a, b) (float64)	float64	100,000	0.1123	0.0093	12.05×	8%
🟠	np.dot(a, b) (float64)	float64	10,000,000	0.8690	3.0303	0.29×	349%
🟠	np.matmul(A, B) (float64)	float64	1,000	0.0027	0.0060	0.45×	223%
🟠	np.matmul(A, B) (float64)	float64	100,000	0.5771	2.7815	0.21×	482%
🔴	np.matmul(A, B) (float64)	float64	10,000,000	0.6896	4.4742	0.15×	649%
🟠	np.outer(a, b) (float64)	float64	1,000	0.0022	0.0061	0.35×	284%
🟡	np.outer(a, b) (float64)	float64	100,000	0.0380	0.0708	0.54×	186%
✅	np.outer(a, b) (float64)	float64	10,000,000	13.4954	11.7542	1.15×	87%

Selection

	Operation	Type	N	NumPy (ms)	NumSharp (ms)	Ratio	%NumPy🕐
▫	np.where(cond) (float64)	float64	1,000	0.0009	0.0014	0.66×	152%
🟠	np.where(cond) (float64)	float64	100,000	0.0294	0.0981	0.30×	333%
✅	np.where(cond) (float64)	float64	10,000,000	7.4500	6.9913	1.07×	94%
🟡	np.where(cond, a, b) (float64)	float64	1,000	0.0017	0.0020	0.85×	117%
🟡	np.where(cond, a, b) (float64)	float64	100,000	0.0399	0.0688	0.58×	173%
✅	np.where(cond, a, b) (float64)	float64	10,000,000	17.1294	14.8189	1.16×	86%

---

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-29 · 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.20× geomean · 83%🕐 of NumPy's time · 77 win / 53 lose over 130 cells

OPERATIONS — BY SIZE TIER  (geomean over all families)
        slower ◄───────── 1.0 (parity) ─────────► faster
scalar     ████████████▌ ......   1.26×    79%🕐  ( 17 win /  9 lose)
1K         ███████████▌ .......   1.16×    86%🕐  ( 15 win / 11 lose)
100K       ██████████▋ ........   1.07×    94%🕐  ( 12 win / 14 lose)
1M         ████████████▉ ......   1.30×    77%🕐  ( 17 win /  9 lose)
10M        ████████████▎ ......   1.23×    82%🕐  ( 16 win / 10 lose)
ALL        ███████████▉ .......   1.20×    83%🕐  ( 77 win / 53 lose)

OPERATIONS — BY CATEGORY  (geomean over its families, all sizes)
        slower ◄───────── 1.0 (parity) ─────────► faster
elementwise████████████▊ ......   1.28×    78%🕐  ( 31 win /  9 lose)
reductions █████████████████▍     1.74×    57%🕐  ( 29 win / 11 lose)
selection  (no data)
copy/cast  ███████▎ ...........   0.73×   138%🕐  (  9 win / 16 lose)  ◄ SLOWER
index-math ███████▋ ...........   0.77×   130%🕐  (  4 win /  6 lose)  ◄ SLOWER
dtypes     ███████████▌ .......   1.16×    86%🕐  (  4 win / 11 lose)

CATEGORY × TIER geomean
category       scalar       1K     100K       1M      10M
elementwise     1.65×    1.54×    1.14×    1.10×    1.08×
reductions      2.68×    2.00×    1.51×    1.43×    1.38×
selection           -        -        -        -        -
copy/cast       0.59×    0.53×    0.41×    1.40×    1.12×
index-math      0.34×    0.51×    0.99×    1.23×    1.26×
dtypes          0.70×    0.81×    1.87×    1.39×    1.44×

PER-FAMILY × TIER  (NumPy ÷ NumSharp; >1.0 = NumSharp faster)
family        scalar       1K     100K       1M      10M    geomean
-- elementwise
  add          1.61×    1.43×    0.96×    1.00×    1.02×     1.18×
  sqrt         1.67×    1.16×    1.01×    1.00×    1.01×     1.15×
  copy         1.67×    2.35×    1.62×    1.39×    1.64×     1.71×
  strided      1.65×    1.28×    0.93×    1.01×    0.99×     1.15×
  bcast        1.68×    1.32×    0.89×    0.95×    0.95×     1.12×
  reversed     1.65×    1.26×    0.93×    0.99×    0.95×     1.13×
  castbuf      1.87×    2.20×    1.63×    1.36×    1.12×     1.59×
  mixbuf       1.42×    1.72×    1.41×    1.20×    1.07×     1.35×
-- reductions
  sum          1.92×    1.85×    2.58×    1.76×    1.60×     1.92×
  sum ax0      1.71×    0.86×    1.10×    0.96×    0.96×     1.09×
  sum ax1      1.81×    0.92×    1.52×    1.79×    1.58×     1.48×
  sum dt=      1.89×    1.35×    0.48×    0.46×    0.54×     0.79×
  amin         1.69×    1.62×    0.71×    0.71×    0.76×     1.01×
  cumsum       1.35×    1.13×    1.07×    1.87×    1.65×     1.38×
  any(F)      10.04×    8.39×    2.00×    1.23×    1.00×     2.90×
  any(hit)    10.25×    8.49×    8.50×    7.88×    7.98×     8.58×
-- 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.41×    0.33×    0.17×    2.21×    1.13×     0.56×
  astype       0.31×    0.53×    0.54×    1.94×    1.89×     0.80×
  ravel.T      0.50×    0.58×    0.53×    2.22×    1.09×     0.82×
  in-place     1.45×    0.77×    0.96×    1.03×    1.04×     1.03×
  less->b      0.81×    0.52×    0.25×    0.55×    0.75×     0.53×
-- index-math
  unravel      0.36×    0.50×    0.96×    1.00×    1.04×     0.71×
  ravel_mi     0.32×    0.53×    1.01×    1.53×    1.54×     0.83×
-- dtypes
  complex      0.71×    0.58×    0.97×    0.77×    0.93×     0.78×
  float16      0.72×    0.64×    0.58×    0.56×    0.57×     0.61×
  int8         0.66×    1.43×   11.53×    6.16×    5.66×     3.28×

CONSTRUCTION — iterator build+dispose vs np.nditer (size-invariant, 1K)
        slower ◄───────── 1.0 (parity) ─────────► faster
1op          █████████▋ .........   0.97×   103%🕐  (  0 win /  1 lose)  ◄ SLOWER
3op_exl      ███████████████████▶   2.44×    41%🕐  (  1 win /  0 lose)
ufunc        ███████████████████▶   2.91×    34%🕐  (  1 win /  0 lose)
bufcast      ███████████████████▶   2.56×    39%🕐  (  1 win /  0 lose)
multiindex   █████████████▉ .....   1.40×    72%🕐  (  1 win /  0 lose)
8op          ███████████████████▶   3.67×    27%🕐  (  1 win /  0 lose)
4d           █████████████████▊     1.78×    56%🕐  (  1 win /  0 lose)
8d           ██████████████████▌    1.85×    54%🕐  (  1 win /  0 lose)
strided2d    ███████████████████▌   1.95×    51%🕐  (  1 win /  0 lose)
geomean      ███████████████████▶   2.03×    49%🕐  (  8 win /  1 lose)

CHUNK-WIDTH dispatch — strided rows, 2M total, inner width w (NumPy = np.positive)
        slower ◄───────── 1.0 (parity) ─────────► faster
w=4          ██████▉ ............   0.69×   145%🕐  (  0 win /  1 lose)  ◄ SLOWER
w=16         █████████▊ .........   0.98×   102%🕐  (  0 win /  1 lose)  ◄ PARITY
w=64         ██████████▏ ........   1.02×    98%🕐  (  1 win /  0 lose)  ◄ PARITY
w=256        ██████████████▌ ....   1.45×    69%🕐  (  1 win /  0 lose)
w=1024       █████████████ ......   1.31×    76%🕐  (  1 win /  0 lose)

PATHOLOGY canaries — known taxes/losses to track (NumPy ÷ NumSharp)
  bcast_reduce    522.42×   (522.4× faster, faster)
  allocate          1.06×   (1.1× faster, faster)
  overlap_copy      1.77×   (1.8× faster, faster)
  forder_out        1.17×   (1.2× faster, faster)
  zerodim           1.55×   (1.6× faster, faster)

DIVIDENDS — NumSharp-only machinery (NumPy baseline = closest it can do)
                scalar       1K     100K       1M      10M   note
fuse7           12.55×    3.86×    1.44×    1.67×    2.09×   vs chained 6× add
reuse            6.06×    6.12×    1.07×    1.00×    1.00×   vs rebuild each call
par8                 -    0.67×    2.78×    3.95×    5.40×   vs single-thread

biggest NumSharp wins: i8@100K 11.53× · anyeh@1 10.25× · anyff@1 10.04× · anyeh@100K 8.50× · anyeh@1K 8.49×
most behind:           flatten@100K 0.17× · lessbool@100K 0.25× · astype@1 0.31× · ravelmi@1 0.32× · flatten@1K 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	0.99 🟡	1.02 ✅	1.02 ✅	0.55 🟡	0.70 🟡	0.70 🟡	0.72 🟡	0.74 🟡
1M	0.95 🟡	0.94 🟡	0.95 🟡	0.65 🟡	0.87 🟡	0.73 🟡	0.75 🟡	0.68 🟡

Geomean by dt

size	f64	f32	c128	dec	f16	i32	i64
100K	0.87 🟡	1.00 🟡	0.98 🟡	0.08 🔴	1.03 ✅	1.33 ✅	1.14 ✅
1M	1.12 ✅	1.15 ✅	1.04 ✅	0.07 🔴	1.02 ✅	1.19 ✅	1.02 ✅

Geomean by op

size	sum	min	max	prod
100K	0.80 🟡	0.66 🟡	0.66 🟡	1.19 ✅
1M	0.84 🟡	0.65 🟡	0.64 🟡	1.28 ✅

Worst 15 cells (NumSharp slowest vs NumPy)

key	NumSharp ms	NumPy ms	ratio
1M|dec|bcast|sum|ax0	5.5269	0.0655	0.01 🔴
100K|dec|bcast|sum|ax0	0.5555	0.0087	0.02 🔴
100K|dec|F|sum|ax1	0.5585	0.0094	0.02 🔴
100K|dec|C|sum|ax0	0.5615	0.0111	0.02 🔴
100K|dec|T|sum|ax1	0.5582	0.0111	0.02 🔴
100K|dec|negrow|sum|ax0	0.5592	0.0114	0.02 🔴
100K|dec|sliced|sum|ax0	0.5517	0.0115	0.02 🔴
1M|dec|sliced|sum|ax0	5.5802	0.1240	0.02 🔴
1M|dec|negrow|sum|ax0	5.5707	0.1242	0.02 🔴
1M|dec|F|sum|ax1	5.6157	0.1254	0.02 🔴
1M|dec|T|sum|ax1	5.5849	0.1278	0.02 🔴
1M|dec|C|sum|ax0	5.5736	0.1524	0.03 🔴
100K|dec|C|min|ax0	0.3021	0.0141	0.05 🔴
1M|dec|negcol|sum|ax0	5.6678	0.2866	0.05 🔴
100K|dec|negcol|sum|ax0	0.5594	0.0302	0.05 🔴

Copy / identity-ufunc (np.positive)

Geomean by lay

size	C	F	T	strided	sliced	negrow	negcol	bcast
100K	1.22 ✅	1.51 ✅	1.28 ✅	0.83 🟡	1.54 ✅	1.48 ✅	2.20 ✅	1.62 ✅
1M	2.82 ✅	2.89 ✅	2.88 ✅	2.08 ✅	2.58 ✅	2.64 ✅	3.16 ✅	2.66 ✅

Geomean by dt

size	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	c128
100K	0.92 🟡	1.03 ✅	1.51 ✅	1.99 ✅	1.02 ✅	1.09 ✅	1.65 ✅	1.08 ✅	2.56 ✅	2.47 ✅	1.15 ✅	0.85 🟡	2.56 ✅
1M	4.60 ✅	4.87 ✅	2.13 ✅	2.14 ✅	2.11 ✅	2.12 ✅	2.56 ✅	2.46 ✅	2.20 ✅	2.10 ✅	2.14 ✅	2.59 ✅	5.47 ✅

Worst 15 cells (NumSharp slowest vs NumPy)

key	NumSharp ms	NumPy ms	ratio
100K|f64|strided|pos	0.0243	0.0100	0.41 🟠
100K|u64|strided|pos	0.0241	0.0110	0.46 🟠
100K|i64|strided|pos	0.0237	0.0109	0.46 🟠
100K|f32|strided|pos	0.0216	0.0100	0.46 🟠
100K|i32|strided|pos	0.0213	0.0110	0.52 🟡
100K|i64|C|pos	0.0400	0.0210	0.53 🟡
100K|i64|T|pos	0.0387	0.0208	0.54 🟡
100K|i8|sliced|pos	0.0423	0.0228	0.54 🟡
100K|u8|bcast|pos	0.0416	0.0229	0.55 🟡
100K|u8|sliced|pos	0.0410	0.0227	0.55 🟡
100K|u8|negrow|pos	0.0410	0.0231	0.56 🟡
100K|u32|strided|pos	0.0191	0.0109	0.57 🟡
100K|f64|T|pos	0.0389	0.0227	0.58 🟡
100K|f64|F|pos	0.0362	0.0227	0.63 🟡
100K|f64|C|pos	0.0361	0.0228	0.63 🟡

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

Geomean by lay

size	C	F	T	strided	sliced	negrow	negcol	bcast
100K	0.73 🟡	0.70 🟡	0.68 🟡	0.53 🟡	0.84 🟡	0.85 🟡	1.18 ✅	0.85 🟡
1M	1.54 ✅	1.48 ✅	1.48 ✅	1.12 ✅	1.64 ✅	1.65 ✅	1.80 ✅	1.63 ✅

Geomean by dt

size	f64	f32	c128	f16	i32	i64
100K	0.67 🟡	0.57 🟡	1.15 ✅	0.75 🟡	0.82 🟡	0.81 🟡
1M	1.86 ✅	1.53 ✅	1.73 ✅	0.94 🟡	1.54 ✅	1.79 ✅

Geomean by op

size	add	mul	neg	abs	sqrt	less	copy
100K	1.04 ✅	0.99 🟡	0.76 🟡	0.74 🟡	0.94 🟡	0.61 🟡	0.51 🟡
1M	1.81 ✅	1.78 ✅	2.11 ✅	1.62 ✅	1.50 ✅	0.68 🟡	1.75 ✅

Worst 15 cells (NumSharp slowest vs NumPy)

key	NumSharp ms	NumPy ms	ratio
100K|f64|strided|abs	0.0466	0.0077	0.17 🔴
100K|f64|strided|neg	0.0473	0.0088	0.19 🔴
100K|i32|bcast|copy	0.0233	0.0050	0.21 🟠
100K|f16|bcast|copy	0.0134	0.0030	0.22 🟠
100K|f16|negrow|copy	0.0168	0.0038	0.23 🟠
100K|f32|C|copy	0.0244	0.0059	0.24 🟠
100K|i64|strided|neg	0.0296	0.0076	0.26 🟠
100K|f64|strided|copy	0.0413	0.0108	0.26 🟠
100K|f64|negrow|copy	0.0595	0.0160	0.27 🟠
100K|f16|sliced|copy	0.0134	0.0037	0.27 🟠
100K|f64|sliced|copy	0.0592	0.0162	0.27 🟠
100K|i32|negrow|copy	0.0234	0.0064	0.28 🟠
100K|f32|C|add	0.0240	0.0066	0.28 🟠
100K|f64|strided|mul	0.0509	0.0142	0.28 🟠
100K|f64|strided|add	0.0516	0.0147	0.28 🟠

---

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.41 ✅	2.16 ✅	0.63 🟡	2.13 ✅	2.45 ✅	2.35 ✅	1.85 ✅
1-D strided a[::2]	1.84 ✅	1.46 ✅	0.53 🟡	1.51 ✅	1.81 ✅	1.93 ✅	1.40 ✅
1-D reversed a[::-1]	2.49 ✅	1.95 ✅	0.56 🟡	2.14 ✅	2.29 ✅	2.22 ✅	1.76 ✅
array + scalar	2.72 ✅	1.93 ✅	0.63 🟡	1.91 ✅	2.26 ✅	2.64 ✅	1.83 ✅
scalar + array	2.40 ✅	1.98 ✅	0.64 🟡	2.01 ✅	2.19 ✅	2.69 ✅	1.82 ✅
mixed C + F	2.29 ✅	2.02 ✅	0.62 🟡	2.02 ✅	2.09 ✅	1.87 ✅	1.68 ✅
mixed C + T	2.53 ✅	2.04 ✅	0.62 🟡	2.01 ✅	2.33 ✅	2.30 ✅	1.80 ✅
binary broadcast +row(1,C)	2.71 ✅	2.09 ✅	0.63 🟡	1.95 ✅	2.52 ✅	2.58 ✅	1.89 ✅
binary broadcast +col(R,1)	2.61 ✅	2.02 ✅	0.56 🟡	2.07 ✅	2.54 ✅	2.96 ✅	1.89 ✅
col-broadcast unary (inner stride-0)	2.54 ✅	1.56 ✅	0.88 🟡	1.65 ✅	2.64 ✅	6.22 ✅	2.13 ✅

Worst 12 cells

key	NumSharp ms	NumPy ms	ratio
1d_strided	f16	2.6261	1.3926	0.53 🟡
1d_rev	f16	5.2838	2.9653	0.56 🟡
bcast_col	f16	5.2887	2.9837	0.56 🟡
mix_C_T	f16	5.3031	3.2873	0.62 🟡
mix_C_F	f16	5.3153	3.3015	0.62 🟡
1d_C	f16	4.7456	2.9682	0.63 🟡
bcast_row	f16	4.7695	2.9999	0.63 🟡
scalar_rhs	f16	4.7058	2.9602	0.63 🟡
scalar_lhs	f16	4.6383	2.9742	0.64 🟡
colbcast_unary	f16	0.4753	0.4173	0.88 🟡
1d_strided	f32	0.2366	0.3444	1.46 ✅
1d_strided	i32	0.2433	0.3676	1.51 ✅

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

• 118 / 1568 comparable cells lag (<1.0); 1450 win (≥1.0).
• 🔴 <0.2 — 0 cells.
• 🟠 0.2–0.5 — 1 cells. Top: 1× * → bool
• 🟡 0.5–1.0 — 117 cells. Top: 23× int → sub-word (narrow); 21× float/cplx → narrow-int (bool/u8/i8/i16/u16/char); 8× f16 → f64

float/complex → narrow-int geomean by src (the historical cliff): f32→narrow 1.96, f64→narrow 1.38, f16→narrow 3.71, c128→narrow 1.08.

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

C	F	T	sliced	negrow	negcol	strided	bcast
1.86 ✅	1.88 ✅	1.93 ✅	1.95 ✅	1.97 ✅	1.82 ✅	1.47 ✅	2.25 ✅

Geomean by src dtype (all layouts×dst)

bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
2.35 ✅	2.18 ✅	2.16 ✅	2.19 ✅	2.14 ✅	1.92 ✅	1.88 ✅	1.62 ✅	1.55 ✅	1.98 ✅	2.36 ✅	1.75 ✅	1.43 ✅	nan ?	1.23 ✅

Geomean by dst dtype (all layouts×src)

bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
2.17 ✅	1.94 ✅	1.93 ✅	1.61 ✅	1.60 ✅	1.80 ✅	1.64 ✅	1.89 ✅	1.73 ✅	1.60 ✅	2.48 ✅	1.60 ✅	2.03 ✅	nan ?	2.59 ✅

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

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	3.04✅	2.60✅	2.76✅	2.10✅	1.98✅	1.53✅	1.46✅	2.04✅	2.25✅	1.73✅	3.29✅	1.71✅	2.49✅	—	2.94✅
u8	3.55✅	1.55✅	3.56✅	1.69✅	1.83✅	2.01✅	1.89✅	2.21✅	2.47✅	1.62✅	3.90✅	1.38✅	2.41✅	—	3.07✅
i8	2.61✅	3.17✅	0.91🟡	1.82✅	1.76✅	1.95✅	1.95✅	2.35✅	2.66✅	1.76✅	3.94✅	1.79✅	2.64✅	—	2.98✅
i16	2.20✅	2.29✅	2.59✅	1.39✅	2.11✅	2.09✅	1.95✅	2.42✅	2.52✅	1.57✅	3.71✅	1.92✅	2.61✅	—	2.79✅
u16	2.22✅	2.80✅	2.81✅	2.12✅	1.24✅	2.09✅	2.14✅	2.63✅	2.22✅	1.08✅	3.71✅	1.93✅	2.46✅	—	2.97✅
i32	1.50✅	1.15✅	1.16✅	1.46✅	1.51✅	1.70✅	2.12✅	2.26✅	2.27✅	1.43✅	3.64✅	1.64✅	2.62✅	—	2.86✅
u32	1.77✅	1.18✅	1.17✅	1.35✅	1.44✅	2.17✅	1.65✅	2.19✅	2.29✅	1.48✅	3.66✅	1.47✅	2.34✅	—	2.69✅
i64	1.08✅	0.98🟡	0.96🟡	1.23✅	1.27✅	1.83✅	1.78✅	1.87✅	2.76✅	1.38✅	1.81✅	1.81✅	2.22✅	—	2.52✅
u64	1.14✅	0.92🟡	0.95🟡	1.22✅	1.18✅	1.73✅	1.73✅	2.56✅	2.09✅	1.30✅	1.65✅	1.14✅	1.79✅	—	2.45✅
char	2.07✅	2.02✅	2.14✅	1.49✅	0.97🟡	1.55✅	1.53✅	2.26✅	2.20✅	1.21✅	3.67✅	1.42✅	2.11✅	—	2.62✅
f16	4.51✅	5.42✅	5.35✅	3.82✅	3.94✅	3.80✅	1.96✅	2.94✅	0.99🟡	4.16✅	1.25✅	1.10✅	0.92🟡	—	1.64✅
f32	2.82✅	1.92✅	2.05✅	1.64✅	1.55✅	1.84✅	1.38✅	0.83🟡	0.87🟡	1.48✅	3.59✅	1.76✅	2.21✅	—	2.35✅
f64	1.81✅	0.81🟡	0.81🟡	1.32✅	1.29✅	1.68✅	1.51✅	0.86🟡	0.89🟡	1.38✅	1.04✅	1.72✅	2.05✅	—	2.60✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	1.11✅	0.93🟡	0.94🟡	1.19✅	1.13✅	1.69✅	1.35✅	0.92🟡	0.84🟡	1.10✅	1.50✅	1.39✅	1.75✅	—	3.18✅

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

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	0.24🟠	2.72✅	2.71✅	1.94✅	1.91✅	1.43✅	1.42✅	2.24✅	2.40✅	1.89✅	4.03✅	1.74✅	2.55✅	—	2.98✅
u8	4.01✅	1.11✅	3.48✅	1.70✅	1.71✅	2.07✅	2.06✅	2.11✅	2.33✅	1.62✅	3.89✅	1.39✅	2.49✅	—	3.06✅
i8	3.53✅	3.24✅	1.05✅	1.93✅	1.80✅	2.14✅	2.13✅	2.59✅	2.51✅	1.71✅	3.88✅	1.77✅	2.40✅	—	2.95✅
i16	1.87✅	2.06✅	2.52✅	1.31✅	1.98✅	1.84✅	2.01✅	2.59✅	2.39✅	2.19✅	3.71✅	2.05✅	2.39✅	—	3.01✅
u16	2.26✅	2.74✅	2.63✅	1.93✅	1.27✅	1.88✅	2.02✅	2.68✅	2.26✅	1.35✅	3.65✅	1.96✅	2.17✅	—	2.85✅
i32	1.69✅	1.11✅	1.18✅	1.48✅	1.49✅	1.76✅	2.17✅	2.46✅	2.48✅	1.50✅	3.90✅	1.72✅	2.33✅	—	2.85✅
u32	1.85✅	1.13✅	1.06✅	1.54✅	1.43✅	2.15✅	1.64✅	2.31✅	2.26✅	1.50✅	3.87✅	1.55✅	2.16✅	—	2.46✅
i64	1.11✅	0.94🟡	0.92🟡	1.17✅	1.26✅	1.88✅	1.75✅	2.16✅	2.70✅	1.28✅	1.87✅	1.55✅	2.17✅	—	2.24✅
u64	1.15✅	0.92🟡	0.94🟡	1.21✅	1.13✅	1.73✅	1.73✅	2.46✅	2.05✅	1.39✅	2.48✅	1.14✅	1.76✅	—	2.34✅
char	2.08✅	2.63✅	2.03✅	1.90✅	1.20✅	1.67✅	1.69✅	2.52✅	2.46✅	1.20✅	3.60✅	1.41✅	2.10✅	—	2.89✅
f16	4.49✅	6.02✅	6.33✅	3.79✅	4.31✅	3.73✅	2.06✅	2.85✅	1.11✅	4.33✅	1.24✅	2.44✅	0.95🟡	—	1.62✅
f32	3.44✅	2.12✅	2.26✅	1.62✅	1.64✅	1.92✅	1.35✅	0.82🟡	0.84🟡	1.69✅	3.63✅	1.67✅	2.21✅	—	2.26✅
f64	1.90✅	1.27✅	1.33✅	1.40✅	1.43✅	1.95✅	1.47✅	0.87🟡	0.90🟡	1.41✅	1.61✅	1.73✅	2.05✅	—	2.69✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	0.99🟡	0.91🟡	0.88🟡	1.15✅	1.07✅	1.57✅	1.33✅	0.96🟡	0.81🟡	1.09✅	1.49✅	1.15✅	1.75✅	—	3.26✅

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

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	3.40✅	3.39✅	3.74✅	1.71✅	1.80✅	1.47✅	1.41✅	2.31✅	2.32✅	1.91✅	4.20✅	1.78✅	2.68✅	—	2.99✅
u8	3.94✅	1.21✅	2.55✅	1.68✅	1.68✅	2.05✅	1.92✅	2.21✅	2.56✅	1.67✅	3.98✅	1.41✅	2.41✅	—	2.98✅
i8	2.58✅	3.43✅	0.85🟡	1.84✅	1.75✅	2.01✅	2.12✅	2.50✅	2.42✅	1.76✅	3.79✅	1.80✅	2.46✅	—	3.04✅
i16	2.29✅	2.12✅	3.21✅	1.25✅	2.11✅	2.01✅	2.04✅	2.43✅	2.25✅	2.00✅	3.86✅	2.02✅	2.46✅	—	3.02✅
u16	2.23✅	2.51✅	2.45✅	1.91✅	1.26✅	2.03✅	1.99✅	2.44✅	2.39✅	1.44✅	3.67✅	1.90✅	2.29✅	—	2.50✅
i32	1.77✅	1.13✅	1.19✅	1.52✅	1.52✅	1.69✅	2.31✅	2.07✅	2.11✅	1.66✅	3.96✅	1.65✅	2.57✅	—	2.95✅
u32	1.89✅	1.16✅	1.16✅	1.49✅	1.47✅	2.25✅	1.72✅	2.18✅	2.15✅	1.47✅	3.71✅	1.49✅	2.27✅	—	2.82✅
i64	1.28✅	1.04✅	0.93🟡	1.25✅	1.27✅	1.79✅	1.78✅	2.09✅	2.64✅	1.33✅	1.86✅	1.74✅	2.23✅	—	2.69✅
u64	1.20✅	0.94🟡	0.95🟡	1.21✅	1.16✅	1.79✅	1.62✅	2.52✅	2.00✅	1.36✅	2.47✅	1.12✅	1.90✅	—	2.54✅
char	2.14✅	2.15✅	2.63✅	1.84✅	1.22✅	1.61✅	1.62✅	2.24✅	2.47✅	1.31✅	3.50✅	1.44✅	2.32✅	—	2.56✅
f16	5.17✅	6.28✅	6.15✅	4.27✅	4.26✅	3.56✅	2.03✅	3.02✅	1.14✅	4.33✅	1.18✅	2.84✅	1.00🟡	—	1.65✅
f32	3.33✅	2.16✅	2.30✅	1.77✅	1.63✅	2.04✅	1.38✅	0.83🟡	0.86🟡	1.63✅	3.75✅	1.70✅	2.56✅	—	2.20✅
f64	2.00✅	1.35✅	1.35✅	1.37✅	1.41✅	1.81✅	1.48✅	0.87🟡	0.89🟡	1.31✅	1.63✅	1.74✅	1.93✅	—	2.61✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	1.00✅	1.11✅	1.21✅	1.27✅	1.18✅	1.66✅	1.28✅	0.90🟡	0.85🟡	1.11✅	1.53✅	1.41✅	1.79✅	—	3.42✅

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

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	3.14✅	5.84✅	5.99✅	1.96✅	2.00✅	1.49✅	1.56✅	2.38✅	2.06✅	1.99✅	3.95✅	1.74✅	2.66✅	—	3.02✅
u8	2.74✅	1.25✅	3.91✅	1.79✅	1.88✅	2.24✅	2.14✅	2.44✅	2.55✅	1.72✅	3.71✅	1.40✅	2.83✅	—	3.17✅
i8	2.96✅	3.03✅	0.92🟡	1.75✅	1.74✅	1.99✅	1.92✅	2.30✅	2.14✅	1.65✅	3.86✅	1.69✅	2.48✅	—	3.07✅
i16	2.25✅	2.82✅	2.56✅	1.45✅	1.71✅	1.93✅	1.90✅	2.47✅	2.50✅	1.62✅	3.54✅	2.06✅	2.58✅	—	2.85✅
u16	2.98✅	2.66✅	2.90✅	1.46✅	1.33✅	2.06✅	1.96✅	2.50✅	2.20✅	1.36✅	3.62✅	1.88✅	2.45✅	—	3.01✅
i32	1.94✅	2.20✅	2.10✅	1.43✅	1.54✅	1.90✅	1.81✅	2.14✅	2.23✅	1.55✅	3.70✅	1.58✅	2.39✅	—	2.86✅
u32	1.99✅	2.01✅	2.13✅	1.44✅	1.53✅	2.02✅	1.85✅	2.10✅	2.22✅	1.55✅	3.72✅	1.47✅	2.12✅	—	2.74✅
i64	1.20✅	1.18✅	1.28✅	1.42✅	1.33✅	1.78✅	1.78✅	2.22✅	2.35✅	1.42✅	1.82✅	1.52✅	2.36✅	—	2.68✅
u64	1.29✅	1.24✅	1.22✅	1.33✅	1.30✅	1.74✅	1.79✅	2.14✅	2.22✅	1.36✅	2.39✅	0.97🟡	1.58✅	—	2.45✅
char	2.16✅	2.26✅	2.43✅	1.50✅	1.31✅	1.61✅	1.60✅	2.27✅	2.32✅	1.31✅	3.47✅	1.42✅	2.23✅	—	2.80✅
f16	4.70✅	4.95✅	4.99✅	4.11✅	4.05✅	4.02✅	1.97✅	3.08✅	1.10✅	4.21✅	1.33✅	2.70✅	0.96🟡	—	1.49✅
f32	3.63✅	2.20✅	2.35✅	1.64✅	1.67✅	1.90✅	1.34✅	0.86🟡	0.88🟡	1.59✅	3.62✅	1.97✅	2.04✅	—	2.35✅
f64	2.01✅	1.26✅	1.31✅	1.42✅	1.33✅	0.70🟡	1.49✅	0.84🟡	0.84🟡	1.34✅	1.58✅	1.71✅	2.49✅	—	2.58✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	0.97🟡	1.07✅	0.96🟡	1.13✅	1.14✅	1.72✅	1.30✅	0.93🟡	0.80🟡	0.91🟡	1.47✅	1.40✅	1.75✅	—	2.20✅

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

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	3.38✅	4.26✅	4.97✅	1.92✅	2.03✅	1.41✅	1.57✅	2.32✅	2.40✅	1.98✅	3.91✅	1.79✅	2.59✅	—	3.34✅
u8	3.67✅	1.14✅	3.99✅	1.71✅	1.63✅	2.15✅	2.24✅	2.37✅	2.35✅	1.87✅	3.81✅	1.44✅	2.29✅	—	3.05✅
i8	3.35✅	3.21✅	0.97🟡	2.04✅	1.87✅	2.02✅	2.04✅	2.32✅	2.48✅	1.72✅	3.67✅	1.73✅	2.58✅	—	3.25✅
i16	3.19✅	2.80✅	2.70✅	1.39✅	1.68✅	1.99✅	2.03✅	2.29✅	2.48✅	1.78✅	3.72✅	2.09✅	2.42✅	—	3.13✅
u16	2.41✅	2.59✅	2.35✅	1.53✅	1.32✅	1.77✅	1.84✅	2.45✅	2.56✅	1.53✅	3.57✅	2.04✅	2.46✅	—	2.82✅
i32	2.01✅	2.01✅	2.04✅	1.52✅	1.53✅	1.97✅	1.89✅	2.21✅	2.32✅	1.57✅	3.58✅	1.54✅	2.04✅	—	2.86✅
u32	1.96✅	2.10✅	2.14✅	1.47✅	1.49✅	1.80✅	1.91✅	2.27✅	2.52✅	1.59✅	3.59✅	1.50✅	2.18✅	—	2.54✅
i64	1.17✅	1.21✅	1.33✅	1.39✅	1.41✅	1.84✅	1.78✅	2.65✅	2.22✅	1.31✅	1.84✅	1.46✅	2.33✅	—	2.59✅
u64	1.13✅	1.26✅	1.29✅	1.33✅	1.37✅	1.83✅	1.96✅	2.17✅	2.39✅	1.31✅	2.35✅	1.00🟡	1.59✅	—	2.32✅
char	2.36✅	2.38✅	2.28✅	1.71✅	1.37✅	1.57✅	1.58✅	2.34✅	2.32✅	1.33✅	3.52✅	1.49✅	2.37✅	—	2.79✅
f16	5.08✅	4.80✅	4.78✅	3.80✅	3.83✅	3.85✅	2.03✅	3.13✅	1.09✅	3.83✅	1.34✅	2.87✅	0.97🟡	—	1.60✅
f32	3.30✅	2.23✅	2.25✅	1.60✅	1.67✅	1.91✅	1.36✅	0.84🟡	0.85🟡	1.66✅	3.58✅	1.95✅	2.09✅	—	2.25✅
f64	1.87✅	1.23✅	1.33✅	1.44✅	1.48✅	1.87✅	1.44✅	0.80🟡	0.88🟡	1.46✅	1.58✅	1.69✅	2.36✅	—	2.54✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	1.10✅	0.94🟡	1.01✅	1.15✅	1.11✅	1.47✅	1.37✅	0.87🟡	0.92🟡	1.26✅	1.41✅	1.37✅	1.61✅	—	2.29✅

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

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	4.56✅	7.06✅	6.59✅	2.26✅	2.21✅	1.54✅	1.48✅	2.25✅	2.21✅	2.40✅	2.80✅	1.88✅	2.48✅	—	3.10✅
u8	1.42✅	3.55✅	3.38✅	2.00✅	1.85✅	1.77✅	1.83✅	2.16✅	2.24✅	1.88✅	2.52✅	1.47✅	2.46✅	—	3.02✅
i8	1.31✅	4.32✅	2.73✅	1.70✅	1.89✅	1.82✅	1.83✅	2.24✅	2.26✅	1.73✅	2.63✅	1.65✅	2.37✅	—	3.10✅
i16	3.46✅	2.49✅	2.83✅	1.78✅	1.77✅	1.66✅	1.68✅	2.17✅	2.25✅	1.70✅	2.01✅	1.78✅	2.24✅	—	2.86✅
u16	3.61✅	3.01✅	3.11✅	1.76✅	1.62✅	1.68✅	1.75✅	2.43✅	2.22✅	1.69✅	2.02✅	1.43✅	2.38✅	—	2.92✅
i32	2.10✅	1.95✅	1.67✅	1.60✅	1.61✅	1.55✅	1.55✅	2.56✅	2.15✅	1.68✅	2.06✅	1.65✅	2.06✅	—	2.76✅
u32	2.08✅	1.60✅	1.53✅	1.59✅	1.58✅	1.48✅	1.61✅	2.46✅	2.30✅	1.63✅	2.02✅	1.47✅	2.34✅	—	2.84✅
i64	1.33✅	0.96🟡	0.97🟡	1.29✅	1.41✅	1.75✅	1.87✅	2.41✅	2.36✅	1.39✅	1.30✅	1.58✅	2.17✅	—	2.44✅
u64	1.26✅	1.01✅	0.93🟡	1.27✅	1.33✅	1.72✅	1.69✅	2.32✅	2.19✅	1.34✅	1.65✅	1.05✅	1.50✅	—	2.50✅
char	3.38✅	2.34✅	3.24✅	1.67✅	1.60✅	1.67✅	1.65✅	2.21✅	2.35✅	1.64✅	2.03✅	1.56✅	2.27✅	—	2.96✅
f16	4.65✅	1.73✅	1.73✅	1.74✅	1.76✅	2.23✅	1.33✅	2.07✅	0.89🟡	1.76✅	1.61✅	1.56✅	0.96🟡	—	1.51✅
f32	2.48✅	1.71✅	1.67✅	1.65✅	1.62✅	1.90✅	1.08✅	0.85🟡	0.81🟡	1.61✅	1.94✅	1.62✅	1.20✅	—	2.30✅
f64	1.45✅	1.12✅	1.10✅	1.33✅	1.38✅	1.75✅	1.10✅	0.83🟡	0.83🟡	1.39✅	1.19✅	1.65✅	2.67✅	—	2.68✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	1.02✅	0.98🟡	1.08✅	1.19✅	1.10✅	1.54✅	1.16✅	0.98🟡	0.90🟡	1.22✅	0.95🟡	1.49✅	1.71✅	—	2.26✅

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

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	2.26✅	3.65✅	3.30✅	3.63✅	3.72✅	1.18✅	1.12✅	1.74✅	1.77✅	2.09✅	2.71✅	1.41✅	1.75✅	—	2.30✅
u8	0.97🟡	2.00✅	2.27✅	2.28✅	1.89✅	1.30✅	1.27✅	2.06✅	1.84✅	1.90✅	2.55✅	1.13✅	1.78✅	—	2.61✅
i8	0.91🟡	2.13✅	2.46✅	1.91✅	1.77✅	1.35✅	1.55✅	2.04✅	1.89✅	1.86✅	2.45✅	1.33✅	1.92✅	—	2.34✅
i16	2.41✅	1.68✅	1.97✅	1.14✅	2.07✅	1.21✅	1.26✅	1.90✅	1.96✅	1.70✅	1.89✅	1.18✅	1.73✅	—	2.39✅
u16	2.39✅	1.77✅	1.76✅	1.37✅	1.41✅	1.29✅	1.32✅	1.89✅	1.90✅	1.52✅	1.90✅	1.04✅	1.81✅	—	2.32✅
i32	1.60✅	1.43✅	1.39✅	1.16✅	1.16✅	1.23✅	1.08✅	1.86✅	1.78✅	1.26✅	1.88✅	1.28✅	1.76✅	—	2.44✅
u32	1.74✅	1.22✅	1.18✅	1.10✅	1.25✅	1.13✅	1.14✅	1.86✅	1.84✅	1.18✅	1.95✅	1.13✅	1.77✅	—	2.24✅
i64	1.11✅	0.95🟡	0.94🟡	0.86🟡	0.94🟡	1.22✅	1.35✅	1.77✅	1.74✅	0.91🟡	1.19✅	1.26✅	1.74✅	—	2.43✅
u64	1.07✅	0.93🟡	0.94🟡	0.83🟡	1.01✅	1.20✅	1.27✅	1.58✅	1.70✅	1.03✅	1.48✅	0.74🟡	1.47✅	—	2.17✅
char	2.39✅	1.80✅	1.68✅	1.26✅	1.49✅	1.21✅	1.30✅	1.85✅	1.75✅	1.51✅	1.83✅	1.13✅	1.73✅	—	2.34✅
f16	2.62✅	1.49✅	1.52✅	1.59✅	1.66✅	1.76✅	1.14✅	1.85✅	0.89🟡	1.59✅	1.11✅	1.23✅	0.95🟡	—	1.44✅
f32	1.98✅	1.31✅	1.31✅	1.30✅	1.37✅	1.34✅	0.91🟡	0.94🟡	0.80🟡	1.30✅	1.78✅	1.16✅	1.20✅	—	2.43✅
f64	1.25✅	0.98🟡	0.97🟡	0.91🟡	0.86🟡	1.22✅	0.94🟡	0.89🟡	0.80🟡	0.94🟡	1.06✅	1.07✅	1.81✅	—	2.08✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	1.07✅	1.14✅	0.99🟡	0.93🟡	0.91🟡	1.15✅	1.03✅	0.97🟡	0.83🟡	0.94🟡	0.89🟡	1.08✅	1.59✅	—	1.66✅

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

src\dst	bool	u8	i8	i16	u16	i32	u32	i64	u64	char	f16	f32	f64	dec	c128
bool	1.26✅	5.38✅	6.24✅	2.28✅	2.24✅	1.51✅	1.46✅	2.32✅	2.18✅	2.26✅	3.97✅	1.91✅	2.37✅	—	3.14✅
u8	4.95✅	0.89🟡	4.29✅	1.87✅	1.88✅	2.08✅	2.14✅	2.52✅	2.39✅	1.87✅	3.76✅	2.32✅	2.15✅	—	2.95✅
i8	5.13✅	4.15✅	0.80🟡	1.82✅	1.87✅	2.12✅	2.43✅	2.55✅	2.38✅	1.91✅	3.81✅	2.16✅	2.28✅	—	3.14✅
i16	4.77✅	3.50✅	3.80✅	1.60✅	1.72✅	1.98✅	1.91✅	2.18✅	2.32✅	1.69✅	3.62✅	2.22✅	2.52✅	—	3.12✅
u16	4.57✅	4.20✅	3.20✅	1.85✅	1.63✅	1.98✅	1.89✅	2.26✅	2.27✅	1.66✅	3.72✅	2.08✅	2.26✅	—	2.70✅
i32	3.42✅	2.89✅	3.25✅	1.70✅	1.67✅	2.12✅	1.92✅	2.09✅	2.34✅	1.94✅	3.82✅	2.24✅	2.67✅	—	3.00✅
u32	3.64✅	3.72✅	2.42✅	1.66✅	1.77✅	2.02✅	1.99✅	2.23✅	2.31✅	1.90✅	3.73✅	2.29✅	2.27✅	—	2.94✅
i64	2.70✅	2.23✅	2.29✅	1.73✅	1.72✅	2.04✅	2.10✅	2.41✅	2.12✅	1.72✅	1.85✅	2.08✅	2.00✅	—	2.67✅
u64	2.57✅	2.40✅	2.16✅	1.60✅	1.66✅	2.08✅	1.92✅	2.24✅	2.29✅	1.75✅	2.43✅	2.26✅	2.14✅	—	2.72✅
char	4.78✅	3.81✅	3.84✅	1.74✅	1.50✅	1.65✅	1.66✅	2.17✅	2.36✅	1.65✅	3.64✅	1.54✅	2.36✅	—	2.75✅
f16	6.87✅	5.51✅	5.35✅	4.23✅	4.21✅	3.88✅	2.04✅	3.04✅	1.09✅	3.86✅	1.46✅	2.87✅	0.96🟡	—	1.55✅
f32	4.89✅	3.29✅	2.71✅	1.88✅	2.02✅	2.15✅	1.47✅	2.21✅	0.86🟡	1.84✅	3.65✅	2.09✅	2.11✅	—	2.29✅
f64	2.70✅	2.15✅	2.14✅	1.78✅	1.77✅	2.11✅	1.49✅	1.99✅	0.88🟡	1.81✅	1.58✅	2.04✅	2.51✅	—	2.66✅
dec	—	—	—	—	—	—	—	—	—	—	—	—	—	—	—
c128	1.09✅	1.06✅	1.05✅	1.38✅	1.40✅	1.75✅	1.35✅	0.84🟡	0.80🟡	1.39✅	1.50✅	1.56✅	2.01✅	—	2.94✅

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

key	NumSharp ms	NumPy ms	ratio
bool|F|bool	0.0595	0.0144	0.24 🟠
f64|sliced|i32	0.9124	0.6414	0.70 🟡
u64|strided|f32	0.5215	0.3885	0.74 🟡
c128|bcast|u64	1.5413	1.2301	0.80 🟡
f32|strided|u64	0.7987	0.6399	0.80 🟡
i8|bcast|i8	0.0619	0.0496	0.80 🟡
c128|sliced|u64	1.7479	1.4021	0.80 🟡
f64|strided|u64	0.7758	0.6243	0.80 🟡
f64|negrow|i64	1.5209	1.2241	0.80 🟡
c128|F|u64	1.7023	1.3717	0.81 🟡
f32|negcol|u64	1.5659	1.2627	0.81 🟡
f64|C|i8	0.2927	0.2376	0.81 🟡
f64|C|u8	0.2892	0.2350	0.81 🟡
f32|F|i64	1.4588	1.1945	0.82 🟡
c128|strided|u64	0.9366	0.7745	0.83 🟡
u64|strided|i16	0.1726	0.1432	0.83 🟡
f32|C|i64	1.4773	1.2276	0.83 🟡
f64|negcol|u64	1.5574	1.2946	0.83 🟡
f32|T|i64	1.4640	1.2208	0.83 🟡
f64|negcol|i64	1.4625	1.2196	0.83 🟡
c128|C|u64	1.6652	1.3911	0.84 🟡
f32|negrow|i64	1.4768	1.2373	0.84 🟡
f32|F|u64	1.4675	1.2315	0.84 🟡
f64|sliced|i64	1.4533	1.2221	0.84 🟡
c128|bcast|i64	1.4280	1.2013	0.84 🟡
f64|sliced|u64	1.4453	1.2198	0.84 🟡
i8|T|i8	0.0613	0.0519	0.85 🟡
c128|T|u64	1.6154	1.3692	0.85 🟡
f32|negrow|u64	1.4957	1.2720	0.85 🟡
f32|negcol|i64	1.4173	1.2088	0.85 🟡
f64|C|i64	1.4556	1.2468	0.86 🟡
i64|strided|i16	0.1748	0.1499	0.86 🟡
f32|sliced|i64	1.4408	1.2354	0.86 🟡
f64|strided|u16	0.1706	0.1469	0.86 🟡
f32|T|u64	1.4532	1.2546	0.86 🟡
f32|bcast|u64	1.4571	1.2602	0.86 🟡
c128|negrow|i64	1.5665	1.3619	0.87 🟡
f64|F|i64	1.4506	1.2612	0.87 🟡
f64|T|i64	1.4409	1.2540	0.87 🟡
f32|C|u64	1.4695	1.2834	0.87 🟡
f64|bcast|u64	1.4020	1.2277	0.88 🟡
f64|negrow|u64	1.4430	1.2673	0.88 🟡
c128|F|i8	0.3572	0.3148	0.88 🟡
f32|sliced|u64	1.4888	1.3174	0.88 🟡
f16|negcol|u64	2.1147	1.8765	0.89 🟡
u8|bcast|u8	0.0587	0.0522	0.89 🟡
f64|strided|i64	0.7057	0.6283	0.89 🟡
f64|C|u64	1.4293	1.2761	0.89 🟡
f16|strided|u64	1.0346	0.9241	0.89 🟡
c128|strided|f16	0.8811	0.7874	0.89 🟡
f64|T|u64	1.4221	1.2717	0.89 🟡
c128|T|i64	1.5151	1.3650	0.90 🟡
c128|negcol|u64	1.6586	1.4945	0.90 🟡
f64|F|u64	1.4496	1.3097	0.90 🟡
f32|strided|u32	0.3838	0.3480	0.91 🟡
c128|sliced|char	0.5601	0.5081	0.91 🟡
f64|strided|i16	0.1641	0.1489	0.91 🟡
c128|F|u8	0.3391	0.3083	0.91 🟡
i64|strided|char	0.1534	0.1397	0.91 🟡
i8|strided|bool	0.1632	0.1489	0.91 🟡
i8|C|i8	0.0595	0.0543	0.91 🟡
c128|strided|u16	0.3051	0.2789	0.91 🟡
c128|C|i64	1.5153	1.3895	0.92 🟡
u64|F|u8	0.2149	0.1979	0.92 🟡
c128|negrow|u64	1.7009	1.5680	0.92 🟡
i64|F|i8	0.2150	0.1982	0.92 🟡
f16|C|f64	1.5894	1.4665	0.92 🟡
u64|C|u8	0.2155	0.1988	0.92 🟡
i8|sliced|i8	0.0575	0.0530	0.92 🟡
c128|strided|i16	0.3130	0.2897	0.93 🟡
c128|C|u8	0.3526	0.3283	0.93 🟡
u64|negcol|i8	0.2475	0.2306	0.93 🟡
i64|T|i8	0.2114	0.1973	0.93 🟡
c128|sliced|i64	1.4869	1.3889	0.93 🟡
u64|strided|u8	0.1409	0.1316	0.93 🟡
c128|strided|char	0.2944	0.2754	0.94 🟡
f32|strided|i64	0.7048	0.6596	0.94 🟡
c128|C|i8	0.3417	0.3201	0.94 🟡
i64|strided|u16	0.1550	0.1454	0.94 🟡
u64|F|i8	0.2121	0.1991	0.94 🟡
u64|strided|i8	0.1389	0.1305	0.94 🟡
u64|T|u8	0.2105	0.1978	0.94 🟡
i64|F|u8	0.2204	0.2078	0.94 🟡
c128|negrow|u8	0.3492	0.3294	0.94 🟡
f64|strided|char	0.1593	0.1504	0.94 🟡
f64|strided|u32	0.3797	0.3587	0.94 🟡
i64|strided|i8	0.1438	0.1358	0.94 🟡
u64|C|i8	0.2096	0.1981	0.95 🟡
f16|strided|f64	0.7709	0.7306	0.95 🟡
f16|F|f64	1.5066	1.4286	0.95 🟡
i64|strided|u8	0.1424	0.1351	0.95 🟡
u64|T|i8	0.2094	0.1987	0.95 🟡
c128|negcol|f16	1.8203	1.7315	0.95 🟡
f16|sliced|f64	1.4890	1.4241	0.96 🟡
c128|F|i64	1.5008	1.4359	0.96 🟡
i64|negcol|u8	0.2439	0.2335	0.96 🟡
f16|bcast|f64	1.5177	1.4532	0.96 🟡
c128|sliced|i8	0.3253	0.3118	0.96 🟡
i64|C|i8	0.2090	0.2004	0.96 🟡
f16|negcol|f64	1.5238	1.4668	0.96 🟡
char|C|u16	0.2540	0.2457	0.97 🟡
c128|sliced|bool	0.4498	0.4355	0.97 🟡
c128|strided|i64	0.8006	0.7755	0.97 🟡
u64|sliced|f32	0.7665	0.7425	0.97 🟡
f16|negrow|f64	1.5293	1.4823	0.97 🟡
f64|strided|i8	0.1454	0.1413	0.97 🟡
i8|negrow|i8	0.0558	0.0542	0.97 🟡
u8|strided|bool	0.1537	0.1495	0.97 🟡
i64|negcol|i8	0.2480	0.2414	0.97 🟡
i64|C|u8	0.2108	0.2062	0.98 🟡
c128|negcol|u8	0.3485	0.3423	0.98 🟡
f64|strided|u8	0.1456	0.1431	0.98 🟡
c128|negcol|i64	1.6104	1.5838	0.98 🟡
f16|C|u64	1.8886	1.8634	0.99 🟡
c128|F|bool	0.4151	0.4098	0.99 🟡
c128|strided|i8	0.2650	0.2633	0.99 🟡
f16|T|f64	1.4800	1.4751	1.00 🟡
u64|negrow|f32	0.7923	0.7904	1.00 🟡

1568 comparable cells (1800 NumSharp rows; 118 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    3.53 ms   unfused    6.08 ms   (1.72x)
  (a-b)/(a+b) fused    3.16 ms   unfused   12.32 ms   (3.90x)
  sum(a*b)    fused    2.30 ms   unfused    4.33 ms   (1.88x)
  sum(af*bf)  fused    1.43 ms   unfused    1.57 ms   (1.10x)  [f32]
  a*b+c out=  fused    3.56 ms   [1-pass fused-into-out]
  i4*2+f8     fused    2.78 ms   unfused    4.04 ms   (1.45x)

  a*b+c across operand layouts (2-D 2000x2000, all 3 operands same layout):
    [C      ] fused    3.43 ms   unfused    6.05 ms   (1.77x)
    [F      ] fused    3.52 ms   unfused    6.18 ms   (1.75x)
    [T      ] fused    3.50 ms   unfused    6.27 ms   (1.79x)
    [strided] fused    3.31 ms   unfused    4.72 ms   (1.43x)
    [bcast  ] fused    1.06 ms   unfused    3.75 ms   (3.53x)

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

numpy 2.4.2, 4M float64, best of 9:
  a*b+c         12.35 ms
  (a-b)/(a+b)   18.75 ms
  sum(a*b)       8.60 ms
  sum(af*bf)     4.14 ms  [f32]
  a*b+c out=     4.68 ms  [two-pass with out=]
  i4*2+f8        9.67 ms
  a*b+c across operand layouts (2-D 2000x2000, unfused):
    [C      ]   12.52 ms
    [F      ]   12.54 ms
    [T      ]   12.51 ms
    [strided]    7.91 ms
    [bcast  ]   11.95 ms