archery

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array with negative values
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{-1, 2, -3, 4, -5}, nil)
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Calculate absolute values
	ctx := context.Background()
	result, err := archery.Abs(ctx, arr)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(result)

	// Print the result
	fmt.Println("Absolute values:")
	for i := 0; i < result.Len(); i++ {
		if i > 0 {
			fmt.Printf(" ")
		}
		fmt.Printf("%.1f", result.(*array.Float64).Value(i))
	}
	fmt.Println()

}

Output:

Absolute values:
1.0 2.0 3.0 4.0 5.0

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create two test arrays
	builder1 := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder1.Release()

	builder1.AppendValues([]float64{1, 2, 3, 4, 5}, nil)
	arr1 := builder1.NewFloat64Array()
	defer arr1.Release()

	builder2 := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder2.Release()
	builder2.AppendValues([]float64{10, 20, 30, 40, 50}, nil)
	arr2 := builder2.NewFloat64Array()
	defer arr2.Release()

	// Add arrays
	ctx := context.Background()
	result, err := archery.Add(ctx, arr1, arr2)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(result)

	// Print the result
	fmt.Println("Add arrays:")
	for i := 0; i < result.Len(); i++ {
		if i > 0 {
			fmt.Printf(" ")
		}
		fmt.Printf("%.1f", result.(*array.Float64).Value(i))
	}
	fmt.Println()

}

Output:

Add arrays:
11.0 22.0 33.0 44.0 55.0

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{1, 2, 3, 4, 5}, nil)
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Add a scalar
	ctx := context.Background()
	result, err := archery.AddScalar(ctx, arr, float64(10))
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(result)

	// Print the result
	fmt.Println("Add 10:")
	for i := 0; i < result.Len(); i++ {
		if i > 0 {
			fmt.Printf(" ")
		}
		fmt.Printf("%.1f", result.(*array.Float64).Value(i))
	}
	fmt.Println()

}

Output:

Add 10:
11.0 12.0 13.0 14.0 15.0

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array with some null values
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{1, 2, 3, 4, 5}, []bool{true, true, false, true, true})
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Count non-null values
	ctx := context.Background()
	count, err := archery.Count(ctx, arr)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	// Count null values
	nullCount := archery.CountNull(ctx, arr)

	// Print the results
	fmt.Printf("Count: %d\n", count)
	fmt.Printf("Null Count: %d\n", nullCount)

}

Output:

Count: 4
Null Count: 1

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array with duplicates
	builder := array.NewInt64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]int64{1, 2, 2, 3, 1, 4, 5, 5}, nil)
	arr := builder.NewInt64Array()
	defer arr.Release()

	// Count values
	ctx := context.Background()
	values, counts, err := archery.CountValues(ctx, arr)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(values)
	defer archery.ReleaseArray(counts)

	// Print the values and counts
	fmt.Println("Value counts:")
	for i := 0; i < values.Len(); i++ {
		fmt.Printf("%d: %d\n", values.(*array.Int64).Value(i), counts.(*array.Int64).Value(i))
	}

}

Output:

Value counts:
1: 2
2: 2
3: 1
4: 1
5: 2

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewInt64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, nil)
	arr := builder.NewInt64Array()
	defer arr.Release()

	// Create a mask for values > 5
	ctx := context.Background()
	mask, err := archery.GreaterScalar(ctx, arr, int64(5))
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(mask)

	// Apply the mask
	filtered, err := archery.Filter(ctx, arr, mask)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(filtered)

	// Print the filtered array
	fmt.Println("Values > 5:")
	for i := 0; i < filtered.Len(); i++ {
		if i > 0 {
			fmt.Printf(" ")
		}
		fmt.Printf("%d", filtered.(*array.Int64).Value(i))
	}
	fmt.Println()

}

Output:

Values > 5:
6 7 8 9 10

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewInt64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, nil)
	arr := builder.NewInt64Array()
	defer arr.Release()

	// Create masks for 3 <= x <= 7
	ctx := context.Background()
	lowerMask, err := archery.GreaterEqualScalar(ctx, arr, int64(3))
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(lowerMask)

	upperMask, err := archery.LessEqualScalar(ctx, arr, int64(7))
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(upperMask)

	// Combine masks
	combinedMask, err := archery.And(ctx, lowerMask, upperMask)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(combinedMask)

	// Apply the combined mask
	filtered, err := archery.Filter(ctx, arr, combinedMask)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(filtered)

	// Print the filtered array
	fmt.Println("Values between 3 and 7:")
	for i := 0; i < filtered.Len(); i++ {
		if i > 0 {
			fmt.Printf(" ")
		}
		fmt.Printf("%d", filtered.(*array.Int64).Value(i))
	}
	fmt.Println()

}

Output:

Values between 3 and 7:
3 4 5 6 7

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewInt64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]int64{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, nil)
	arr := builder.NewInt64Array()
	defer arr.Release()

	// Create a set of values to check against
	setValues := []int64{2, 4, 6, 8, 10}

	// Create a mask for values in the set
	ctx := context.Background()

	// Create individual masks for each value in the set
	masks := make([]arrow.Array, len(setValues))
	for i, val := range setValues {
		mask, err := archery.EqualScalar(ctx, arr, val)
		if err != nil {
			fmt.Println("Error:", err)
			return
		}
		masks[i] = mask
	}

	// Combine all masks with OR
	var combinedMask arrow.Array
	if len(masks) > 0 {
		combinedMask = masks[0]
		for i := 1; i < len(masks); i++ {
			newMask, err := archery.Or(ctx, combinedMask, masks[i])
			if err != nil {
				fmt.Println("Error:", err)
				return
			}
			combinedMask.Release()
			masks[i].Release()
			combinedMask = newMask
		}
	}
	defer archery.ReleaseArray(combinedMask)

	// Apply the mask
	filtered, err := archery.Filter(ctx, arr, combinedMask)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(filtered)

	// Print the filtered array
	fmt.Println("Values in set [2, 4, 6, 8, 10]:")
	for i := 0; i < filtered.Len(); i++ {
		if i > 0 {
			fmt.Printf(" ")
		}
		fmt.Printf("%d", filtered.(*array.Int64).Value(i))
	}
	fmt.Println()

}

Output:

Values in set [2, 4, 6, 8, 10]:
2 4 6 8 10

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{1, 2, 3, 4, 5}, nil)
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Calculate mean
	ctx := context.Background()
	mean, err := archery.Mean(ctx, arr)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	// Print the result
	fmt.Printf("Mean: %.1f\n", mean)

}

Output:

Mean: 3.0

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{1, 2, 3, 4, 5}, nil)
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Calculate min and max
	ctx := context.Background()
	min, err := archery.Min(ctx, arr)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	max, err := archery.Max(ctx, arr)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	// Print the results
	fmt.Printf("Min: %.1f\n", min)
	fmt.Printf("Max: %.1f\n", max)

}

Output:

Min: 1.0
Max: 5.0

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{1, 2, 3, 4, 5}, nil)
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Multiply by a scalar
	ctx := context.Background()
	result, err := archery.MultiplyScalar(ctx, arr, float64(2))
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(result)

	// Print the result
	fmt.Println("Multiply by 2:")
	for i := 0; i < result.Len(); i++ {
		if i > 0 {
			fmt.Printf(" ")
		}
		fmt.Printf("%.1f", result.(*array.Float64).Value(i))
	}
	fmt.Println()

}

Output:

Multiply by 2:
2.0 4.0 6.0 8.0 10.0

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{5, 3, 1, 4, 2}, nil)
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Get the 2nd element (0-indexed) in sorted order
	ctx := context.Background()
	element, err := archery.NthElement(ctx, arr, 2, archery.Ascending)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	// Print the result
	fmt.Printf("3rd smallest element: %.1f\n", element)

}

Output:

3rd smallest element: 3.0

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array with nulls
	builder := array.NewInt64Builder(memory.DefaultAllocator)
	defer builder.Release()

	// Add values with some nulls
	builder.AppendValues([]int64{1, 2, 3}, []bool{true, false, true})
	builder.AppendNull()
	builder.AppendValues([]int64{5, 6}, []bool{true, true})

	arr := builder.NewInt64Array()
	defer arr.Release()

	// Create a manual mask for non-null values
	maskBuilder := array.NewBooleanBuilder(memory.DefaultAllocator)
	defer maskBuilder.Release()

	for i := 0; i < arr.Len(); i++ {
		maskBuilder.Append(!arr.IsNull(i))
	}

	mask := maskBuilder.NewBooleanArray()
	defer mask.Release()

	// Apply the mask to drop nulls
	ctx := context.Background()
	nonNullArr, err := archery.Filter(ctx, arr, mask)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(nonNullArr)

	// Print the non-null values
	fmt.Println("Non-null values:")
	for i := 0; i < nonNullArr.Len(); i++ {
		if i > 0 {
			fmt.Printf(" ")
		}
		fmt.Printf("%d", nonNullArr.(*array.Int64).Value(i))
	}
	fmt.Println()

	// Count nulls
	nullCount := archery.CountNull(ctx, arr)
	fmt.Printf("Null count: %d\n", nullCount)

}

Output:

Non-null values:
1 3 5 6
Null count: 2

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{5, 3, 1, 4, 2}, nil)
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Sort the array in ascending order
	ctx := context.Background()
	sorted, err := archery.Sort(ctx, arr, archery.Ascending)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(sorted)

	// Print the sorted array
	fmt.Println("Sorted (ascending):")
	for i := 0; i < sorted.Len(); i++ {
		if i > 0 {
			fmt.Printf(" ")
		}
		fmt.Printf("%.1f", sorted.(*array.Float64).Value(i))
	}
	fmt.Println()

}

Output:

Sorted (ascending):
1.0 2.0 3.0 4.0 5.0

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{5, 3, 1, 4, 2}, nil)
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Sort the array in descending order
	ctx := context.Background()
	sorted, err := archery.Sort(ctx, arr, archery.Descending)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(sorted)

	// Print the sorted array
	fmt.Println("Sorted (descending):")
	for i := 0; i < sorted.Len(); i++ {
		if i > 0 {
			fmt.Printf(" ")
		}
		fmt.Printf("%.1f", sorted.(*array.Float64).Value(i))
	}
	fmt.Println()

}

Output:

Sorted (descending):
5.0 4.0 3.0 2.0 1.0

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{5, 3, 1, 4, 2}, nil)
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Get sort indices
	ctx := context.Background()
	indices, err := archery.SortIndices(ctx, arr, archery.Ascending)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(indices)

	// Print the indices
	fmt.Println("Sort indices:")
	for i := 0; i < indices.Len(); i++ {
		if i > 0 {
			fmt.Printf(" ")
		}
		fmt.Printf("%d", indices.(*array.Int64).Value(i))
	}
	fmt.Println()

}

Output:

Sort indices:
2 4 1 3 0

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{1, 4, 9, 16, 25}, nil)
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Calculate square root
	ctx := context.Background()
	result, err := archery.Sqrt(ctx, arr)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(result)

	// Print the result
	fmt.Println("Square root:")
	for i := 0; i < result.Len(); i++ {
		if i > 0 {
			fmt.Printf(" ")
		}
		fmt.Printf("%.1f", result.(*array.Float64).Value(i))
	}
	fmt.Println()

}

Output:

Square root:
1.0 2.0 3.0 4.0 5.0

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{1, 2, 3, 4, 5}, nil)
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Calculate standard deviation
	ctx := context.Background()
	stdDev, err := archery.StandardDeviation(ctx, arr)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	// Print the result (rounded to 1 decimal place)
	fmt.Printf("Standard Deviation: %.1f\n", stdDev)

}

Output:

Standard Deviation: 1.4

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{1, 2, 3, 4, 5}, nil)
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Calculate sum
	ctx := context.Background()
	sum, err := archery.Sum(ctx, arr)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	// Print the result
	fmt.Printf("Sum: %.1f\n", sum)

}

Output:

Sum: 15.0

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array with duplicates
	builder := array.NewInt64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]int64{1, 2, 2, 3, 1, 4, 5, 5}, nil)
	arr := builder.NewInt64Array()
	defer arr.Release()

	// Get unique values
	ctx := context.Background()
	unique, err := archery.UniqueValues(ctx, arr)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}
	defer archery.ReleaseArray(unique)

	// Print the unique values
	fmt.Println("Unique values:")
	for i := 0; i < unique.Len(); i++ {
		if i > 0 {
			fmt.Printf(" ")
		}
		fmt.Printf("%d", unique.(*array.Int64).Value(i))
	}
	fmt.Println()

}

Output:

Unique values:
1 2 3 4 5

package main

import (
	"context"
	"fmt"

	"github.com/TFMV/archery"
	"github.com/apache/arrow-go/v18/arrow/array"
	"github.com/apache/arrow-go/v18/arrow/memory"
)

func main() {
	// Create a test array
	builder := array.NewFloat64Builder(memory.DefaultAllocator)
	defer builder.Release()
	builder.AppendValues([]float64{1, 2, 3, 4, 5}, nil)
	arr := builder.NewFloat64Array()
	defer arr.Release()

	// Calculate variance
	ctx := context.Background()
	variance, err := archery.Variance(ctx, arr)
	if err != nil {
		fmt.Println("Error:", err)
		return
	}

	// Print the result
	fmt.Printf("Variance: %.1f\n", variance)

}

Output:

Variance: 2.0