simd

package module

Go to main page

Versions in this module

v1

v1.20.0

Aug 8, 2026

Changes in this version

+ func Bitshuffle(dst, src []byte)

+ func HashUint64(dst, keys []uint64, seed uint64)

+ func Unbitshuffle(dst, src []byte)

+ func VarintDecode(dst []uint64, src []byte) (n, consumed int)

v1.19.0

Aug 8, 2026

Changes in this version

+ func Deinterleave2(a, b, src []byte)

+ func Interleave2(dst, a, b []byte)

+ func MergeSortedUint32(dst, a, b []uint32) int

+ func RandFillU64(dst []uint64, seed uint64)

+ func Transpose8x8Bytes(dst, src []byte)

v1.18.0

Aug 8, 2026

Changes in this version

+ func LZ4BlockDecode(dst, src []byte) int

v1.17.0

Aug 8, 2026

Changes in this version

+ func FormatFloat64(dst []byte, v float64) int

v1.16.0

Aug 8, 2026

Changes in this version

+ func Adler32[S Text](p S, seed uint32) uint32

+ func CRC32C[S Text](p S, seed uint32) uint32

v1.15.0

Aug 8, 2026

Changes in this version

+ func CompressBitsInto[T ColumnarElem](dst, src []T, validity []byte) int

+ func CountValid(validity []byte, n int) int

+ func SumValid[T ColumnarElem](a []T, validity []byte) T

+ type ColumnarElem interface

v1.14.0

Aug 8, 2026

v1.13.0

Aug 8, 2026

Changes in this version

+ func JSONValid(b []byte, stk []uint64) int

v1.12.0

Aug 6, 2026

Changes in this version

+ func JSONValidTokens(b []byte, masks []uint64, stk []uint64) int

v1.11.0

Aug 6, 2026

Changes in this version

+ func JSONStage1(out []uint64, masks []byte, nw int, carr []uint64, res []int64)

v1.10.2

Aug 5, 2026

v1.10.1

Aug 5, 2026

v1.10.0

Aug 5, 2026

Changes in this version

+ func JSONCopyValid[S Text](dst []byte, s S, html bool) int

+ func JSONQuote[S Text](dst []byte, s S, html bool) int

+ func KernelThreshold(op string) int

v1.9.1

Aug 4, 2026

Changes in this version

+ func MaskWords(n int) int

v1.9.0

Aug 3, 2026

Changes in this version

+ const JSONMaskAll

+ const JSONMaskControl

+ const JSONMaskEscape

+ const JSONMaskQuote

+ const JSONMaskSpace

+ const JSONMaskStructural

+ func JSONMasks[S Text](dst []byte, s S, want uint32)

v1.8.0

Aug 3, 2026

Changes in this version

+ func JSONCopyRun[S Text](dst []byte, s S, html bool) int

v1.7.1

Aug 3, 2026

v1.7.0

Aug 3, 2026

Changes in this version

+ func IndexAnyOrLess[S, T Text](s S, chars T, lo byte) int

v1.6.0

Aug 3, 2026

v1.5.0

Aug 2, 2026

v1.4.0

Aug 2, 2026

Changes in this version

+ func MaskBitsAny[S Text](dst []byte, s S, chars string)

+ func MaskBitsLess[S Text](dst []byte, s S, c byte)

+ func MaskBits[S Text](dst []byte, s S, c byte)

+ func MaskLen(n int) int

v1.3.0

Aug 1, 2026

Changes in this version

+ func IndexAllAny[S Text](dst []int32, s S, chars string) int

v1.2.0

Aug 1, 2026

Changes in this version

+ func RankOneInto[T Float](a, x, y []T, alpha T, m, n int)

+ func Rotate[T Float](x, y []T, c, s T)

+ func Swap[T Number](x, y []T)

v1.1.0

Jul 31, 2026

Changes in this version

+ func GemvParallelInto[T Number](dst, a, x []T, m, k int)

+ func MatMulParallelInto[T Number](dst, a, b []T, m, k, n int)

v1.0.5

Jul 31, 2026

v1.0.4

Jul 31, 2026

v1.0.3

Jul 31, 2026

v1.0.2

Jul 31, 2026

Changes in this version

+ const HasVectorType

+ func AbsComplexInto[R Float, C Complex](dst []R, a []C)

+ func AbsInto[T Number](dst, a []T)

+ func Abs[T Number](a []T)

+ func AcosInto[T Float](dst, a []T)

+ func Acos[T Float](a []T)

+ func AcoshInto[T Float](dst, a []T)

+ func Acosh[T Float](a []T)

+ func AddAll[T Number](dst []T, srcs ...[]T)

+ func AddComplexInto[C Complex](dst, a, b []C)

+ func AddComplex[C Complex](a, b []C)

+ func AddInto[T Number](dst, a, b []T)

+ func AddScalarInto[T Number](dst, a []T, s T)

+ func AddScalar[T Number](a []T, s T)

+ func AddScaledInto[T Number](dst, a, b []T, s T)

+ func AddScaled[T Number](a, b []T, s T)

+ func Add[T Number](a, b []T)

+ func All(m []bool) bool

+ func And(a, b []byte)

+ func AndInto(dst, a, b []byte)

+ func AndMask(a, b []bool)

+ func AndMaskInto(dst, a, b []bool)

+ func AndNot(a, b []byte)

+ func AndNotInto(dst, a, b []byte)

+ func Any(m []bool) bool

+ func AnyNaN[T Float](a []T, mask []bool) bool

+ func AppendEscapeJSON[S Text](dst []byte, s S) []byte

+ func AppendRunes[S Text](dst []rune, s S) []rune

+ func AppendUTF16[S Text](dst []uint16, s S) []uint16

+ func AppendUTF8(dst []byte, s []uint16) []byte

+ func AppendUTF8FromRunes(dst []byte, s []rune) []byte

+ func AppendVarints[T VarintValue](dst []byte, a []T) []byte

+ func ApplyWindowInto[T Float](dst, a, w []T)

+ func ArgMax[T Number](a []T) int

+ func ArgMin[T Number](a []T) int

+ func Argsort[T Number](idx []int32, a []T) int

+ func AsinInto[T Float](dst, a []T)

+ func Asin[T Float](a []T)

+ func AsinhInto[T Float](dst, a []T)

+ func Asinh[T Float](a []T)

+ func Atan2Into[T Float](dst, a, b []T)

+ func Atan2[T Float](a, b []T)

+ func AtanInto[T Float](dst, a []T)

+ func Atan[T Float](a []T)

+ func AtanhInto[T Float](dst, a []T)

+ func Atanh[T Float](a []T)

+ func AvailableTiers() []string

+ func BFloat16ToFloat32Into(dst []float32, a []uint16)

+ func Bartlett[T Float](dst []T)

+ func Base64Decode[S Text](dst []byte, src S) int

+ func Base64DecodedLen(n int) int

+ func Base64Encode[S Text](dst []byte, src S) int

+ func Base64EncodedLen(n int) int

+ func BincountInto[T Integer](counts []int32, a []T)

+ func Bincount[T Integer](a []T, n int) []int32

+ func BitPackInto(dst, a []uint32, bits int32)

+ func BitUnpackInto(dst, a []uint32, bits int32)

+ func Blackman[T Float](dst []T)

+ func BottomKInto[T Number](dst []T, a []T, k int, scratch []T) int

+ func BottomK[T Number](a []T, k int) []T

+ func ByteSwapInto[T Integer](dst, a []T)

+ func CbrtInto[T Float](dst, a []T)

+ func Cbrt[T Float](a []T)

+ func CeilInto[T Float](dst, a []T)

+ func Ceil[T Float](a []T)

+ func ClampInto[T Number](dst, a []T, lo, hi T)

+ func Clamp[T Number](a []T, lo, hi T)

+ func CommonPrefixLen[S, T Text](a S, b T) int

+ func Compare[S, T Text](a S, b T) int

+ func CompressInto[T Number](dst, src []T, mask []bool) int

+ func ConjComplexInto[C Complex](dst, a []C)

+ func ConjComplex[C Complex](a []C)

+ func ContainsAny[S, T Text](s S, chars T) bool

+ func ContainsByte[S Text](s S, c byte) bool

+ func ContainsFoldASCII[S, T Text](haystack S, needle T, scratch []byte) bool

+ func Contains[S, T Text](haystack S, needle T) bool

+ func ConvertInto[D, S Number](dst []D, src []S)

+ func ConvolveFullInto[T Float](dst, a, b []T)

+ func ConvolveFull[T Float](a, b []T) []T

+ func ConvolveInto[T Number](dst, sig, ker []T)

+ func CorrelateFullInto[T Float](dst, a, b, scratch []T)

+ func CorrelateFull[T Float](a, b []T) []T

+ func CorrelateInto[T Number](dst, sig, ker []T)

+ func Correlation[T Float](x, y []T) T

+ func CosInto[T Float](dst, a []T)

+ func Cos[T Float](a []T)

+ func CoshInto[T Float](dst, a []T)

+ func Cosh[T Float](a []T)

+ func CosineSimilarity[T Float](a, b []T) T

+ func CountAny[S, T Text](s S, chars T) int

+ func CountByte[S Text](s S, c byte) int

+ func CountFoldASCII[S, T Text](haystack S, needle T, scratch []byte) int

+ func CountNaN[T Float](a []T, mask []bool) int

+ func CountTrue(m []bool) int

+ func Count[S, T Text](haystack S, needle T) int

+ func Covariance[T Float](x, y []T) T

+ func CumMaxInto[T Number](dst, a []T)

+ func CumMax[T Number](a []T)

+ func CumMinInto[T Number](dst, a []T)

+ func CumMin[T Number](a []T)

+ func CumProdInto[T Number](dst, a []T)

+ func CumProd[T Number](a []T)

+ func CumSumInto[T Number](dst, a []T)

+ func CumSum[T Number](a []T)

+ func DequantizeInt8(dst []float32, a []int8, scale float32, zeroPoint int32)

+ func DequantizePerChannelInt8(dst []float32, a []int8, scale []float32, zeroPoint []int32, ...)

+ func DequantizePerChannelUint8(dst []float32, a []uint8, scale []float32, zeroPoint []int32, ...)

+ func DequantizeUint8(dst []float32, a []uint8, scale float32, zeroPoint int32)

+ func Describe() string

+ func DiffInto[T Number](dst, a []T)

+ func DifferenceInto[T Integer](dst, a, b []T) int

+ func Distance[T Float](a, b []T) T

+ func DivComplexInto[C Complex](dst, a, b []C)

+ func DivComplex[C Complex](a, b []C)

+ func DivInto[T Float](dst, a, b []T)

+ func DivScalarInto[T Number](dst, a []T, s T)

+ func DivScalar[T Number](a []T, s T)

+ func Div[T Float](a, b []T)

+ func DotComplexConj[C Complex](a, b []C) C

+ func DotComplex[C Complex](a, b []C) C

+ func Dot[T Number](a, b []T) T

+ func EMAInto[T Number](dst, a []T, alpha T)

+ func EqualFoldASCII[S, T Text](a S, b T) bool

+ func EqualInto[T Number](dst []bool, a, b []T)

+ func EqualScalarInto[T Number](dst []bool, a []T, v T)

+ func Equal[S, T Text](a S, b T) bool

+ func ErfInto[T Float](dst, a []T)

+ func Erf[T Float](a []T)

+ func ErfcInto[T Float](dst, a []T)

+ func Erfc[T Float](a []T)

+ func EulerStep[T Float](y, dydt []T, t, h T, f Derivative[T])

+ func Exp2Into[T Float](dst, a []T)

+ func Exp2[T Float](a []T)

+ func ExpInto[T Float](dst, a []T)

+ func Exp[T Float](a []T)

+ func ExpandInto[T Number](dst, src []T, mask []bool) int

+ func Expm1Into[T Float](dst, a []T)

+ func Expm1[T Float](a []T)

+ func FFT(a []complex128) []complex128

+ func FFTInto(p *FFTPlan, dst, src []complex128)

+ func FastAcosInto[T Float](dst, a []T)

+ func FastAcos[T Float](a []T)

+ func FastAcoshInto[T Float](dst, a []T)

+ func FastAcosh[T Float](a []T)

+ func FastAsinInto[T Float](dst, a []T)

+ func FastAsin[T Float](a []T)

+ func FastAsinhInto[T Float](dst, a []T)

+ func FastAsinh[T Float](a []T)

+ func FastAtan2Into[T Float](dst, a, b []T)

+ func FastAtan2[T Float](a, b []T)

+ func FastAtanInto[T Float](dst, a []T)

+ func FastAtan[T Float](a []T)

+ func FastAtanhInto[T Float](dst, a []T)

+ func FastAtanh[T Float](a []T)

+ func FastCbrtInto[T Float](dst, a []T)

+ func FastCbrt[T Float](a []T)

+ func FastCosInto[T Float](dst, a []T)

+ func FastCos[T Float](a []T)

+ func FastCoshInto[T Float](dst, a []T)

+ func FastCosh[T Float](a []T)

+ func FastCumProdInto[T Float](dst, a []T)

+ func FastCumProd[T Float](a []T)

+ func FastCumSumInto[T Float](dst, a []T)

+ func FastCumSum[T Float](a []T)

+ func FastErfInto[T Float](dst, a []T)

+ func FastErf[T Float](a []T)

+ func FastExp2Into[T Float](dst, a []T)

+ func FastExp2[T Float](a []T)

+ func FastExpInto[T Float](dst, a []T)

+ func FastExp[T Float](a []T)

+ func FastExpm1Into[T Float](dst, a []T)

+ func FastExpm1[T Float](a []T)

+ func FastHypotInto[T Float](dst, a, b []T)

+ func FastHypot[T Float](a, b []T)

+ func FastLog10Into[T Float](dst, a []T)

+ func FastLog10[T Float](a []T)

+ func FastLog1pInto[T Float](dst, a []T)

+ func FastLog1p[T Float](a []T)

+ func FastLog2Into[T Float](dst, a []T)

+ func FastLog2[T Float](a []T)

+ func FastLogInto[T Float](dst, a []T)

+ func FastLog[T Float](a []T)

+ func FastPowInto[T Float](dst, a, b []T)

+ func FastPow[T Float](a, b []T)

+ func FastSigmoidInto[T Float](dst, a []T)

+ func FastSigmoid[T Float](a []T)

+ func FastSinInto[T Float](dst, a []T)

+ func FastSin[T Float](a []T)

+ func FastSinhInto[T Float](dst, a []T)

+ func FastSinh[T Float](a []T)

+ func FastTanInto[T Float](dst, a []T)

+ func FastTan[T Float](a []T)

+ func FastTanhInto[T Float](dst, a []T)

+ func FastTanh[T Float](a []T)

+ func Fill[T Number](a []T, v T)

+ func FilterInto[T Number](dst, src []T, pred func(T) bool) int

+ func Float16ToFloat32Into(dst []float32, a []uint16)

+ func Float32ToBFloat16Into(dst []uint16, a []float32)

+ func Float32ToFloat16Into(dst []uint16, a []float32)

+ func Float32ToFloat8E4M3Into(dst []byte, a []float32)

+ func Float32ToFloat8E5M2Into(dst []byte, a []float32)

+ func Float8E4M3ToFloat32Into(dst []float32, a []byte)

+ func Float8E5M2ToFloat32Into(dst []float32, a []byte)

+ func FloorInto[T Float](dst, a []T)

+ func Floor[T Float](a []T)

+ func FormatInts(dst []byte, vals []int64, sep byte) int

+ func FromPartsInto[C Complex, R Float](dst []C, re, im []R)

+ func GELU[T Float](a []T)

+ func GatherInto[T Number](dst, src []T, idx []int32)

+ func GemmPackLen[T Float](k, n int) int

+ func GemvInto[T Number](dst, a, x []T, m, k int)

+ func GrayscaleInto(dst, r, g, b []byte)

+ func GreaterEqualInto[T Number](dst []bool, a, b []T)

+ func GreaterEqualScalarInto[T Number](dst []bool, a []T, v T)

+ func GreaterInto[T Number](dst []bool, a, b []T)

+ func GreaterScalarInto[T Number](dst []bool, a []T, v T)

+ func HammingDistanceWords(a, b []uint64) int

+ func HammingDistance[S, T Text](a S, b T) int

+ func Hamming[T Float](dst []T)

+ func HannPeriodic[T Float](dst []T)

+ func Hann[T Float](dst []T)

+ func HasPrefix[S, T Text](s S, prefix T) bool

+ func HasSuffix[S, T Text](s S, suffix T) bool

+ func HexDecode[S Text](dst []byte, src S) (int, bool)

+ func HexEncode[S Text](dst []byte, src S) int

+ func Hilbert(src []float64) []complex128

+ func HilbertInto(p *FFTPlan, dst []complex128, src []float64)

+ func HistogramInto[T Number](counts []int32, a []T, lo, hi T)

+ func Histogram[T Number](a []T, n int, lo, hi T) []int32

+ func HypotInto[T Float](dst, a, b []T)

+ func Hypot[T Float](a, b []T)

+ func IFFT(a []complex128) []complex128

+ func IFFTInto(p *FFTPlan, dst, src []complex128)

+ func ImagInto[R Float, C Complex](dst []R, a []C)

+ func IndexAll[S Text](dst []int32, s S, c byte) int

+ func IndexAny[S, T Text](s S, chars T) int

+ func IndexByte[S Text](s S, c byte) int

+ func IndexFoldASCII[S, T Text](haystack S, needle T, scratch []byte) int

+ func IndexNotAny[S, T Text](s S, chars T) int

+ func Index[S, T Text](haystack S, needle T) int

+ func InterpInto[T Float](dst []T, x, xp, fp []T)

+ func Interp[T Float](x, xp, fp []T) []T

+ func IntersectInto[T Integer](dst, a, b []T) int

+ func IsASCII[S Text](s S) bool

+ func IsFiniteInto[T Float](dst []bool, a []T, scratch []T)

+ func IsInfInto[T Float](dst []bool, a []T, scratch []T)

+ func IsNaNInto[T Float](dst []bool, a []T)

+ func L1Norm[T Number](a []T) T

+ func Lanes[T float32 | float64 | int32 | int64 | uint8]() int

+ func LastIndexByte[S Text](s S, c byte) int

+ func LastIndexNotAny[S, T Text](s S, chars T) int

+ func LastIndex[S, T Text](haystack S, needle T) int

+ func LayerNormInto[T Float](dst, a, gamma, beta []T, eps T)

+ func LayerNorm[T Float](a []T, eps T)

+ func LeadingZerosInto[T Integer](dst, a []T)

+ func LeakyReLU[T Float](a []T, slope T)

+ func LerpInto[T Number](dst, a, b []T, t T)

+ func Lerp[T Number](a, b []T, t T)

+ func LessEqualInto[T Number](dst []bool, a, b []T)

+ func LessEqualScalarInto[T Number](dst []bool, a []T, v T)

+ func LessInto[T Number](dst []bool, a, b []T)

+ func LessScalarInto[T Number](dst []bool, a []T, v T)

+ func LinearRegression[T Float](x, y []T) (slope, intercept T)

+ func Log10Into[T Float](dst, a []T)

+ func Log10[T Float](a []T)

+ func Log1pInto[T Float](dst, a []T)

+ func Log1p[T Float](a []T)

+ func Log2Into[T Float](dst, a []T)

+ func Log2[T Float](a []T)

+ func LogInto[T Float](dst, a []T)

+ func LogSumExp[T Float](a []T) T

+ func Log[T Float](a []T)

+ func LowerBoundInto[T Number](dst []int32, a, q []T)

+ func ManhattanDistance[T Number](a, b []T) T

+ func MatMulIntoPacked[T Float](dst, a, bp []T, m, k, n int)

+ func MatMulIntoScratch[T Float](dst, a, b, scratch []T, m, k, n int)

+ func MatMulInto[T Number](dst, a, b []T, m, k, n int)

+ func Max[T Number](a []T) T

+ func MaximumInto[T Number](dst, a, b []T)

+ func Maximum[T Number](a, b []T)

+ func Mean[T Float](a []T) T

+ func MedianInto[T Number](a, scratch []T) T

+ func Median[T Number](a []T) T

+ func MinMax[T Number](a []T) (lo, hi T)

+ func Min[T Number](a []T) T

+ func MinimumInto[T Number](dst, a, b []T)

+ func Minimum[T Number](a, b []T)

+ func MovingAverageInto[T Number](dst, a []T, width int)

+ func MulAll[T Number](dst []T, srcs ...[]T)

+ func MulComplexInto[C Complex](dst, a, b []C)

+ func MulComplex[C Complex](a, b []C)

+ func MulInto[T Number](dst, a, b []T)

+ func Mul[T Number](a, b []T)

+ func NanMean[T Float](a []T, scratch []T, mask []bool) (T, int)

+ func NanSum[T Float](a []T, scratch []T, mask []bool) T

+ func NeedsEscapeJSON[S Text](s S) bool

+ func NegComplexInto[C Complex](dst, a []C)

+ func NegComplex[C Complex](a []C)

+ func NegInto[T Number](dst, a []T)

+ func Neg[T Number](a []T)

+ func Norm[T Float](a []T) T

+ func Normalize[T Float](a []T)

+ func NotEqualInto[T Number](dst []bool, a, b []T)

+ func NotEqualScalarInto[T Number](dst []bool, a []T, v T)

+ func NotMask(a []bool)

+ func NotMaskInto(dst, a []bool)

+ func OnesCountInto[T Integer](dst, a []T)

+ func Or(a, b []byte)

+ func OrInto(dst, a, b []byte)

+ func OrMask(a, b []bool)

+ func OrMaskInto(dst, a, b []bool)

+ func PackBInto[T Float](bp, b []T, k, n int)

+ func ParseFloats[S Text](dst []float64, src S, idx []int32) (int, bool)

+ func ParseInts[S Text](dst []int64, src S, idx []int32) (int, bool)

+ func ParseUints[S Text](dst []uint64, src S, idx []int32) (int, bool)

+ func PartitionInto[T Number](dst, src []T, pivot T) int

+ func PolyEvalInto[T Number](dst, x, coeffs []T)

+ func PolyEval[T Number](x, coeffs []T)

+ func PopCount[S Text](s S) int

+ func PowInto[T Float](dst, a, b []T)

+ func Pow[T Float](a, b []T)

+ func Prod[T Number](a []T) T

+ func QMatMulInt8Into(dst []int32, a, b []int8, m, k, n int)

+ func QuantileInto[T Number](a, scratch []T, q float64) T

+ func Quantile[T Number](a []T, q float64) T

+ func QuantizeInt8(dst []int8, a []float32, scale float32, zeroPoint int32)

+ func QuantizePerChannelInt8(dst []int8, a []float32, scale []float32, zeroPoint []int32, ...)

+ func QuantizePerChannelUint8(dst []uint8, a []float32, scale []float32, zeroPoint []int32, ...)

+ func QuantizeUint8(dst []uint8, a []float32, scale float32, zeroPoint int32)

+ func RFFT(src []float64) []complex128

+ func RFFTInto(p *RFFTPlan, dst []complex128, src []float64, scratch []complex128)

+ func RGBToUVInto(u, v, r, g, b []byte)

+ func RK4Step[T Float](y []T, t, h T, f Derivative[T], w *RK4Workspace[T])

+ func RMSNorm[T Float](a []T, eps T)

+ func Ramp[T Number](a []T, start, step T)

+ func RandomInto[T float32 | float64 | uint64](dst []T, seed uint64)

+ func Rank(v, table []uint64, p int) int

+ func RankTableInto(dst, v []uint64)

+ func ReLU[T Float](a []T)

+ func RealInto[R Float, C Complex](dst []R, a []C)

+ func ReciprocalInto[T Float](dst, a []T)

+ func Reciprocal[T Float](a []T)

+ func ReplaceByte(b []byte, old, new byte)

+ func ReplaceByteInto[S Text](dst []byte, s S, old, new byte)

+ func RequantizeInt8Into(dst []int8, a []int32, scale float32, zeroPoint int32)

+ func Rescale[T Float](a []T, lo, hi T)

+ func ReverseBitsInto[T Integer](dst, a []T)

+ func ReverseInto[T Number](dst, a []T)

+ func Reverse[T Number](a []T)

+ func RollingMaxInto[T Number](dst, a []T, window int)

+ func RollingMinInto[T Number](dst, a []T, window int)

+ func RotlInto[T Integer](dst, a []T, s uint64)

+ func Rotl[T Integer](a []T, s uint64)

+ func RotrInto[T Integer](dst, a []T, s uint64)

+ func Rotr[T Integer](a []T, s uint64)

+ func RoundInto[T Float](dst, a []T)

+ func RoundToEvenInto[T Float](dst, a []T)

+ func RoundToEven[T Float](a []T)

+ func Round[T Float](a []T)

+ func RunLengthDecodeInt32(dst, values, lengths []int32) int

+ func RunLengthEncodeInt32(values, lengths, a []int32, scratch []bool) int

+ func RunStartsBytesInto(dst []bool, a []byte)

+ func RunStartsInt64Into(dst []bool, a []int64)

+ func RunStartsInto(dst []bool, a []int32)

+ func RuneCount[S Text](s S) int

+ func SampleStdDev[T Float](a []T) T

+ func SampleVariance[T Float](a []T) T

+ func SatAddInto[T Saturating](dst, a, b []T)

+ func SatAdd[T Saturating](a, b []T)

+ func SatSubInto[T Saturating](dst, a, b []T)

+ func SatSub[T Saturating](a, b []T)

+ func ScaleComplexInto[C Complex, R Float](dst, a []C, s R)

+ func ScaleComplex[C Complex, R Float](a []C, s R)

+ func ScaleInto[T Number](dst, a []T, s T)

+ func Scale[T Number](a []T, s T)

+ func ScatterInto[T Number](dst []T, idx []int32, src []T)

+ func Select(v, table []uint64, k int) int

+ func SelectInto[T Number](dst []T, mask []bool, yes, no []T)

+ func ShlInto[T Integer](dst, a []T, s uint64)

+ func Shl[T Integer](a []T, s uint64)

+ func ShrInto[T Integer](dst, a []T, s uint64)

+ func Shr[T Integer](a []T, s uint64)

+ func SiLU[T Float](a []T)

+ func SigmoidInto[T Float](dst, a []T)

+ func Sigmoid[T Float](a []T)

+ func SignInto[T Float](dst []T, a []T, scratch []T, mask []bool)

+ func Simpson[T Float](y []T, h T) T

+ func SinInto[T Float](dst, a []T)

+ func Sin[T Float](a []T)

+ func SinhInto[T Float](dst, a []T)

+ func Sinh[T Float](a []T)

+ func Softmax[T Float](a []T)

+ func Softplus[T Float](a []T)

+ func SortInto[T Number](a, scratch []T)

+ func Sort[T Number](a []T)

+ func SortedIndex[T Number](a []T, v T) (int, bool)

+ func SpMVInto[T Float](dst []T, values []T, colIdx []int32, rowPtr []int32, x []T)

+ func SparseDot[T Float](v []T, idx []int32, x []T) T

+ func SqrtInto[T Float](dst, a []T)

+ func Sqrt[T Float](a []T)

+ func SquaredDistance[T Number](a, b []T) T

+ func Standardize[T Float](a []T)

+ func StdDev[T Float](a []T) T

+ func SubComplexInto[C Complex](dst, a, b []C)

+ func SubComplex[C Complex](a, b []C)

+ func SubInto[T Number](dst, a, b []T)

+ func SubScalarInto[T Number](dst, a []T, s T)

+ func SubScalar[T Number](a []T, s T)

+ func Sub[T Number](a, b []T)

+ func SumComplex[C Complex](a []C) C

+ func SumSquares[T Number](a []T) T

+ func Sum[T Number](a []T) T

+ func TanInto[T Float](dst, a []T)

+ func Tan[T Float](a []T)

+ func TanhInto[T Float](dst, a []T)

+ func Tanh[T Float](a []T)

+ func Tier() string

+ func Tile[T Number](a, pattern []T)

+ func ToLowerASCII(b []byte)

+ func ToLowerASCIIInto[S Text](dst []byte, s S)

+ func ToUpperASCII(b []byte)

+ func ToUpperASCIIInto[S Text](dst []byte, s S)

+ func TopKInto[T Number](dst []T, a []T, k int, scratch []T) int

+ func TopK[T Number](a []T, k int) []T

+ func TrailingZerosInto[T Integer](dst, a []T)

+ func TransposeInto[T Number](dst, a []T, m, n int)

+ func Transpose[T Number](a []T, m, n int) []T

+ func Trapezoid[T Float](y []T, h T) T

+ func TrimAny[S, T Text](s S, cutset T) S

+ func TrimLeftAny[S, T Text](s S, cutset T) S

+ func TrimRightAny[S, T Text](s S, cutset T) S

+ func TrimSpaceASCII[S Text](s S) S

+ func TruncInto[T Float](dst, a []T)

+ func Trunc[T Float](a []T)

+ func UTF16Len[S Text](s S) int

+ func UTF8Len(s []uint16) int

+ func ValidUTF8[S Text](s S) bool

+ func Variance[T Float](a []T) T

+ func VarintLenInto[T VarintValue](dst []int32, a []T)

+ func VarintSize[T VarintValue](a []T) int

+ func VerletStep[T Float](pos, vel, acc []T, h T, accel func(pos, out []T))

+ func Xor(a, b []byte)

+ func XorInto(dst, a, b []byte)

+ func XorMask(a, b []bool)

+ func XorMaskInto(dst, a, b []bool)

+ func Zero[T Number](a []T)

+ func ZigzagDecodeInt16Into(dst []int16, a []uint16)

+ func ZigzagDecodeInt32Into(dst []int32, a []uint32)

+ func ZigzagDecodeInt64Into(dst []int64, a []uint64)

+ func ZigzagDecodeInt8Into(dst []int8, a []byte)

+ func ZigzagEncodeInt16Into(dst []uint16, a []int16)

+ func ZigzagEncodeInt32Into(dst []uint32, a []int32)

+ func ZigzagEncodeInt64Into(dst []uint64, a []int64)

+ func ZigzagEncodeInt8Into(dst []byte, a []int8)

+ type Accumulator struct

+ func (s *Accumulator[T]) Add(a []T)

+ func (s *Accumulator[T]) Count() int

+ func (s *Accumulator[T]) Mean() T

+ func (s *Accumulator[T]) Reset()

+ func (s *Accumulator[T]) Sum() T

+ type Complex interface

+ type Derivative func(t T, y, dydt []T)

+ type FFTPlan struct

+ func NewFFTPlan(n int) *FFTPlan

+ func (p *FFTPlan) Len() int

+ type Float interface

+ type IntAccumulator struct

+ func (s *IntAccumulator[T]) Add(a []T)

+ func (s *IntAccumulator[T]) Count() int

+ func (s *IntAccumulator[T]) Reset()

+ func (s *IntAccumulator[T]) Sum() T

+ type Integer interface

+ type MinMaxAccumulator struct

+ func (s *MinMaxAccumulator[T]) Add(a []T)

+ func (s *MinMaxAccumulator[T]) MinMax() (min, max T, ok bool)

+ func (s *MinMaxAccumulator[T]) Reset()

+ type MultiSearcher struct

+ func NewMultiSearcher[T Text](needles []T) *MultiSearcher

+ func (m *MultiSearcher) Contains(haystack []byte) bool

+ func (m *MultiSearcher) ContainsString(haystack string) bool

+ func (m *MultiSearcher) Index(haystack []byte) (pos, which int)

+ func (m *MultiSearcher) IndexString(haystack string) (pos, which int)

+ type Number interface

+ type RFFTPlan struct

+ func NewRFFTPlan(n int) *RFFTPlan

+ func (p *RFFTPlan) Len() int

+ func (p *RFFTPlan) OutLen() int

+ type RK4Workspace struct

+ func NewRK4Workspace[T Float](n int) *RK4Workspace[T]

+ type Saturating interface

+ type Text interface

+ type VarintValue interface

v1.0.1

Jul 31, 2026

v1.0.0

Jul 31, 2026

v0

v0.2.0

Jul 28, 2026

v0.1.1

Jul 28, 2026

v0.1.0

Jul 27, 2026

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL