flopscope 0.2.0__py3-none-any.whl

flopscope/data/weights.csv

@@ -0,0 +1,509 @@
+Operation,Status,Category,Cost Formula,Active Weight,Empirical Weight,Reviewer Weight,Effective Cost Example,Confidence,Notes,Exclusion Reason,Hardware FP Instructions (per analytical FLOP),Timing Weight,Perf/Timing Agreement,Measurement Spread (CV),Benchmark Command,Benchmark Size,Total Perf Instructions,Total Timing (ns),Implementation,Weight Tier,Repeats
+exp,benchmarked,Pointwise Unary,numel(output),16.0000,22.0000,,"16,000 FLOPs (1000 elements)",high,Element-wise e^x.,,22.30,0.6258,25.5673,0.0222,"np.exp(x, out=_out)","x: (10000000,)","[2214116711, 2230009638, 2307666327]",122532583,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L245,moderate,10
+exp2,benchmarked,Pointwise Unary,numel(output),16.0000,15.0000,,"16,000 FLOPs (1000 elements)",high,Element-wise 2^x.,,15.30,0.5741,27.8697,0.0060,"np.exp2(x, out=_out)","x: (10000000,)","[1514116711, 1530009638, 1530009597]",112398740,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L313,moderate,10
+expm1,benchmarked,Pointwise Unary,numel(output),16.0000,41.0000,,"16,000 FLOPs (1000 elements)",high,Element-wise e^x - 1 (accurate near zero).,,41.30,0.7730,20.6986,0.0040,"np.expm1(x, out=_out)","x: (10000000,)","[4114116711, 4130009638, 4146810477]",151351549,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L314,moderate,10
+log,benchmarked,Pointwise Unary,numel(output),16.0000,31.3410,,"16,000 FLOPs (1000 elements)",high,Element-wise natural logarithm.,,31.64,3.4792,4.5988,0.0081,"np.log(x, out=_out)","x: (10000000,)","[3164111511, 3130009638, 3180037447]",681220433,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L246,moderate,10
+log2,benchmarked,Pointwise Unary,numel(output),16.0000,34.8410,,"16,000 FLOPs (1000 elements)",high,Element-wise base-2 logarithm.,,35.14,3.7852,4.2270,0.0154,"np.log2(x, out=_out)","x: (10000000,)","[3514106091, 3430009638, 3530065077]",741132137,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L247,moderate,10
+log10,benchmarked,Pointwise Unary,numel(output),16.0000,35.3410,,"16,000 FLOPs (1000 elements)",high,Element-wise base-10 logarithm.,,35.64,3.3505,4.7754,0.0072,"np.log10(x, out=_out)","x: (10000000,)","[3564111511, 3530009638, 3580037447]",656022193,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L248,moderate,10
+log1p,benchmarked,Pointwise Unary,numel(output),16.0000,41.1581,,"16,000 FLOPs (1000 elements)",high,Element-wise log(1+x) (accurate near zero).,,41.46,2.6303,6.0830,0.0129,"np.log1p(x, out=_out)","x: (10000000,)","[4145821771, 4130009638, 4229965257]",515013600,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L327,moderate,10
+cbrt,benchmarked,Pointwise Unary,numel(output),16.0000,38.0000,,"16,000 FLOPs (1000 elements)",high,Element-wise cube root.,,38.30,0.6549,24.4312,0.0024,"np.cbrt(x, out=_out)","x: (10000000,)","[3814116711, 3830009638, 3830009597]",128224189,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L307,moderate,10
+sin,benchmarked,Pointwise Unary,numel(output),16.0000,39.8606,,"16,000 FLOPs (1000 elements)",high,Element-wise sine.,,40.16,8.7998,1.8182,0.0054,"np.sin(x, out=_out)","x: (10000000,)","[4015606037, 4016070578, 4053542187]",1722977555,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L253,moderate,10
+cos,benchmarked,Pointwise Unary,numel(output),16.0000,39.9073,,"16,000 FLOPs (1000 elements)",high,Element-wise cosine.,,40.21,8.9970,1.7784,0.0048,"np.cos(x, out=_out)","x: (10000000,)","[4020308387, 4020737758, 4054117597]",1761590785,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L254,moderate,10
+tan,benchmarked,Pointwise Unary,numel(output),16.0000,60.0000,,"16,000 FLOPs (1000 elements)",high,Element-wise tangent.,,60.30,0.7671,20.8578,0.0015,"np.tan(x, out=_out)","x: (10000000,)","[6014116711, 6030009638, 6030009597]",150203772,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L379,moderate,10
+arcsin,benchmarked,Pointwise Unary,numel(output),16.0000,55.9901,,"16,000 FLOPs (1000 elements)",high,Element-wise inverse sine.,,56.29,4.4035,3.6335,0.0086,"np.arcsin(x, out=_out)","x: (10000000,)","[5545820361, 5629018068, 5629909417]",862199483,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L270,moderate,10
+arccos,benchmarked,Pointwise Unary,numel(output),16.0000,52.9901,,"16,000 FLOPs (1000 elements)",high,Element-wise inverse cosine.,,53.29,4.6868,3.4138,0.0091,"np.arccos(x, out=_out)","x: (10000000,)","[5245820361, 5329018068, 5329909417]",917672711,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L268,moderate,10
+arctan,benchmarked,Pointwise Unary,numel(output),16.0000,47.0000,,"16,000 FLOPs (1000 elements)",high,Element-wise inverse tangent.,,47.30,0.7029,22.7628,0.0019,"np.arctan(x, out=_out)","x: (10000000,)","[4714116711, 4730009638, 4730009597]",137625923,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L272,moderate,10
+sinh,benchmarked,Pointwise Unary,numel(output),16.0000,33.0000,,"16,000 FLOPs (1000 elements)",high,Element-wise hyperbolic sine.,,33.30,0.7247,22.0781,0.0218,"np.sinh(x, out=_out)","x: (10000000,)","[3314116711, 3330009638, 3448425607]",141888350,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L365,moderate,10
+cosh,benchmarked,Pointwise Unary,numel(output),16.0000,28.0000,,"16,000 FLOPs (1000 elements)",high,Element-wise hyperbolic cosine.,,28.30,0.6961,22.9852,0.0092,"np.cosh(x, out=_out)","x: (10000000,)","[2814116711, 2830009638, 2865053307]",136304057,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L310,moderate,10
+tanh,benchmarked,Pointwise Unary,numel(output),16.0000,33.0000,,"16,000 FLOPs (1000 elements)",high,Element-wise hyperbolic tangent.,,33.30,0.7493,21.3533,0.0028,"np.tanh(x, out=_out)","x: (10000000,)","[3314116711, 3330009638, 3330009597]",146717613,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L255,moderate,10
+arcsinh,benchmarked,Pointwise Unary,numel(output),16.0000,79.0000,,"16,000 FLOPs (1000 elements)",high,Element-wise inverse hyperbolic sine.,,79.30,1.1621,13.7682,0.0012,"np.arcsinh(x, out=_out)","x: (10000000,)","[7914116711, 7930009638, 7930009597]",227543623,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L271,moderate,10
+arccosh,benchmarked,Pointwise Unary,numel(output),16.0000,82.5008,,"16,000 FLOPs (1000 elements)",high,Element-wise inverse hyperbolic cosine.,,82.80,2.6758,5.9795,0.0042,"np.arccosh(x, out=_out)","x: (10000000,)","[8298265921, 8231001648, 8280087937]",523920995,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L269,moderate,10
+arctanh,benchmarked,Pointwise Unary,numel(output),16.0000,71.9901,,"16,000 FLOPs (1000 elements)",high,Element-wise inverse hyperbolic tangent.,,72.29,2.2801,7.0172,0.0067,"np.arctanh(x, out=_out)","x: (10000000,)","[7145820361, 7229018068, 7229909417]",446438686,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L273,moderate,10
+sinc,benchmarked,Pointwise Unary,numel(output),16.0000,41.1250,,"16,000 FLOPs (1000 elements)",high,"Re-benchmarked on c6i.metal with correct input. α_raw=41.4251, overhead=0.3001, weight=41.1250",,41.43,0.0000,N/A,0.0000,"np.sinc(x, out=_out)","x: (10000000,)","[14117551, 30010478, 30010437]",,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L364,moderate,10
+i0,benchmarked,Pointwise Unary,numel(output),16.0000,111.3745,,"16,000 FLOPs (1000 elements)",high,"Re-benchmarked on c6i.metal with correct input. α_raw=111.6746, overhead=0.3001, weight=111.3745",,111.67,0.0000,N/A,0.0000,"np.i0(x, out=_out)","x: (10000000,)","[14117551, 30010478, 30010437]",,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L317,moderate,10
+abs,benchmarked,Pointwise Unary,numel(output),1.0000,0.8690,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.8690,,0.30,0.5277,1.8950,0.0035,"np.abs(x, out=_out)","x: (10000000,)","[14116711, 30009638, 30009597]",103316422,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L249,baseline,10
+negative,benchmarked,Pointwise Unary,numel(output),1.0000,0.8447,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.8447,,0.30,0.5290,1.8904,0.0048,"np.negative(x, out=_out)","x: (10000000,)","[14116711, 30009638, 30009597]",103586777,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L250,baseline,10
+positive,benchmarked,Pointwise Unary,numel(output),1.0000,0.9146,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.9146,,0.30,0.5325,1.8779,0.0038,"np.positive(x, out=_out)","x: (10000000,)","[14116711, 30009638, 30009597]",104261270,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L330,baseline,10
+sqrt,benchmarked,Pointwise Unary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Element-wise square root.,,1.30,0.5197,1.9242,0.0736,"np.sqrt(x, out=_out)","x: (10000000,)","[114116931, 130009638, 130009817]",101749130,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L251,baseline,10
+square,benchmarked,Pointwise Unary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Element-wise x^2.,,1.30,0.5276,1.8954,0.0736,"np.square(x, out=_out)","x: (10000000,)","[114116711, 130009638, 130009597]",103301237,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L252,baseline,10
+reciprocal,benchmarked,Pointwise Unary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Element-wise 1/x.,,1.30,0.5347,1.8702,0.0736,"np.reciprocal(x, out=_out)","x: (10000000,)","[114116711, 130009638, 130009597]",104702018,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L335,baseline,10
+ceil,benchmarked,Pointwise Unary,numel(output),1.0000,0.8783,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.8783,,0.30,0.5289,1.8907,0.0034,"np.ceil(x, out=_out)","x: (10000000,)","[14116711, 30009638, 30009597]",103561020,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L257,baseline,10
+floor,benchmarked,Pointwise Unary,numel(output),1.0000,0.8783,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.8783,,0.30,0.5312,1.8825,0.0032,"np.floor(x, out=_out)","x: (10000000,)","[14116711, 30009638, 30009597]",104004180,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L258,baseline,10
+trunc,benchmarked,Pointwise Unary,numel(output),1.0000,0.8777,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.8777,,0.30,0.5326,1.8776,0.0035,"np.trunc(x, out=_out)","x: (10000000,)","[14116711, 30009638, 30009597]",104286764,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L380,baseline,10
+rint,benchmarked,Pointwise Unary,numel(output),1.0000,0.8722,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.8722,,0.30,0.5293,1.8893,0.0037,"np.rint(x, out=_out)","x: (10000000,)","[14116711, 30009638, 30009597]",103632755,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L336,baseline,10
+sign,benchmarked,Pointwise Unary,numel(output),1.0000,1.0057,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=1.0057,,0.30,0.6025,1.6598,0.0043,"np.sign(x, out=_out)","x: (10000000,)","[14116711, 30009638, 30009597]",117964594,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L256,baseline,10
+signbit,benchmarked,Pointwise Unary,numel(output),1.0000,0.3407,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.3407,,0.30,0.2478,4.0355,0.0057,"np.signbit(x, out=_out)","x: (10000000,)","[14116711, 30009638, 30009597]",48518802,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L363,baseline,10
+fabs,benchmarked,Pointwise Unary,numel(output),1.0000,1.1184,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=1.1184,,0.30,0.9636,1.0378,0.0027,"np.fabs(x, out=_out)","x: (10000000,)","[14116711, 30009638, 30009597]",188667761,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L315,baseline,10
+deg2rad,benchmarked,Pointwise Unary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Alias for radians.,,1.30,0.7330,1.3643,0.0736,"np.deg2rad(x, out=_out)","x: (10000000,)","[114116711, 130009638, 130009597]",143518639,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L311,baseline,10
+rad2deg,benchmarked,Pointwise Unary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Alias for degrees.,,1.30,0.7325,1.3652,0.0736,"np.rad2deg(x, out=_out)","x: (10000000,)","[114116711, 130009638, 130009597]",143427005,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L331,baseline,10
+degrees,benchmarked,Pointwise Unary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Convert radians to degrees element-wise.,,1.30,0.7330,1.3643,0.0736,"np.degrees(x, out=_out)","x: (10000000,)","[114116711, 130009638, 130009597]",143527726,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L312,baseline,10
+radians,benchmarked,Pointwise Unary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Convert degrees to radians element-wise.,,1.30,0.7337,1.3630,0.0736,"np.radians(x, out=_out)","x: (10000000,)","[114116711, 130009638, 130009597]",143647343,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L332,baseline,10
+logical_not,benchmarked,Pointwise Unary,numel(output),1.0000,0.4378,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.4378,,0.30,0.4547,2.1993,0.0044,"np.logical_not(x, out=_out)","x: (10000000,)","[14116711, 30009638, 30009597]",89022638,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L328,baseline,10
+frexp,benchmarked,Pointwise Unary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Decompose x into mantissa and exponent element-wise.,,1.30,1.2268,0.8151,0.0736,np.frexp(x),"x: (10000000,)","[114116711, 130009638, 130009597]",240213718,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L384,baseline,10
+modf,benchmarked,Pointwise Unary,numel(output),1.0000,0.9901,,"1,000 FLOPs (1000 elements)",low,Return fractional and integral parts element-wise.,,1.29,2.0971,0.4768,0.4754,np.modf(x),"x: (10000000,)","[45820141, 129017848, 129909197]",410605164,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L383,baseline,10
+spacing,benchmarked,Pointwise Unary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Return ULP spacing for each element.,,1.30,1.4109,0.7088,0.0736,"np.spacing(x, out=_out)","x: (10000000,)","[114116711, 130009638, 130009597]",276252521,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L378,baseline,10
+nan_to_num,benchmarked,Pointwise Unary,numel(output),1.0000,3.0865,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=3.0865,,0.30,0.0000,N/A,0.0003,"np.nan_to_num(x, out=_out)","x: (10000000,)","[14117551, 30010478, 30010437]",,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L329,baseline,10
+isneginf,benchmarked,Pointwise Unary,numel(output),1.0000,0.8331,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.8331,,0.30,0.7331,1.3641,0.0017,"np.isneginf(x, out=_out)","x: (10000000,)","[14116711, 30009638, 30009597]",143541490,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L323,baseline,10
+isposinf,benchmarked,Pointwise Unary,numel(output),1.0000,0.9379,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.9379,,0.30,0.8106,1.2337,0.0006,"np.isposinf(x, out=_out)","x: (10000000,)","[14116711, 30009638, 30009597]",158722178,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L324,baseline,10
+isclose,benchmarked,Pointwise Unary,numel(output),1.0000,3.0000,,"1,000 FLOPs (1000 elements)",medium,Element-wise approximate equality test.,,3.60,6.5260,0.1532,0.0525,"np.isclose(a, b)","a: (10000000,), b: (10000000,)","[328214641, 360009654, 360009598]",1277784437,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L399,baseline,10
+floor_divide,benchmarked,Pointwise Binary,numel(output),16.0000,3.1888,,"16,000 FLOPs (1000 elements)",medium,Element-wise floor division.,,3.79,9.1220,1.7540,0.0648,"np.floor_divide(a, b, out=_out)","a: (10000000,), b: (10000000,)","[378887531, 360866574, 409984908]",1786073035,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L441,moderate,10
+power,benchmarked,Pointwise Binary,numel(output),16.0000,72.1819,,"16,000 FLOPs (1000 elements)",medium,Element-wise exponentiation x**y.,,72.78,7.4837,2.1380,0.1469,"np.power(a, b, out=_out)","a: (10000000,), b: (10000000,)","[7278198601, 7160009654, 9222808248]",1465298682,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L424,moderate,10
+float_power,benchmarked,Pointwise Binary,numel(output),16.0000,31.1853,,"16,000 FLOPs (1000 elements)",low,Element-wise exponentiation in float64.,,31.79,7.3582,2.1744,0.5060,"np.float_power(a, b, out=_out)","a: (10000000,), b: (10000000,)","[3178534641, 6160009654, 2408550898]",1440712141,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L440,moderate,10
+mod,benchmarked,Pointwise Binary,numel(output),16.0000,0.1821,,"16,000 FLOPs (1000 elements)",low,Element-wise modulo.,,0.78,8.2488,1.9397,0.3057,"np.mod(a, b, out=_out)","a: (10000000,), b: (10000000,)","[78222931, 60009654, 109984908]",1615093752,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L425,moderate,10
+remainder,benchmarked,Pointwise Binary,numel(output),16.0000,0.1821,,"16,000 FLOPs (1000 elements)",low,Element-wise remainder (same as mod).,,0.78,8.2622,1.9365,0.3057,"np.remainder(a, b, out=_out)","a: (10000000,), b: (10000000,)","[78222931, 60009654, 109984908]",1617728761,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L463,moderate,10
+fmod,benchmarked,Pointwise Binary,numel(output),16.0000,5.5996,,"16,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to comparisons). Ratio vs add=5.5996,,0.60,4.6272,3.4578,0.0178,"np.fmod(a, b, out=_out)","a: (10000000,), b: (10000000,)","[28214641, 60009654, 60009598]",905993611,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L444,moderate,10
+arctan2,benchmarked,Pointwise Binary,numel(output),16.0000,53.0000,,"16,000 FLOPs (1000 elements)",high,Element-wise arctan(y/x) considering quadrant.,,53.60,1.2116,13.2057,0.0034,"np.arctan2(a, b, out=_out)","a: (10000000,), b: (10000000,)","[5328214641, 5360009654, 5360009598]",237221062,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L431,moderate,10
+hypot,benchmarked,Pointwise Binary,numel(output),16.0000,10.5006,,"16,000 FLOPs (1000 elements)",high,Element-wise Euclidean norm sqrt(x1^2 + x2^2).,,11.10,7.7522,2.0639,0.0312,"np.hypot(a, b, out=_out)","a: (10000000,), b: (10000000,)","[1051162261, 1110120774, 1110066478]",1517869779,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L449,moderate,10
+logaddexp,benchmarked,Pointwise Binary,numel(output),16.0000,32.5991,,"16,000 FLOPs (1000 elements)",low,log(exp(x1) + exp(x2)) element-wise.,,33.20,13.0729,1.2239,0.4269,"np.logaddexp(a, b, out=_out)","a: (10000000,), b: (10000000,)","[5195291011, 3319914924, 2180741858]",2559639448,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L455,moderate,10
+logaddexp2,benchmarked,Pointwise Binary,numel(output),16.0000,34.0363,,"16,000 FLOPs (1000 elements)",low,log2(2**x1 + 2**x2) element-wise.,,34.64,12.8104,1.2490,0.4557,"np.logaddexp2(a, b, out=_out)","a: (10000000,), b: (10000000,)","[5159803631, 3463642594, 1949649478]",2508251979,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L456,moderate,10
+matvec,benchmarked,Pointwise Binary,output_size * contracted_axis,1.0000,0.5551,,"1,000 FLOPs (C=1000)",,EC2 timing = 0.56. BLAS matrix-vector product — efficient.,,0.00,0.0000,N/A,N/A,,,,,,baseline,
+vecmat,benchmarked,Pointwise Binary,output_size * contracted_axis,1.0000,0.6085,,"1,000 FLOPs (C=1000)",,EC2 timing = 0.61. BLAS vector-matrix product — efficient.,,0.00,0.0000,N/A,N/A,,,,,,baseline,
+add,benchmarked,Pointwise Binary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Element-wise addition.,,1.60,0.9643,1.0370,0.1229,"np.add(a, b, out=_out)","a: (10000000,), b: (10000000,)","[128214641, 160009654, 160009598]",188798220,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L418,baseline,10
+subtract,benchmarked,Pointwise Binary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Element-wise subtraction.,,1.60,0.9571,1.0448,0.1229,"np.subtract(a, b, out=_out)","a: (10000000,), b: (10000000,)","[128214641, 160009654, 160009598]",187388223,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L419,baseline,10
+multiply,benchmarked,Pointwise Binary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Element-wise multiplication.,,1.60,0.9532,1.0491,0.1229,"np.multiply(a, b, out=_out)","a: (10000000,), b: (10000000,)","[128214641, 160009654, 160009598]",186631919,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L420,baseline,10
+divide,benchmarked,Pointwise Binary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Element-wise true division.,,1.60,1.0455,0.9565,0.1229,"np.divide(a, b, out=_out)","a: (10000000,), b: (10000000,)","[128214641, 160009654, 160009598]",204700030,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L421,baseline,10
+true_divide,benchmarked,Pointwise Binary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Element-wise true division (explicit).,,1.60,1.0398,0.9617,0.1229,"np.true_divide(a, b, out=_out)","a: (10000000,), b: (10000000,)","[128214641, 160009654, 160009598]",203585149,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L465,baseline,10
+maximum,benchmarked,Pointwise Binary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Element-wise maximum (propagates NaN).,,1.60,0.7762,1.2883,0.1229,"np.maximum(a, b, out=_out)","a: (10000000,), b: (10000000,)","[128214641, 160009654, 160009598]",151980827,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L422,baseline,10
+minimum,benchmarked,Pointwise Binary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Element-wise minimum (propagates NaN).,,1.60,0.7716,1.2960,0.1229,"np.minimum(a, b, out=_out)","a: (10000000,), b: (10000000,)","[128214641, 160009654, 160009598]",151072638,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L423,baseline,10
+fmax,benchmarked,Pointwise Binary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Element-wise maximum ignoring NaN.,,1.60,0.7759,1.2888,0.1229,"np.fmax(a, b, out=_out)","a: (10000000,), b: (10000000,)","[128214641, 160009654, 160009598]",151911295,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L442,baseline,10
+fmin,benchmarked,Pointwise Binary,numel(output),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Element-wise minimum ignoring NaN.,,1.60,0.7727,1.2942,0.1229,"np.fmin(a, b, out=_out)","a: (10000000,), b: (10000000,)","[128214641, 160009654, 160009598]",151296431,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L443,baseline,10
+greater,benchmarked,Pointwise Binary,numel(output),1.0000,0.5759,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to comparisons). Ratio vs add=0.5759,,0.60,0.5154,1.9402,0.0029,"np.greater(a, b, out=_out)","a: (10000000,), b: (10000000,)","[28214641, 60009654, 60009598]",100907203,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L446,baseline,10
+greater_equal,benchmarked,Pointwise Binary,numel(output),1.0000,0.5734,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to comparisons). Ratio vs add=0.5734,,0.60,0.5117,1.9543,0.0032,"np.greater_equal(a, b, out=_out)","a: (10000000,), b: (10000000,)","[28214641, 60009654, 60009598]",100183803,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L447,baseline,10
+less,benchmarked,Pointwise Binary,numel(output),1.0000,0.5761,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to comparisons). Ratio vs add=0.5761,,0.60,0.5138,1.9463,0.0031,"np.less(a, b, out=_out)","a: (10000000,), b: (10000000,)","[28214641, 60009654, 60009598]",100603291,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L453,baseline,10
+less_equal,benchmarked,Pointwise Binary,numel(output),1.0000,0.5745,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to comparisons). Ratio vs add=0.5745,,0.60,0.5123,1.9520,0.0027,"np.less_equal(a, b, out=_out)","a: (10000000,), b: (10000000,)","[28214641, 60009654, 60009598]",100304307,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L454,baseline,10
+equal,benchmarked,Pointwise Binary,numel(output),1.0000,0.5761,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to comparisons). Ratio vs add=0.5761,,0.60,0.5155,1.9399,0.0027,"np.equal(a, b, out=_out)","a: (10000000,), b: (10000000,)","[28214641, 60009654, 60009598]",100940561,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L439,baseline,10
+not_equal,benchmarked,Pointwise Binary,numel(output),1.0000,0.5736,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to comparisons). Ratio vs add=0.5736,,0.60,0.5113,1.9558,0.0033,"np.not_equal(a, b, out=_out)","a: (10000000,), b: (10000000,)","[28214641, 60009654, 60009598]",100104460,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L461,baseline,10
+logical_and,benchmarked,Pointwise Binary,numel(output),1.0000,0.8026,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to comparisons). Ratio vs add=0.8026,,0.60,0.7405,1.3504,0.0031,"np.logical_and(a, b, out=_out)","a: (10000000,), b: (10000000,)","[28214641, 60009654, 60009598]",144988484,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L457,baseline,10
+logical_or,benchmarked,Pointwise Binary,numel(output),1.0000,0.7986,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to comparisons). Ratio vs add=0.7986,,0.60,0.7391,1.3530,0.0034,"np.logical_or(a, b, out=_out)","a: (10000000,), b: (10000000,)","[28214641, 60009654, 60009598]",144717490,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L458,baseline,10
+logical_xor,benchmarked,Pointwise Binary,numel(output),1.0000,0.8007,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to comparisons). Ratio vs add=0.8007,,0.60,0.7498,1.3337,0.0031,"np.logical_xor(a, b, out=_out)","a: (10000000,), b: (10000000,)","[28214641, 60009654, 60009598]",146812920,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L459,baseline,10
+copysign,benchmarked,Pointwise Binary,numel(output),1.0000,1.1021,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to comparisons). Ratio vs add=1.1021,,0.60,0.7209,1.3872,0.0011,"np.copysign(a, b, out=_out)","a: (10000000,), b: (10000000,)","[28214641, 60009654, 60009598]",141157127,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L438,baseline,10
+nextafter,benchmarked,Pointwise Binary,numel(output),1.0000,5.7999,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=5.7999,,0.60,5.7999,0.1724,0.3715,"np.nextafter(a, b, out=_out)","a: (10000000,), b: (10000000,)","[28214641, 60009654, 60009598]",1135600279,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L460,baseline,10
+ldexp,benchmarked,Pointwise Binary,numel(output),1.0000,3.3667,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to comparisons). Ratio vs add=3.3667,,0.60,0.0000,N/A,0.0014,"np.ldexp(a, b, out=_out)","a: (10000000,), b: (10000000,)","[28215481, 60010494, 60010438]",,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L451,baseline,10
+heaviside,benchmarked,Pointwise Binary,numel(output),1.0000,1.3916,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to comparisons). Ratio vs add=1.3916,,0.30,1.3789,0.7252,0.0015,"np.heaviside(x, 0.5)","x: (10000000,), h=0.5","[14116734, 30009661, 30009620]",269979729,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L448,baseline,10
+std,benchmarked,Reductions,numel(input),2.0000,4.0000,,"2,000 FLOPs (1000 elements)",high,Standard deviation; cost_multiplier=2 (two passes).,,4.30,1.6020,1.2484,0.0216,np.std(x),"x: (10000000,)","[414116751, 430009678, 430009637]",313671080,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L533,moderate,10
+var,benchmarked,Reductions,numel(input),2.0000,4.0000,,"2,000 FLOPs (1000 elements)",high,Variance; cost_multiplier=2 (two passes).,,4.30,1.6012,1.2491,0.0216,np.var(x),"x: (10000000,)","[414116731, 430009658, 430009617]",313505568,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L534,moderate,10
+nanstd,benchmarked,Reductions,numel(input),2.0000,4.0000,,"2,000 FLOPs (1000 elements)",high,Standard deviation ignoring NaNs.,,4.30,3.1232,0.6404,0.0216,np.nanstd(x),"x: (10000000,)","[414116751, 430009678, 430009637]",611516405,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L564,moderate,10
+nanvar,benchmarked,Reductions,numel(input),2.0000,4.0000,,"2,000 FLOPs (1000 elements)",high,Variance ignoring NaNs.,,4.30,3.0977,0.6456,0.0216,np.nanvar(x),"x: (10000000,)","[414116731, 430009658, 430009617]",606531077,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L566,moderate,10
+sum,benchmarked,Reductions,numel(input),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Sum of array elements.,,1.30,0.2440,4.0984,0.0736,np.sum(x),"x: (10000000,)","[114116711, 130009638, 130009597]",47773697,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L528,baseline,10
+prod,benchmarked,Reductions,numel(input),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Product of array elements.,,1.30,0.6193,1.6147,0.0736,np.prod(x),"x: (10000000,)","[114116711, 130009875, 130009834]",121250152,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L531,baseline,10
+mean,benchmarked,Reductions,numel(input),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Arithmetic mean of array elements.,,1.30,0.2447,4.0866,0.0736,np.mean(x),"x: (10000000,)","[114116721, 130009648, 130009607]",47907808,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L532,baseline,10
+max,benchmarked,Reductions,numel(input),1.0000,1.0010,,"1,000 FLOPs (1000 elements)",medium,Maximum value of array.,,1.30,0.2070,4.8309,0.0735,np.max(x),"x: (10000000,)","[114214381, 130107308, 130107267]",40537906,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L529,baseline,10
+min,benchmarked,Reductions,numel(input),1.0000,1.0010,,"1,000 FLOPs (1000 elements)",medium,Minimum value of array.,,1.30,0.2073,4.8239,0.0735,np.min(x),"x: (10000000,)","[114214381, 130107308, 130107267]",40586751,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L530,baseline,10
+argmax,benchmarked,Reductions,numel(input),1.0000,0.2320,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=0.2320,,0.30,0.2320,4.3103,0.3713,np.argmax(x),"x: (10000000,)","[14116711, 30009638, 30009597]",45416961,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L535,baseline,10
+argmin,benchmarked,Reductions,numel(input),1.0000,0.2313,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=0.2313,,0.30,0.2313,4.3234,0.3713,np.argmin(x),"x: (10000000,)","[14116711, 30009638, 30009597]",45292423,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L536,baseline,10
+any,benchmarked,Reductions,numel(input),1.0000,0.2513,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=0.2513,,0.30,0.2513,3.9793,0.3713,np.any(x),"x: (10000000,)","[14116711, 30009638, 30009597]",49205904,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L547,baseline,10
+all,benchmarked,Reductions,numel(input),1.0000,0.2525,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=0.2525,,0.30,0.2525,3.9604,0.3713,np.all(x),"x: (10000000,)","[14116711, 30009638, 30009597]",49448065,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L544,baseline,10
+cumsum,benchmarked,Reductions,numel(input),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Cumulative sum of array elements.,,1.30,1.3315,0.7510,0.0736,"np.cumsum(x, out=_out)","x: (10000000,)","[114116701, 130009628, 130009587]",260710434,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L537,baseline,10
+cumprod,benchmarked,Reductions,numel(input),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Cumulative product of array elements.,,1.30,1.3316,0.7510,0.0736,"np.cumprod(x, out=_out)","x: (10000000,)","[114116701, 130009865, 130009824]",260723936,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L538,baseline,10
+nansum,benchmarked,Reductions,numel(input),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Sum ignoring NaNs.,,1.30,1.4399,0.6945,0.0736,np.nansum(x),"x: (10000000,)","[114116711, 130009638, 130009597]",281922550,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L565,baseline,10
+nanmean,benchmarked,Reductions,numel(input),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Mean ignoring NaNs.,,1.30,1.8008,0.5553,0.0736,np.nanmean(x),"x: (10000000,)","[114116721, 130009648, 130009607]",352589356,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L558,baseline,10
+nanmax,benchmarked,Reductions,numel(input),1.0000,1.0010,,"1,000 FLOPs (1000 elements)",medium,Maximum ignoring NaNs.,,1.30,0.2130,4.6948,0.0735,np.nanmax(x),"x: (10000000,)","[114214381, 130107308, 130107267]",41712910,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L557,baseline,10
+nanmin,benchmarked,Reductions,numel(input),1.0000,1.0010,,"1,000 FLOPs (1000 elements)",medium,Minimum ignoring NaNs.,,1.30,0.2122,4.7125,0.0735,np.nanmin(x),"x: (10000000,)","[114214381, 130107308, 130107267]",41553113,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L560,baseline,10
+nanprod,benchmarked,Reductions,numel(input),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Product ignoring NaNs.,,1.30,1.8246,0.5481,0.0736,np.nanprod(x),"x: (10000000,)","[114116711, 130009875, 130009834]",357257013,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L562,baseline,10
+median,benchmarked,Reductions,numel(input),1.0000,5.3855,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=5.3855,,0.30,5.3855,0.1857,0.3713,np.median(x),"x: (10000000,)","[14117754, 30010681, 30010640]",1054477424,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L552,baseline,10
+nanmedian,benchmarked,Reductions,numel(input),1.0000,5.7796,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=5.7796,,0.30,5.7796,0.1730,0.3713,np.nanmedian(x),"x: (10000000,)","[14117754, 30010681, 30010640]",1131629455,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L559,baseline,10
+percentile,benchmarked,Reductions,numel(input),1.0000,6.5693,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=6.5693,,0.30,6.5693,0.1522,0.3713,"np.percentile(x, 50)","x: (10000000,)","[14117371, 30010298, 30010257]",1286250757,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L567,baseline,10
+nanpercentile,benchmarked,Reductions,numel(input),1.0000,6.9821,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=6.9821,,0.30,6.9821,0.1432,0.3713,"np.nanpercentile(x, 50)","x: (10000000,)","[14117371, 30010298, 30010257]",1367086667,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L561,baseline,10
+quantile,benchmarked,Reductions,numel(input),1.0000,6.5837,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=6.5837,,0.30,6.5837,0.1519,0.3713,"np.quantile(x, 0.5)","x: (10000000,)","[14117384, 30010311, 30010270]",1289068257,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L568,baseline,10
+nanquantile,benchmarked,Reductions,numel(input),1.0000,6.9870,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=6.9870,,0.30,6.9870,0.1431,0.3713,"np.nanquantile(x, 0.5)","x: (10000000,)","[14117384, 30010311, 30010270]",1368029249,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L563,baseline,10
+count_nonzero,benchmarked,Reductions,numel(input),1.0000,0.7773,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=0.7773,,0.30,0.7773,1.2865,0.3713,np.count_nonzero(x),"x: (10000000,)","[14116711, 30009638, 30009597]",152201477,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L549,baseline,10
+average,benchmarked,Reductions,numel(input),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Weighted average of array elements.,,1.30,0.2450,4.0816,0.0736,np.average(x),"x: (10000000,)","[114116731, 130009658, 130009617]",47963189,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L548,baseline,10
+nanargmax,benchmarked,Reductions,numel(input),1.0000,1.4897,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=1.4897,,0.30,1.4897,0.6713,0.3713,np.nanargmax(x),"x: (10000000,)","[14116711, 30009638, 30009597]",291681598,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L553,baseline,10
+nanargmin,benchmarked,Reductions,numel(input),1.0000,1.4777,,"1,000 FLOPs (1000 elements)",low,Timing-based weight (fp_arith_inst_retired blind to this op). Ratio vs add=1.4777,,0.30,1.4777,0.6767,0.3713,np.nanargmin(x),"x: (10000000,)","[14116711, 30009638, 30009597]",289322396,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L554,baseline,10
+ptp,benchmarked,Reductions,numel(input),1.0000,2.0020,,"1,000 FLOPs (1000 elements)",high,Peak-to-peak (max - min) range of array.,,2.30,0.3969,2.5195,0.0408,np.ptp(x),"x: (10000000,)","[214312061, 230204988, 230204947]",77708606,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L581,baseline,10
+nancumprod,benchmarked,Reductions,numel(input),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Cumulative product ignoring NaNs.,,1.30,2.5619,0.3903,0.0736,"np.nancumprod(x, out=_out)","x: (10000000,)","[114116701, 130009865, 130009824]",501619878,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L555,baseline,10
+nancumsum,benchmarked,Reductions,numel(input),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Cumulative sum ignoring NaNs.,,1.30,2.5711,0.3889,0.0736,"np.nancumsum(x, out=_out)","x: (10000000,)","[114116701, 130009628, 130009587]",503422485,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L556,baseline,10
+cumulative_sum,benchmarked,Reductions,numel(input),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Cumulative sum (NumPy 2.x array API).,,1.30,1.3312,0.7512,0.0736,"np.cumulative_sum(x, out=_out)","x: (10000000,)","[114116701, 130009628, 130009587]",260647988,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L551,baseline,10
+cumulative_prod,benchmarked,Reductions,numel(input),1.0000,1.0000,,"1,000 FLOPs (1000 elements)",medium,Cumulative product (NumPy 2.x array API).,,1.30,1.3317,0.7509,0.0736,"np.cumulative_prod(x, out=_out)","x: (10000000,)","[114116701, 130009865, 130009824]",260737404,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L550,baseline,10
+sort,benchmarked,Sorting,n * ceil(log2(n)),1.0000,4.0363,,"10,000 FLOPs (1000 elements, C=10000)",medium,Comparison sort; cost = n*ceil(log2(n)) per slice.,,4.04,0.1984,5.0403,0.0548,np.sort(x),"x: (10000000,)","[8800112491, 9687149969, 9698011109]",932432777,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L43,baseline,10
+argsort,benchmarked,Sorting,n * ceil(log2(n)),1.0000,4.8736,,"10,000 FLOPs (1000 elements, C=10000)",high,Indirect sort; cost = n*ceil(log2(n)) per slice.,,4.87,0.4263,2.3458,0.0381,np.argsort(x),"x: (10000000,)","[10949422051, 11696586249, 11713083429]",2003017675,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L62,baseline,10
+lexsort,benchmarked,Sorting,k * n * ceil(log2(n)),1.0000,0.3723,,"10,000 FLOPs (1000 elements, C=10000)",low,Multi-key sort; cost = k*n*ceil(log2(n)).,,0.37,0.0429,23.3100,0.8457,"np.lexsort((x, y))","x: (10000000,), y: (10000000,), k=2","[28214641, 1786878565, 1786878565]",402915554,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L88,baseline,10
+partition,benchmarked,Sorting,n,1.0000,4.4268,,"1,000 FLOPs (1000 elements)",medium,Quickselect; cost = n per slice.,,4.43,1.7653,0.5665,0.0947,"np.partition(x, 5000000)","x: (10000000,), kth=5000000","[453953791, 379247516, 442683608]",345650682,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L113,baseline,10
+argpartition,benchmarked,Sorting,n * len(kth),1.0000,4.6015,,"1,000 FLOPs (C=1000)",medium,Indirect partition; cost = n per slice.,,4.60,2.7384,0.3652,0.0889,"np.argpartition(x, 5000000)","x: (10000000,), kth=5000000","[449292471, 460154256, 527919708]",536172646,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L140,baseline,10
+searchsorted,benchmarked,Sorting,m * ceil(log2(n)),1.0000,0.7445,,"10,000 FLOPs (1000 elements, C=10000)",low,Binary search; cost = m*ceil(log2(n)).,,0.74,0.8573,1.1665,0.3402,"np.searchsorted(x, q)","x: (10000000,), q: (10000000,)","[906814219, 1786878565, 1786878565]",4028499025,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L170,baseline,10
+unique,benchmarked,Sorting,n * ceil(log2(n)),1.0000,4.0363,,"10,000 FLOPs (1000 elements, C=10000)",medium,Sort-based unique; cost = n*ceil(log2(n)).,,4.04,0.2684,3.7258,0.0548,np.unique(x),"x: (10000000,)","[8800112491, 9687149969, 9698011109]",1261458337,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L231,baseline,10
+in1d,benchmarked,Sorting,(n+m) * ceil(log2(n+m)),1.0000,4.2770,,"10,000 FLOPs (1000 elements, C=10000)",high,Set membership; cost = (n+m)*ceil(log2(n+m)).,,4.28,0.8495,1.1772,0.0459,"np.in1d(a, b)","a: (10000000,), b: (10000000,)","[19741640021, 21385183045, 21412541365]",8316520216,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L317,baseline,10
+isin,benchmarked,Sorting,(n+m) * ceil(log2(n+m)),1.0000,4.2770,,"10,000 FLOPs (1000 elements, C=10000)",high,Set membership; cost = (n+m)*ceil(log2(n+m)).,,4.28,0.8518,1.1740,0.0459,"np.isin(a, b)","a: (10000000,), b: (10000000,)","[19741639801, 21385182825, 21412541145]",8339184342,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L330,baseline,10
+intersect1d,benchmarked,Sorting,(n+m) * ceil(log2(n+m)),1.0000,7.7863,,"10,000 FLOPs (1000 elements, C=10000)",high,Set intersection; cost = (n+m)*ceil(log2(n+m)).,,7.79,0.4893,2.0437,0.0312,"np.intersect1d(a, b)","a: (10000000,), b: (10000000,)","[36872420621, 38931661325, 38953383605]",4790456196,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L344,baseline,10
+setdiff1d,benchmarked,Sorting,(n+m) * ceil(log2(n+m)),1.0000,3.8751,,"10,000 FLOPs (1000 elements, C=10000)",medium,Set difference; cost = (n+m)*ceil(log2(n+m)).,,3.88,0.6161,1.6231,0.0551,"np.setdiff1d(a, b)","a: (10000000,), b: (10000000,)","[17592330241, 19375746545, 19397468825]",6031745431,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L376,baseline,10
+setxor1d,benchmarked,Sorting,(n+m) * ceil(log2(n+m)),1.0000,7.7863,,"10,000 FLOPs (1000 elements, C=10000)",high,Symmetric set difference; cost = (n+m)*ceil(log2(n+m)).,,7.79,0.5430,1.8416,0.0312,"np.setxor1d(a, b)","a: (10000000,), b: (10000000,)","[36872420621, 38931661325, 38953383605]",5316218585,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L393,baseline,10
+union1d,benchmarked,Sorting,(n+m) * ceil(log2(n+m)),1.0000,4.2686,,"10,000 FLOPs (1000 elements, C=10000)",medium,Set union; cost = (n+m)*ceil(log2(n+m)).,,4.27,0.3263,3.0647,0.1077,"np.union1d(a, b)","a: (10000000,), b: (10000000,)","[18036303441, 21342793965, 22232929825]",3194255931,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L361,baseline,10
+unique_all,benchmarked,Sorting,n * ceil(log2(n)),1.0000,0.3720,,"10,000 FLOPs (1000 elements, C=10000)",low,Sort-based unique; cost = n*ceil(log2(n)).,,0.37,0.5672,1.7630,0.8456,np.unique_all(x),"x: (10000000,)","[14116721, 892716299, 892716299]",2665501291,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L243,baseline,10
+unique_counts,benchmarked,Sorting,n * ceil(log2(n)),1.0000,4.0363,,"10,000 FLOPs (1000 elements, C=10000)",medium,Sort-based unique; cost = n*ceil(log2(n)).,,4.04,0.3764,2.6567,0.0548,np.unique_counts(x),"x: (10000000,)","[8800112501, 9687149979, 9698011119]",1768893671,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L256,baseline,10
+unique_inverse,benchmarked,Sorting,n * ceil(log2(n)),1.0000,4.8736,,"10,000 FLOPs (1000 elements, C=10000)",high,Sort-based unique; cost = n*ceil(log2(n)).,,4.87,0.7716,1.2960,0.0381,np.unique_inverse(x),"x: (10000000,)","[10949422051, 11696586249, 11713083429]",3625691674,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L272,baseline,10
+unique_values,benchmarked,Sorting,n * ceil(log2(n)),1.0000,4.0363,,"10,000 FLOPs (1000 elements, C=10000)",medium,Sort-based unique; cost = n*ceil(log2(n)).,,4.04,0.2693,3.7133,0.0548,np.unique_values(x),"x: (10000000,)","[8800112491, 9687149969, 9698011109]",1265690087,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L288,baseline,10
+fft.fft,benchmarked,FFT,5*n*ceil(log2(n)),1.0000,0.8404,,"10,000 FLOPs (1000 elements, C=10000)",medium,1-D complex FFT. Cost: 5*n*ceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).,,0.84,0.1623,6.1614,0.0562,np.fft.fft(x),"x: (1048576,)","[879517872, 968943262, 881183625]",333239070,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L173,baseline,10
+fft.ifft,benchmarked,FFT,5*n*ceil(log2(n)),1.0000,1.3274,,"10,000 FLOPs (1000 elements, C=10000)",high,Inverse 1-D complex FFT. Cost: 5*n*ceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).,,1.33,0.1300,7.6923,0.0289,np.fft.ifft(x),"x: (1048576,)","[1388587884, 1460999289, 1391915176]",266861733,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L189,baseline,10
+fft.rfft,benchmarked,FFT,5*(n/2)*ceil(log2(n)),1.0000,0.8288,,"10,000 FLOPs (1000 elements, C=10000)",medium,1-D real FFT. Cost: 5*(n//2)*ceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).,,0.83,0.1387,7.2098,0.1104,np.fft.rfft(x),"x: (1048576,)","[432875462, 522300852, 434541215]",142425342,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L205,baseline,10
+fft.irfft,benchmarked,FFT,5*(n/2)*ceil(log2(n)),1.0000,0.9466,,"10,000 FLOPs (1000 elements, C=10000)",high,Inverse 1-D real FFT. Cost: 5*(n//2)*ceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).,,0.95,0.1507,6.6357,0.0017,np.fft.irfft(x),"x: (1048576,)","[495237927, 496903680, 496284085]",154652093,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L221,baseline,10
+fft.fft2,benchmarked,FFT,5*n*ceil(log2(n)),1.0000,0.7183,,"10,000 FLOPs (1000 elements, C=10000)",medium,"2-D complex FFT. Cost: 5*N*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).",,0.72,0.0802,12.4688,0.0654,np.fft.fft2(x),"x: (1024,1024)","[751501532, 840926922, 753167285]",164672547,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L242,baseline,10
+fft.ifft2,benchmarked,FFT,5*n*ceil(log2(n)),1.0000,0.7693,,"10,000 FLOPs (1000 elements, C=10000)",high,"Inverse 2-D complex FFT. Cost: 5*N*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).",,0.77,0.0776,12.8866,0.0493,np.fft.ifft2(x),"x: (1024,1024)","[803317434, 875728839, 806644726]",159394671,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L265,baseline,10
+fft.rfft2,benchmarked,FFT,5*(n/2)*ceil(log2(n)),1.0000,0.7013,,"10,000 FLOPs (1000 elements, C=10000)",medium,"2-D real FFT. Cost: 5*(N//2)*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).",,0.70,0.0675,14.8148,0.1290,np.fft.rfft2(x),"x: (1024,1024)","[366041252, 455466642, 367707005]",69317534,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L288,baseline,10
+fft.irfft2,benchmarked,FFT,5*(n/2)*ceil(log2(n)),1.0000,0.8267,,"10,000 FLOPs (1000 elements, C=10000)",high,"Inverse 2-D real FFT. Cost: 5*(N//2)*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).",,0.83,0.0710,14.0845,0.0019,np.fft.irfft2(x),"x: (1024,1024)","[432364696, 434030449, 433410854]",72869688,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L314,baseline,10
+fft.fftn,benchmarked,FFT,5*n*ceil(log2(n)),1.0000,0.7183,,"10,000 FLOPs (1000 elements, C=10000)",medium,"N-D complex FFT. Cost: 5*N*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).",,0.72,0.0820,12.1951,0.0654,np.fft.fftn(x),"x: (1024,1024)","[751501532, 840926922, 753167285]",168435361,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L339,baseline,10
+fft.ifftn,benchmarked,FFT,5*n*ceil(log2(n)),1.0000,0.7693,,"10,000 FLOPs (1000 elements, C=10000)",high,"Inverse N-D complex FFT. Cost: 5*N*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).",,0.77,0.0856,11.6822,0.0493,np.fft.ifftn(x),"x: (1024,1024)","[803317434, 875728839, 806644726]",175707140,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L363,baseline,10
+fft.rfftn,benchmarked,FFT,5*(n/2)*ceil(log2(n)),1.0000,0.7013,,"10,000 FLOPs (1000 elements, C=10000)",medium,"N-D real FFT. Cost: 5*(N//2)*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).",,0.70,0.0668,14.9701,0.1290,np.fft.rfftn(x),"x: (1024,1024)","[366041252, 455466642, 367707005]",68526092,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L387,baseline,10
+fft.irfftn,benchmarked,FFT,5*(n/2)*ceil(log2(n)),1.0000,0.8267,,"10,000 FLOPs (1000 elements, C=10000)",high,"Inverse N-D real FFT. Cost: 5*(N//2)*ceil(log2(N)), N=prod(s) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).",,0.83,0.0708,14.1243,0.0019,np.fft.irfftn(x),"x: (1024,1024)","[432364696, 434030449, 433410854]",72720975,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L423,baseline,10
+fft.hfft,benchmarked,FFT,5*n*ceil(log2(n)),1.0000,2.2743,,"10,000 FLOPs (1000 elements, C=10000)",high,FFT of Hermitian-symmetric signal. Cost: 5*n_out*ceil(log2(n_out)) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).,,2.27,0.3634,2.7518,0.0170,np.fft.hfft(x),"x: (1048576,)","[2381467114, 2453878519, 2384794406]",746112380,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L443,baseline,10
+fft.ihfft,benchmarked,FFT,5*(n/2)*ceil(log2(n)),1.0000,0.4244,,"10,000 FLOPs (1000 elements, C=10000)",medium,Inverse FFT of Hermitian signal. Cost: 5*n*ceil(log2(n)) (Cooley-Tukey radix-2; Van Loan 1992 §1.4).,,0.42,0.0722,13.8504,0.1080,np.fft.ihfft(x),"x: (1048576,)","[443361242, 532786632, 445026995]",148207455,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/fft/_transforms.py#L462,baseline,10
+fft.fftfreq,benchmarked,FFT,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+fft.fftshift,benchmarked,FFT,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+fft.ifftshift,benchmarked,FFT,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+fft.rfftfreq,benchmarked,FFT,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+linalg.cholesky,benchmarked,Linalg,n^3,4.0000,0.5350,,"131,072 FLOPs (n=32, C=32768)",high,Cholesky decomposition. Cost: $n^3$.,,0.54,0.0346,115.6069,0.0002,np.linalg.cholesky(A),"A: (1024,1024)","[5745012772, 5746678587, 5745012772]",728009826,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_decompositions.py#L45,moderate,10
+linalg.qr,benchmarked,Linalg,"m*n*min(m,n)",4.0000,2.7316,,"4,000 FLOPs (C=1000)",high,"QR decomposition. Cost: $m \cdot n \cdot \min(m,n)$.",,2.73,0.4927,8.1185,0.0413,np.linalg.qr(A),"A: (1024,1024)","[29327982061, 29330079463, 31476590935]",10358642929,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_decompositions.py#L83,moderate,10
+linalg.eig,benchmarked,Linalg,n^3,4.0000,14.5964,,"131,072 FLOPs (n=32, C=32768)",medium,Eigendecomposition. Cost: $n^3$.,,14.60,1.7472,2.2894,0.1273,np.linalg.eig(A),"A: (1024,1024)","[163560804541, 156727584723, 127741075235]",36732097538,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_decompositions.py#L119,moderate,10
+linalg.eigh,benchmarked,Linalg,n^3,4.0000,4.6253,,"131,072 FLOPs (n=32, C=32768)",high,Symmetric eigendecomposition. Cost: $n^3$.,,4.63,0.6022,6.6423,0.0050,np.linalg.eigh(A),"A: (1024,1024)","[49795457031, 49311418466, 49663612761]",12659651127,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_decompositions.py#L155,moderate,10
+linalg.eigvals,benchmarked,Linalg,n^3,4.0000,7.0728,,"131,072 FLOPs (n=32, C=32768)",medium,Eigenvalues only. Cost: $n^3$.,,7.07,0.8645,4.6270,0.0550,np.linalg.eigvals(A),"A: (1024,1024)","[79645804781, 75943243603, 71340451775]",18175664749,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_decompositions.py#L192,moderate,10
+linalg.eigvalsh,benchmarked,Linalg,n^3,4.0000,1.5505,,"131,072 FLOPs (n=32, C=32768)",high,Symmetric eigenvalues. Cost: $n^3$.,,1.55,0.1505,26.5781,0.0002,np.linalg.eigvalsh(A),"A: (1024,1024)","[16649561681, 16648400766, 16644603561]",3164416648,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_decompositions.py#L228,moderate,10
+linalg.svd,benchmarked,Linalg,"m*n*min(m,n)",4.0000,8.9457,,"4,000 FLOPs (C=1000)",medium,"Singular value decomposition; cost ~ O(min(m,n)*m*n).",,8.95,1.1376,3.5162,0.0840,np.linalg.svd(A),"A: (1024,1024)","[96054010861, 96544297033, 82943736995]",23915836847,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_svd.py#L67,moderate,10
+linalg.svdvals,benchmarked,Linalg,"m*n*min(m,n)",4.0000,2.8094,,"4,000 FLOPs (C=1000)",high,"Singular values only. Cost: m*n*min(m,n) (Golub-Reinsch).",,2.81,0.4127,9.6923,0.0384,np.linalg.svdvals(A),"A: (1024,1024)","[30120401961, 30165253113, 32191919285]",8675713772,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_decompositions.py#L274,moderate,10
+linalg.solve,benchmarked,Linalg,n^3,4.0000,0.6690,,"131,072 FLOPs (n=32, C=32768)",medium,Solve Ax=b. Cost: $n^3$.,,0.67,0.0536,74.6269,0.1570,"np.linalg.solve(A, b)","A: (1024,1024), b: (1024,)","[7180789151, 7182886303, 9329398175]",1125862911,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_solvers.py#L50,moderate,10
+linalg.inv,benchmarked,Linalg,n^3,4.0000,2.0003,,"131,072 FLOPs (n=32, C=32768)",medium,Matrix inverse. Cost: $n^3$ (LU + solve).,,2.00,0.1887,21.1977,0.0559,np.linalg.inv(A),"A: (1024,1024)","[21476382111, 21478479263, 23624991135]",3967030675,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_solvers.py#L92,moderate,10
+linalg.lstsq,benchmarked,Linalg,"m*n*min(m,n)",4.0000,2.9676,,"4,000 FLOPs (C=1000)",high,"Least squares. Cost: m*n*min(m,n) (LAPACK gelsd/SVD).",,2.97,0.4302,9.2980,0.0249,"np.linalg.lstsq(A, b, rcond=None)","A: (1024,1024), b: (1024,)","[31823631007, 31864008989, 33236367561]",9045316164,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_solvers.py#L138,moderate,10
+linalg.pinv,benchmarked,Linalg,"m*n*min(m,n)",4.0000,10.9467,,"4,000 FLOPs (C=1000)",medium,"Pseudoinverse. Cost: m*n*min(m,n) (via SVD).",,10.95,2.6041,1.5360,0.0681,np.linalg.pinv(A),"A: (1024,1024)","[117539353661, 118029639833, 104429079795]",54747510933,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_solvers.py#L178,moderate,10
+linalg.det,benchmarked,Linalg,n^3,4.0000,0.6670,,"131,072 FLOPs (n=32, C=32768)",medium,Determinant. Cost: $n^3$.,,0.67,0.0533,75.0469,0.1574,np.linalg.det(A),"A: (1024,1024)","[7160063645, 7162160797, 9308673455]",1120538106,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_properties.py#L84,moderate,10
+linalg.slogdet,benchmarked,Linalg,n^3,4.0000,0.6670,,"131,072 FLOPs (n=32, C=32768)",medium,Sign + log determinant. Cost: $n^3$.,,0.67,0.0533,75.0469,0.1574,np.linalg.slogdet(A),"A: (1024,1024)","[7160063391, 7162160543, 9308673435]",1120742184,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_properties.py#L123,moderate,10
+linalg.cond,benchmarked,Linalg Delegates,"m*n*min(m,n)",4.0000,2.9318,,"4,000 FLOPs (C=1000)",high,"Condition number. Cost: m*n*min(m,n) (via SVD).",,2.93,0.4371,9.1512,0.0017,np.linalg.cond(A),"A: (512,512)","[3934113497, 3934929460, 3946132305]",1148677874,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_properties.py#L339,moderate,10
+linalg.matrix_rank,benchmarked,Linalg Delegates,"m*n*min(m,n)",4.0000,2.9318,,"4,000 FLOPs (C=1000)",high,"Matrix rank. Cost: m*n*min(m,n) (via SVD).",,2.93,0.4377,9.1387,0.0017,np.linalg.matrix_rank(A),"A: (512,512)","[3934118703, 3934934666, 3946137511]",1150307726,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_properties.py#L383,moderate,10
+linalg.tensorinv,benchmarked,Linalg Delegates,n^3 (delegates to inv),4.0000,2.2304,,"131,072 FLOPs (n=32, C=32768)",high,Weight=4 (same as linalg.inv). Reshapes to 2D then calls inv. Cost n^3 in formula.,,2.23,0.2463,16.2404,0.0006,"np.linalg.tensorinv(A, ind=2)","A: (8,8,8,8)","[5846832, 5853366, 5846832]",1264054,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_solvers.py#L269,moderate,10
+linalg.tensorsolve,benchmarked,Linalg Delegates,n^3 (delegates to solve),4.0000,0.9282,,"131,072 FLOPs (n=32, C=32768)",high,Weight=4 (same as linalg.solve). Reshapes to 2D then calls solve. Cost n^3 in formula.,,0.93,0.0839,47.6758,0.0016,"np.linalg.tensorsolve(A, b)","A: (8,8,8,8), b: (8,8)","[2433162, 2439821, 2433162]",430397,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_solvers.py#L224,moderate,10
+linalg.cross,benchmarked,Linalg Delegates,6*n,1.0000,1.7413,,"1,000 FLOPs (C=1000)",high,Delegates to `me.cross` which charges `numel(output)` FLOPs.,,1.74,3.3076,0.3023,0.0465,"np.linalg.cross(a, b)","a: (1000000,3), b: (1000000,3)","[98478050, 108009598, 104478091]",388571181,,baseline,10
+linalg.matmul,benchmarked,Linalg Delegates,MNK,1.0000,2.0009,,"1,000 FLOPs (C=1000)",high,Delegates to `me.matmul` which charges `m*k*n` FLOPs (FMA=1).,,2.00,1.3932,0.7178,0.0002,"np.linalg.matmul(A, B)","A: (512,512), B: (512,512)","[2685103983, 2685937106, 2685628312]",3661346910,,baseline,10
+linalg.matrix_norm,benchmarked,Linalg Delegates,"2*numel (fro/L1/Linf, FMA=2) or 4*m*n*min(m,n) (ord=2/nuc)",1.0000,1.1225,,"1,000 FLOPs (1000 elements)",high,"Weight=1 (baked into cost function). Elementwise norms cost 2*numel (FMA=2). SVD-based norms (ord=2, nuc) cost 4*m*n*min(m,n) — the 4x is baked in for SVD consistency.",,1.12,0.2024,4.9407,0.0360,np.linalg.matrix_norm(A),"A: (512,512)","[5622748, 6038991, 5884892]",2077385,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_properties.py#L289,baseline,10
+linalg.matrix_power,benchmarked,Linalg Delegates,(ceil(log2(k))+popcount(k)-1)*n^3,1.0000,2.0030,,"10,000 FLOPs (1000 elements, C=10000)",high,Matrix power. Cost: $(\lfloor\log_2 k\rfloor + \text{popcount}(k) - 1) \cdot n^3$ (exponentiation by squaring).,,2.00,0.4316,2.3170,0.0002,"np.linalg.matrix_power(A, 5)","A: (64,64), n=5","[15752245, 15758779, 15752245]",6646475,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_compound.py#L116,baseline,10
+linalg.multi_dot,benchmarked,Linalg Delegates,2 * sum of chain MNK costs (FMA=2),1.0000,1.0029,,"1,000 FLOPs (C=1000)",high,Chain matmul. Cost: 2 * sum of optimal chain matmul costs (CLRS §15.2) (FMA=2).,,1.00,0.2153,4.6447,0.0009,"np.linalg.multi_dot([A, B, C])","A: (128,64), B: (64,128), C: (128,64)","[21016315, 21054953, 21032740]",8839020,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_compound.py#L68,baseline,10
+linalg.norm,benchmarked,Linalg Delegates,"2*numel (vector/fro/L1/Linf, FMA=2) or 4*m*n*min(m,n) (ord=2/nuc)",1.0000,2.2412,,"1,000 FLOPs (1000 elements)",high,"Weight=1 (baked into cost function). Elementwise norms cost 2*numel (FMA=2). SVD-based norms (ord=2, nuc) cost 4*m*n*min(m,n) — the 4x is baked in for SVD consistency.",,2.24,0.6245,1.6013,0.0361,np.linalg.norm(x),"x: (10000000,)","[214116731, 230009679, 224116731]",122275816,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_properties.py#L187,baseline,10
+linalg.outer,benchmarked,Linalg Delegates,M*N,1.0000,1.0001,,"1,000 FLOPs (C=1000)",high,Delegates to `me.outer` which charges `m*n` FLOPs.,,1.00,1.1337,0.8821,0.0000,"np.linalg.outer(a, b)","a: (5000,), b: (5000,)","[250024028, 250039682, 250034069]",554932888,,baseline,10
+linalg.tensordot,benchmarked,Linalg Delegates,product of free * contracted dims,1.0000,2.0001,,"1,000 FLOPs (C=1000)",high,Delegates to `me.tensordot` which charges FLOPs based on contraction.,,2.00,0.5089,1.9650,0.0000,"np.linalg.tensordot(A, B, axes=1)","A: (64,64,64), B: (64,64,64)","[21475585963, 21476419086, 21476110292]",10699767686,,baseline,10
+linalg.trace,benchmarked,Linalg Delegates,"min(m,n)",1.0000,0.7872,,"1,000 FLOPs (n=1000, C=1000)",high,Blacklisted per reviewer — datetime ops not in scope.,,1.09,0.3628,2.7563,0.0000,np.linalg.trace(A),"A: (10000,10000) [np.ones]","[108731, 108731, 108731]",71042,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_properties.py#L45,baseline,10
+linalg.vecdot,benchmarked,Linalg Delegates,batch*K,1.0000,2.4841,,"1,000 FLOPs (1000-element vector, C=1000)",medium,Delegates to `me.vecdot` which charges `2*n` FLOPs.,,2.48,0.5579,1.7924,0.0654,"np.linalg.vecdot(A, B)","A: (1000,512), B: (1000,512)","[11694688, 13321682, 12718729]",5593153,,baseline,10
+linalg.vector_norm,benchmarked,Linalg Delegates,2*numel (FMA=2),1.0000,2.2412,,"1,000 FLOPs (1000 elements)",high,Vector norm. Cost: 2*numel (FMA=2 — one multiply + accumulate per element).,,2.24,1.1385,0.8783,0.0361,np.linalg.vector_norm(x),"x: (10000000,)","[214116731, 230009679, 224116731]",222907683,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/_properties.py#L238,baseline,10
+linalg.diagonal,benchmarked,Linalg Delegates,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+linalg.matrix_transpose,benchmarked,Linalg Delegates,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+dot,benchmarked,Contractions,MNK,1.0000,2.0012,,"1,000 FLOPs (C=1000)",high,Dot product; cost = M*K*N (FMA=1).,,2.00,1.4051,0.7117,0.0002,"np.dot(A, B)","A: (512,512), B: (512,512)","[2685103983, 2685937078, 2685937022]",3692552746,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L619,baseline,10
+matmul,benchmarked,Contractions,MNK,1.0000,2.0012,,"1,000 FLOPs (C=1000)",high,Matrix multiplication; cost = M*K*N (FMA=1).,,2.00,1.3807,0.7243,0.0002,"np.matmul(A, B)","A: (512,512), B: (512,512)","[2685103983, 2685937078, 2685937022]",3628406734,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L655,baseline,10
+inner,benchmarked,Contractions,N (a.size),1.0000,2.6010,,"1,000 FLOPs (1000-element vector, C=1000)",medium,Inner product; cost = N (FMA=1).,,2.60,0.5863,1.7056,0.0736,"np.inner(a, b)","a: (1000000,), b: (1000000,)","[22829921, 26009654, 26009598]",11480154,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L681,baseline,10
+vdot,benchmarked,Contractions,N (a.size),1.0000,2.6010,,"1,000 FLOPs (1000-element vector, C=1000)",medium,Dot product with conjugation; cost = N (FMA=1).,,2.60,0.5856,1.7077,0.0736,"np.vdot(a, b)","a: (1000000,), b: (1000000,)","[22829921, 26009654, 26009598]",11466213,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L739,baseline,10
+vecdot,benchmarked,Contractions,batch * K (output_size * contracted_axis),1.0000,2.6019,,"1,000 FLOPs (1000-element vector, C=1000)",medium,Vector dot product along last axis.,,2.60,0.5576,1.7934,0.0735,"np.vecdot(A, B)","A: (1000,512), B: (1000,512)","[11694688, 13321654, 13321598]",5589383,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L485,baseline,10
+outer,benchmarked,Contractions,M*N,1.0000,1.0002,,"1,000 FLOPs (C=1000)",high,Outer product of two vectors; cost = M*N.,,1.00,1.1328,0.8828,0.0000,"np.outer(a, b)","a: (5000,), b: (5000,)","[250024028, 250039654, 250039598]",554495980,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L697,baseline,10
+tensordot,benchmarked,Contractions,product of free * contracted dims,1.0000,2.0001,,"1,000 FLOPs (C=1000)",high,Tensor dot product along specified axes.,,2.00,0.5076,1.9701,0.0000,"np.tensordot(A, B, axes=1)","A: (64,64,64), B: (64,64,64), axes=1","[21475585963, 21476419058, 21476419002]",10672136921,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/__init__.py#L74,baseline,10
+kron,benchmarked,Contractions,numel(output),1.0000,1.0002,,"1,000 FLOPs (1000 elements)",high,Kronecker product; cost proportional to output size.,,1.00,1.1531,0.8672,0.0000,"np.kron(A, B)","A: (64,64), B: (64,64)","[167793697, 167806390, 167806334]",378782165,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L755,baseline,10
+einsum,benchmarked,Contractions,product of index dims (FMA=1),1.0000,2.0012,,"1,000 FLOPs (C=1000)",high,Generalized Einstein summation.,,2.00,0.1338,7.4738,0.0002,"np.einsum('ij,jk->ik', A, B)","A: (512,512), B: (512,512), subscripts='ij,jk->ik'","[2685103983, 2685937078, 2685937022]",351740209,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_einsum.py#L139,baseline,10
+roots,benchmarked,Polynomial,degree^3,16.0000,10.2924,,"32,000 FLOPs (n=100 deg=10, C=2000)",high,"Return roots of polynomial with given coefficients. Cost: $n^3$ (companion matrix eig, simplified).",,10.29,1.9369,8.2606,0.0420,np.roots(c),"c: (101,)","[102095583, 110123593, 102924427]",37924915,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_polynomial.py#L217,moderate,10
+polyval,benchmarked,Polynomial,2 * n * degree (FMA=2),1.0000,2.0214,,"2,000 FLOPs (n=100 deg=10, C=2000)",high,"Evaluate polynomial at given points. Cost: $2m \cdot \text{deg}$ (Horner's method, FMA=2).",,2.02,0.7014,1.4257,0.0000,"np.polyval(c, x)","c: (101,), x: (1000000,)","[2021420470, 2021425593, 2021417915]",1373284400,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_polynomial.py#L78,baseline,10
+polyfit,benchmarked,Polynomial,2 * n * (degree+1)^2,1.0000,1.1977,,"2,000 FLOPs (n=100 deg=10, C=2000)",high,Least squares polynomial fit. Cost: 2 * m * (deg+1)^2 FLOPs.,,1.20,0.3746,2.6695,0.0000,"np.polyfit(x, y, 100)","x: (1000000,), y: (1000000,), degree=100","[244347826566, 244347831689, 244347823985]",149626487897,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_polynomial.py#L187,baseline,10
+polyadd,benchmarked,Polynomial,degree + 1,1.0000,10.8861,,"2,000 FLOPs (n=100 deg=10, C=2000)",high,"Add two polynomials. Cost: max(n1, n2) FLOPs.",,10.89,7.3313,0.1364,0.0055,"np.polyadd(c, d)","c: (101,), d: (101,)","[10917, 10995, 11035]",14498,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_polynomial.py#L96,baseline,10
+polysub,benchmarked,Polynomial,degree + 1,1.0000,10.8861,,"2,000 FLOPs (n=100 deg=10, C=2000)",high,"Difference (subtraction) of two polynomials. Cost: max(n1, n2) FLOPs.",,10.89,7.3651,0.1358,0.0055,"np.polysub(c, d)","c: (101,), d: (101,)","[10917, 10995, 11035]",14565,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_polynomial.py#L113,baseline,10
+polymul,benchmarked,Polynomial,(degree+1)^2,1.0000,2.0976,,"2,000 FLOPs (n=100 deg=10, C=2000)",high,Multiply polynomials. Cost: n1 * n2 FLOPs.,,2.10,0.7839,1.2757,0.0003,"np.polymul(c, d)","c: (101,), d: (101,)","[213897, 213975, 214015]",156580,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_polynomial.py#L158,baseline,10
+polydiv,benchmarked,Polynomial,(degree+1)^2,1.0000,0.1393,,"2,000 FLOPs (n=100 deg=10, C=2000)",high,Divide one polynomial by another. Cost: n1 * n2 FLOPs.,,0.14,1.4615,0.6842,0.0042,"np.polydiv(c, d)","c: (101,), d: (101,)","[14127, 14205, 14245]",291911,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_polynomial.py#L174,baseline,10
+polyder,benchmarked,Polynomial,degree + 1,1.0000,11.7564,,"2,000 FLOPs (n=100 deg=10, C=2000)",high,Differentiate polynomial. Cost: n FLOPs.,,11.76,20.2300,0.0494,0.0067,np.polyder(c),"c: (101,)","[11744, 11874, 11888]",40006,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_polynomial.py#L127,baseline,10
+polyint,benchmarked,Polynomial,degree + 1,1.0000,10.7960,,"2,000 FLOPs (n=100 deg=10, C=2000)",high,Integrate polynomial. Cost: n FLOPs.,,10.80,23.5053,0.0425,0.0073,np.polyint(c),"c: (101,)","[10774, 10904, 10918]",46483,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_polynomial.py#L140,baseline,10
+poly,benchmarked,Polynomial,degree^2,1.0000,2.1195,,"2,000 FLOPs (n=100 deg=10, C=2000)",high,Polynomial from roots. Cost: $n^2$ FLOPs.,,2.12,10.5347,0.0949,0.0003,np.poly(r),"r: (100,)","[211876, 211954, 211994]",2062663,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_polynomial.py#L204,baseline,10
+random.standard_normal,benchmarked,Random,numel(output),16.0000,22.3069,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,22.31,10.2815,1.5562,0.0001,np.random.standard_normal(10000000),"output: (10000000,)","[2230672130, 2230895083, 2230693184]",2013098135,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L119,moderate,10
+random.standard_exponential,benchmarked,Random,numel(output),16.0000,27.0629,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,27.06,7.5213,2.1273,0.0000,np.random.standard_exponential(10000000),"output: (10000000,)","[2706290621, 2706353011, 2706228129]",1472648741,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L121,moderate,10
+random.standard_cauchy,benchmarked,Random,numel(output),16.0000,45.6145,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,45.61,20.5333,0.7792,0.0000,np.random.standard_cauchy(10000000),"output: (10000000,)","[4561367789, 4561590738, 4561450385]",4020367925,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L133,moderate,10
+random.standard_gamma,benchmarked,Random,numel(output),16.0000,27.0629,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,27.06,7.7138,2.0742,0.0000,"np.random.standard_gamma(1.0, 10000000)","output: (10000000,)","[2706290642, 2706353032, 2706228150]",1510345446,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L135,moderate,10
+random.standard_t,benchmarked,Random,numel(output),16.0000,71.1389,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,71.14,29.8832,0.5354,0.0000,"np.random.standard_t(3, 10000000)","output: (10000000,)","[7113894332, 7113768294, 7113919871]",5851057714,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L134,moderate,10
+random.poisson,benchmarked,Random,numel(output),16.0000,43.9992,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,44.00,30.8160,0.5192,0.0000,"np.random.poisson(5.0, 10000000)","output: (10000000,)","[4399924921, 4399857753, 4400059269]",6033709540,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L124,moderate,10
+random.binomial,benchmarked,Random,numel(output),16.0000,28.9996,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,29.00,20.4958,0.7806,0.0000,"np.random.binomial(10, 0.5, 10000000)","output: (10000000,)","[2899962364, 2899953294, 2900031664]",4013032967,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L125,moderate,10
+random.beta,benchmarked,Random,numel(output),16.0000,88.5899,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,88.59,39.3822,0.4063,0.0000,"np.random.beta(2.0, 5.0, 10000000)","output: (10000000,)","[8858989002, 8859154503, 8858499346]",7710939754,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L151,moderate,10
+random.chisquare,benchmarked,Random,numel(output),16.0000,29.0629,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,29.06,7.8306,2.0433,0.0000,"np.random.chisquare(2, 10000000)","output: (10000000,)","[2906290621, 2906353011, 2906228129]",1533208096,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L145,moderate,10
+random.dirichlet,benchmarked,Random,numel(output),16.0000,120.8423,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,120.84,50.0509,0.3197,0.0000,"np.random.dirichlet([1.0, 2.0, 3.0], 10000000)","alpha: (3,), size=10000000","[12084057801, 12084582941, 12084231305]",9799849982,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L157,moderate,10
+random.exponential,benchmarked,Random,numel(output),16.0000,28.0629,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,28.06,7.6413,2.0939,0.0000,"np.random.exponential(1.0, 10000000)","output: (10000000,)","[2806290642, 2806353032, 2806228150]",1496146094,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L123,moderate,10
+random.f,benchmarked,Random,numel(output),16.0000,93.4150,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,93.41,39.1102,0.4091,0.0000,"np.random.f(5, 10, 10000000)","output: (10000000,)","[9341495643, 9341982826, 9341443339]",7657678467,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L150,moderate,10
+random.gamma,benchmarked,Random,numel(output),16.0000,44.5281,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,44.53,20.1877,0.7926,0.0000,"np.random.gamma(2.0, 1.0, 10000000)","output: (10000000,)","[4452906405, 4452807840, 4452685178]",3952712443,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L152,moderate,10
+random.geometric,benchmarked,Random,numel(output),16.0000,6.0000,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,6.00,11.7887,1.3572,0.0000,"np.random.geometric(0.5, 10000000)","output: (10000000,)","[599973713, 599998363, 599997049]",2308207315,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L126,moderate,10
+random.gumbel,benchmarked,Random,numel(output),16.0000,51.8584,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,51.86,12.8632,1.2439,0.0000,"np.random.gumbel(0.0, 1.0, 10000000)","output: (10000000,)","[5185839629, 5185901713, 5185717552]",2518590093,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L138,moderate,10
+random.hypergeometric,benchmarked,Random,numel(output),16.0000,573.5947,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,573.59,125.5766,0.1274,0.0000,"np.random.hypergeometric(100, 50, 20, 10000000)","output: (10000000,)","[57355551117, 57359471843, 57360943316]",24587616622,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L127,moderate,10
+random.laplace,benchmarked,Random,numel(output),16.0000,29.5617,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,29.56,11.3316,1.4120,0.0000,"np.random.laplace(0.0, 1.0, 10000000)","output: (10000000,)","[2956305476, 2956162932, 2956168393]",2218706857,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L139,moderate,10
+random.logistic,benchmarked,Random,numel(output),16.0000,29.5397,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,29.54,8.2108,1.9487,0.0000,"np.random.logistic(0.0, 1.0, 10000000)","output: (10000000,)","[2954111933, 2953952490, 2953970748]",1607662898,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L140,moderate,10
+random.lognormal,benchmarked,Random,numel(output),16.0000,44.3069,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,44.31,17.3850,0.9203,0.0000,"np.random.lognormal(0.0, 1.0, 10000000)","output: (10000000,)","[4430672154, 4430895107, 4430693208]",3403948740,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L141,moderate,10
+random.logseries,benchmarked,Random,numel(output),16.0000,43.5238,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,43.52,18.1831,0.8799,0.0001,"np.random.logseries(0.5, 10000000)","output: (10000000,)","[4352380333, 4352564797, 4352117365]",3560206382,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L129,moderate,10
+random.multinomial,benchmarked,Random,numel(output),16.0000,136.9985,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,137.00,57.4964,0.2783,0.0000,"np.random.multinomial(10, [0.2, 0.3, 0.5], 10000000)","n_trials=10, pvals: (3,), size=10000000","[13699848224, 13699743882, 13699859245]",11257654205,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L153,moderate,10
+random.multivariate_normal,benchmarked,Random,numel(output),16.0000,433.0721,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,433.07,155.2207,0.1031,0.0000,"np.random.multivariate_normal(_mean, _cov, 10000000)","mean: (10,), cov: (10,10), size=10000000","[43306919828, 43307835048, 43307210747]",30391857141,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L155,moderate,10
+random.negative_binomial,benchmarked,Random,numel(output),16.0000,141.8094,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,141.81,63.1891,0.2532,0.0001,"np.random.negative_binomial(10, 0.5, 10000000)","output: (10000000,)","[14181999938, 14180603895, 14180944956]",12372280448,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L128,moderate,10
+random.noncentral_chisquare,benchmarked,Random,numel(output),16.0000,150.1467,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,150.15,40.8391,0.3918,0.0000,"np.random.noncentral_chisquare(2, 1.0, 10000000)","output: (10000000,)","[15014116380, 15014672435, 15014868407]",7996199158,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L147,moderate,10
+random.noncentral_f,benchmarked,Random,numel(output),16.0000,120.8930,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,120.89,48.6699,0.3287,0.0000,"np.random.noncentral_f(5, 10, 1.0, 10000000)","output: (10000000,)","[12089303643, 12089909616, 12089132805]",9529450301,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L149,moderate,10
+random.normal,benchmarked,Random,numel(output),16.0000,24.3069,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,24.31,10.8815,1.4704,0.0001,"np.random.normal(0.0, 1.0, 10000000)","output: (10000000,)","[2430672154, 2430895107, 2430693208]",2130579713,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L117,moderate,10
+random.pareto,benchmarked,Random,numel(output),16.0000,49.0629,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,49.06,12.2031,1.3111,0.0000,"np.random.pareto(3.0, 10000000)","output: (10000000,)","[4906290642, 4906353032, 4906228150]",2389344238,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L131,moderate,10
+random.power,benchmarked,Random,numel(output),16.0000,110.0629,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,110.06,25.3803,0.6304,0.0000,"np.random.power(5.0, 10000000)","output: (10000000,)","[11006290642, 11006353032, 11006228150]",4969411290,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L130,moderate,10
+random.randn,benchmarked,Random,numel(output),16.0000,22.3069,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,22.31,10.4860,1.5258,0.0001,np.random.randn(10000000),"output: (10000000,)","[2230672130, 2230895083, 2230693184]",2053131062,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L110,moderate,10
+random.rayleigh,benchmarked,Random,numel(output),16.0000,38.0709,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,38.07,12.9351,1.2369,0.0000,"np.random.rayleigh(1.0, 10000000)","output: (10000000,)","[3807131639, 3807080807, 3807090982]",2532661523,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L132,moderate,10
+random.triangular,benchmarked,Random,numel(output),16.0000,11.0000,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,11.00,8.2561,1.9380,0.0000,"np.random.triangular(-1.0, 0.0, 1.0, 10000000)","output: (10000000,)","[1099999360, 1100018810, 1100001070]",1616520497,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L144,moderate,10
+random.vonmises,benchmarked,Random,numel(output),16.0000,104.4415,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,104.44,40.8426,0.3917,0.0000,"np.random.vonmises(0.0, 1.0, 10000000)","output: (10000000,)","[10444148443, 10444455075, 10444132521]",7996888839,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L142,moderate,10
+random.wald,benchmarked,Random,numel(output),16.0000,39.9707,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,39.97,23.4729,0.6816,0.0000,"np.random.wald(1.0, 1.0, 10000000)","output: (10000000,)","[3997065808, 3997200656, 3997005363]",4595941410,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L143,moderate,10
+random.weibull,benchmarked,Random,numel(output),16.0000,89.0629,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,89.06,19.7279,0.8110,0.0000,"np.random.weibull(2.0, 10000000)","output: (10000000,)","[8906290642, 8906353032, 8906228150]",3862676400,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L136,moderate,10
+random.zipf,benchmarked,Random,numel(output),16.0000,229.7840,,"16,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,229.78,54.5976,0.2931,0.0000,"np.random.zipf(2.0, 10000000)","output: (10000000,)","[22978396963, 22977949429, 22978550971]",10690089301,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L137,moderate,10
+random.uniform,benchmarked,Random,numel(output),1.0000,5.0001,,"1,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,5.00,3.3088,0.3022,0.0000,"np.random.uniform(0.0, 1.0, 10000000)","output: (10000000,)","[500009630, 500009630, 500009630]",647861890,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L118,baseline,10
+random.permutation,benchmarked,Random,numel(output),1.0000,0.0001,,"1,000 FLOPs (1000 elements)",high,Shuffle; cost = n*ceil(log2(n)).,,0.00,10.2756,0.0973,0.0000,np.random.permutation(10000000),n=10000000,"[9606, 9606, 9606]",2011937361,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L198,baseline,10
+random.shuffle,benchmarked,Random,numel(output),1.0000,0.2001,,"1,000 FLOPs (1000 elements)",high,Shuffle; cost = n*ceil(log2(n)).,,0.20,9.4054,0.1063,0.0000,np.random.shuffle(x),"x: (10000000,)","[20009594, 20009594, 20009594]",1841548897,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L213,baseline,10
+random.choice,benchmarked,Random,numel(output),1.0000,0.0001,,"1,000 FLOPs (1000 elements)",high,"Sampling; cost = numel(output) if replace, n*ceil(log2(n)) if not.",,0.00,2.9891,0.3345,0.0000,"np.random.choice(_pool, 10000000)","pool: (1000,), size=10000000","[9597, 9597, 9597]",585249739,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L237,baseline,10
+random.rand,benchmarked,Random,numel(output),1.0000,3.0001,,"1,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,3.00,2.9985,0.3335,0.0000,np.random.rand(10000000),"output: (10000000,)","[300009596, 300009596, 300009596]",587092693,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L109,baseline,10
+random.randint,benchmarked,Random,numel(output),1.0000,0.0001,,"1,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,0.00,1.9079,0.5241,0.0000,"np.random.randint(0, 1000, 10000000)","output: (10000000,)","[9596, 9596, 9596]",373561982,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L158,baseline,10
+random.random,benchmarked,Random,numel(output),1.0000,3.0001,,"1,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,3.00,3.0165,0.3315,0.0000,np.random.random(10000000),"output: (10000000,)","[300009596, 300009596, 300009596]",590627361,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L179,baseline,10
+random.random_sample,benchmarked,Random,numel(output),1.0000,3.0001,,"1,000 FLOPs (1000 elements)",high,Sampling; cost = numel(output).,,3.00,3.0089,0.3323,0.0000,np.random.random_sample(10000000),"output: (10000000,)","[300009596, 300009596, 300009596]",589134243,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/random/__init__.py#L180,baseline,10
+random.bytes,benchmarked,Random,numel(output),1.0000,0.8610,,"1,000 FLOPs (1000 elements)",,EC2 timing = 0.86. Fast PRNG byte generation — cheaper than add.,,1.00,0.0000,N/A,N/A,np.random.bytes(N),N: 10000000,[],0,,baseline,0
+random.random_integers,benchmarked,Random,numel(output),1.0000,3.5105,,"1,000 FLOPs (1000 elements)",,EC2 timing = 3.51. Deprecated randint wrapper.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+random.default_rng,benchmarked,Random,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+random.get_state,benchmarked,Random,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+random.seed,benchmarked,Random,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+random.set_state,benchmarked,Random,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+stats.norm.pdf,benchmarked,Stats,numel(input),16.0000,27.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=27.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,27.30,0.0000,N/A,0.0034,_dist._compute_pdf(x),"x: (10000000,)","[2714153591, 2730018817, 2730018858]",,,moderate,10
+stats.norm.cdf,benchmarked,Stats,numel(input),16.0000,47.5991,,"16,000 FLOPs (1000 elements)",low,"Raw alpha=47.8993, setup overhead=0.3002 subtracted. FP instruction count per element.",,47.90,0.0000,N/A,0.2654,_dist._compute_cdf(x),"x: (10000000,)","[3007601731, 5143335657, 4789933658]",,,moderate,10
+stats.norm.ppf,benchmarked,Stats,numel(input),16.0000,83.0527,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=83.3529, setup overhead=0.3002 subtracted. FP instruction count per element.",,83.35,0.0000,N/A,0.0000,_dist._compute_ppf(x),"x: (10000000,)","[8335593509, 8335291409, 8335097729]",,,moderate,10
+stats.expon.pdf,benchmarked,Stats,numel(input),16.0000,25.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=25.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,25.30,0.0000,N/A,0.0036,_dist._compute_pdf(x),"x: (10000000,)","[2514125921, 2530018807, 2530018848]",,,moderate,10
+stats.expon.cdf,benchmarked,Stats,numel(input),16.0000,25.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=25.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,25.30,0.0000,N/A,0.0036,_dist._compute_cdf(x),"x: (10000000,)","[2514125921, 2530018807, 2530018848]",,,moderate,10
+stats.expon.ppf,benchmarked,Stats,numel(input),16.0000,43.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=43.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,43.30,0.0000,N/A,0.0000,_dist._compute_ppf(x),"x: (10000000,)","[4330018889, 4330018889, 4330018889]",,,moderate,10
+stats.cauchy.cdf,benchmarked,Stats,numel(input),16.0000,51.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=51.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,51.30,0.0000,N/A,0.0018,_dist._compute_cdf(x),"x: (10000000,)","[5114125921, 5130018807, 5130018848]",,,moderate,10
+stats.cauchy.ppf,benchmarked,Stats,numel(input),16.0000,64.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=64.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,64.30,0.0000,N/A,0.0000,_dist._compute_ppf(x),"x: (10000000,)","[6430018889, 6430018889, 6430018889]",,,moderate,10
+stats.logistic.pdf,benchmarked,Stats,numel(input),16.0000,28.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=28.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,28.30,0.0000,N/A,0.0032,_dist._compute_pdf(x),"x: (10000000,)","[2814125921, 2830018807, 2830018848]",,,moderate,10
+stats.logistic.cdf,benchmarked,Stats,numel(input),16.0000,26.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=26.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,26.30,0.0000,N/A,0.0035,_dist._compute_cdf(x),"x: (10000000,)","[2614125921, 2630018807, 2630018848]",,,moderate,10
+stats.logistic.ppf,benchmarked,Stats,numel(input),16.0000,35.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=35.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,35.30,0.0000,N/A,0.0000,_dist._compute_ppf(x),"x: (10000000,)","[3530018889, 3530018889, 3530018889]",,,moderate,10
+stats.laplace.pdf,benchmarked,Stats,numel(input),16.0000,25.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=25.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,25.30,0.0000,N/A,0.0036,_dist._compute_pdf(x),"x: (10000000,)","[2514125931, 2530018817, 2530018858]",,,moderate,10
+stats.laplace.cdf,benchmarked,Stats,numel(input),16.0000,49.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=49.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,49.30,0.0000,N/A,0.0019,_dist._compute_cdf(x),"x: (10000000,)","[4914125921, 4930018807, 4930018848]",,,moderate,10
+stats.laplace.ppf,benchmarked,Stats,numel(input),16.0000,71.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=71.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,71.30,0.0000,N/A,0.0000,_dist._compute_ppf(x),"x: (10000000,)","[7130018889, 7130018889, 7130018889]",,,moderate,10
+stats.lognorm.pdf,benchmarked,Stats,numel(input),16.0000,62.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=62.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,62.30,0.0000,N/A,0.0015,"_dist._compute_pdf(x, s=0.5)","x: (10000000,)","[6214125944, 6230018830, 6230018871]",,,moderate,10
+stats.lognorm.cdf,benchmarked,Stats,numel(input),16.0000,69.9835,,"16,000 FLOPs (1000 elements)",medium,"Raw alpha=70.2837, setup overhead=0.3002 subtracted. FP instruction count per element.",,70.28,0.0000,N/A,0.1699,"_dist._compute_cdf(x, s=0.5)","x: (10000000,)","[6461856914, 7028367200, 8884587401]",,,moderate,10
+stats.lognorm.ppf,benchmarked,Stats,numel(input),16.0000,106.0527,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=106.3529, setup overhead=0.3002 subtracted. FP instruction count per element.",,106.35,0.0000,N/A,0.0000,"_dist._compute_ppf(x, s=0.5)","x: (10000000,)","[10635593532, 10635291432, 10635097752]",,,moderate,10
+stats.truncnorm.pdf,benchmarked,Stats,numel(input),16.0000,28.0000,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=28.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,28.30,0.0000,N/A,0.0032,"_dist._compute_pdf(x, a=-2, b=2)","x: (10000000,)","[2814130301, 2830023187, 2830023228]",,,moderate,10
+stats.truncnorm.cdf,benchmarked,Stats,numel(input),16.0000,50.5992,,"16,000 FLOPs (1000 elements)",low,"Raw alpha=50.8994, setup overhead=0.3002 subtracted. FP instruction count per element.",,50.90,0.0000,N/A,0.2481,"_dist._compute_cdf(x, a=-2, b=2)","x: (10000000,)","[3307606091, 5443340017, 5089938018]",,,moderate,10
+stats.truncnorm.ppf,benchmarked,Stats,numel(input),16.0000,82.5206,,"16,000 FLOPs (1000 elements)",high,"Raw alpha=82.8208, setup overhead=0.3002 subtracted. FP instruction count per element.",,82.82,0.0000,N/A,0.0000,"_dist._compute_ppf(x, a=-2, b=2)","x: (10000000,)","[8282075099, 8282142419, 8282011819]",,,moderate,10
+stats.cauchy.pdf,benchmarked,Stats,numel(input),4.0000,6.0000,,"4,000 FLOPs (1000 elements)",high,"Raw alpha=6.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,6.30,0.0000,N/A,0.0147,_dist._compute_pdf(x),"x: (10000000,)","[614125931, 630018817, 630018858]",,,moderate,10
+stats.uniform.pdf,benchmarked,Stats,numel(input),1.0000,0.0000,,"1,000 FLOPs (1000 elements)",low,"Raw alpha=0.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,0.30,0.0000,N/A,0.3712,_dist._compute_pdf(x),"x: (10000000,)","[14125931, 30018817, 30018858]",,,baseline,10
+stats.uniform.cdf,benchmarked,Stats,numel(input),1.0000,4.0000,,"1,000 FLOPs (1000 elements)",high,"Raw alpha=4.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,4.30,0.0000,N/A,0.0216,_dist._compute_cdf(x),"x: (10000000,)","[414125921, 430018807, 430018848]",,,baseline,10
+stats.uniform.ppf,benchmarked,Stats,numel(input),1.0000,2.0000,,"1,000 FLOPs (1000 elements)",high,"Raw alpha=2.3002, setup overhead=0.3002 subtracted. FP instruction count per element.",,2.30,0.0000,N/A,0.0000,_dist._compute_ppf(x),"x: (10000000,)","[230018889, 230018889, 230018889]",,,baseline,10
+fromiter,benchmarked,Misc,numel(output),16.0000,20.3777,,"16,000 FLOPs (1000 elements)",,EC2 timing = 20.38. Python iterator overhead per element.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+apply_along_axis,benchmarked,Misc,numel(output),4.0000,1.9490,,"4,000 FLOPs (1000 elements)",,EC2 timing = 1.95. Note: cost formula (result.size) underestimates — actual work is input.size.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+argwhere,benchmarked,Misc,numel(input),4.0000,1.9631,,"4,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 1.9631.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+bmat,benchmarked,Misc,numel(output),4.0000,3.0046,,"4,000 FLOPs (1000 elements)",,EC2 timing = 3.00. Block matrix assembly from nested list.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+choose,benchmarked,Misc,numel(output),4.0000,8.0516,,"4,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 8.0516.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+compress,benchmarked,Misc,numel(input),4.0000,2.4640,,"4,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 2.4640.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+diag,benchmarked,Misc,"numel(output) when 1D->2D, min(m,n) when 2D->1D",4.0000,0.3780,,"4,000 FLOPs (1000 elements)",,EC2 timing = 0.38 (1D->2D). Formula fixed to numel(output) for construction.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+extract,benchmarked,Misc,numel(input),4.0000,2.4549,,"4,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 2.4549.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+fill_diagonal,benchmarked,Misc,"min(m,n)",4.0000,6.2633,,"4,000 FLOPs (n=1000, C=1000)",,EC2 timing = 6.26 per diagonal element. Strided cache misses in large matrices.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+insert,benchmarked,Misc,numel(values),4.0000,1.6005,,"4,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 1.6005.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+mask_indices,benchmarked,Misc,numel(output),4.0000,4.5645,,"4,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 4.5645.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+piecewise,benchmarked,Misc,numel(input),4.0000,13.7055,,"4,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 13.7055.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+place,benchmarked,Misc,numel(input),4.0000,3.7818,,"4,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 3.7818.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+putmask,benchmarked,Misc,numel(input),4.0000,3.0306,,"4,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 3.0306.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+select,benchmarked,Misc,numel(input),4.0000,7.9267,,"4,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 7.9267.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+take,benchmarked,Misc,numel(output),4.0000,3.8564,,"4,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 3.8564.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+trim_zeros,benchmarked,Misc,num trimmed,4.0000,2.3378,,"4,000 FLOPs (C=1000)",,EC2 timing ratio vs add = 2.3378.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+where,benchmarked,Misc,numel(input),4.0000,3.5686,,"4,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 3.5686.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,moderate,0
+allclose,benchmarked,Misc,n,1.0000,3.7001,,"1,000 FLOPs (1000 elements)",high,Element-wise tolerance check; cost = numel(a).,,3.70,6.5083,0.1536,0.0347,"np.allclose(a, b)","a: (10000000,), b: (10000000,)","[348214682, 370009734, 370009693]",1274318396,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_counting_ops.py#L45,baseline,10
+array_equal,benchmarked,Misc,n,1.0000,0.6001,,"1,000 FLOPs (1000 elements)",low,Element-wise equality; cost = numel(a).,,0.60,0.5241,1.9080,0.3716,"np.array_equal(a, b)","a: (10000000,), b: (10000000,)","[28207571, 60009654, 60009598]",102616465,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_counting_ops.py#L60,baseline,10
+array_equiv,benchmarked,Misc,n,1.0000,0.6001,,"1,000 FLOPs (1000 elements)",low,Element-wise equivalence; cost = numel(a).,,0.60,0.5176,1.9320,0.3716,"np.array_equiv(a, b)","a: (10000000,), b: (10000000,)","[28207571, 60009654, 60009598]",101344179,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_counting_ops.py#L82,baseline,10
+clip,benchmarked,Misc,numel(output),1.0000,2.0000,,"1,000 FLOPs (1000 elements)",high,"Clip array to [a_min, a_max] element-wise.",,2.30,0.8446,1.1840,0.0408,"np.clip(x, -1.0, 1.0)","x: (10000000,), a_min=-1.0, a_max=1.0","[214116760, 230009687, 230009646]",165361079,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L505,baseline,10
+diff,benchmarked,Misc,n,1.0000,1.3001,,"1,000 FLOPs (1000 elements)",medium,n-th discrete difference along axis.,,1.30,0.8974,1.1143,0.0736,np.diff(x),"x: (10000000,)","[114116711, 130009638, 130009597]",175714300,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L791,baseline,10
+ediff1d,benchmarked,Misc,n,1.0000,1.3001,,"1,000 FLOPs (1000 elements)",medium,Differences between consecutive elements.,,1.30,0.8822,1.1335,0.0736,np.ediff1d(x),"x: (10000000,)","[114116711, 130009638, 130009597]",172734787,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L821,baseline,10
+gradient,benchmarked,Misc,n,1.0000,2.3001,,"1,000 FLOPs (1000 elements)",high,Gradient using central differences.,,2.30,2.8186,0.3548,0.0408,np.gradient(x),"x: (10000000,)","[214116761, 230009688, 230009647]",551866623,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L807,baseline,10
+unwrap,benchmarked,Misc,n,1.0000,6.7693,,"1,000 FLOPs (1000 elements)",medium,Phase unwrap. Cost: $\text{numel}(\text{input})$ (diff + conditional adjustment).,,6.77,17.4546,0.0573,0.0553,np.unwrap(x),"x: (10000000,)","[615433031, 676929798, 679869857]",3417569903,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_unwrap.py#L40,baseline,10
+convolve,benchmarked,Misc,n * k,1.0000,2.0003,,"100,000 FLOPs (n=1000 k=100, C=100000)",high,1-D discrete convolution.,,2.00,0.5680,1.7606,0.0000,"np.convolve(x, k, mode='full')","x: (100000,), k: (1000,)","[2000152430, 2000312654, 2000312598]",1112186242,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L841,baseline,10
+correlate,benchmarked,Misc,n * k,1.0000,2.0003,,"100,000 FLOPs (n=1000 k=100, C=100000)",high,1-D cross-correlation.,,2.00,0.5680,1.7606,0.0000,"np.correlate(x, k, mode='full')","x: (100000,), k: (1000,)","[2000152430, 2000312654, 2000312598]",1112171862,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L861,baseline,10
+corrcoef,benchmarked,Misc,2 * f^2 * s,1.0000,1.0014,,"20,000 FLOPs (10 features x 100 samples, C=20000)",high,Pearson correlation coefficients.,,1.00,0.3118,3.2072,0.0000,np.corrcoef(x),"x: (1000,10000)","[200264136731, 200280029658, 200280029617]",122080608145,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L898,baseline,10
+cov,benchmarked,Misc,2 * f^2 * s,1.0000,1.0012,,"20,000 FLOPs (10 features x 100 samples, C=20000)",high,Covariance matrix.,,1.00,0.3108,3.2175,0.0000,np.cov(x),"x: (1000,10000)","[200224126731, 200240019658, 200240019617]",121692349044,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L913,baseline,10
+cross,benchmarked,Misc,6 * n,1.0000,1.8002,,"1,000 FLOPs (n=1000, C=1000)",medium,Cross product of two 3-D vectors.,,1.80,3.2738,0.3055,0.0525,"np.cross(a, b)","a: (1000000,3), b: (1000000,3)","[98473816, 108009654, 108009598]",384598259,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/linalg/__init__.py#L72,baseline,10
+histogram,benchmarked,Misc,n * ceil(log2(bins)),1.0000,0.7574,,"10,000 FLOPs (1000 elements, C=10000)",high,Binning; cost = n*ceil(log2(bins)).,,0.76,0.9254,1.0806,0.0175,"np.histogram(x, bins=100)","x: (10000000,), bins=100","[514316161, 530209088, 530209047]",1268394924,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_counting_ops.py#L106,baseline,10
+histogram2d,benchmarked,Misc,n * 2 * ceil(log2(bins)),1.0000,0.3289,,"10,000 FLOPs (1000 elements, C=10000)",high,2D binning; cost = n*(ceil(log2(bx))+ceil(log2(by))).,,0.33,3.6328,0.2753,0.0408,"np.histogram2d(x, y, bins=100)","x: (10000000,), y: (10000000,), bins=100","[428608451, 460410534, 460410478]",9958014642,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_counting_ops.py#L148,baseline,10
+histogramdd,benchmarked,Misc,n * ndim * ceil(log2(bins)),1.0000,0.3834,,"10,000 FLOPs (1000 elements, C=10000)",high,ND binning; cost = n*sum(ceil(log2(b_i))).,,0.38,3.4690,0.2883,0.0408,"np.histogramdd(x, bins=50)","x: (1000000,3), bins=50","[64252820, 69017318, 69017277]",1222604096,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_counting_ops.py#L189,baseline,10
+histogram_bin_edges,benchmarked,Misc,n,1.0000,2.3021,,"1,000 FLOPs (1000 elements)",high,Bin edge computation; cost = numel(a).,,2.30,0.4060,2.4631,0.0408,"np.histogram_bin_edges(x, bins=100)","x: (10000000,), bins=100","[214316151, 230209078, 230209037]",79500558,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_counting_ops.py#L207,baseline,10
+digitize,benchmarked,Misc,n * ceil(log2(bins)),1.0000,0.0429,,"10,000 FLOPs (1000 elements, C=10000)",low,Bin search; cost = n*ceil(log2(bins)).,,0.04,3.1251,0.3200,0.3713,"np.digitize(x, bins)","x: (10000000,), bins: (100,)","[14117111, 30010038, 30009997]",4283257612,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_sorting_ops.py#L197,baseline,10
+bincount,benchmarked,Misc,n,1.0000,0.0001,,"1,000 FLOPs (1000 elements)",high,Integer counting; cost = numel(x).,,0.00,0.7605,1.3149,0.0000,np.bincount(x),"x: (10000000,)","[9596, 9596, 9596]",148901857,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_counting_ops.py#L221,baseline,10
+interp,benchmarked,Misc,n * ceil(log2(xp)),1.0000,0.2364,,"10,000 FLOPs (1000 elements, C=10000)",high,1-D linear interpolation.,,0.24,3.3535,0.2982,0.0281,"np.interp(x, xp, fp)","x: (10000000,), xp: (10000,), fp: (10000,)","[315097044, 330938632, 330938561]",9192377199,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L955,baseline,10
+trace,benchmarked,Misc,"min(m, n)",1.0000,0.7872,,"1,000 FLOPs (n=1000, C=1000)",high,Re-benchmarked with np.ones setup to avoid random-gen overhead. Trace is a sum of diagonal — mode=ufunc_reduction.,,1.09,0.3413,2.9300,0.0000,np.trace(A),"A: (10000,10000) [np.ones]","[108731, 108731, 108731]",66832,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_counting_ops.py#L26,baseline,10
+trapezoid,benchmarked,Misc,n,1.0000,4.3001,,"1,000 FLOPs (1000 elements)",high,Integrate using the trapezoidal rule.,,4.30,2.9164,0.3429,0.0216,_trapfn(x),"x: (10000000,)","[414116701, 430009628, 430009587]",571023004,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L926,baseline,10
+logspace,benchmarked,Misc,n,1.0000,75.0001,,"1,000 FLOPs (1000 elements)",high,Log-spaced generation; cost = num.,,75.00,4.7278,0.2115,0.0000,"np.logspace(0, 10, 10000000)","output: (10000000,)","[7500008731, 7500008731, 7500008731]",925689725,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_counting_ops.py#L236,baseline,10
+geomspace,benchmarked,Misc,n,1.0000,76.0001,,"1,000 FLOPs (1000 elements)",high,Geometric-spaced generation; cost = num.,,76.00,4.9395,0.2024,0.0000,"np.geomspace(1, 1000, 10000000)","output: (10000000,)","[7600014351, 7600014392, 7600014374]",967145738,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_counting_ops.py#L246,baseline,10
+vander,benchmarked,Misc,n * (degree - 1),1.0000,0.9939,,"2,000 FLOPs (n=100 deg=10, C=2000)",high,Vandermonde matrix; cost = len(x)*(N-1).,,0.99,1.5389,0.6498,0.0009,"np.vander(x, 100)","x: (10000,), degree=100","[9824028, 9839638, 9839597]",29829848,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_counting_ops.py#L260,baseline,10
+isnan,benchmarked,Misc,numel(output),1.0000,0.3375,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.3375,,0.00,0.0000,N/A,0.0067,np.isnan(x),"x: (100000000,)",[],,,baseline,5
+isinf,benchmarked,Misc,numel(output),1.0000,0.3493,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.3493,,0.00,0.0000,N/A,0.0071,np.isinf(x),"x: (100000000,)",[],,,baseline,5
+isfinite,benchmarked,Misc,numel(output),1.0000,0.3454,,"1,000 FLOPs (1000 elements)",high,Timing-based (fp_arith_inst_retired blind to this op). Ratio vs add=0.3454,,0.00,0.0000,N/A,0.0074,np.isfinite(x),"x: (100000000,)",[],,,baseline,5
+append,benchmarked,Misc,numel(values),1.0000,0.9206,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.9206.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+apply_over_axes,benchmarked,Misc,numel(output),1.0000,0.1407,,"1,000 FLOPs (1000 elements)",,EC2 timing = 0.14. Efficient numpy reduction path.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+arange,benchmarked,Misc,numel(output),1.0000,0.6141,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.6141.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+array,benchmarked,Misc,numel(input),1.0000,0.9035,,"1,000 FLOPs (1000 elements)",,"Timing ratio vs add = 0.9035. Benchmark: 10,000,000 elements.",,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+asarray_chkfinite,benchmarked,Misc,numel(input),1.0000,0.2892,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.2892.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+block,benchmarked,Misc,numel(output),1.0000,0.0167,,"1,000 FLOPs (1000 elements)",,Formerly-free op. Timing ratio vs add = 0.0167.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+concat,benchmarked,Misc,numel(output),1.0000,0.9209,,"1,000 FLOPs (1000 elements)",,EC2 timing = 0.92. Memcpy (alias for concatenate).,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+concatenate,benchmarked,Misc,numel(output),1.0000,0.9106,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.9106.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+copyto,benchmarked,Misc,numel(output),1.0000,1.1734,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 1.1734.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+delete,benchmarked,Misc,num deleted,1.0000,1.1182,,"1,000 FLOPs (C=1000)",,EC2 timing ratio vs add = 1.1182.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+diagflat,benchmarked,Misc,numel(output),1.0000,0.2349,,"1,000 FLOPs (1000 elements)",,EC2 timing = 0.23. Formula fixed from len(v) to numel(output).,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+diagonal,benchmarked,Misc,numel(input),1.0000,0.5792,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.5792.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+dstack,benchmarked,Misc,numel(output),1.0000,1.1037,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 1.1037.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+einsum_path,benchmarked,Misc,1,1.0000,1.0000,,"1,000 FLOPs (C=1000)",,Weight=1 by design. Path planning only — intentionally charges 1 FLOP for budget tracking.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+flatnonzero,benchmarked,Misc,numel(input),1.0000,0.8717,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.8717.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+fromfunction,benchmarked,Misc,numel(output),1.0000,0.7226,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.7226.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+full,benchmarked,Misc,numel(output),1.0000,0.5706,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.5706.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+full_like,benchmarked,Misc,numel(output),1.0000,0.5616,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.5616.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+indices,benchmarked,Misc,numel(output),1.0000,0.1694,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.1694.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+ix_,benchmarked,Misc,numel(output),1.0000,1.2920,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 1.2920.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+linspace,benchmarked,Misc,numel(output),1.0000,1.1761,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 1.1761.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+meshgrid,benchmarked,Misc,numel(output),1.0000,0.1446,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.1446.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+nonzero,benchmarked,Misc,numel(input),1.0000,0.8322,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.8322.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+packbits,benchmarked,Misc,numel(input),1.0000,0.3987,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.3987.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+pad,benchmarked,Misc,numel(output),1.0000,0.9146,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.9146.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+put,benchmarked,Misc,numel(input),1.0000,0.9866,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.9866.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+put_along_axis,benchmarked,Misc,numel(input),1.0000,0.0310,,"1,000 FLOPs (1000 elements)",,Formerly-free op. Timing ratio vs add = 0.0310.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+repeat,benchmarked,Misc,numel(output),1.0000,0.5985,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.5985.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+resize,benchmarked,Misc,numel(output),1.0000,0.6234,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.6234.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+roll,benchmarked,Misc,numel(output),1.0000,0.9077,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.9077.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+stack,benchmarked,Misc,numel(output),1.0000,0.9017,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.9017.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+take_along_axis,benchmarked,Misc,numel(output),1.0000,0.4811,,"1,000 FLOPs (1000 elements)",,Formerly-free op. Timing ratio vs add = 0.4811.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+tile,benchmarked,Misc,numel(output),1.0000,0.6244,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.6244.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+unpackbits,benchmarked,Misc,numel(input),1.0000,0.0385,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.0385.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+unstack,benchmarked,Misc,numel(input),1.0000,0.0007,,"1,000 FLOPs (1000 elements)",,EC2 timing = 0.0007. Returns views — should be free.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+vstack,benchmarked,Misc,numel(output),1.0000,0.9082,,"1,000 FLOPs (1000 elements)",,EC2 timing ratio vs add = 0.9082.,,0.00,0.0000,N/A,N/A,N/A,N/A,[],,,baseline,0
+array_split,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+asarray,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+astype,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+atleast_1d,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+atleast_2d,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+atleast_3d,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+broadcast_arrays,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+broadcast_shapes,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+broadcast_to,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+can_cast,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+column_stack,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+common_type,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+copy,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+diag_indices,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+diag_indices_from,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+dsplit,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+empty,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+empty_like,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+expand_dims,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+eye,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+flip,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+fliplr,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+flipud,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+from_dlpack,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+frombuffer,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+hsplit,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+hstack,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+identity,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+isdtype,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+isfortran,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+isscalar,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+issubdtype,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+iterable,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+matrix_transpose,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+may_share_memory,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+min_scalar_type,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+mintypecode,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+moveaxis,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+ndim,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+ones,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+ones_like,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+permute_dims,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+promote_types,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+ravel,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+ravel_multi_index,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+require,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+reshape,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+result_type,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+rollaxis,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+rot90,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+row_stack,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+shape,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+shares_memory,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+size,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+split,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+squeeze,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+swapaxes,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+transpose,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+tri,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+tril,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+tril_indices,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+tril_indices_from,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+triu,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+triu_indices,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+triu_indices_from,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+typename,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+unravel_index,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+vsplit,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+zeros,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+zeros_like,benchmarked,Misc,,0.0000,0.0000,,,,,,0.00,0.0000,N/A,N/A,,,,,,negligible,
+blackman,benchmarked,Window,3*n,16.0000,24.2347,,"16,000 FLOPs (C=1000)",high,Blackman window. Cost: 3*n (three cosine terms per sample).,,24.23,5.4740,2.9229,0.0000,np.blackman(10000000),"output: (10000000,)","[7270403371, 7270403371, 7270403371]",3215360813,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_window.py#L65,moderate,10
+kaiser,benchmarked,Window,3*n,16.0000,37.4439,,"16,000 FLOPs (C=1000)",high,Kaiser window. Cost: 3*n (Bessel function eval per sample).,,37.44,32.3231,0.4950,0.0000,"np.kaiser(10000000, 14.0)","output: (10000000,)","[11233169142, 11233169142, 11233169142]",18986364623,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_window.py#L155,moderate,10
+hamming,benchmarked,Window,n,8.0000,34.3767,,"8,000 FLOPs (1000 elements)",high,Hamming window. Cost: n (one cosine per sample).,,34.38,8.1705,0.9791,0.0000,np.hamming(10000000),"output: (10000000,)","[3437669311, 3437669311, 3437669311]",1599765179,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_window.py#L95,moderate,10
+hanning,benchmarked,Window,n,8.0000,34.3767,,"8,000 FLOPs (1000 elements)",high,Hanning window. Cost: n (one cosine per sample).,,34.38,8.2375,0.9712,0.0000,np.hanning(10000000),"output: (10000000,)","[3437669311, 3437669311, 3437669311]",1612877985,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_window.py#L125,moderate,10
+bartlett,benchmarked,Window,n,1.0000,6.0001,,"1,000 FLOPs (1000 elements)",high,Bartlett window. Cost: n (one linear eval per sample).,,6.00,5.5446,0.1804,0.0000,np.bartlett(10000000),"output: (10000000,)","[600008761, 600008761, 600008761]",1085612353,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_window.py#L35,baseline,10
+gcd,benchmarked,Bitwise,n,16.0000,99.0872,,"16,000 FLOPs (1000 elements)",high,Element-wise greatest common divisor.,,99.09,50.6014,0.3162,0.0001,"np.gcd(a, b)","a: (10000000,), b: (10000000,)","[9907712467, 9908716009, 9909361215]",9907632609,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L445,moderate,10
+lcm,benchmarked,Bitwise,n,16.0000,104.1010,,"16,000 FLOPs (1000 elements)",high,Element-wise least common multiple.,,104.10,53.1550,0.3010,0.0000,"np.lcm(a, b)","a: (10000000,), b: (10000000,)","[10410346762, 10410101865, 10410065468]",10407623075,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L450,moderate,10
+bitwise_not,benchmarked,Bitwise,n,1.0000,8.2180,,"1,000 FLOPs (1000 elements)",high,Element-wise bitwise NOT.,,8.22,4.1882,0.2388,0.0030,np.bitwise_not(x),"x: (10000000,)","[822288975, 817817705, 821802118]",820040865,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L306,baseline,10
+bitwise_invert,benchmarked,Bitwise,n,1.0000,8.2113,,"1,000 FLOPs (1000 elements)",high,Element-wise bitwise invert (alias for bitwise_not).,,8.21,4.1873,0.2388,0.0012,np.bitwise_invert(x),"x: (10000000,)","[822556877, 821131715, 820744880]",819864061,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L305,baseline,10
+bitwise_count,benchmarked,Bitwise,n,1.0000,15.3460,,"1,000 FLOPs (1000 elements)",high,Count set bits element-wise (popcount).,,15.35,7.8433,0.1275,0.0002,np.bitwise_count(x),"x: (10000000,)","[1534963371, 1534227966, 1534597734]",1535707945,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L304,baseline,10
+invert,benchmarked,Bitwise,n,1.0000,8.1990,,"1,000 FLOPs (1000 elements)",high,Bitwise NOT element-wise.,,8.20,4.1852,0.2389,0.0025,np.invert(x),"x: (10000000,)","[819895288, 821558411, 817455379]",819445312,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L319,baseline,10
+bitwise_and,benchmarked,Bitwise,n,1.0000,11.5166,,"1,000 FLOPs (1000 elements)",high,Element-wise bitwise AND.,,11.52,5.9055,0.1693,0.0092,"np.bitwise_and(a, b)","a: (10000000,), b: (10000000,)","[1153953512, 1134603750, 1151659409]",1156285593,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L433,baseline,10
+bitwise_or,benchmarked,Bitwise,n,1.0000,11.5722,,"1,000 FLOPs (1000 elements)",high,Element-wise bitwise OR.,,11.57,5.8962,0.1696,0.0114,"np.bitwise_or(a, b)","a: (10000000,), b: (10000000,)","[1134631565, 1157222691, 1157292334]",1154461965,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L435,baseline,10
+bitwise_xor,benchmarked,Bitwise,n,1.0000,11.5398,,"1,000 FLOPs (1000 elements)",high,Element-wise bitwise XOR.,,11.54,5.9066,0.1693,0.0024,"np.bitwise_xor(a, b)","a: (10000000,), b: (10000000,)","[1151921255, 1157309060, 1153979072]",1156506171,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L437,baseline,10
+bitwise_left_shift,benchmarked,Bitwise,n,1.0000,12.8120,,"1,000 FLOPs (1000 elements)",high,Element-wise left bit shift.,,12.81,6.5365,0.1530,0.0100,"np.bitwise_left_shift(a, b)","a: (10000000,), b: (10000000,) (values 0-10)","[1281199148, 1259102115, 1281335038]",1279823921,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L434,baseline,10
+bitwise_right_shift,benchmarked,Bitwise,n,1.0000,18.7846,,"1,000 FLOPs (1000 elements)",high,Element-wise right bit shift.,,18.78,9.6066,0.1041,0.0014,"np.bitwise_right_shift(a, b)","a: (10000000,), b: (10000000,) (values 0-10)","[1881907300, 1876700496, 1878461658]",1880940673,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L436,baseline,10
+left_shift,benchmarked,Bitwise,n,1.0000,12.7592,,"1,000 FLOPs (1000 elements)",high,Element-wise left bit shift (legacy name).,,12.76,6.5213,0.1533,0.0086,"np.left_shift(a, b)","a: (10000000,), b: (10000000,) (values 0-10)","[1280244752, 1259410135, 1275916310]",1276863674,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L452,baseline,10
+right_shift,benchmarked,Bitwise,n,1.0000,18.7921,,"1,000 FLOPs (1000 elements)",high,Element-wise right bit shift (legacy name).,,18.79,9.5969,0.1042,0.0065,"np.right_shift(a, b)","a: (10000000,), b: (10000000,) (values 0-10)","[1881581119, 1879209826, 1859414595]",1879041530,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L464,baseline,10
+angle,benchmarked,Complex,numel(output),16.0000,53.7818,,"16,000 FLOPs (1000 elements)",high,Return angle of complex argument element-wise.,,54.08,3.5576,4.4974,0.0000,np.angle(x),"x: (10000000,) complex128","[5408207595, 5408194453, 5408184002]",696570025,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L267,moderate,10
+conj,benchmarked,Complex,numel(output),1.0000,0.7818,,"1,000 FLOPs (1000 elements)",high,Complex conjugate element-wise.,,1.08,1.6904,0.5916,0.0001,np.conj(x),"x: (10000000,) complex128","[108207595, 108194453, 108184002]",330980383,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L308,baseline,10
+conjugate,benchmarked,Complex,numel(output),1.0000,0.7818,,"1,000 FLOPs (1000 elements)",high,Complex conjugate element-wise.,,1.08,1.7053,0.5864,0.0001,np.conjugate(x),"x: (10000000,) complex128","[108207595, 108194453, 108184002]",333901426,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L309,baseline,10
+imag,benchmarked,Complex,numel(output),1.0000,0.7818,,"1,000 FLOPs (1000 elements)",high,Return imaginary part of complex array.,,1.08,0.0000,N/A,0.0001,np.imag(x),"x: (10000000,) complex128","[108207595, 108194453, 108184002]",4364,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L318,baseline,10
+real,benchmarked,Complex,numel(output),1.0000,0.7818,,"1,000 FLOPs (1000 elements)",high,Return real part of complex array.,,1.08,0.0000,N/A,0.0001,np.real(x),"x: (10000000,) complex128","[108207595, 108194453, 108184002]",4351,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L333,baseline,10
+real_if_close,benchmarked,Complex,numel(output),1.0000,0.7818,,"1,000 FLOPs (1000 elements)",low,Return real array if imaginary part is negligible.,,1.08,1.3590,0.7358,0.2703,np.real_if_close(x),"x: (10000000,) complex128","[168207652, 108194469, 108184018]",266095082,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L334,baseline,10
+iscomplex,benchmarked,Complex,numel(output),1.0000,0.7818,,"1,000 FLOPs (1000 elements)",high,Test if element is complex element-wise.,,1.08,0.6240,1.6026,0.0001,np.iscomplex(x),"x: (10000000,) complex128","[108207595, 108194453, 108184002]",122186803,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L320,baseline,10
+isreal,benchmarked,Complex,numel(output),1.0000,0.7818,,"1,000 FLOPs (1000 elements)",high,Test if element is real (imag == 0) element-wise.,,1.08,0.6273,1.5941,0.0001,np.isreal(x),"x: (10000000,) complex128","[108207595, 108194453, 108184002]",122832416,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L325,baseline,10
+sort_complex,benchmarked,Complex,n * ceil(log2(n)),1.0000,0.7830,,"10,000 FLOPs (1000 elements, C=10000)",high,Sort complex array. Cost: $n \cdot \lceil\log_2 n\rceil$.,,1.08,42.4852,0.0235,0.0007,np.sort_complex(x),"x: (1000000,) complex128","[10836159, 10821404, 10830690]",831850867,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L376,baseline,10
+iscomplexobj,benchmarked,Complex,numel(output),1.0000,18.3055,,"1,000 FLOPs (1000 elements)",high,Return True if input is a complex type or array.,,18.31,9.3510,0.1069,0.0000,np.iscomplexobj(x),"x: (10000000,) complex128 (instructions counter)","[1830503591, 1830547873, 1830665683]",1830909130,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L321,baseline,10
+isrealobj,benchmarked,Complex,numel(output),1.0000,18.3070,,"1,000 FLOPs (1000 elements)",high,Return True if x is a not complex type or array.,,18.31,9.3496,0.1070,0.0001,np.isrealobj(x),"x: (10000000,) complex128 (instructions counter)","[1830986281, 1830635933, 1830702604]",1830626398,https://github.com/AIcrowd/flopscope/blob/main/src/flopscope/_pointwise.py#L326,baseline,10
+acos,alias,counted_unary,,16.0000,52.9901,,,,Alias for arccos (NumPy 2.x).,Alias of arccos (weight: 16.00),53.29,,,,,,,,,,
+acosh,alias,counted_unary,,16.0000,82.5008,,,,Alias for arccosh (NumPy 2.x).,Alias of arccosh (weight: 16.00),82.80,,,,,,,,,,
+asin,alias,counted_unary,,16.0000,55.9901,,,,Alias for arcsin (NumPy 2.x).,Alias of arcsin (weight: 16.00),56.29,,,,,,,,,,
+asinh,alias,counted_unary,,16.0000,79.0000,,,,Alias for arcsinh (NumPy 2.x).,Alias of arcsinh (weight: 16.00),79.30,,,,,,,,,,
+atan,alias,counted_unary,,16.0000,47.0000,,,,Alias for arctan (NumPy 2.x).,Alias of arctan (weight: 16.00),47.30,,,,,,,,,,
+atan2,alias,counted_binary,,16.0000,53.0000,,,,Alias for arctan2 (NumPy 2.x).,Alias of arctan2 (weight: 16.00),53.60,,,,,,,,,,
+atanh,alias,counted_unary,,16.0000,71.9901,,,,Alias for arctanh (NumPy 2.x).,Alias of arctanh (weight: 16.00),72.29,,,,,,,,,,
+divmod,alias,counted_binary,,16.0000,3.1888,,,,"Element-wise (quotient, remainder) tuple.",Alias of floor_divide (weight: 16.00),3.79,,,,,,,,,,
+pow,alias,counted_binary,,16.0000,72.1819,,,,Alias for power (NumPy 2.x).,Alias of power (weight: 16.00),72.78,,,,,,,,,,
+absolute,alias,counted_unary,,1.0000,0.8690,,,,Element-wise absolute value.,Alias of abs (weight: 1.00),0.30,,,,,,,,,,
+amax,alias,counted_reduction,,1.0000,1.0010,,,,Maximum value of array (alias for max/numpy.amax).,Alias of max (weight: 1.00),1.30,,,,,,,,,,
+amin,alias,counted_reduction,,1.0000,1.0010,,,,Minimum value of array (alias for min/numpy.amin).,Alias of min (weight: 1.00),1.30,,,,,,,,,,
+around,alias,counted_unary,,1.0000,0.8722,,,,Alias for round.,Alias of rint (weight: 1.00),0.30,,,,,,,,,,
+fix,alias,counted_unary,,1.0000,0.8777,,,,Round toward zero element-wise (alias for trunc).,Alias of trunc (weight: 1.00),0.30,,,,,,,,,,
+random.ranf,alias,counted_custom,,1.0000,3.0001,,,,Sampling; cost = numel(output).,Alias of random.random_sample (weight: 1.00),3.00,,,,,,,,,,
+random.sample,alias,counted_custom,,1.0000,3.0001,,,,Sampling; cost = numel(output).,Alias of random.random_sample (weight: 1.00),3.00,,,,,,,,,,
+round,alias,counted_unary,,1.0000,0.8722,,,,Round to given number of decimals element-wise.,Alias of rint (weight: 1.00),0.30,,,,,,,,,,
+trapz,alias,counted_custom,,1.0000,4.3001,,,,Alias for trapezoid (deprecated). Removed in numpy 2.4; use `trapezoid` instead.,Alias of trapezoid (weight: 1.00),4.30,,,,,,,,,,
+array2string,blacklisted,blacklisted,,,,,,,Return string representation of array. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+array_repr,blacklisted,blacklisted,,,,,,,Return string representation of array. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+array_str,blacklisted,blacklisted,,,,,,,Return string representation of data in array. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+asmatrix,blacklisted,blacklisted,,,,,,,Interpret input as matrix (deprecated). Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+base_repr,blacklisted,blacklisted,,,,,,,Return string representation of number in given base. Cost: numel(input).,Intentionally unsupported in flopscope,,,,,,,,,,,
+binary_repr,blacklisted,blacklisted,,,,,,,Return binary string representation of the input number. Cost: numel(input).,Intentionally unsupported in flopscope,,,,,,,,,,,
+busday_count,blacklisted,blacklisted,,,,,,,Count valid days between begindate and enddate. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+busday_offset,blacklisted,blacklisted,,,,,,,Apply offset to dates subject to valid day rules. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+datetime_as_string,blacklisted,blacklisted,,,,,,,Convert datetime array to string representation. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+datetime_data,blacklisted,blacklisted,,,,,,,Get information about the step size of datetime dtype. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+format_float_positional,blacklisted,blacklisted,,,,,,,Format floating point scalar as decimal string. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+format_float_scientific,blacklisted,blacklisted,,,,,,,Format floating point scalar as scientific notation. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+fromfile,blacklisted,blacklisted,,,,,,,Construct array from binary/text file. Cost: numel(output).,Intentionally unsupported in flopscope,,,,,,,,,,,
+frompyfunc,blacklisted,blacklisted,,,,,,,Take arbitrary Python function and return NumPy ufunc. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+fromregex,blacklisted,blacklisted,,,,,,,Construct array from text file using regex. Cost: numel(output).,Intentionally unsupported in flopscope,,,,,,,,,,,
+fromstring,blacklisted,blacklisted,,,,,,,Create 1-D array from string data. Cost: numel(output).,Intentionally unsupported in flopscope,,,,,,,,,,,
+genfromtxt,blacklisted,blacklisted,,,,,,,Load data from text file with missing values. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+get_include,blacklisted,blacklisted,,,,,,,Return directory containing NumPy C header files. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+getbufsize,blacklisted,blacklisted,,,,,,,Return size of buffer used in ufuncs. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+geterr,blacklisted,blacklisted,,,,,,,Get current way of handling floating-point errors. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+geterrcall,blacklisted,blacklisted,,,,,,,Return current callback function for floating-point errors. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+is_busday,blacklisted,blacklisted,,,,,,,Calculates which of given dates are valid days. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+isnat,blacklisted,blacklisted,,,,,,,Blacklisted per reviewer — datetime ops not in scope.,Intentionally unsupported in flopscope,,,,,,,,,,,
+load,blacklisted,blacklisted,,,,,,,Load arrays from .npy/.npz files. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+loadtxt,blacklisted,blacklisted,,,,,,,Load data from text file. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+nested_iters,blacklisted,blacklisted,,,,,,,Create nested iterators for multi-index broadcasting. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+save,blacklisted,blacklisted,,,,,,,Save array to .npy file. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+savetxt,blacklisted,blacklisted,,,,,,,Save array to text file. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+savez,blacklisted,blacklisted,,,,,,,Save multiple arrays to .npz file. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+savez_compressed,blacklisted,blacklisted,,,,,,,Save multiple arrays to compressed .npz file. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+setbufsize,blacklisted,blacklisted,,,,,,,Set size of buffer used in ufuncs. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+seterr,blacklisted,blacklisted,,,,,,,Set how floating-point errors are handled. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+seterrcall,blacklisted,blacklisted,,,,,,,Set callback function for floating-point errors. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+show_config,blacklisted,blacklisted,,,,,,,Show NumPy build configuration. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,
+show_runtime,blacklisted,blacklisted,,,,,,,Show runtime info. Not supported.,Intentionally unsupported in flopscope,,,,,,,,,,,