More arithmetic benchmarks

vortex-array/benches/binary_ops.rs

@@ -56,6 +56,70 @@ fn mul_i64_nonnull(bencher: Bencher) {
     bench_primitive(bencher, lhs, rhs, Operator::Mul);
 }
 
+#[divan::bench]
+fn mul_i8_nonnull(bencher: Bencher) {
+    let lhs = primitive_i8_small_nonnull(1).into_array();
+    let rhs = primitive_i8_small_nonnull(7).into_array();
+
+    bench_primitive(bencher, lhs, rhs, Operator::Mul);
+}
+
+#[divan::bench]
+fn mul_u8_nonnull(bencher: Bencher) {
+    let lhs = primitive_u8_small_nonnull(1).into_array();
+    let rhs = primitive_u8_small_nonnull(7).into_array();
+
+    bench_primitive(bencher, lhs, rhs, Operator::Mul);
+}
+
+#[divan::bench]
+fn mul_i16_nonnull(bencher: Bencher) {
+    let lhs = primitive_i16_small_nonnull(1).into_array();
+    let rhs = primitive_i16_small_nonnull(17).into_array();
+
+    bench_primitive(bencher, lhs, rhs, Operator::Mul);
+}
+
+#[divan::bench]
+fn mul_u16_nonnull(bencher: Bencher) {
+    let lhs = primitive_u16_small_nonnull(1).into_array();
+    let rhs = primitive_u16_small_nonnull(17).into_array();
+
+    bench_primitive(bencher, lhs, rhs, Operator::Mul);
+}
+
+#[divan::bench]
+fn mul_i32_nonnull(bencher: Bencher) {
+    let lhs = primitive_i32_small_nonnull(1).into_array();
+    let rhs = primitive_i32_small_nonnull(17).into_array();
+
+    bench_primitive(bencher, lhs, rhs, Operator::Mul);
+}
+
+#[divan::bench]
+fn mul_u32_nonnull(bencher: Bencher) {
+    let lhs = primitive_u32_small_nonnull(1).into_array();
+    let rhs = primitive_u32_small_nonnull(17).into_array();
+
+    bench_primitive(bencher, lhs, rhs, Operator::Mul);
+}
+
+#[divan::bench]
+fn mul_i32_nullable(bencher: Bencher) {
+    let lhs = primitive_i32_small_nullable(1, 7).into_array();
+    let rhs = primitive_i32_small_nullable(17, 5).into_array();
+
+    bench_primitive(bencher, lhs, rhs, Operator::Mul);
+}
+
+#[divan::bench]
+fn mul_i32_constant(bencher: Bencher) {
+    let lhs = primitive_i32_small_nonnull(1).into_array();
+    let rhs = ConstantArray::new(31i32, LEN).into_array();
+
+    bench_primitive(bencher, lhs, rhs, Operator::Mul);
+}
+
 #[divan::bench]
 fn div_i64_nonnull(bencher: Bencher) {
     let lhs = primitive_nonnull(1_000_000).into_array();
@@ -137,6 +201,30 @@ fn primitive_small_nonnull(offset: i64) -> PrimitiveArray {
     PrimitiveArray::from_iter((0..LEN as i64).map(|i| ((i + offset) % 1024) + 1))
 }
 
+fn primitive_i8_small_nonnull(offset: i8) -> PrimitiveArray {
+    PrimitiveArray::from_iter((0..LEN).map(|i| (((i as i32 + offset as i32) % 21) - 10) as i8))
+}
+
+fn primitive_u8_small_nonnull(offset: u8) -> PrimitiveArray {
+    PrimitiveArray::from_iter((0..LEN).map(|i| ((i + offset as usize) % 15 + 1) as u8))
+}
+
+fn primitive_i16_small_nonnull(offset: i16) -> PrimitiveArray {
+    PrimitiveArray::from_iter((0..LEN).map(|i| (((i as i32 + offset as i32) % 255) - 127) as i16))
+}
+
+fn primitive_u16_small_nonnull(offset: u16) -> PrimitiveArray {
+    PrimitiveArray::from_iter((0..LEN).map(|i| ((i + offset as usize) % 251 + 1) as u16))
+}
+
+fn primitive_i32_small_nonnull(offset: i32) -> PrimitiveArray {
+    PrimitiveArray::from_iter((0..LEN).map(|i| (((i as i64 + offset as i64) % 4096) - 2048) as i32))
+}
+
+fn primitive_u32_small_nonnull(offset: u32) -> PrimitiveArray {
+    PrimitiveArray::from_iter((0..LEN).map(|i| ((i + offset as usize) % 4096 + 1) as u32))
+}
+
 fn primitive_nonzero() -> PrimitiveArray {
     PrimitiveArray::from_iter((0..LEN as i64).map(|i| (i % 255) + 1))
 }
@@ -147,6 +235,13 @@ fn primitive_nullable(base: i64, null_every: usize) -> PrimitiveArray {
     )
 }
 
+fn primitive_i32_small_nullable(offset: i32, null_every: usize) -> PrimitiveArray {
+    PrimitiveArray::from_option_iter((0..LEN).map(|i| {
+        (!i.is_multiple_of(null_every))
+            .then_some((((i as i64 + offset as i64) % 4096) - 2048) as i32)
+    }))
+}
+
 fn bool_nullable(true_every: usize, null_every: usize) -> BoolArray {
     BoolArray::from_iter(
         (0..LEN).map(|i| (!i.is_multiple_of(null_every)).then_some(i.is_multiple_of(true_every))),