benchmark_test.go

package hybridarray

import (
	"math"
	"testing"
)

// BenchmarkFromMap measures array creation from map.
func BenchmarkFromMap(b *testing.B) {
	data := map[string][]any{
		"x": make([]any, 1000),
		"y": make([]any, 1000),
		"z": make([]any, 1000),
	}

	// Fill with data
	for i := range 1000 {
		data["x"][i] = float64(i)
		data["y"][i] = float64(i * 2)
		data["z"][i] = float64(i * 3)
	}

	for b.Loop() {
		_, _ = FromMap(data)
	}
}

// BenchmarkAddColumn measures column addition performance.
func BenchmarkAddColumn(b *testing.B) {
	nrows := 1000
	data := make([]any, nrows)
	for i := range data {
		data[i] = float64(i)
	}

	for b.Loop() {
		b.StopTimer()
		arr := New(nrows)
		b.StartTimer()

		arr.AddColumn("x", data, DTypeFloat64)
	}
}

// BenchmarkGetColumn measures column lookup speed.
func BenchmarkGetColumn(b *testing.B) {
	arr := New(1000)
	data := make([]any, 1000)
	arr.AddColumn("x", data, DTypeFloat64)

	for b.Loop() {
		_ = arr.GetColumn("x")
	}
}

// BenchmarkColumnNames measures column name retrieval.
func BenchmarkColumnNames(b *testing.B) {
	arr := New(100)
	for i := range 10 {
		data := make([]any, 100)
		arr.AddColumn(string(rune('a'+i)), data, DTypeFloat64)
	}

	for b.Loop() {
		_ = arr.ColumnNames()
	}
}

// BenchmarkColumnsIterator measures iterator performance.
func BenchmarkColumnsIterator(b *testing.B) {
	arr := New(100)
	for i := range 10 {
		data := make([]any, 100)
		arr.AddColumn(string(rune('a'+i)), data, DTypeFloat64)
	}

	for b.Loop() {
		for range arr.Columns() {
			// Just iterate
		}
	}
}

// BenchmarkSlice measures zero-copy slicing.
func BenchmarkSlice(b *testing.B) {
	arr := New(10000)
	data := make([]any, 10000)
	for i := range data {
		data[i] = float64(i)
	}
	arr.AddColumn("x", data, DTypeFloat64)

	for b.Loop() {
		_, _ = arr.Slice(1000, 5000)
	}
}

// BenchmarkSelect measures column selection.
func BenchmarkSelect(b *testing.B) {
	arr := New(1000)
	for i := range 10 {
		data := make([]any, 1000)
		arr.AddColumn(string(rune('a'+i)), data, DTypeFloat64)
	}

	for b.Loop() {
		_, _ = arr.Select("a", "c", "e")
	}
}

// BenchmarkAt measures single value access.
func BenchmarkAt(b *testing.B) {
	arr := New(10000)
	data := make([]any, 10000)
	for i := range data {
		data[i] = float64(i)
	}
	arr.AddColumn("x", data, DTypeFloat64)

	for b.Loop() {
		_, _ = arr.At(5000, "x")
	}
}

// BenchmarkAtView measures value access on a view.
func BenchmarkAtView(b *testing.B) {
	arr := New(10000)
	data := make([]any, 10000)
	for i := range data {
		data[i] = float64(i)
	}
	arr.AddColumn("x", data, DTypeFloat64)

	view, _ := arr.Slice(1000, 9000)

	for b.Loop() {
		_, _ = view.At(4000, "x")
	}
}

// BenchmarkRow measures full row access.
func BenchmarkRow(b *testing.B) {
	arr := New(1000)
	for i := range 10 {
		data := make([]any, 1000)
		arr.AddColumn(string(rune('a'+i)), data, DTypeFloat64)
	}

	for b.Loop() {
		_, _ = arr.Row(500)
	}
}

// BenchmarkInferDType measures type inference speed.
func BenchmarkInferDType(b *testing.B) {
	data := make([]any, 1000)
	for i := range data {
		data[i] = float64(i)
	}

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_ = inferDType(data)
	}
}

// BenchmarkVectorizedSum simulates vectorized operations.
func BenchmarkVectorizedSum(b *testing.B) {
	arr := New(100000)
	data := make([]any, 100000)
	for i := range data {
		data[i] = float64(i)
	}
	arr.AddColumn("x", data, DTypeFloat64)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		sum := 0.0
		col := arr.GetColumn("x")
		for _, v := range col.Data {
			sum += v.(float64)
		}
		_ = sum
	}
}

// BenchmarkMultiColumnOperation measures operations across columns.
func BenchmarkMultiColumnOperation(b *testing.B) {
	arr := New(10000)
	x := make([]any, 10000)
	y := make([]any, 10000)
	for i := range x {
		x[i] = float64(i)
		y[i] = float64(i * 2)
	}
	arr.AddColumn("x", x, DTypeFloat64)
	arr.AddColumn("y", y, DTypeFloat64)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		xCol := arr.GetColumn("x")
		yCol := arr.GetColumn("y")
		result := 0.0
		for j := range xCol.Data {
			result += xCol.Data[j].(float64) + yCol.Data[j].(float64)
		}
		_ = result
	}
}

// BenchmarkMemoryFootprint measures memory usage (run with -benchmem).
func BenchmarkMemoryFootprint(b *testing.B) {
	b.ReportAllocs()

	for b.Loop() {
		arr := New(1000)
		for j := range 5 {
			data := make([]any, 1000)
			for k := range data {
				data[k] = float64(k)
			}
			arr.AddColumn(string(rune('a'+j)), data, DTypeFloat64)
		}
	}
}

// BenchmarkSliceChain measures nested view creation.
func BenchmarkSliceChain(b *testing.B) {
	arr := New(100000)
	data := make([]any, 100000)
	for i := range data {
		data[i] = float64(i)
	}
	arr.AddColumn("x", data, DTypeFloat64)

	for b.Loop() {
		view1, _ := arr.Slice(10000, 90000)
		view2, _ := view1.Slice(10000, 70000)
		view3, _ := view2.Slice(10000, 50000)
		_ = view3
	}
}

// BenchmarkComplexPipeline simulates a realistic data pipeline.
func BenchmarkComplexPipeline(b *testing.B) {
	// Create base array
	data := map[string][]any{
		"x": make([]any, 10000),
		"y": make([]any, 10000),
		"z": make([]any, 10000),
	}
	for i := 0; i < 10000; i++ {
		data["x"][i] = float64(i)
		data["y"][i] = float64(i) * 1.5
		data["z"][i] = math.Sin(float64(i) * 0.01)
	}

	for b.Loop() {
		arr, _ := FromMap(data)

		// Slice to middle rows
		view1, _ := arr.Slice(2000, 8000)

		// Select two columns
		view2, _ := view1.Select("x", "z")

		// Access some values
		for j := range 100 {
			_, _ = view2.At(j*10, "x")
		}
	}
}