execution

package

v0.9.18 Latest Latest Go to latest Published: Jan 14, 2021 License: Apache-2.0 Imports: 10 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/gorgonia/tensor

Links

Open Source Insights

Documentation ¶

Index ¶

Variables
func AbsF32(a []float32)
func AbsF64(a []float64)
func AbsI(a []int)
func AbsI16(a []int16)
func AbsI32(a []int32)
func AbsI64(a []int64)
func AbsI8(a []int8)
func AbsIterF32(a []float32, ait Iterator) (err error)
func AbsIterF64(a []float64, ait Iterator) (err error)
func AbsIterI(a []int, ait Iterator) (err error)
func AbsIterI16(a []int16, ait Iterator) (err error)
func AbsIterI32(a []int32, ait Iterator) (err error)
func AbsIterI64(a []int64, ait Iterator) (err error)
func AbsIterI8(a []int8, ait Iterator) (err error)
func AddC128(a complex128, b complex128) complex128
func AddC64(a complex64, b complex64) complex64
func AddF32(a float32, b float32) float32
func AddF64(a float64, b float64) float64
func AddI(a int, b int) int
func AddI16(a int16, b int16) int16
func AddI32(a int32, b int32) int32
func AddI64(a int64, b int64) int64
func AddI8(a int8, b int8) int8
func AddIncrC128(a []complex128, b []complex128, incr []complex128)
func AddIncrC64(a []complex64, b []complex64, incr []complex64)
func AddIncrF32(a []float32, b []float32, incr []float32)
func AddIncrF64(a []float64, b []float64, incr []float64)
func AddIncrI(a []int, b []int, incr []int)
func AddIncrI16(a []int16, b []int16, incr []int16)
func AddIncrI32(a []int32, b []int32, incr []int32)
func AddIncrI64(a []int64, b []int64, incr []int64)
func AddIncrI8(a []int8, b []int8, incr []int8)
func AddIncrSVC128(a complex128, b []complex128, incr []complex128)
func AddIncrSVC64(a complex64, b []complex64, incr []complex64)
func AddIncrSVF32(a float32, b []float32, incr []float32)
func AddIncrSVF64(a float64, b []float64, incr []float64)
func AddIncrSVI(a int, b []int, incr []int)
func AddIncrSVI16(a int16, b []int16, incr []int16)
func AddIncrSVI32(a int32, b []int32, incr []int32)
func AddIncrSVI64(a int64, b []int64, incr []int64)
func AddIncrSVI8(a int8, b []int8, incr []int8)
func AddIncrSVStr(a string, b []string, incr []string)
func AddIncrSVU(a uint, b []uint, incr []uint)
func AddIncrSVU16(a uint16, b []uint16, incr []uint16)
func AddIncrSVU32(a uint32, b []uint32, incr []uint32)
func AddIncrSVU64(a uint64, b []uint64, incr []uint64)
func AddIncrSVU8(a uint8, b []uint8, incr []uint8)
func AddIncrStr(a []string, b []string, incr []string)
func AddIncrU(a []uint, b []uint, incr []uint)
func AddIncrU16(a []uint16, b []uint16, incr []uint16)
func AddIncrU32(a []uint32, b []uint32, incr []uint32)
func AddIncrU64(a []uint64, b []uint64, incr []uint64)
func AddIncrU8(a []uint8, b []uint8, incr []uint8)
func AddIncrVSC128(a []complex128, b complex128, incr []complex128)
func AddIncrVSC64(a []complex64, b complex64, incr []complex64)
func AddIncrVSF32(a []float32, b float32, incr []float32)
func AddIncrVSF64(a []float64, b float64, incr []float64)
func AddIncrVSI(a []int, b int, incr []int)
func AddIncrVSI16(a []int16, b int16, incr []int16)
func AddIncrVSI32(a []int32, b int32, incr []int32)
func AddIncrVSI64(a []int64, b int64, incr []int64)
func AddIncrVSI8(a []int8, b int8, incr []int8)
func AddIncrVSStr(a []string, b string, incr []string)
func AddIncrVSU(a []uint, b uint, incr []uint)
func AddIncrVSU16(a []uint16, b uint16, incr []uint16)
func AddIncrVSU32(a []uint32, b uint32, incr []uint32)
func AddIncrVSU64(a []uint64, b uint64, incr []uint64)
func AddIncrVSU8(a []uint8, b uint8, incr []uint8)
func AddIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)
func AddIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)
func AddIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)
func AddIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)
func AddIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)
func AddIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)
func AddIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)
func AddIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)
func AddIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)
func AddIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, ...) (err error)
func AddIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, ...) (err error)
func AddIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, ...) (err error)
func AddIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, ...) (err error)
func AddIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error)
func AddIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error)
func AddIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error)
func AddIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error)
func AddIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVC128(a complex128, b []complex128, incr []complex128, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVC64(a complex64, b []complex64, incr []complex64, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVF32(a float32, b []float32, incr []float32, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVF64(a float64, b []float64, incr []float64, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVI(a int, b []int, incr []int, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVI16(a int16, b []int16, incr []int16, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVI32(a int32, b []int32, incr []int32, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVI64(a int64, b []int64, incr []int64, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVI8(a int8, b []int8, incr []int8, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVStr(a string, b []string, incr []string, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVU(a uint, b []uint, incr []uint, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVU16(a uint16, b []uint16, incr []uint16, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVU32(a uint32, b []uint32, incr []uint32, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVU64(a uint64, b []uint64, incr []uint64, bit Iterator, iit Iterator) (err error)
func AddIterIncrSVU8(a uint8, b []uint8, incr []uint8, bit Iterator, iit Iterator) (err error)
func AddIterIncrStr(a []string, b []string, incr []string, ait Iterator, bit Iterator, ...) (err error)
func AddIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error)
func AddIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, ...) (err error)
func AddIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, ...) (err error)
func AddIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, ...) (err error)
func AddIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error)
func AddIterIncrVSC128(a []complex128, b complex128, incr []complex128, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSC64(a []complex64, b complex64, incr []complex64, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSF32(a []float32, b float32, incr []float32, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSF64(a []float64, b float64, incr []float64, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSI(a []int, b int, incr []int, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSI16(a []int16, b int16, incr []int16, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSI32(a []int32, b int32, incr []int32, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSI64(a []int64, b int64, incr []int64, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSI8(a []int8, b int8, incr []int8, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSStr(a []string, b string, incr []string, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSU(a []uint, b uint, incr []uint, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSU16(a []uint16, b uint16, incr []uint16, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSU32(a []uint32, b uint32, incr []uint32, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSU64(a []uint64, b uint64, incr []uint64, ait Iterator, iit Iterator) (err error)
func AddIterIncrVSU8(a []uint8, b uint8, incr []uint8, ait Iterator, iit Iterator) (err error)
func AddIterSVC128(a complex128, b []complex128, bit Iterator) (err error)
func AddIterSVC64(a complex64, b []complex64, bit Iterator) (err error)
func AddIterSVF32(a float32, b []float32, bit Iterator) (err error)
func AddIterSVF64(a float64, b []float64, bit Iterator) (err error)
func AddIterSVI(a int, b []int, bit Iterator) (err error)
func AddIterSVI16(a int16, b []int16, bit Iterator) (err error)
func AddIterSVI32(a int32, b []int32, bit Iterator) (err error)
func AddIterSVI64(a int64, b []int64, bit Iterator) (err error)
func AddIterSVI8(a int8, b []int8, bit Iterator) (err error)
func AddIterSVStr(a string, b []string, bit Iterator) (err error)
func AddIterSVU(a uint, b []uint, bit Iterator) (err error)
func AddIterSVU16(a uint16, b []uint16, bit Iterator) (err error)
func AddIterSVU32(a uint32, b []uint32, bit Iterator) (err error)
func AddIterSVU64(a uint64, b []uint64, bit Iterator) (err error)
func AddIterSVU8(a uint8, b []uint8, bit Iterator) (err error)
func AddIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)
func AddIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)
func AddIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)
func AddIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)
func AddIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)
func AddIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)
func AddIterVSC128(a []complex128, b complex128, ait Iterator) (err error)
func AddIterVSC64(a []complex64, b complex64, ait Iterator) (err error)
func AddIterVSF32(a []float32, b float32, ait Iterator) (err error)
func AddIterVSF64(a []float64, b float64, ait Iterator) (err error)
func AddIterVSI(a []int, b int, ait Iterator) (err error)
func AddIterVSI16(a []int16, b int16, ait Iterator) (err error)
func AddIterVSI32(a []int32, b int32, ait Iterator) (err error)
func AddIterVSI64(a []int64, b int64, ait Iterator) (err error)
func AddIterVSI8(a []int8, b int8, ait Iterator) (err error)
func AddIterVSStr(a []string, b string, ait Iterator) (err error)
func AddIterVSU(a []uint, b uint, ait Iterator) (err error)
func AddIterVSU16(a []uint16, b uint16, ait Iterator) (err error)
func AddIterVSU32(a []uint32, b uint32, ait Iterator) (err error)
func AddIterVSU64(a []uint64, b uint64, ait Iterator) (err error)
func AddIterVSU8(a []uint8, b uint8, ait Iterator) (err error)
func AddSVC128(a complex128, b []complex128)
func AddSVC64(a complex64, b []complex64)
func AddSVF32(a float32, b []float32)
func AddSVF64(a float64, b []float64)
func AddSVI(a int, b []int)
func AddSVI16(a int16, b []int16)
func AddSVI32(a int32, b []int32)
func AddSVI64(a int64, b []int64)
func AddSVI8(a int8, b []int8)
func AddSVStr(a string, b []string)
func AddSVU(a uint, b []uint)
func AddSVU16(a uint16, b []uint16)
func AddSVU32(a uint32, b []uint32)
func AddSVU64(a uint64, b []uint64)
func AddSVU8(a uint8, b []uint8)
func AddStr(a string, b string) string
func AddU(a uint, b uint) uint
func AddU16(a uint16, b uint16) uint16
func AddU32(a uint32, b uint32) uint32
func AddU64(a uint64, b uint64) uint64
func AddU8(a uint8, b uint8) uint8
func AddVSC128(a []complex128, b complex128)
func AddVSC64(a []complex64, b complex64)
func AddVSF32(a []float32, b float32)
func AddVSF64(a []float64, b float64)
func AddVSI(a []int, b int)
func AddVSI16(a []int16, b int16)
func AddVSI32(a []int32, b int32)
func AddVSI64(a []int64, b int64)
func AddVSI8(a []int8, b int8)
func AddVSStr(a []string, b string)
func AddVSU(a []uint, b uint)
func AddVSU16(a []uint16, b uint16)
func AddVSU32(a []uint32, b uint32)
func AddVSU64(a []uint64, b uint64)
func AddVSU8(a []uint8, b uint8)
func ArgmaxF32(a []float32) int
func ArgmaxF64(a []float64) int
func ArgmaxI(a []int) int
func ArgmaxI16(a []int16) int
func ArgmaxI32(a []int32) int
func ArgmaxI64(a []int64) int
func ArgmaxI8(a []int8) int
func ArgmaxMaskedF32(a []float32, mask []bool) int
func ArgmaxMaskedF64(a []float64, mask []bool) int
func ArgmaxMaskedI(a []int, mask []bool) int
func ArgmaxMaskedI16(a []int16, mask []bool) int
func ArgmaxMaskedI32(a []int32, mask []bool) int
func ArgmaxMaskedI64(a []int64, mask []bool) int
func ArgmaxMaskedI8(a []int8, mask []bool) int
func ArgmaxMaskedStr(a []string, mask []bool) int
func ArgmaxMaskedU(a []uint, mask []bool) int
func ArgmaxMaskedU16(a []uint16, mask []bool) int
func ArgmaxMaskedU32(a []uint32, mask []bool) int
func ArgmaxMaskedU64(a []uint64, mask []bool) int
func ArgmaxMaskedU8(a []uint8, mask []bool) int
func ArgmaxStr(a []string) int
func ArgmaxU(a []uint) int
func ArgmaxU16(a []uint16) int
func ArgmaxU32(a []uint32) int
func ArgmaxU64(a []uint64) int
func ArgmaxU8(a []uint8) int
func ArgminF32(a []float32) int
func ArgminF64(a []float64) int
func ArgminI(a []int) int
func ArgminI16(a []int16) int
func ArgminI32(a []int32) int
func ArgminI64(a []int64) int
func ArgminI8(a []int8) int
func ArgminMaskedF32(a []float32, mask []bool) int
func ArgminMaskedF64(a []float64, mask []bool) int
func ArgminMaskedI(a []int, mask []bool) int
func ArgminMaskedI16(a []int16, mask []bool) int
func ArgminMaskedI32(a []int32, mask []bool) int
func ArgminMaskedI64(a []int64, mask []bool) int
func ArgminMaskedI8(a []int8, mask []bool) int
func ArgminMaskedStr(a []string, mask []bool) int
func ArgminMaskedU(a []uint, mask []bool) int
func ArgminMaskedU16(a []uint16, mask []bool) int
func ArgminMaskedU32(a []uint32, mask []bool) int
func ArgminMaskedU64(a []uint64, mask []bool) int
func ArgminMaskedU8(a []uint8, mask []bool) int
func ArgminStr(a []string) int
func ArgminU(a []uint) int
func ArgminU16(a []uint16) int
func ArgminU32(a []uint32) int
func ArgminU64(a []uint64) int
func ArgminU8(a []uint8) int
func CbrtF32(a []float32)
func CbrtF64(a []float64)
func CbrtIterF32(a []float32, ait Iterator) (err error)
func CbrtIterF64(a []float64, ait Iterator) (err error)
func ClampF32(a []float32, min float32, max float32)
func ClampF64(a []float64, min float64, max float64)
func ClampI(a []int, min int, max int)
func ClampI16(a []int16, min int16, max int16)
func ClampI32(a []int32, min int32, max int32)
func ClampI64(a []int64, min int64, max int64)
func ClampI8(a []int8, min int8, max int8)
func ClampIterF32(a []float32, ait Iterator, min float32, max float32) (err error)
func ClampIterF64(a []float64, ait Iterator, min float64, max float64) (err error)
func ClampIterI(a []int, ait Iterator, min int, max int) (err error)
func ClampIterI16(a []int16, ait Iterator, min int16, max int16) (err error)
func ClampIterI32(a []int32, ait Iterator, min int32, max int32) (err error)
func ClampIterI64(a []int64, ait Iterator, min int64, max int64) (err error)
func ClampIterI8(a []int8, ait Iterator, min int8, max int8) (err error)
func ClampIterU(a []uint, ait Iterator, min uint, max uint) (err error)
func ClampIterU16(a []uint16, ait Iterator, min uint16, max uint16) (err error)
func ClampIterU32(a []uint32, ait Iterator, min uint32, max uint32) (err error)
func ClampIterU64(a []uint64, ait Iterator, min uint64, max uint64) (err error)
func ClampIterU8(a []uint8, ait Iterator, min uint8, max uint8) (err error)
func ClampU(a []uint, min uint, max uint)
func ClampU16(a []uint16, min uint16, max uint16)
func ClampU32(a []uint32, min uint32, max uint32)
func ClampU64(a []uint64, min uint64, max uint64)
func ClampU8(a []uint8, min uint8, max uint8)
func CubeC128(a []complex128)
func CubeC64(a []complex64)
func CubeF32(a []float32)
func CubeF64(a []float64)
func CubeI(a []int)
func CubeI16(a []int16)
func CubeI32(a []int32)
func CubeI64(a []int64)
func CubeI8(a []int8)
func CubeIterC128(a []complex128, ait Iterator) (err error)
func CubeIterC64(a []complex64, ait Iterator) (err error)
func CubeIterF32(a []float32, ait Iterator) (err error)
func CubeIterF64(a []float64, ait Iterator) (err error)
func CubeIterI(a []int, ait Iterator) (err error)
func CubeIterI16(a []int16, ait Iterator) (err error)
func CubeIterI32(a []int32, ait Iterator) (err error)
func CubeIterI64(a []int64, ait Iterator) (err error)
func CubeIterI8(a []int8, ait Iterator) (err error)
func CubeIterU(a []uint, ait Iterator) (err error)
func CubeIterU16(a []uint16, ait Iterator) (err error)
func CubeIterU32(a []uint32, ait Iterator) (err error)
func CubeIterU64(a []uint64, ait Iterator) (err error)
func CubeIterU8(a []uint8, ait Iterator) (err error)
func CubeU(a []uint)
func CubeU16(a []uint16)
func CubeU32(a []uint32)
func CubeU64(a []uint64)
func CubeU8(a []uint8)
func DivC128(a complex128, b complex128) complex128
func DivC64(a complex64, b complex64) complex64
func DivF32(a float32, b float32) float32
func DivF64(a float64, b float64) float64
func DivI(a int, b int) int
func DivI16(a int16, b int16) int16
func DivI32(a int32, b int32) int32
func DivI64(a int64, b int64) int64
func DivI8(a int8, b int8) int8
func DivIncrC128(a []complex128, b []complex128, incr []complex128)
func DivIncrC64(a []complex64, b []complex64, incr []complex64)
func DivIncrF32(a []float32, b []float32, incr []float32)
func DivIncrF64(a []float64, b []float64, incr []float64)
func DivIncrI(a []int, b []int, incr []int) (err error)
func DivIncrI16(a []int16, b []int16, incr []int16) (err error)
func DivIncrI32(a []int32, b []int32, incr []int32) (err error)
func DivIncrI64(a []int64, b []int64, incr []int64) (err error)
func DivIncrI8(a []int8, b []int8, incr []int8) (err error)
func DivIncrSVC128(a complex128, b []complex128, incr []complex128)
func DivIncrSVC64(a complex64, b []complex64, incr []complex64)
func DivIncrSVF32(a float32, b []float32, incr []float32)
func DivIncrSVF64(a float64, b []float64, incr []float64)
func DivIncrSVI(a int, b []int, incr []int) (err error)
func DivIncrSVI16(a int16, b []int16, incr []int16) (err error)
func DivIncrSVI32(a int32, b []int32, incr []int32) (err error)
func DivIncrSVI64(a int64, b []int64, incr []int64) (err error)
func DivIncrSVI8(a int8, b []int8, incr []int8) (err error)
func DivIncrSVU(a uint, b []uint, incr []uint) (err error)
func DivIncrSVU16(a uint16, b []uint16, incr []uint16) (err error)
func DivIncrSVU32(a uint32, b []uint32, incr []uint32) (err error)
func DivIncrSVU64(a uint64, b []uint64, incr []uint64) (err error)
func DivIncrSVU8(a uint8, b []uint8, incr []uint8) (err error)
func DivIncrU(a []uint, b []uint, incr []uint) (err error)
func DivIncrU16(a []uint16, b []uint16, incr []uint16) (err error)
func DivIncrU32(a []uint32, b []uint32, incr []uint32) (err error)
func DivIncrU64(a []uint64, b []uint64, incr []uint64) (err error)
func DivIncrU8(a []uint8, b []uint8, incr []uint8) (err error)
func DivIncrVSC128(a []complex128, b complex128, incr []complex128)
func DivIncrVSC64(a []complex64, b complex64, incr []complex64)
func DivIncrVSF32(a []float32, b float32, incr []float32)
func DivIncrVSF64(a []float64, b float64, incr []float64)
func DivIncrVSI(a []int, b int, incr []int) (err error)
func DivIncrVSI16(a []int16, b int16, incr []int16) (err error)
func DivIncrVSI32(a []int32, b int32, incr []int32) (err error)
func DivIncrVSI64(a []int64, b int64, incr []int64) (err error)
func DivIncrVSI8(a []int8, b int8, incr []int8) (err error)
func DivIncrVSU(a []uint, b uint, incr []uint) (err error)
func DivIncrVSU16(a []uint16, b uint16, incr []uint16) (err error)
func DivIncrVSU32(a []uint32, b uint32, incr []uint32) (err error)
func DivIncrVSU64(a []uint64, b uint64, incr []uint64) (err error)
func DivIncrVSU8(a []uint8, b uint8, incr []uint8) (err error)
func DivIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)
func DivIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)
func DivIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)
func DivIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)
func DivIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)
func DivIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)
func DivIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)
func DivIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)
func DivIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)
func DivIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, ...) (err error)
func DivIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, ...) (err error)
func DivIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, ...) (err error)
func DivIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, ...) (err error)
func DivIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error)
func DivIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error)
func DivIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error)
func DivIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error)
func DivIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVC128(a complex128, b []complex128, incr []complex128, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVC64(a complex64, b []complex64, incr []complex64, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVF32(a float32, b []float32, incr []float32, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVF64(a float64, b []float64, incr []float64, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVI(a int, b []int, incr []int, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVI16(a int16, b []int16, incr []int16, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVI32(a int32, b []int32, incr []int32, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVI64(a int64, b []int64, incr []int64, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVI8(a int8, b []int8, incr []int8, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVU(a uint, b []uint, incr []uint, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVU16(a uint16, b []uint16, incr []uint16, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVU32(a uint32, b []uint32, incr []uint32, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVU64(a uint64, b []uint64, incr []uint64, bit Iterator, iit Iterator) (err error)
func DivIterIncrSVU8(a uint8, b []uint8, incr []uint8, bit Iterator, iit Iterator) (err error)
func DivIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error)
func DivIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, ...) (err error)
func DivIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, ...) (err error)
func DivIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, ...) (err error)
func DivIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error)
func DivIterIncrVSC128(a []complex128, b complex128, incr []complex128, ait Iterator, iit Iterator) (err error)
func DivIterIncrVSC64(a []complex64, b complex64, incr []complex64, ait Iterator, iit Iterator) (err error)
func DivIterIncrVSF32(a []float32, b float32, incr []float32, ait Iterator, iit Iterator) (err error)
func DivIterIncrVSF64(a []float64, b float64, incr []float64, ait Iterator, iit Iterator) (err error)
func DivIterIncrVSI(a []int, b int, incr []int, ait Iterator, iit Iterator) (err error)
func DivIterIncrVSI16(a []int16, b int16, incr []int16, ait Iterator, iit Iterator) (err error)
func DivIterIncrVSI32(a []int32, b int32, incr []int32, ait Iterator, iit Iterator) (err error)
func DivIterIncrVSI64(a []int64, b int64, incr []int64, ait Iterator, iit Iterator) (err error)
func DivIterIncrVSI8(a []int8, b int8, incr []int8, ait Iterator, iit Iterator) (err error)
func DivIterIncrVSU(a []uint, b uint, incr []uint, ait Iterator, iit Iterator) (err error)
func DivIterIncrVSU16(a []uint16, b uint16, incr []uint16, ait Iterator, iit Iterator) (err error)
func DivIterIncrVSU32(a []uint32, b uint32, incr []uint32, ait Iterator, iit Iterator) (err error)
func DivIterIncrVSU64(a []uint64, b uint64, incr []uint64, ait Iterator, iit Iterator) (err error)
func DivIterIncrVSU8(a []uint8, b uint8, incr []uint8, ait Iterator, iit Iterator) (err error)
func DivIterSVC128(a complex128, b []complex128, bit Iterator) (err error)
func DivIterSVC64(a complex64, b []complex64, bit Iterator) (err error)
func DivIterSVF32(a float32, b []float32, bit Iterator) (err error)
func DivIterSVF64(a float64, b []float64, bit Iterator) (err error)
func DivIterSVI(a int, b []int, bit Iterator) (err error)
func DivIterSVI16(a int16, b []int16, bit Iterator) (err error)
func DivIterSVI32(a int32, b []int32, bit Iterator) (err error)
func DivIterSVI64(a int64, b []int64, bit Iterator) (err error)
func DivIterSVI8(a int8, b []int8, bit Iterator) (err error)
func DivIterSVU(a uint, b []uint, bit Iterator) (err error)
func DivIterSVU16(a uint16, b []uint16, bit Iterator) (err error)
func DivIterSVU32(a uint32, b []uint32, bit Iterator) (err error)
func DivIterSVU64(a uint64, b []uint64, bit Iterator) (err error)
func DivIterSVU8(a uint8, b []uint8, bit Iterator) (err error)
func DivIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)
func DivIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)
func DivIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)
func DivIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)
func DivIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)
func DivIterVSC128(a []complex128, b complex128, ait Iterator) (err error)
func DivIterVSC64(a []complex64, b complex64, ait Iterator) (err error)
func DivIterVSF32(a []float32, b float32, ait Iterator) (err error)
func DivIterVSF64(a []float64, b float64, ait Iterator) (err error)
func DivIterVSI(a []int, b int, ait Iterator) (err error)
func DivIterVSI16(a []int16, b int16, ait Iterator) (err error)
func DivIterVSI32(a []int32, b int32, ait Iterator) (err error)
func DivIterVSI64(a []int64, b int64, ait Iterator) (err error)
func DivIterVSI8(a []int8, b int8, ait Iterator) (err error)
func DivIterVSU(a []uint, b uint, ait Iterator) (err error)
func DivIterVSU16(a []uint16, b uint16, ait Iterator) (err error)
func DivIterVSU32(a []uint32, b uint32, ait Iterator) (err error)
func DivIterVSU64(a []uint64, b uint64, ait Iterator) (err error)
func DivIterVSU8(a []uint8, b uint8, ait Iterator) (err error)
func DivSVC128(a complex128, b []complex128)
func DivSVC64(a complex64, b []complex64)
func DivSVF32(a float32, b []float32)
func DivSVF64(a float64, b []float64)
func DivSVI(a int, b []int) (err error)
func DivSVI16(a int16, b []int16) (err error)
func DivSVI32(a int32, b []int32) (err error)
func DivSVI64(a int64, b []int64) (err error)
func DivSVI8(a int8, b []int8) (err error)
func DivSVU(a uint, b []uint) (err error)
func DivSVU16(a uint16, b []uint16) (err error)
func DivSVU32(a uint32, b []uint32) (err error)
func DivSVU64(a uint64, b []uint64) (err error)
func DivSVU8(a uint8, b []uint8) (err error)
func DivU(a uint, b uint) uint
func DivU16(a uint16, b uint16) uint16
func DivU32(a uint32, b uint32) uint32
func DivU64(a uint64, b uint64) uint64
func DivU8(a uint8, b uint8) uint8
func DivVSC128(a []complex128, b complex128)
func DivVSC64(a []complex64, b complex64)
func DivVSF32(a []float32, b float32)
func DivVSF64(a []float64, b float64)
func DivVSI(a []int, b int) (err error)
func DivVSI16(a []int16, b int16) (err error)
func DivVSI32(a []int32, b int32) (err error)
func DivVSI64(a []int64, b int64) (err error)
func DivVSI8(a []int8, b int8) (err error)
func DivVSU(a []uint, b uint) (err error)
func DivVSU16(a []uint16, b uint16) (err error)
func DivVSU32(a []uint32, b uint32) (err error)
func DivVSU64(a []uint64, b uint64) (err error)
func DivVSU8(a []uint8, b uint8) (err error)
func EqB(a []bool, b []bool, retVal []bool)
func EqC128(a []complex128, b []complex128, retVal []bool)
func EqC64(a []complex64, b []complex64, retVal []bool)
func EqF32(a []float32, b []float32, retVal []bool)
func EqF64(a []float64, b []float64, retVal []bool)
func EqI(a []int, b []int, retVal []bool)
func EqI16(a []int16, b []int16, retVal []bool)
func EqI32(a []int32, b []int32, retVal []bool)
func EqI64(a []int64, b []int64, retVal []bool)
func EqI8(a []int8, b []int8, retVal []bool)
func EqIterB(a []bool, b []bool, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func EqIterC128(a []complex128, b []complex128, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func EqIterC64(a []complex64, b []complex64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func EqIterF32(a []float32, b []float32, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func EqIterF64(a []float64, b []float64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func EqIterI(a []int, b []int, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func EqIterI16(a []int16, b []int16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func EqIterI32(a []int32, b []int32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func EqIterI64(a []int64, b []int64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func EqIterI8(a []int8, b []int8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func EqIterSVB(a bool, b []bool, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVC128(a complex128, b []complex128, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVC64(a complex64, b []complex64, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVF32(a float32, b []float32, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVF64(a float64, b []float64, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVI(a int, b []int, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVI16(a int16, b []int16, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVI32(a int32, b []int32, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVI64(a int64, b []int64, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVI8(a int8, b []int8, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVStr(a string, b []string, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVU(a uint, b []uint, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVU16(a uint16, b []uint16, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVU32(a uint32, b []uint32, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVU64(a uint64, b []uint64, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVU8(a uint8, b []uint8, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVUintptr(a uintptr, b []uintptr, retVal []bool, bit Iterator, rit Iterator) (err error)
func EqIterSVUnsafePointer(a unsafe.Pointer, b []unsafe.Pointer, retVal []bool, bit Iterator, ...) (err error)
func EqIterStr(a []string, b []string, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func EqIterU(a []uint, b []uint, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func EqIterU16(a []uint16, b []uint16, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func EqIterU32(a []uint32, b []uint32, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func EqIterU64(a []uint64, b []uint64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func EqIterU8(a []uint8, b []uint8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func EqIterUintptr(a []uintptr, b []uintptr, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func EqIterUnsafePointer(a []unsafe.Pointer, b []unsafe.Pointer, retVal []bool, ait Iterator, ...) (err error)
func EqIterVSB(a []bool, b bool, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSC128(a []complex128, b complex128, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSC64(a []complex64, b complex64, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSF32(a []float32, b float32, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSF64(a []float64, b float64, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSI(a []int, b int, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSI16(a []int16, b int16, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSI32(a []int32, b int32, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSI64(a []int64, b int64, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSI8(a []int8, b int8, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSStr(a []string, b string, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSU(a []uint, b uint, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSU16(a []uint16, b uint16, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSU32(a []uint32, b uint32, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSU64(a []uint64, b uint64, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSU8(a []uint8, b uint8, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSUintptr(a []uintptr, b uintptr, retVal []bool, ait Iterator, rit Iterator) (err error)
func EqIterVSUnsafePointer(a []unsafe.Pointer, b unsafe.Pointer, retVal []bool, ait Iterator, ...) (err error)
func EqSVB(a bool, b []bool, retVal []bool)
func EqSVC128(a complex128, b []complex128, retVal []bool)
func EqSVC64(a complex64, b []complex64, retVal []bool)
func EqSVF32(a float32, b []float32, retVal []bool)
func EqSVF64(a float64, b []float64, retVal []bool)
func EqSVI(a int, b []int, retVal []bool)
func EqSVI16(a int16, b []int16, retVal []bool)
func EqSVI32(a int32, b []int32, retVal []bool)
func EqSVI64(a int64, b []int64, retVal []bool)
func EqSVI8(a int8, b []int8, retVal []bool)
func EqSVStr(a string, b []string, retVal []bool)
func EqSVU(a uint, b []uint, retVal []bool)
func EqSVU16(a uint16, b []uint16, retVal []bool)
func EqSVU32(a uint32, b []uint32, retVal []bool)
func EqSVU64(a uint64, b []uint64, retVal []bool)
func EqSVU8(a uint8, b []uint8, retVal []bool)
func EqSVUintptr(a uintptr, b []uintptr, retVal []bool)
func EqSVUnsafePointer(a unsafe.Pointer, b []unsafe.Pointer, retVal []bool)
func EqSameB(a []bool, b []bool)
func EqSameC128(a []complex128, b []complex128)
func EqSameC64(a []complex64, b []complex64)
func EqSameF32(a []float32, b []float32)
func EqSameF64(a []float64, b []float64)
func EqSameI(a []int, b []int)
func EqSameI16(a []int16, b []int16)
func EqSameI32(a []int32, b []int32)
func EqSameI64(a []int64, b []int64)
func EqSameI8(a []int8, b []int8)
func EqSameIterB(a []bool, b []bool, ait Iterator, bit Iterator) (err error)
func EqSameIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)
func EqSameIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)
func EqSameIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)
func EqSameIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)
func EqSameIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)
func EqSameIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)
func EqSameIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)
func EqSameIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)
func EqSameIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)
func EqSameIterSVB(a bool, b []bool, bit Iterator) (err error)
func EqSameIterSVC128(a complex128, b []complex128, bit Iterator) (err error)
func EqSameIterSVC64(a complex64, b []complex64, bit Iterator) (err error)
func EqSameIterSVF32(a float32, b []float32, bit Iterator) (err error)
func EqSameIterSVF64(a float64, b []float64, bit Iterator) (err error)
func EqSameIterSVI(a int, b []int, bit Iterator) (err error)
func EqSameIterSVI16(a int16, b []int16, bit Iterator) (err error)
func EqSameIterSVI32(a int32, b []int32, bit Iterator) (err error)
func EqSameIterSVI64(a int64, b []int64, bit Iterator) (err error)
func EqSameIterSVI8(a int8, b []int8, bit Iterator) (err error)
func EqSameIterSVStr(a string, b []string, bit Iterator) (err error)
func EqSameIterSVU(a uint, b []uint, bit Iterator) (err error)
func EqSameIterSVU16(a uint16, b []uint16, bit Iterator) (err error)
func EqSameIterSVU32(a uint32, b []uint32, bit Iterator) (err error)
func EqSameIterSVU64(a uint64, b []uint64, bit Iterator) (err error)
func EqSameIterSVU8(a uint8, b []uint8, bit Iterator) (err error)
func EqSameIterSVUintptr(a uintptr, b []uintptr, bit Iterator) (err error)
func EqSameIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)
func EqSameIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)
func EqSameIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)
func EqSameIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)
func EqSameIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)
func EqSameIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)
func EqSameIterUintptr(a []uintptr, b []uintptr, ait Iterator, bit Iterator) (err error)
func EqSameIterVSB(a []bool, b bool, ait Iterator) (err error)
func EqSameIterVSC128(a []complex128, b complex128, ait Iterator) (err error)
func EqSameIterVSC64(a []complex64, b complex64, ait Iterator) (err error)
func EqSameIterVSF32(a []float32, b float32, ait Iterator) (err error)
func EqSameIterVSF64(a []float64, b float64, ait Iterator) (err error)
func EqSameIterVSI(a []int, b int, ait Iterator) (err error)
func EqSameIterVSI16(a []int16, b int16, ait Iterator) (err error)
func EqSameIterVSI32(a []int32, b int32, ait Iterator) (err error)
func EqSameIterVSI64(a []int64, b int64, ait Iterator) (err error)
func EqSameIterVSI8(a []int8, b int8, ait Iterator) (err error)
func EqSameIterVSStr(a []string, b string, ait Iterator) (err error)
func EqSameIterVSU(a []uint, b uint, ait Iterator) (err error)
func EqSameIterVSU16(a []uint16, b uint16, ait Iterator) (err error)
func EqSameIterVSU32(a []uint32, b uint32, ait Iterator) (err error)
func EqSameIterVSU64(a []uint64, b uint64, ait Iterator) (err error)
func EqSameIterVSU8(a []uint8, b uint8, ait Iterator) (err error)
func EqSameIterVSUintptr(a []uintptr, b uintptr, ait Iterator) (err error)
func EqSameSVB(a bool, b []bool)
func EqSameSVC128(a complex128, b []complex128)
func EqSameSVC64(a complex64, b []complex64)
func EqSameSVF32(a float32, b []float32)
func EqSameSVF64(a float64, b []float64)
func EqSameSVI(a int, b []int)
func EqSameSVI16(a int16, b []int16)
func EqSameSVI32(a int32, b []int32)
func EqSameSVI64(a int64, b []int64)
func EqSameSVI8(a int8, b []int8)
func EqSameSVStr(a string, b []string)
func EqSameSVU(a uint, b []uint)
func EqSameSVU16(a uint16, b []uint16)
func EqSameSVU32(a uint32, b []uint32)
func EqSameSVU64(a uint64, b []uint64)
func EqSameSVU8(a uint8, b []uint8)
func EqSameSVUintptr(a uintptr, b []uintptr)
func EqSameStr(a []string, b []string)
func EqSameU(a []uint, b []uint)
func EqSameU16(a []uint16, b []uint16)
func EqSameU32(a []uint32, b []uint32)
func EqSameU64(a []uint64, b []uint64)
func EqSameU8(a []uint8, b []uint8)
func EqSameUintptr(a []uintptr, b []uintptr)
func EqSameVSB(a []bool, b bool)
func EqSameVSC128(a []complex128, b complex128)
func EqSameVSC64(a []complex64, b complex64)
func EqSameVSF32(a []float32, b float32)
func EqSameVSF64(a []float64, b float64)
func EqSameVSI(a []int, b int)
func EqSameVSI16(a []int16, b int16)
func EqSameVSI32(a []int32, b int32)
func EqSameVSI64(a []int64, b int64)
func EqSameVSI8(a []int8, b int8)
func EqSameVSStr(a []string, b string)
func EqSameVSU(a []uint, b uint)
func EqSameVSU16(a []uint16, b uint16)
func EqSameVSU32(a []uint32, b uint32)
func EqSameVSU64(a []uint64, b uint64)
func EqSameVSU8(a []uint8, b uint8)
func EqSameVSUintptr(a []uintptr, b uintptr)
func EqStr(a []string, b []string, retVal []bool)
func EqU(a []uint, b []uint, retVal []bool)
func EqU16(a []uint16, b []uint16, retVal []bool)
func EqU32(a []uint32, b []uint32, retVal []bool)
func EqU64(a []uint64, b []uint64, retVal []bool)
func EqU8(a []uint8, b []uint8, retVal []bool)
func EqUintptr(a []uintptr, b []uintptr, retVal []bool)
func EqUnsafePointer(a []unsafe.Pointer, b []unsafe.Pointer, retVal []bool)
func EqVSB(a []bool, b bool, retVal []bool)
func EqVSC128(a []complex128, b complex128, retVal []bool)
func EqVSC64(a []complex64, b complex64, retVal []bool)
func EqVSF32(a []float32, b float32, retVal []bool)
func EqVSF64(a []float64, b float64, retVal []bool)
func EqVSI(a []int, b int, retVal []bool)
func EqVSI16(a []int16, b int16, retVal []bool)
func EqVSI32(a []int32, b int32, retVal []bool)
func EqVSI64(a []int64, b int64, retVal []bool)
func EqVSI8(a []int8, b int8, retVal []bool)
func EqVSStr(a []string, b string, retVal []bool)
func EqVSU(a []uint, b uint, retVal []bool)
func EqVSU16(a []uint16, b uint16, retVal []bool)
func EqVSU32(a []uint32, b uint32, retVal []bool)
func EqVSU64(a []uint64, b uint64, retVal []bool)
func EqVSU8(a []uint8, b uint8, retVal []bool)
func EqVSUintptr(a []uintptr, b uintptr, retVal []bool)
func EqVSUnsafePointer(a []unsafe.Pointer, b unsafe.Pointer, retVal []bool)
func ExpC128(a []complex128)
func ExpC64(a []complex64)
func ExpF32(a []float32)
func ExpF64(a []float64)
func ExpIterC128(a []complex128, ait Iterator) (err error)
func ExpIterC64(a []complex64, ait Iterator) (err error)
func ExpIterF32(a []float32, ait Iterator) (err error)
func ExpIterF64(a []float64, ait Iterator) (err error)
func GtF32(a []float32, b []float32, retVal []bool)
func GtF64(a []float64, b []float64, retVal []bool)
func GtI(a []int, b []int, retVal []bool)
func GtI16(a []int16, b []int16, retVal []bool)
func GtI32(a []int32, b []int32, retVal []bool)
func GtI64(a []int64, b []int64, retVal []bool)
func GtI8(a []int8, b []int8, retVal []bool)
func GtIterF32(a []float32, b []float32, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func GtIterF64(a []float64, b []float64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func GtIterI(a []int, b []int, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GtIterI16(a []int16, b []int16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GtIterI32(a []int32, b []int32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GtIterI64(a []int64, b []int64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GtIterI8(a []int8, b []int8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GtIterSVF32(a float32, b []float32, retVal []bool, bit Iterator, rit Iterator) (err error)
func GtIterSVF64(a float64, b []float64, retVal []bool, bit Iterator, rit Iterator) (err error)
func GtIterSVI(a int, b []int, retVal []bool, bit Iterator, rit Iterator) (err error)
func GtIterSVI16(a int16, b []int16, retVal []bool, bit Iterator, rit Iterator) (err error)
func GtIterSVI32(a int32, b []int32, retVal []bool, bit Iterator, rit Iterator) (err error)
func GtIterSVI64(a int64, b []int64, retVal []bool, bit Iterator, rit Iterator) (err error)
func GtIterSVI8(a int8, b []int8, retVal []bool, bit Iterator, rit Iterator) (err error)
func GtIterSVStr(a string, b []string, retVal []bool, bit Iterator, rit Iterator) (err error)
func GtIterSVU(a uint, b []uint, retVal []bool, bit Iterator, rit Iterator) (err error)
func GtIterSVU16(a uint16, b []uint16, retVal []bool, bit Iterator, rit Iterator) (err error)
func GtIterSVU32(a uint32, b []uint32, retVal []bool, bit Iterator, rit Iterator) (err error)
func GtIterSVU64(a uint64, b []uint64, retVal []bool, bit Iterator, rit Iterator) (err error)
func GtIterSVU8(a uint8, b []uint8, retVal []bool, bit Iterator, rit Iterator) (err error)
func GtIterStr(a []string, b []string, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func GtIterU(a []uint, b []uint, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GtIterU16(a []uint16, b []uint16, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func GtIterU32(a []uint32, b []uint32, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func GtIterU64(a []uint64, b []uint64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func GtIterU8(a []uint8, b []uint8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GtIterVSF32(a []float32, b float32, retVal []bool, ait Iterator, rit Iterator) (err error)
func GtIterVSF64(a []float64, b float64, retVal []bool, ait Iterator, rit Iterator) (err error)
func GtIterVSI(a []int, b int, retVal []bool, ait Iterator, rit Iterator) (err error)
func GtIterVSI16(a []int16, b int16, retVal []bool, ait Iterator, rit Iterator) (err error)
func GtIterVSI32(a []int32, b int32, retVal []bool, ait Iterator, rit Iterator) (err error)
func GtIterVSI64(a []int64, b int64, retVal []bool, ait Iterator, rit Iterator) (err error)
func GtIterVSI8(a []int8, b int8, retVal []bool, ait Iterator, rit Iterator) (err error)
func GtIterVSStr(a []string, b string, retVal []bool, ait Iterator, rit Iterator) (err error)
func GtIterVSU(a []uint, b uint, retVal []bool, ait Iterator, rit Iterator) (err error)
func GtIterVSU16(a []uint16, b uint16, retVal []bool, ait Iterator, rit Iterator) (err error)
func GtIterVSU32(a []uint32, b uint32, retVal []bool, ait Iterator, rit Iterator) (err error)
func GtIterVSU64(a []uint64, b uint64, retVal []bool, ait Iterator, rit Iterator) (err error)
func GtIterVSU8(a []uint8, b uint8, retVal []bool, ait Iterator, rit Iterator) (err error)
func GtSVF32(a float32, b []float32, retVal []bool)
func GtSVF64(a float64, b []float64, retVal []bool)
func GtSVI(a int, b []int, retVal []bool)
func GtSVI16(a int16, b []int16, retVal []bool)
func GtSVI32(a int32, b []int32, retVal []bool)
func GtSVI64(a int64, b []int64, retVal []bool)
func GtSVI8(a int8, b []int8, retVal []bool)
func GtSVStr(a string, b []string, retVal []bool)
func GtSVU(a uint, b []uint, retVal []bool)
func GtSVU16(a uint16, b []uint16, retVal []bool)
func GtSVU32(a uint32, b []uint32, retVal []bool)
func GtSVU64(a uint64, b []uint64, retVal []bool)
func GtSVU8(a uint8, b []uint8, retVal []bool)
func GtSameF32(a []float32, b []float32)
func GtSameF64(a []float64, b []float64)
func GtSameI(a []int, b []int)
func GtSameI16(a []int16, b []int16)
func GtSameI32(a []int32, b []int32)
func GtSameI64(a []int64, b []int64)
func GtSameI8(a []int8, b []int8)
func GtSameIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)
func GtSameIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)
func GtSameIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)
func GtSameIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)
func GtSameIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)
func GtSameIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)
func GtSameIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)
func GtSameIterSVF32(a float32, b []float32, bit Iterator) (err error)
func GtSameIterSVF64(a float64, b []float64, bit Iterator) (err error)
func GtSameIterSVI(a int, b []int, bit Iterator) (err error)
func GtSameIterSVI16(a int16, b []int16, bit Iterator) (err error)
func GtSameIterSVI32(a int32, b []int32, bit Iterator) (err error)
func GtSameIterSVI64(a int64, b []int64, bit Iterator) (err error)
func GtSameIterSVI8(a int8, b []int8, bit Iterator) (err error)
func GtSameIterSVStr(a string, b []string, bit Iterator) (err error)
func GtSameIterSVU(a uint, b []uint, bit Iterator) (err error)
func GtSameIterSVU16(a uint16, b []uint16, bit Iterator) (err error)
func GtSameIterSVU32(a uint32, b []uint32, bit Iterator) (err error)
func GtSameIterSVU64(a uint64, b []uint64, bit Iterator) (err error)
func GtSameIterSVU8(a uint8, b []uint8, bit Iterator) (err error)
func GtSameIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)
func GtSameIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)
func GtSameIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)
func GtSameIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)
func GtSameIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)
func GtSameIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)
func GtSameIterVSF32(a []float32, b float32, ait Iterator) (err error)
func GtSameIterVSF64(a []float64, b float64, ait Iterator) (err error)
func GtSameIterVSI(a []int, b int, ait Iterator) (err error)
func GtSameIterVSI16(a []int16, b int16, ait Iterator) (err error)
func GtSameIterVSI32(a []int32, b int32, ait Iterator) (err error)
func GtSameIterVSI64(a []int64, b int64, ait Iterator) (err error)
func GtSameIterVSI8(a []int8, b int8, ait Iterator) (err error)
func GtSameIterVSStr(a []string, b string, ait Iterator) (err error)
func GtSameIterVSU(a []uint, b uint, ait Iterator) (err error)
func GtSameIterVSU16(a []uint16, b uint16, ait Iterator) (err error)
func GtSameIterVSU32(a []uint32, b uint32, ait Iterator) (err error)
func GtSameIterVSU64(a []uint64, b uint64, ait Iterator) (err error)
func GtSameIterVSU8(a []uint8, b uint8, ait Iterator) (err error)
func GtSameSVF32(a float32, b []float32)
func GtSameSVF64(a float64, b []float64)
func GtSameSVI(a int, b []int)
func GtSameSVI16(a int16, b []int16)
func GtSameSVI32(a int32, b []int32)
func GtSameSVI64(a int64, b []int64)
func GtSameSVI8(a int8, b []int8)
func GtSameSVStr(a string, b []string)
func GtSameSVU(a uint, b []uint)
func GtSameSVU16(a uint16, b []uint16)
func GtSameSVU32(a uint32, b []uint32)
func GtSameSVU64(a uint64, b []uint64)
func GtSameSVU8(a uint8, b []uint8)
func GtSameStr(a []string, b []string)
func GtSameU(a []uint, b []uint)
func GtSameU16(a []uint16, b []uint16)
func GtSameU32(a []uint32, b []uint32)
func GtSameU64(a []uint64, b []uint64)
func GtSameU8(a []uint8, b []uint8)
func GtSameVSF32(a []float32, b float32)
func GtSameVSF64(a []float64, b float64)
func GtSameVSI(a []int, b int)
func GtSameVSI16(a []int16, b int16)
func GtSameVSI32(a []int32, b int32)
func GtSameVSI64(a []int64, b int64)
func GtSameVSI8(a []int8, b int8)
func GtSameVSStr(a []string, b string)
func GtSameVSU(a []uint, b uint)
func GtSameVSU16(a []uint16, b uint16)
func GtSameVSU32(a []uint32, b uint32)
func GtSameVSU64(a []uint64, b uint64)
func GtSameVSU8(a []uint8, b uint8)
func GtStr(a []string, b []string, retVal []bool)
func GtU(a []uint, b []uint, retVal []bool)
func GtU16(a []uint16, b []uint16, retVal []bool)
func GtU32(a []uint32, b []uint32, retVal []bool)
func GtU64(a []uint64, b []uint64, retVal []bool)
func GtU8(a []uint8, b []uint8, retVal []bool)
func GtVSF32(a []float32, b float32, retVal []bool)
func GtVSF64(a []float64, b float64, retVal []bool)
func GtVSI(a []int, b int, retVal []bool)
func GtVSI16(a []int16, b int16, retVal []bool)
func GtVSI32(a []int32, b int32, retVal []bool)
func GtVSI64(a []int64, b int64, retVal []bool)
func GtVSI8(a []int8, b int8, retVal []bool)
func GtVSStr(a []string, b string, retVal []bool)
func GtVSU(a []uint, b uint, retVal []bool)
func GtVSU16(a []uint16, b uint16, retVal []bool)
func GtVSU32(a []uint32, b uint32, retVal []bool)
func GtVSU64(a []uint64, b uint64, retVal []bool)
func GtVSU8(a []uint8, b uint8, retVal []bool)
func GteF32(a []float32, b []float32, retVal []bool)
func GteF64(a []float64, b []float64, retVal []bool)
func GteI(a []int, b []int, retVal []bool)
func GteI16(a []int16, b []int16, retVal []bool)
func GteI32(a []int32, b []int32, retVal []bool)
func GteI64(a []int64, b []int64, retVal []bool)
func GteI8(a []int8, b []int8, retVal []bool)
func GteIterF32(a []float32, b []float32, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func GteIterF64(a []float64, b []float64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func GteIterI(a []int, b []int, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GteIterI16(a []int16, b []int16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GteIterI32(a []int32, b []int32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GteIterI64(a []int64, b []int64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GteIterI8(a []int8, b []int8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GteIterSVF32(a float32, b []float32, retVal []bool, bit Iterator, rit Iterator) (err error)
func GteIterSVF64(a float64, b []float64, retVal []bool, bit Iterator, rit Iterator) (err error)
func GteIterSVI(a int, b []int, retVal []bool, bit Iterator, rit Iterator) (err error)
func GteIterSVI16(a int16, b []int16, retVal []bool, bit Iterator, rit Iterator) (err error)
func GteIterSVI32(a int32, b []int32, retVal []bool, bit Iterator, rit Iterator) (err error)
func GteIterSVI64(a int64, b []int64, retVal []bool, bit Iterator, rit Iterator) (err error)
func GteIterSVI8(a int8, b []int8, retVal []bool, bit Iterator, rit Iterator) (err error)
func GteIterSVStr(a string, b []string, retVal []bool, bit Iterator, rit Iterator) (err error)
func GteIterSVU(a uint, b []uint, retVal []bool, bit Iterator, rit Iterator) (err error)
func GteIterSVU16(a uint16, b []uint16, retVal []bool, bit Iterator, rit Iterator) (err error)
func GteIterSVU32(a uint32, b []uint32, retVal []bool, bit Iterator, rit Iterator) (err error)
func GteIterSVU64(a uint64, b []uint64, retVal []bool, bit Iterator, rit Iterator) (err error)
func GteIterSVU8(a uint8, b []uint8, retVal []bool, bit Iterator, rit Iterator) (err error)
func GteIterStr(a []string, b []string, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func GteIterU(a []uint, b []uint, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GteIterU16(a []uint16, b []uint16, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func GteIterU32(a []uint32, b []uint32, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func GteIterU64(a []uint64, b []uint64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func GteIterU8(a []uint8, b []uint8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func GteIterVSF32(a []float32, b float32, retVal []bool, ait Iterator, rit Iterator) (err error)
func GteIterVSF64(a []float64, b float64, retVal []bool, ait Iterator, rit Iterator) (err error)
func GteIterVSI(a []int, b int, retVal []bool, ait Iterator, rit Iterator) (err error)
func GteIterVSI16(a []int16, b int16, retVal []bool, ait Iterator, rit Iterator) (err error)
func GteIterVSI32(a []int32, b int32, retVal []bool, ait Iterator, rit Iterator) (err error)
func GteIterVSI64(a []int64, b int64, retVal []bool, ait Iterator, rit Iterator) (err error)
func GteIterVSI8(a []int8, b int8, retVal []bool, ait Iterator, rit Iterator) (err error)
func GteIterVSStr(a []string, b string, retVal []bool, ait Iterator, rit Iterator) (err error)
func GteIterVSU(a []uint, b uint, retVal []bool, ait Iterator, rit Iterator) (err error)
func GteIterVSU16(a []uint16, b uint16, retVal []bool, ait Iterator, rit Iterator) (err error)
func GteIterVSU32(a []uint32, b uint32, retVal []bool, ait Iterator, rit Iterator) (err error)
func GteIterVSU64(a []uint64, b uint64, retVal []bool, ait Iterator, rit Iterator) (err error)
func GteIterVSU8(a []uint8, b uint8, retVal []bool, ait Iterator, rit Iterator) (err error)
func GteSVF32(a float32, b []float32, retVal []bool)
func GteSVF64(a float64, b []float64, retVal []bool)
func GteSVI(a int, b []int, retVal []bool)
func GteSVI16(a int16, b []int16, retVal []bool)
func GteSVI32(a int32, b []int32, retVal []bool)
func GteSVI64(a int64, b []int64, retVal []bool)
func GteSVI8(a int8, b []int8, retVal []bool)
func GteSVStr(a string, b []string, retVal []bool)
func GteSVU(a uint, b []uint, retVal []bool)
func GteSVU16(a uint16, b []uint16, retVal []bool)
func GteSVU32(a uint32, b []uint32, retVal []bool)
func GteSVU64(a uint64, b []uint64, retVal []bool)
func GteSVU8(a uint8, b []uint8, retVal []bool)
func GteSameF32(a []float32, b []float32)
func GteSameF64(a []float64, b []float64)
func GteSameI(a []int, b []int)
func GteSameI16(a []int16, b []int16)
func GteSameI32(a []int32, b []int32)
func GteSameI64(a []int64, b []int64)
func GteSameI8(a []int8, b []int8)
func GteSameIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)
func GteSameIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)
func GteSameIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)
func GteSameIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)
func GteSameIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)
func GteSameIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)
func GteSameIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)
func GteSameIterSVF32(a float32, b []float32, bit Iterator) (err error)
func GteSameIterSVF64(a float64, b []float64, bit Iterator) (err error)
func GteSameIterSVI(a int, b []int, bit Iterator) (err error)
func GteSameIterSVI16(a int16, b []int16, bit Iterator) (err error)
func GteSameIterSVI32(a int32, b []int32, bit Iterator) (err error)
func GteSameIterSVI64(a int64, b []int64, bit Iterator) (err error)
func GteSameIterSVI8(a int8, b []int8, bit Iterator) (err error)
func GteSameIterSVStr(a string, b []string, bit Iterator) (err error)
func GteSameIterSVU(a uint, b []uint, bit Iterator) (err error)
func GteSameIterSVU16(a uint16, b []uint16, bit Iterator) (err error)
func GteSameIterSVU32(a uint32, b []uint32, bit Iterator) (err error)
func GteSameIterSVU64(a uint64, b []uint64, bit Iterator) (err error)
func GteSameIterSVU8(a uint8, b []uint8, bit Iterator) (err error)
func GteSameIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)
func GteSameIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)
func GteSameIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)
func GteSameIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)
func GteSameIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)
func GteSameIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)
func GteSameIterVSF32(a []float32, b float32, ait Iterator) (err error)
func GteSameIterVSF64(a []float64, b float64, ait Iterator) (err error)
func GteSameIterVSI(a []int, b int, ait Iterator) (err error)
func GteSameIterVSI16(a []int16, b int16, ait Iterator) (err error)
func GteSameIterVSI32(a []int32, b int32, ait Iterator) (err error)
func GteSameIterVSI64(a []int64, b int64, ait Iterator) (err error)
func GteSameIterVSI8(a []int8, b int8, ait Iterator) (err error)
func GteSameIterVSStr(a []string, b string, ait Iterator) (err error)
func GteSameIterVSU(a []uint, b uint, ait Iterator) (err error)
func GteSameIterVSU16(a []uint16, b uint16, ait Iterator) (err error)
func GteSameIterVSU32(a []uint32, b uint32, ait Iterator) (err error)
func GteSameIterVSU64(a []uint64, b uint64, ait Iterator) (err error)
func GteSameIterVSU8(a []uint8, b uint8, ait Iterator) (err error)
func GteSameSVF32(a float32, b []float32)
func GteSameSVF64(a float64, b []float64)
func GteSameSVI(a int, b []int)
func GteSameSVI16(a int16, b []int16)
func GteSameSVI32(a int32, b []int32)
func GteSameSVI64(a int64, b []int64)
func GteSameSVI8(a int8, b []int8)
func GteSameSVStr(a string, b []string)
func GteSameSVU(a uint, b []uint)
func GteSameSVU16(a uint16, b []uint16)
func GteSameSVU32(a uint32, b []uint32)
func GteSameSVU64(a uint64, b []uint64)
func GteSameSVU8(a uint8, b []uint8)
func GteSameStr(a []string, b []string)
func GteSameU(a []uint, b []uint)
func GteSameU16(a []uint16, b []uint16)
func GteSameU32(a []uint32, b []uint32)
func GteSameU64(a []uint64, b []uint64)
func GteSameU8(a []uint8, b []uint8)
func GteSameVSF32(a []float32, b float32)
func GteSameVSF64(a []float64, b float64)
func GteSameVSI(a []int, b int)
func GteSameVSI16(a []int16, b int16)
func GteSameVSI32(a []int32, b int32)
func GteSameVSI64(a []int64, b int64)
func GteSameVSI8(a []int8, b int8)
func GteSameVSStr(a []string, b string)
func GteSameVSU(a []uint, b uint)
func GteSameVSU16(a []uint16, b uint16)
func GteSameVSU32(a []uint32, b uint32)
func GteSameVSU64(a []uint64, b uint64)
func GteSameVSU8(a []uint8, b uint8)
func GteStr(a []string, b []string, retVal []bool)
func GteU(a []uint, b []uint, retVal []bool)
func GteU16(a []uint16, b []uint16, retVal []bool)
func GteU32(a []uint32, b []uint32, retVal []bool)
func GteU64(a []uint64, b []uint64, retVal []bool)
func GteU8(a []uint8, b []uint8, retVal []bool)
func GteVSF32(a []float32, b float32, retVal []bool)
func GteVSF64(a []float64, b float64, retVal []bool)
func GteVSI(a []int, b int, retVal []bool)
func GteVSI16(a []int16, b int16, retVal []bool)
func GteVSI32(a []int32, b int32, retVal []bool)
func GteVSI64(a []int64, b int64, retVal []bool)
func GteVSI8(a []int8, b int8, retVal []bool)
func GteVSStr(a []string, b string, retVal []bool)
func GteVSU(a []uint, b uint, retVal []bool)
func GteVSU16(a []uint16, b uint16, retVal []bool)
func GteVSU32(a []uint32, b uint32, retVal []bool)
func GteVSU64(a []uint64, b uint64, retVal []bool)
func GteVSU8(a []uint8, b uint8, retVal []bool)
func InvC128(a []complex128)
func InvC64(a []complex64)
func InvF32(a []float32)
func InvF64(a []float64)
func InvI(a []int)
func InvI16(a []int16)
func InvI32(a []int32)
func InvI64(a []int64)
func InvI8(a []int8)
func InvIterC128(a []complex128, ait Iterator) (err error)
func InvIterC64(a []complex64, ait Iterator) (err error)
func InvIterF32(a []float32, ait Iterator) (err error)
func InvIterF64(a []float64, ait Iterator) (err error)
func InvIterI(a []int, ait Iterator) (err error)
func InvIterI16(a []int16, ait Iterator) (err error)
func InvIterI32(a []int32, ait Iterator) (err error)
func InvIterI64(a []int64, ait Iterator) (err error)
func InvIterI8(a []int8, ait Iterator) (err error)
func InvIterU(a []uint, ait Iterator) (err error)
func InvIterU16(a []uint16, ait Iterator) (err error)
func InvIterU32(a []uint32, ait Iterator) (err error)
func InvIterU64(a []uint64, ait Iterator) (err error)
func InvIterU8(a []uint8, ait Iterator) (err error)
func InvSqrtF32(a []float32)
func InvSqrtF64(a []float64)
func InvSqrtIterF32(a []float32, ait Iterator) (err error)
func InvSqrtIterF64(a []float64, ait Iterator) (err error)
func InvU(a []uint)
func InvU16(a []uint16)
func InvU32(a []uint32)
func InvU64(a []uint64)
func InvU8(a []uint8)
func Log10C128(a []complex128)
func Log10C64(a []complex64)
func Log10F32(a []float32)
func Log10F64(a []float64)
func Log10IterC128(a []complex128, ait Iterator) (err error)
func Log10IterC64(a []complex64, ait Iterator) (err error)
func Log10IterF32(a []float32, ait Iterator) (err error)
func Log10IterF64(a []float64, ait Iterator) (err error)
func Log2F32(a []float32)
func Log2F64(a []float64)
func Log2IterF32(a []float32, ait Iterator) (err error)
func Log2IterF64(a []float64, ait Iterator) (err error)
func LogC128(a []complex128)
func LogC64(a []complex64)
func LogF32(a []float32)
func LogF64(a []float64)
func LogIterC128(a []complex128, ait Iterator) (err error)
func LogIterC64(a []complex64, ait Iterator) (err error)
func LogIterF32(a []float32, ait Iterator) (err error)
func LogIterF64(a []float64, ait Iterator) (err error)
func LtF32(a []float32, b []float32, retVal []bool)
func LtF64(a []float64, b []float64, retVal []bool)
func LtI(a []int, b []int, retVal []bool)
func LtI16(a []int16, b []int16, retVal []bool)
func LtI32(a []int32, b []int32, retVal []bool)
func LtI64(a []int64, b []int64, retVal []bool)
func LtI8(a []int8, b []int8, retVal []bool)
func LtIterF32(a []float32, b []float32, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func LtIterF64(a []float64, b []float64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func LtIterI(a []int, b []int, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LtIterI16(a []int16, b []int16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LtIterI32(a []int32, b []int32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LtIterI64(a []int64, b []int64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LtIterI8(a []int8, b []int8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LtIterSVF32(a float32, b []float32, retVal []bool, bit Iterator, rit Iterator) (err error)
func LtIterSVF64(a float64, b []float64, retVal []bool, bit Iterator, rit Iterator) (err error)
func LtIterSVI(a int, b []int, retVal []bool, bit Iterator, rit Iterator) (err error)
func LtIterSVI16(a int16, b []int16, retVal []bool, bit Iterator, rit Iterator) (err error)
func LtIterSVI32(a int32, b []int32, retVal []bool, bit Iterator, rit Iterator) (err error)
func LtIterSVI64(a int64, b []int64, retVal []bool, bit Iterator, rit Iterator) (err error)
func LtIterSVI8(a int8, b []int8, retVal []bool, bit Iterator, rit Iterator) (err error)
func LtIterSVStr(a string, b []string, retVal []bool, bit Iterator, rit Iterator) (err error)
func LtIterSVU(a uint, b []uint, retVal []bool, bit Iterator, rit Iterator) (err error)
func LtIterSVU16(a uint16, b []uint16, retVal []bool, bit Iterator, rit Iterator) (err error)
func LtIterSVU32(a uint32, b []uint32, retVal []bool, bit Iterator, rit Iterator) (err error)
func LtIterSVU64(a uint64, b []uint64, retVal []bool, bit Iterator, rit Iterator) (err error)
func LtIterSVU8(a uint8, b []uint8, retVal []bool, bit Iterator, rit Iterator) (err error)
func LtIterStr(a []string, b []string, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func LtIterU(a []uint, b []uint, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LtIterU16(a []uint16, b []uint16, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func LtIterU32(a []uint32, b []uint32, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func LtIterU64(a []uint64, b []uint64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func LtIterU8(a []uint8, b []uint8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LtIterVSF32(a []float32, b float32, retVal []bool, ait Iterator, rit Iterator) (err error)
func LtIterVSF64(a []float64, b float64, retVal []bool, ait Iterator, rit Iterator) (err error)
func LtIterVSI(a []int, b int, retVal []bool, ait Iterator, rit Iterator) (err error)
func LtIterVSI16(a []int16, b int16, retVal []bool, ait Iterator, rit Iterator) (err error)
func LtIterVSI32(a []int32, b int32, retVal []bool, ait Iterator, rit Iterator) (err error)
func LtIterVSI64(a []int64, b int64, retVal []bool, ait Iterator, rit Iterator) (err error)
func LtIterVSI8(a []int8, b int8, retVal []bool, ait Iterator, rit Iterator) (err error)
func LtIterVSStr(a []string, b string, retVal []bool, ait Iterator, rit Iterator) (err error)
func LtIterVSU(a []uint, b uint, retVal []bool, ait Iterator, rit Iterator) (err error)
func LtIterVSU16(a []uint16, b uint16, retVal []bool, ait Iterator, rit Iterator) (err error)
func LtIterVSU32(a []uint32, b uint32, retVal []bool, ait Iterator, rit Iterator) (err error)
func LtIterVSU64(a []uint64, b uint64, retVal []bool, ait Iterator, rit Iterator) (err error)
func LtIterVSU8(a []uint8, b uint8, retVal []bool, ait Iterator, rit Iterator) (err error)
func LtSVF32(a float32, b []float32, retVal []bool)
func LtSVF64(a float64, b []float64, retVal []bool)
func LtSVI(a int, b []int, retVal []bool)
func LtSVI16(a int16, b []int16, retVal []bool)
func LtSVI32(a int32, b []int32, retVal []bool)
func LtSVI64(a int64, b []int64, retVal []bool)
func LtSVI8(a int8, b []int8, retVal []bool)
func LtSVStr(a string, b []string, retVal []bool)
func LtSVU(a uint, b []uint, retVal []bool)
func LtSVU16(a uint16, b []uint16, retVal []bool)
func LtSVU32(a uint32, b []uint32, retVal []bool)
func LtSVU64(a uint64, b []uint64, retVal []bool)
func LtSVU8(a uint8, b []uint8, retVal []bool)
func LtSameF32(a []float32, b []float32)
func LtSameF64(a []float64, b []float64)
func LtSameI(a []int, b []int)
func LtSameI16(a []int16, b []int16)
func LtSameI32(a []int32, b []int32)
func LtSameI64(a []int64, b []int64)
func LtSameI8(a []int8, b []int8)
func LtSameIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)
func LtSameIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)
func LtSameIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)
func LtSameIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)
func LtSameIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)
func LtSameIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)
func LtSameIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)
func LtSameIterSVF32(a float32, b []float32, bit Iterator) (err error)
func LtSameIterSVF64(a float64, b []float64, bit Iterator) (err error)
func LtSameIterSVI(a int, b []int, bit Iterator) (err error)
func LtSameIterSVI16(a int16, b []int16, bit Iterator) (err error)
func LtSameIterSVI32(a int32, b []int32, bit Iterator) (err error)
func LtSameIterSVI64(a int64, b []int64, bit Iterator) (err error)
func LtSameIterSVI8(a int8, b []int8, bit Iterator) (err error)
func LtSameIterSVStr(a string, b []string, bit Iterator) (err error)
func LtSameIterSVU(a uint, b []uint, bit Iterator) (err error)
func LtSameIterSVU16(a uint16, b []uint16, bit Iterator) (err error)
func LtSameIterSVU32(a uint32, b []uint32, bit Iterator) (err error)
func LtSameIterSVU64(a uint64, b []uint64, bit Iterator) (err error)
func LtSameIterSVU8(a uint8, b []uint8, bit Iterator) (err error)
func LtSameIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)
func LtSameIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)
func LtSameIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)
func LtSameIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)
func LtSameIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)
func LtSameIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)
func LtSameIterVSF32(a []float32, b float32, ait Iterator) (err error)
func LtSameIterVSF64(a []float64, b float64, ait Iterator) (err error)
func LtSameIterVSI(a []int, b int, ait Iterator) (err error)
func LtSameIterVSI16(a []int16, b int16, ait Iterator) (err error)
func LtSameIterVSI32(a []int32, b int32, ait Iterator) (err error)
func LtSameIterVSI64(a []int64, b int64, ait Iterator) (err error)
func LtSameIterVSI8(a []int8, b int8, ait Iterator) (err error)
func LtSameIterVSStr(a []string, b string, ait Iterator) (err error)
func LtSameIterVSU(a []uint, b uint, ait Iterator) (err error)
func LtSameIterVSU16(a []uint16, b uint16, ait Iterator) (err error)
func LtSameIterVSU32(a []uint32, b uint32, ait Iterator) (err error)
func LtSameIterVSU64(a []uint64, b uint64, ait Iterator) (err error)
func LtSameIterVSU8(a []uint8, b uint8, ait Iterator) (err error)
func LtSameSVF32(a float32, b []float32)
func LtSameSVF64(a float64, b []float64)
func LtSameSVI(a int, b []int)
func LtSameSVI16(a int16, b []int16)
func LtSameSVI32(a int32, b []int32)
func LtSameSVI64(a int64, b []int64)
func LtSameSVI8(a int8, b []int8)
func LtSameSVStr(a string, b []string)
func LtSameSVU(a uint, b []uint)
func LtSameSVU16(a uint16, b []uint16)
func LtSameSVU32(a uint32, b []uint32)
func LtSameSVU64(a uint64, b []uint64)
func LtSameSVU8(a uint8, b []uint8)
func LtSameStr(a []string, b []string)
func LtSameU(a []uint, b []uint)
func LtSameU16(a []uint16, b []uint16)
func LtSameU32(a []uint32, b []uint32)
func LtSameU64(a []uint64, b []uint64)
func LtSameU8(a []uint8, b []uint8)
func LtSameVSF32(a []float32, b float32)
func LtSameVSF64(a []float64, b float64)
func LtSameVSI(a []int, b int)
func LtSameVSI16(a []int16, b int16)
func LtSameVSI32(a []int32, b int32)
func LtSameVSI64(a []int64, b int64)
func LtSameVSI8(a []int8, b int8)
func LtSameVSStr(a []string, b string)
func LtSameVSU(a []uint, b uint)
func LtSameVSU16(a []uint16, b uint16)
func LtSameVSU32(a []uint32, b uint32)
func LtSameVSU64(a []uint64, b uint64)
func LtSameVSU8(a []uint8, b uint8)
func LtStr(a []string, b []string, retVal []bool)
func LtU(a []uint, b []uint, retVal []bool)
func LtU16(a []uint16, b []uint16, retVal []bool)
func LtU32(a []uint32, b []uint32, retVal []bool)
func LtU64(a []uint64, b []uint64, retVal []bool)
func LtU8(a []uint8, b []uint8, retVal []bool)
func LtVSF32(a []float32, b float32, retVal []bool)
func LtVSF64(a []float64, b float64, retVal []bool)
func LtVSI(a []int, b int, retVal []bool)
func LtVSI16(a []int16, b int16, retVal []bool)
func LtVSI32(a []int32, b int32, retVal []bool)
func LtVSI64(a []int64, b int64, retVal []bool)
func LtVSI8(a []int8, b int8, retVal []bool)
func LtVSStr(a []string, b string, retVal []bool)
func LtVSU(a []uint, b uint, retVal []bool)
func LtVSU16(a []uint16, b uint16, retVal []bool)
func LtVSU32(a []uint32, b uint32, retVal []bool)
func LtVSU64(a []uint64, b uint64, retVal []bool)
func LtVSU8(a []uint8, b uint8, retVal []bool)
func LteF32(a []float32, b []float32, retVal []bool)
func LteF64(a []float64, b []float64, retVal []bool)
func LteI(a []int, b []int, retVal []bool)
func LteI16(a []int16, b []int16, retVal []bool)
func LteI32(a []int32, b []int32, retVal []bool)
func LteI64(a []int64, b []int64, retVal []bool)
func LteI8(a []int8, b []int8, retVal []bool)
func LteIterF32(a []float32, b []float32, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func LteIterF64(a []float64, b []float64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func LteIterI(a []int, b []int, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LteIterI16(a []int16, b []int16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LteIterI32(a []int32, b []int32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LteIterI64(a []int64, b []int64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LteIterI8(a []int8, b []int8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LteIterSVF32(a float32, b []float32, retVal []bool, bit Iterator, rit Iterator) (err error)
func LteIterSVF64(a float64, b []float64, retVal []bool, bit Iterator, rit Iterator) (err error)
func LteIterSVI(a int, b []int, retVal []bool, bit Iterator, rit Iterator) (err error)
func LteIterSVI16(a int16, b []int16, retVal []bool, bit Iterator, rit Iterator) (err error)
func LteIterSVI32(a int32, b []int32, retVal []bool, bit Iterator, rit Iterator) (err error)
func LteIterSVI64(a int64, b []int64, retVal []bool, bit Iterator, rit Iterator) (err error)
func LteIterSVI8(a int8, b []int8, retVal []bool, bit Iterator, rit Iterator) (err error)
func LteIterSVStr(a string, b []string, retVal []bool, bit Iterator, rit Iterator) (err error)
func LteIterSVU(a uint, b []uint, retVal []bool, bit Iterator, rit Iterator) (err error)
func LteIterSVU16(a uint16, b []uint16, retVal []bool, bit Iterator, rit Iterator) (err error)
func LteIterSVU32(a uint32, b []uint32, retVal []bool, bit Iterator, rit Iterator) (err error)
func LteIterSVU64(a uint64, b []uint64, retVal []bool, bit Iterator, rit Iterator) (err error)
func LteIterSVU8(a uint8, b []uint8, retVal []bool, bit Iterator, rit Iterator) (err error)
func LteIterStr(a []string, b []string, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func LteIterU(a []uint, b []uint, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LteIterU16(a []uint16, b []uint16, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func LteIterU32(a []uint32, b []uint32, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func LteIterU64(a []uint64, b []uint64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func LteIterU8(a []uint8, b []uint8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func LteIterVSF32(a []float32, b float32, retVal []bool, ait Iterator, rit Iterator) (err error)
func LteIterVSF64(a []float64, b float64, retVal []bool, ait Iterator, rit Iterator) (err error)
func LteIterVSI(a []int, b int, retVal []bool, ait Iterator, rit Iterator) (err error)
func LteIterVSI16(a []int16, b int16, retVal []bool, ait Iterator, rit Iterator) (err error)
func LteIterVSI32(a []int32, b int32, retVal []bool, ait Iterator, rit Iterator) (err error)
func LteIterVSI64(a []int64, b int64, retVal []bool, ait Iterator, rit Iterator) (err error)
func LteIterVSI8(a []int8, b int8, retVal []bool, ait Iterator, rit Iterator) (err error)
func LteIterVSStr(a []string, b string, retVal []bool, ait Iterator, rit Iterator) (err error)
func LteIterVSU(a []uint, b uint, retVal []bool, ait Iterator, rit Iterator) (err error)
func LteIterVSU16(a []uint16, b uint16, retVal []bool, ait Iterator, rit Iterator) (err error)
func LteIterVSU32(a []uint32, b uint32, retVal []bool, ait Iterator, rit Iterator) (err error)
func LteIterVSU64(a []uint64, b uint64, retVal []bool, ait Iterator, rit Iterator) (err error)
func LteIterVSU8(a []uint8, b uint8, retVal []bool, ait Iterator, rit Iterator) (err error)
func LteSVF32(a float32, b []float32, retVal []bool)
func LteSVF64(a float64, b []float64, retVal []bool)
func LteSVI(a int, b []int, retVal []bool)
func LteSVI16(a int16, b []int16, retVal []bool)
func LteSVI32(a int32, b []int32, retVal []bool)
func LteSVI64(a int64, b []int64, retVal []bool)
func LteSVI8(a int8, b []int8, retVal []bool)
func LteSVStr(a string, b []string, retVal []bool)
func LteSVU(a uint, b []uint, retVal []bool)
func LteSVU16(a uint16, b []uint16, retVal []bool)
func LteSVU32(a uint32, b []uint32, retVal []bool)
func LteSVU64(a uint64, b []uint64, retVal []bool)
func LteSVU8(a uint8, b []uint8, retVal []bool)
func LteSameF32(a []float32, b []float32)
func LteSameF64(a []float64, b []float64)
func LteSameI(a []int, b []int)
func LteSameI16(a []int16, b []int16)
func LteSameI32(a []int32, b []int32)
func LteSameI64(a []int64, b []int64)
func LteSameI8(a []int8, b []int8)
func LteSameIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)
func LteSameIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)
func LteSameIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)
func LteSameIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)
func LteSameIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)
func LteSameIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)
func LteSameIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)
func LteSameIterSVF32(a float32, b []float32, bit Iterator) (err error)
func LteSameIterSVF64(a float64, b []float64, bit Iterator) (err error)
func LteSameIterSVI(a int, b []int, bit Iterator) (err error)
func LteSameIterSVI16(a int16, b []int16, bit Iterator) (err error)
func LteSameIterSVI32(a int32, b []int32, bit Iterator) (err error)
func LteSameIterSVI64(a int64, b []int64, bit Iterator) (err error)
func LteSameIterSVI8(a int8, b []int8, bit Iterator) (err error)
func LteSameIterSVStr(a string, b []string, bit Iterator) (err error)
func LteSameIterSVU(a uint, b []uint, bit Iterator) (err error)
func LteSameIterSVU16(a uint16, b []uint16, bit Iterator) (err error)
func LteSameIterSVU32(a uint32, b []uint32, bit Iterator) (err error)
func LteSameIterSVU64(a uint64, b []uint64, bit Iterator) (err error)
func LteSameIterSVU8(a uint8, b []uint8, bit Iterator) (err error)
func LteSameIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)
func LteSameIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)
func LteSameIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)
func LteSameIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)
func LteSameIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)
func LteSameIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)
func LteSameIterVSF32(a []float32, b float32, ait Iterator) (err error)
func LteSameIterVSF64(a []float64, b float64, ait Iterator) (err error)
func LteSameIterVSI(a []int, b int, ait Iterator) (err error)
func LteSameIterVSI16(a []int16, b int16, ait Iterator) (err error)
func LteSameIterVSI32(a []int32, b int32, ait Iterator) (err error)
func LteSameIterVSI64(a []int64, b int64, ait Iterator) (err error)
func LteSameIterVSI8(a []int8, b int8, ait Iterator) (err error)
func LteSameIterVSStr(a []string, b string, ait Iterator) (err error)
func LteSameIterVSU(a []uint, b uint, ait Iterator) (err error)
func LteSameIterVSU16(a []uint16, b uint16, ait Iterator) (err error)
func LteSameIterVSU32(a []uint32, b uint32, ait Iterator) (err error)
func LteSameIterVSU64(a []uint64, b uint64, ait Iterator) (err error)
func LteSameIterVSU8(a []uint8, b uint8, ait Iterator) (err error)
func LteSameSVF32(a float32, b []float32)
func LteSameSVF64(a float64, b []float64)
func LteSameSVI(a int, b []int)
func LteSameSVI16(a int16, b []int16)
func LteSameSVI32(a int32, b []int32)
func LteSameSVI64(a int64, b []int64)
func LteSameSVI8(a int8, b []int8)
func LteSameSVStr(a string, b []string)
func LteSameSVU(a uint, b []uint)
func LteSameSVU16(a uint16, b []uint16)
func LteSameSVU32(a uint32, b []uint32)
func LteSameSVU64(a uint64, b []uint64)
func LteSameSVU8(a uint8, b []uint8)
func LteSameStr(a []string, b []string)
func LteSameU(a []uint, b []uint)
func LteSameU16(a []uint16, b []uint16)
func LteSameU32(a []uint32, b []uint32)
func LteSameU64(a []uint64, b []uint64)
func LteSameU8(a []uint8, b []uint8)
func LteSameVSF32(a []float32, b float32)
func LteSameVSF64(a []float64, b float64)
func LteSameVSI(a []int, b int)
func LteSameVSI16(a []int16, b int16)
func LteSameVSI32(a []int32, b int32)
func LteSameVSI64(a []int64, b int64)
func LteSameVSI8(a []int8, b int8)
func LteSameVSStr(a []string, b string)
func LteSameVSU(a []uint, b uint)
func LteSameVSU16(a []uint16, b uint16)
func LteSameVSU32(a []uint32, b uint32)
func LteSameVSU64(a []uint64, b uint64)
func LteSameVSU8(a []uint8, b uint8)
func LteStr(a []string, b []string, retVal []bool)
func LteU(a []uint, b []uint, retVal []bool)
func LteU16(a []uint16, b []uint16, retVal []bool)
func LteU32(a []uint32, b []uint32, retVal []bool)
func LteU64(a []uint64, b []uint64, retVal []bool)
func LteU8(a []uint8, b []uint8, retVal []bool)
func LteVSF32(a []float32, b float32, retVal []bool)
func LteVSF64(a []float64, b float64, retVal []bool)
func LteVSI(a []int, b int, retVal []bool)
func LteVSI16(a []int16, b int16, retVal []bool)
func LteVSI32(a []int32, b int32, retVal []bool)
func LteVSI64(a []int64, b int64, retVal []bool)
func LteVSI8(a []int8, b int8, retVal []bool)
func LteVSStr(a []string, b string, retVal []bool)
func LteVSU(a []uint, b uint, retVal []bool)
func LteVSU16(a []uint16, b uint16, retVal []bool)
func LteVSU32(a []uint32, b uint32, retVal []bool)
func LteVSU64(a []uint64, b uint64, retVal []bool)
func LteVSU8(a []uint8, b uint8, retVal []bool)
func MapB(fn func(bool) bool, a []bool)
func MapC128(fn func(complex128) complex128, a []complex128)
func MapC64(fn func(complex64) complex64, a []complex64)
func MapErrB(fn func(bool) (bool, error), a []bool) (err error)
func MapErrC128(fn func(complex128) (complex128, error), a []complex128) (err error)
func MapErrC64(fn func(complex64) (complex64, error), a []complex64) (err error)
func MapErrF32(fn func(float32) (float32, error), a []float32) (err error)
func MapErrF64(fn func(float64) (float64, error), a []float64) (err error)
func MapErrI(fn func(int) (int, error), a []int) (err error)
func MapErrI16(fn func(int16) (int16, error), a []int16) (err error)
func MapErrI32(fn func(int32) (int32, error), a []int32) (err error)
func MapErrI64(fn func(int64) (int64, error), a []int64) (err error)
func MapErrI8(fn func(int8) (int8, error), a []int8) (err error)
func MapErrStr(fn func(string) (string, error), a []string) (err error)
func MapErrU(fn func(uint) (uint, error), a []uint) (err error)
func MapErrU16(fn func(uint16) (uint16, error), a []uint16) (err error)
func MapErrU32(fn func(uint32) (uint32, error), a []uint32) (err error)
func MapErrU64(fn func(uint64) (uint64, error), a []uint64) (err error)
func MapErrU8(fn func(uint8) (uint8, error), a []uint8) (err error)
func MapErrUintptr(fn func(uintptr) (uintptr, error), a []uintptr) (err error)
func MapErrUnsafePointer(fn func(unsafe.Pointer) (unsafe.Pointer, error), a []unsafe.Pointer) (err error)
func MapF32(fn func(float32) float32, a []float32)
func MapF64(fn func(float64) float64, a []float64)
func MapI(fn func(int) int, a []int)
func MapI16(fn func(int16) int16, a []int16)
func MapI32(fn func(int32) int32, a []int32)
func MapI64(fn func(int64) int64, a []int64)
func MapI8(fn func(int8) int8, a []int8)
func MapIncrC128(fn func(complex128) complex128, a []complex128)
func MapIncrC64(fn func(complex64) complex64, a []complex64)
func MapIncrErrC128(fn func(complex128) (complex128, error), a []complex128) (err error)
func MapIncrErrC64(fn func(complex64) (complex64, error), a []complex64) (err error)
func MapIncrErrF32(fn func(float32) (float32, error), a []float32) (err error)
func MapIncrErrF64(fn func(float64) (float64, error), a []float64) (err error)
func MapIncrErrI(fn func(int) (int, error), a []int) (err error)
func MapIncrErrI16(fn func(int16) (int16, error), a []int16) (err error)
func MapIncrErrI32(fn func(int32) (int32, error), a []int32) (err error)
func MapIncrErrI64(fn func(int64) (int64, error), a []int64) (err error)
func MapIncrErrI8(fn func(int8) (int8, error), a []int8) (err error)
func MapIncrErrStr(fn func(string) (string, error), a []string) (err error)
func MapIncrErrU(fn func(uint) (uint, error), a []uint) (err error)
func MapIncrErrU16(fn func(uint16) (uint16, error), a []uint16) (err error)
func MapIncrErrU32(fn func(uint32) (uint32, error), a []uint32) (err error)
func MapIncrErrU64(fn func(uint64) (uint64, error), a []uint64) (err error)
func MapIncrErrU8(fn func(uint8) (uint8, error), a []uint8) (err error)
func MapIncrF32(fn func(float32) float32, a []float32)
func MapIncrF64(fn func(float64) float64, a []float64)
func MapIncrI(fn func(int) int, a []int)
func MapIncrI16(fn func(int16) int16, a []int16)
func MapIncrI32(fn func(int32) int32, a []int32)
func MapIncrI64(fn func(int64) int64, a []int64)
func MapIncrI8(fn func(int8) int8, a []int8)
func MapIncrStr(fn func(string) string, a []string)
func MapIncrU(fn func(uint) uint, a []uint)
func MapIncrU16(fn func(uint16) uint16, a []uint16)
func MapIncrU32(fn func(uint32) uint32, a []uint32)
func MapIncrU64(fn func(uint64) uint64, a []uint64)
func MapIncrU8(fn func(uint8) uint8, a []uint8)
func MapIterB(fn func(bool) bool, a []bool, ait Iterator) (err error)
func MapIterC128(fn func(complex128) complex128, a []complex128, ait Iterator) (err error)
func MapIterC64(fn func(complex64) complex64, a []complex64, ait Iterator) (err error)
func MapIterErrB(fn func(bool) (bool, error), a []bool, ait Iterator) (err error)
func MapIterErrC128(fn func(complex128) (complex128, error), a []complex128, ait Iterator) (err error)
func MapIterErrC64(fn func(complex64) (complex64, error), a []complex64, ait Iterator) (err error)
func MapIterErrF32(fn func(float32) (float32, error), a []float32, ait Iterator) (err error)
func MapIterErrF64(fn func(float64) (float64, error), a []float64, ait Iterator) (err error)
func MapIterErrI(fn func(int) (int, error), a []int, ait Iterator) (err error)
func MapIterErrI16(fn func(int16) (int16, error), a []int16, ait Iterator) (err error)
func MapIterErrI32(fn func(int32) (int32, error), a []int32, ait Iterator) (err error)
func MapIterErrI64(fn func(int64) (int64, error), a []int64, ait Iterator) (err error)
func MapIterErrI8(fn func(int8) (int8, error), a []int8, ait Iterator) (err error)
func MapIterErrStr(fn func(string) (string, error), a []string, ait Iterator) (err error)
func MapIterErrU(fn func(uint) (uint, error), a []uint, ait Iterator) (err error)
func MapIterErrU16(fn func(uint16) (uint16, error), a []uint16, ait Iterator) (err error)
func MapIterErrU32(fn func(uint32) (uint32, error), a []uint32, ait Iterator) (err error)
func MapIterErrU64(fn func(uint64) (uint64, error), a []uint64, ait Iterator) (err error)
func MapIterErrU8(fn func(uint8) (uint8, error), a []uint8, ait Iterator) (err error)
func MapIterErrUintptr(fn func(uintptr) (uintptr, error), a []uintptr, ait Iterator) (err error)
func MapIterErrUnsafePointer(fn func(unsafe.Pointer) (unsafe.Pointer, error), a []unsafe.Pointer, ...) (err error)
func MapIterF32(fn func(float32) float32, a []float32, ait Iterator) (err error)
func MapIterF64(fn func(float64) float64, a []float64, ait Iterator) (err error)
func MapIterI(fn func(int) int, a []int, ait Iterator) (err error)
func MapIterI16(fn func(int16) int16, a []int16, ait Iterator) (err error)
func MapIterI32(fn func(int32) int32, a []int32, ait Iterator) (err error)
func MapIterI64(fn func(int64) int64, a []int64, ait Iterator) (err error)
func MapIterI8(fn func(int8) int8, a []int8, ait Iterator) (err error)
func MapIterIncrC128(fn func(complex128) complex128, a []complex128, ait Iterator) (err error)
func MapIterIncrC64(fn func(complex64) complex64, a []complex64, ait Iterator) (err error)
func MapIterIncrErrC128(fn func(complex128) (complex128, error), a []complex128, ait Iterator) (err error)
func MapIterIncrErrC64(fn func(complex64) (complex64, error), a []complex64, ait Iterator) (err error)
func MapIterIncrErrF32(fn func(float32) (float32, error), a []float32, ait Iterator) (err error)
func MapIterIncrErrF64(fn func(float64) (float64, error), a []float64, ait Iterator) (err error)
func MapIterIncrErrI(fn func(int) (int, error), a []int, ait Iterator) (err error)
func MapIterIncrErrI16(fn func(int16) (int16, error), a []int16, ait Iterator) (err error)
func MapIterIncrErrI32(fn func(int32) (int32, error), a []int32, ait Iterator) (err error)
func MapIterIncrErrI64(fn func(int64) (int64, error), a []int64, ait Iterator) (err error)
func MapIterIncrErrI8(fn func(int8) (int8, error), a []int8, ait Iterator) (err error)
func MapIterIncrErrStr(fn func(string) (string, error), a []string, ait Iterator) (err error)
func MapIterIncrErrU(fn func(uint) (uint, error), a []uint, ait Iterator) (err error)
func MapIterIncrErrU16(fn func(uint16) (uint16, error), a []uint16, ait Iterator) (err error)
func MapIterIncrErrU32(fn func(uint32) (uint32, error), a []uint32, ait Iterator) (err error)
func MapIterIncrErrU64(fn func(uint64) (uint64, error), a []uint64, ait Iterator) (err error)
func MapIterIncrErrU8(fn func(uint8) (uint8, error), a []uint8, ait Iterator) (err error)
func MapIterIncrF32(fn func(float32) float32, a []float32, ait Iterator) (err error)
func MapIterIncrF64(fn func(float64) float64, a []float64, ait Iterator) (err error)
func MapIterIncrI(fn func(int) int, a []int, ait Iterator) (err error)
func MapIterIncrI16(fn func(int16) int16, a []int16, ait Iterator) (err error)
func MapIterIncrI32(fn func(int32) int32, a []int32, ait Iterator) (err error)
func MapIterIncrI64(fn func(int64) int64, a []int64, ait Iterator) (err error)
func MapIterIncrI8(fn func(int8) int8, a []int8, ait Iterator) (err error)
func MapIterIncrStr(fn func(string) string, a []string, ait Iterator) (err error)
func MapIterIncrU(fn func(uint) uint, a []uint, ait Iterator) (err error)
func MapIterIncrU16(fn func(uint16) uint16, a []uint16, ait Iterator) (err error)
func MapIterIncrU32(fn func(uint32) uint32, a []uint32, ait Iterator) (err error)
func MapIterIncrU64(fn func(uint64) uint64, a []uint64, ait Iterator) (err error)
func MapIterIncrU8(fn func(uint8) uint8, a []uint8, ait Iterator) (err error)
func MapIterStr(fn func(string) string, a []string, ait Iterator) (err error)
func MapIterU(fn func(uint) uint, a []uint, ait Iterator) (err error)
func MapIterU16(fn func(uint16) uint16, a []uint16, ait Iterator) (err error)
func MapIterU32(fn func(uint32) uint32, a []uint32, ait Iterator) (err error)
func MapIterU64(fn func(uint64) uint64, a []uint64, ait Iterator) (err error)
func MapIterU8(fn func(uint8) uint8, a []uint8, ait Iterator) (err error)
func MapIterUintptr(fn func(uintptr) uintptr, a []uintptr, ait Iterator) (err error)
func MapIterUnsafePointer(fn func(unsafe.Pointer) unsafe.Pointer, a []unsafe.Pointer, ait Iterator) (err error)
func MapStr(fn func(string) string, a []string)
func MapU(fn func(uint) uint, a []uint)
func MapU16(fn func(uint16) uint16, a []uint16)
func MapU32(fn func(uint32) uint32, a []uint32)
func MapU64(fn func(uint64) uint64, a []uint64)
func MapU8(fn func(uint8) uint8, a []uint8)
func MapUintptr(fn func(uintptr) uintptr, a []uintptr)
func MapUnsafePointer(fn func(unsafe.Pointer) unsafe.Pointer, a []unsafe.Pointer)
func MaxF32(a, b float32) (c float32)
func MaxF64(a, b float64) (c float64)
func MaxI(a, b int) (c int)
func MaxI16(a, b int16) (c int16)
func MaxI32(a, b int32) (c int32)
func MaxI64(a, b int64) (c int64)
func MaxI8(a, b int8) (c int8)
func MaxMethods(t reflect.Type) (firstFn, lasFn, defaultFn interface{}, err error)
func MaxStr(a, b string) (c string)
func MaxU(a, b uint) (c uint)
func MaxU16(a, b uint16) (c uint16)
func MaxU32(a, b uint32) (c uint32)
func MaxU64(a, b uint64) (c uint64)
func MaxU8(a, b uint8) (c uint8)
func MinF32(a, b float32) (c float32)
func MinF64(a, b float64) (c float64)
func MinI(a, b int) (c int)
func MinI16(a, b int16) (c int16)
func MinI32(a, b int32) (c int32)
func MinI64(a, b int64) (c int64)
func MinI8(a, b int8) (c int8)
func MinMethods(t reflect.Type) (firstFn, lasFn, defaultFn interface{}, err error)
func MinStr(a, b string) (c string)
func MinU(a, b uint) (c uint)
func MinU16(a, b uint16) (c uint16)
func MinU32(a, b uint32) (c uint32)
func MinU64(a, b uint64) (c uint64)
func MinU8(a, b uint8) (c uint8)
func ModF32(a float32, b float32) float32
func ModF64(a float64, b float64) float64
func ModI(a int, b int) int
func ModI16(a int16, b int16) int16
func ModI32(a int32, b int32) int32
func ModI64(a int64, b int64) int64
func ModI8(a int8, b int8) int8
func ModIncrF32(a []float32, b []float32, incr []float32)
func ModIncrF64(a []float64, b []float64, incr []float64)
func ModIncrI(a []int, b []int, incr []int)
func ModIncrI16(a []int16, b []int16, incr []int16)
func ModIncrI32(a []int32, b []int32, incr []int32)
func ModIncrI64(a []int64, b []int64, incr []int64)
func ModIncrI8(a []int8, b []int8, incr []int8)
func ModIncrSVF32(a float32, b []float32, incr []float32)
func ModIncrSVF64(a float64, b []float64, incr []float64)
func ModIncrSVI(a int, b []int, incr []int)
func ModIncrSVI16(a int16, b []int16, incr []int16)
func ModIncrSVI32(a int32, b []int32, incr []int32)
func ModIncrSVI64(a int64, b []int64, incr []int64)
func ModIncrSVI8(a int8, b []int8, incr []int8)
func ModIncrSVU(a uint, b []uint, incr []uint)
func ModIncrSVU16(a uint16, b []uint16, incr []uint16)
func ModIncrSVU32(a uint32, b []uint32, incr []uint32)
func ModIncrSVU64(a uint64, b []uint64, incr []uint64)
func ModIncrSVU8(a uint8, b []uint8, incr []uint8)
func ModIncrU(a []uint, b []uint, incr []uint)
func ModIncrU16(a []uint16, b []uint16, incr []uint16)
func ModIncrU32(a []uint32, b []uint32, incr []uint32)
func ModIncrU64(a []uint64, b []uint64, incr []uint64)
func ModIncrU8(a []uint8, b []uint8, incr []uint8)
func ModIncrVSF32(a []float32, b float32, incr []float32)
func ModIncrVSF64(a []float64, b float64, incr []float64)
func ModIncrVSI(a []int, b int, incr []int)
func ModIncrVSI16(a []int16, b int16, incr []int16)
func ModIncrVSI32(a []int32, b int32, incr []int32)
func ModIncrVSI64(a []int64, b int64, incr []int64)
func ModIncrVSI8(a []int8, b int8, incr []int8)
func ModIncrVSU(a []uint, b uint, incr []uint)
func ModIncrVSU16(a []uint16, b uint16, incr []uint16)
func ModIncrVSU32(a []uint32, b uint32, incr []uint32)
func ModIncrVSU64(a []uint64, b uint64, incr []uint64)
func ModIncrVSU8(a []uint8, b uint8, incr []uint8)
func ModIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)
func ModIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)
func ModIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)
func ModIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)
func ModIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)
func ModIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)
func ModIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)
func ModIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, ...) (err error)
func ModIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, ...) (err error)
func ModIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error)
func ModIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error)
func ModIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error)
func ModIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error)
func ModIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error)
func ModIterIncrSVF32(a float32, b []float32, incr []float32, bit Iterator, iit Iterator) (err error)
func ModIterIncrSVF64(a float64, b []float64, incr []float64, bit Iterator, iit Iterator) (err error)
func ModIterIncrSVI(a int, b []int, incr []int, bit Iterator, iit Iterator) (err error)
func ModIterIncrSVI16(a int16, b []int16, incr []int16, bit Iterator, iit Iterator) (err error)
func ModIterIncrSVI32(a int32, b []int32, incr []int32, bit Iterator, iit Iterator) (err error)
func ModIterIncrSVI64(a int64, b []int64, incr []int64, bit Iterator, iit Iterator) (err error)
func ModIterIncrSVI8(a int8, b []int8, incr []int8, bit Iterator, iit Iterator) (err error)
func ModIterIncrSVU(a uint, b []uint, incr []uint, bit Iterator, iit Iterator) (err error)
func ModIterIncrSVU16(a uint16, b []uint16, incr []uint16, bit Iterator, iit Iterator) (err error)
func ModIterIncrSVU32(a uint32, b []uint32, incr []uint32, bit Iterator, iit Iterator) (err error)
func ModIterIncrSVU64(a uint64, b []uint64, incr []uint64, bit Iterator, iit Iterator) (err error)
func ModIterIncrSVU8(a uint8, b []uint8, incr []uint8, bit Iterator, iit Iterator) (err error)
func ModIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error)
func ModIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, ...) (err error)
func ModIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, ...) (err error)
func ModIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, ...) (err error)
func ModIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error)
func ModIterIncrVSF32(a []float32, b float32, incr []float32, ait Iterator, iit Iterator) (err error)
func ModIterIncrVSF64(a []float64, b float64, incr []float64, ait Iterator, iit Iterator) (err error)
func ModIterIncrVSI(a []int, b int, incr []int, ait Iterator, iit Iterator) (err error)
func ModIterIncrVSI16(a []int16, b int16, incr []int16, ait Iterator, iit Iterator) (err error)
func ModIterIncrVSI32(a []int32, b int32, incr []int32, ait Iterator, iit Iterator) (err error)
func ModIterIncrVSI64(a []int64, b int64, incr []int64, ait Iterator, iit Iterator) (err error)
func ModIterIncrVSI8(a []int8, b int8, incr []int8, ait Iterator, iit Iterator) (err error)
func ModIterIncrVSU(a []uint, b uint, incr []uint, ait Iterator, iit Iterator) (err error)
func ModIterIncrVSU16(a []uint16, b uint16, incr []uint16, ait Iterator, iit Iterator) (err error)
func ModIterIncrVSU32(a []uint32, b uint32, incr []uint32, ait Iterator, iit Iterator) (err error)
func ModIterIncrVSU64(a []uint64, b uint64, incr []uint64, ait Iterator, iit Iterator) (err error)
func ModIterIncrVSU8(a []uint8, b uint8, incr []uint8, ait Iterator, iit Iterator) (err error)
func ModIterSVF32(a float32, b []float32, bit Iterator) (err error)
func ModIterSVF64(a float64, b []float64, bit Iterator) (err error)
func ModIterSVI(a int, b []int, bit Iterator) (err error)
func ModIterSVI16(a int16, b []int16, bit Iterator) (err error)
func ModIterSVI32(a int32, b []int32, bit Iterator) (err error)
func ModIterSVI64(a int64, b []int64, bit Iterator) (err error)
func ModIterSVI8(a int8, b []int8, bit Iterator) (err error)
func ModIterSVU(a uint, b []uint, bit Iterator) (err error)
func ModIterSVU16(a uint16, b []uint16, bit Iterator) (err error)
func ModIterSVU32(a uint32, b []uint32, bit Iterator) (err error)
func ModIterSVU64(a uint64, b []uint64, bit Iterator) (err error)
func ModIterSVU8(a uint8, b []uint8, bit Iterator) (err error)
func ModIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)
func ModIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)
func ModIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)
func ModIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)
func ModIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)
func ModIterVSF32(a []float32, b float32, ait Iterator) (err error)
func ModIterVSF64(a []float64, b float64, ait Iterator) (err error)
func ModIterVSI(a []int, b int, ait Iterator) (err error)
func ModIterVSI16(a []int16, b int16, ait Iterator) (err error)
func ModIterVSI32(a []int32, b int32, ait Iterator) (err error)
func ModIterVSI64(a []int64, b int64, ait Iterator) (err error)
func ModIterVSI8(a []int8, b int8, ait Iterator) (err error)
func ModIterVSU(a []uint, b uint, ait Iterator) (err error)
func ModIterVSU16(a []uint16, b uint16, ait Iterator) (err error)
func ModIterVSU32(a []uint32, b uint32, ait Iterator) (err error)
func ModIterVSU64(a []uint64, b uint64, ait Iterator) (err error)
func ModIterVSU8(a []uint8, b uint8, ait Iterator) (err error)
func ModSVF32(a float32, b []float32)
func ModSVF64(a float64, b []float64)
func ModSVI(a int, b []int)
func ModSVI16(a int16, b []int16)
func ModSVI32(a int32, b []int32)
func ModSVI64(a int64, b []int64)
func ModSVI8(a int8, b []int8)
func ModSVU(a uint, b []uint)
func ModSVU16(a uint16, b []uint16)
func ModSVU32(a uint32, b []uint32)
func ModSVU64(a uint64, b []uint64)
func ModSVU8(a uint8, b []uint8)
func ModU(a uint, b uint) uint
func ModU16(a uint16, b uint16) uint16
func ModU32(a uint32, b uint32) uint32
func ModU64(a uint64, b uint64) uint64
func ModU8(a uint8, b uint8) uint8
func ModVSF32(a []float32, b float32)
func ModVSF64(a []float64, b float64)
func ModVSI(a []int, b int)
func ModVSI16(a []int16, b int16)
func ModVSI32(a []int32, b int32)
func ModVSI64(a []int64, b int64)
func ModVSI8(a []int8, b int8)
func ModVSU(a []uint, b uint)
func ModVSU16(a []uint16, b uint16)
func ModVSU32(a []uint32, b uint32)
func ModVSU64(a []uint64, b uint64)
func ModVSU8(a []uint8, b uint8)
func MonotonicMax(t reflect.Type, a *storage.Header) (retVal interface{}, err error)
func MonotonicMin(t reflect.Type, a *storage.Header) (retVal interface{}, err error)
func MonotonicSum(t reflect.Type, a *storage.Header) (retVal interface{}, err error)
func MulC128(a complex128, b complex128) complex128
func MulC64(a complex64, b complex64) complex64
func MulF32(a float32, b float32) float32
func MulF64(a float64, b float64) float64
func MulI(a int, b int) int
func MulI16(a int16, b int16) int16
func MulI32(a int32, b int32) int32
func MulI64(a int64, b int64) int64
func MulI8(a int8, b int8) int8
func MulIncrC128(a []complex128, b []complex128, incr []complex128)
func MulIncrC64(a []complex64, b []complex64, incr []complex64)
func MulIncrF32(a []float32, b []float32, incr []float32)
func MulIncrF64(a []float64, b []float64, incr []float64)
func MulIncrI(a []int, b []int, incr []int)
func MulIncrI16(a []int16, b []int16, incr []int16)
func MulIncrI32(a []int32, b []int32, incr []int32)
func MulIncrI64(a []int64, b []int64, incr []int64)
func MulIncrI8(a []int8, b []int8, incr []int8)
func MulIncrSVC128(a complex128, b []complex128, incr []complex128)
func MulIncrSVC64(a complex64, b []complex64, incr []complex64)
func MulIncrSVF32(a float32, b []float32, incr []float32)
func MulIncrSVF64(a float64, b []float64, incr []float64)
func MulIncrSVI(a int, b []int, incr []int)
func MulIncrSVI16(a int16, b []int16, incr []int16)
func MulIncrSVI32(a int32, b []int32, incr []int32)
func MulIncrSVI64(a int64, b []int64, incr []int64)
func MulIncrSVI8(a int8, b []int8, incr []int8)
func MulIncrSVU(a uint, b []uint, incr []uint)
func MulIncrSVU16(a uint16, b []uint16, incr []uint16)
func MulIncrSVU32(a uint32, b []uint32, incr []uint32)
func MulIncrSVU64(a uint64, b []uint64, incr []uint64)
func MulIncrSVU8(a uint8, b []uint8, incr []uint8)
func MulIncrU(a []uint, b []uint, incr []uint)
func MulIncrU16(a []uint16, b []uint16, incr []uint16)
func MulIncrU32(a []uint32, b []uint32, incr []uint32)
func MulIncrU64(a []uint64, b []uint64, incr []uint64)
func MulIncrU8(a []uint8, b []uint8, incr []uint8)
func MulIncrVSC128(a []complex128, b complex128, incr []complex128)
func MulIncrVSC64(a []complex64, b complex64, incr []complex64)
func MulIncrVSF32(a []float32, b float32, incr []float32)
func MulIncrVSF64(a []float64, b float64, incr []float64)
func MulIncrVSI(a []int, b int, incr []int)
func MulIncrVSI16(a []int16, b int16, incr []int16)
func MulIncrVSI32(a []int32, b int32, incr []int32)
func MulIncrVSI64(a []int64, b int64, incr []int64)
func MulIncrVSI8(a []int8, b int8, incr []int8)
func MulIncrVSU(a []uint, b uint, incr []uint)
func MulIncrVSU16(a []uint16, b uint16, incr []uint16)
func MulIncrVSU32(a []uint32, b uint32, incr []uint32)
func MulIncrVSU64(a []uint64, b uint64, incr []uint64)
func MulIncrVSU8(a []uint8, b uint8, incr []uint8)
func MulIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)
func MulIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)
func MulIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)
func MulIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)
func MulIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)
func MulIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)
func MulIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)
func MulIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)
func MulIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)
func MulIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, ...) (err error)
func MulIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, ...) (err error)
func MulIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, ...) (err error)
func MulIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, ...) (err error)
func MulIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error)
func MulIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error)
func MulIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error)
func MulIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error)
func MulIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVC128(a complex128, b []complex128, incr []complex128, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVC64(a complex64, b []complex64, incr []complex64, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVF32(a float32, b []float32, incr []float32, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVF64(a float64, b []float64, incr []float64, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVI(a int, b []int, incr []int, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVI16(a int16, b []int16, incr []int16, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVI32(a int32, b []int32, incr []int32, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVI64(a int64, b []int64, incr []int64, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVI8(a int8, b []int8, incr []int8, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVU(a uint, b []uint, incr []uint, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVU16(a uint16, b []uint16, incr []uint16, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVU32(a uint32, b []uint32, incr []uint32, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVU64(a uint64, b []uint64, incr []uint64, bit Iterator, iit Iterator) (err error)
func MulIterIncrSVU8(a uint8, b []uint8, incr []uint8, bit Iterator, iit Iterator) (err error)
func MulIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error)
func MulIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, ...) (err error)
func MulIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, ...) (err error)
func MulIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, ...) (err error)
func MulIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error)
func MulIterIncrVSC128(a []complex128, b complex128, incr []complex128, ait Iterator, iit Iterator) (err error)
func MulIterIncrVSC64(a []complex64, b complex64, incr []complex64, ait Iterator, iit Iterator) (err error)
func MulIterIncrVSF32(a []float32, b float32, incr []float32, ait Iterator, iit Iterator) (err error)
func MulIterIncrVSF64(a []float64, b float64, incr []float64, ait Iterator, iit Iterator) (err error)
func MulIterIncrVSI(a []int, b int, incr []int, ait Iterator, iit Iterator) (err error)
func MulIterIncrVSI16(a []int16, b int16, incr []int16, ait Iterator, iit Iterator) (err error)
func MulIterIncrVSI32(a []int32, b int32, incr []int32, ait Iterator, iit Iterator) (err error)
func MulIterIncrVSI64(a []int64, b int64, incr []int64, ait Iterator, iit Iterator) (err error)
func MulIterIncrVSI8(a []int8, b int8, incr []int8, ait Iterator, iit Iterator) (err error)
func MulIterIncrVSU(a []uint, b uint, incr []uint, ait Iterator, iit Iterator) (err error)
func MulIterIncrVSU16(a []uint16, b uint16, incr []uint16, ait Iterator, iit Iterator) (err error)
func MulIterIncrVSU32(a []uint32, b uint32, incr []uint32, ait Iterator, iit Iterator) (err error)
func MulIterIncrVSU64(a []uint64, b uint64, incr []uint64, ait Iterator, iit Iterator) (err error)
func MulIterIncrVSU8(a []uint8, b uint8, incr []uint8, ait Iterator, iit Iterator) (err error)
func MulIterSVC128(a complex128, b []complex128, bit Iterator) (err error)
func MulIterSVC64(a complex64, b []complex64, bit Iterator) (err error)
func MulIterSVF32(a float32, b []float32, bit Iterator) (err error)
func MulIterSVF64(a float64, b []float64, bit Iterator) (err error)
func MulIterSVI(a int, b []int, bit Iterator) (err error)
func MulIterSVI16(a int16, b []int16, bit Iterator) (err error)
func MulIterSVI32(a int32, b []int32, bit Iterator) (err error)
func MulIterSVI64(a int64, b []int64, bit Iterator) (err error)
func MulIterSVI8(a int8, b []int8, bit Iterator) (err error)
func MulIterSVU(a uint, b []uint, bit Iterator) (err error)
func MulIterSVU16(a uint16, b []uint16, bit Iterator) (err error)
func MulIterSVU32(a uint32, b []uint32, bit Iterator) (err error)
func MulIterSVU64(a uint64, b []uint64, bit Iterator) (err error)
func MulIterSVU8(a uint8, b []uint8, bit Iterator) (err error)
func MulIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)
func MulIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)
func MulIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)
func MulIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)
func MulIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)
func MulIterVSC128(a []complex128, b complex128, ait Iterator) (err error)
func MulIterVSC64(a []complex64, b complex64, ait Iterator) (err error)
func MulIterVSF32(a []float32, b float32, ait Iterator) (err error)
func MulIterVSF64(a []float64, b float64, ait Iterator) (err error)
func MulIterVSI(a []int, b int, ait Iterator) (err error)
func MulIterVSI16(a []int16, b int16, ait Iterator) (err error)
func MulIterVSI32(a []int32, b int32, ait Iterator) (err error)
func MulIterVSI64(a []int64, b int64, ait Iterator) (err error)
func MulIterVSI8(a []int8, b int8, ait Iterator) (err error)
func MulIterVSU(a []uint, b uint, ait Iterator) (err error)
func MulIterVSU16(a []uint16, b uint16, ait Iterator) (err error)
func MulIterVSU32(a []uint32, b uint32, ait Iterator) (err error)
func MulIterVSU64(a []uint64, b uint64, ait Iterator) (err error)
func MulIterVSU8(a []uint8, b uint8, ait Iterator) (err error)
func MulSVC128(a complex128, b []complex128)
func MulSVC64(a complex64, b []complex64)
func MulSVF32(a float32, b []float32)
func MulSVF64(a float64, b []float64)
func MulSVI(a int, b []int)
func MulSVI16(a int16, b []int16)
func MulSVI32(a int32, b []int32)
func MulSVI64(a int64, b []int64)
func MulSVI8(a int8, b []int8)
func MulSVU(a uint, b []uint)
func MulSVU16(a uint16, b []uint16)
func MulSVU32(a uint32, b []uint32)
func MulSVU64(a uint64, b []uint64)
func MulSVU8(a uint8, b []uint8)
func MulU(a uint, b uint) uint
func MulU16(a uint16, b uint16) uint16
func MulU32(a uint32, b uint32) uint32
func MulU64(a uint64, b uint64) uint64
func MulU8(a uint8, b uint8) uint8
func MulVSC128(a []complex128, b complex128)
func MulVSC64(a []complex64, b complex64)
func MulVSF32(a []float32, b float32)
func MulVSF64(a []float64, b float64)
func MulVSI(a []int, b int)
func MulVSI16(a []int16, b int16)
func MulVSI32(a []int32, b int32)
func MulVSI64(a []int64, b int64)
func MulVSI8(a []int8, b int8)
func MulVSU(a []uint, b uint)
func MulVSU16(a []uint16, b uint16)
func MulVSU32(a []uint32, b uint32)
func MulVSU64(a []uint64, b uint64)
func MulVSU8(a []uint8, b uint8)
func NeB(a []bool, b []bool, retVal []bool)
func NeC128(a []complex128, b []complex128, retVal []bool)
func NeC64(a []complex64, b []complex64, retVal []bool)
func NeF32(a []float32, b []float32, retVal []bool)
func NeF64(a []float64, b []float64, retVal []bool)
func NeI(a []int, b []int, retVal []bool)
func NeI16(a []int16, b []int16, retVal []bool)
func NeI32(a []int32, b []int32, retVal []bool)
func NeI64(a []int64, b []int64, retVal []bool)
func NeI8(a []int8, b []int8, retVal []bool)
func NeIterB(a []bool, b []bool, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func NeIterC128(a []complex128, b []complex128, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func NeIterC64(a []complex64, b []complex64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func NeIterF32(a []float32, b []float32, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func NeIterF64(a []float64, b []float64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func NeIterI(a []int, b []int, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func NeIterI16(a []int16, b []int16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func NeIterI32(a []int32, b []int32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func NeIterI64(a []int64, b []int64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func NeIterI8(a []int8, b []int8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func NeIterSVB(a bool, b []bool, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVC128(a complex128, b []complex128, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVC64(a complex64, b []complex64, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVF32(a float32, b []float32, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVF64(a float64, b []float64, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVI(a int, b []int, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVI16(a int16, b []int16, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVI32(a int32, b []int32, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVI64(a int64, b []int64, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVI8(a int8, b []int8, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVStr(a string, b []string, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVU(a uint, b []uint, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVU16(a uint16, b []uint16, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVU32(a uint32, b []uint32, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVU64(a uint64, b []uint64, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVU8(a uint8, b []uint8, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVUintptr(a uintptr, b []uintptr, retVal []bool, bit Iterator, rit Iterator) (err error)
func NeIterSVUnsafePointer(a unsafe.Pointer, b []unsafe.Pointer, retVal []bool, bit Iterator, ...) (err error)
func NeIterStr(a []string, b []string, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func NeIterU(a []uint, b []uint, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func NeIterU16(a []uint16, b []uint16, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func NeIterU32(a []uint32, b []uint32, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func NeIterU64(a []uint64, b []uint64, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func NeIterU8(a []uint8, b []uint8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)
func NeIterUintptr(a []uintptr, b []uintptr, retVal []bool, ait Iterator, bit Iterator, ...) (err error)
func NeIterUnsafePointer(a []unsafe.Pointer, b []unsafe.Pointer, retVal []bool, ait Iterator, ...) (err error)
func NeIterVSB(a []bool, b bool, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSC128(a []complex128, b complex128, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSC64(a []complex64, b complex64, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSF32(a []float32, b float32, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSF64(a []float64, b float64, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSI(a []int, b int, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSI16(a []int16, b int16, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSI32(a []int32, b int32, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSI64(a []int64, b int64, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSI8(a []int8, b int8, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSStr(a []string, b string, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSU(a []uint, b uint, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSU16(a []uint16, b uint16, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSU32(a []uint32, b uint32, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSU64(a []uint64, b uint64, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSU8(a []uint8, b uint8, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSUintptr(a []uintptr, b uintptr, retVal []bool, ait Iterator, rit Iterator) (err error)
func NeIterVSUnsafePointer(a []unsafe.Pointer, b unsafe.Pointer, retVal []bool, ait Iterator, ...) (err error)
func NeSVB(a bool, b []bool, retVal []bool)
func NeSVC128(a complex128, b []complex128, retVal []bool)
func NeSVC64(a complex64, b []complex64, retVal []bool)
func NeSVF32(a float32, b []float32, retVal []bool)
func NeSVF64(a float64, b []float64, retVal []bool)
func NeSVI(a int, b []int, retVal []bool)
func NeSVI16(a int16, b []int16, retVal []bool)
func NeSVI32(a int32, b []int32, retVal []bool)
func NeSVI64(a int64, b []int64, retVal []bool)
func NeSVI8(a int8, b []int8, retVal []bool)
func NeSVStr(a string, b []string, retVal []bool)
func NeSVU(a uint, b []uint, retVal []bool)
func NeSVU16(a uint16, b []uint16, retVal []bool)
func NeSVU32(a uint32, b []uint32, retVal []bool)
func NeSVU64(a uint64, b []uint64, retVal []bool)
func NeSVU8(a uint8, b []uint8, retVal []bool)
func NeSVUintptr(a uintptr, b []uintptr, retVal []bool)
func NeSVUnsafePointer(a unsafe.Pointer, b []unsafe.Pointer, retVal []bool)
func NeSameB(a []bool, b []bool)
func NeSameC128(a []complex128, b []complex128)
func NeSameC64(a []complex64, b []complex64)
func NeSameF32(a []float32, b []float32)
func NeSameF64(a []float64, b []float64)
func NeSameI(a []int, b []int)
func NeSameI16(a []int16, b []int16)
func NeSameI32(a []int32, b []int32)
func NeSameI64(a []int64, b []int64)
func NeSameI8(a []int8, b []int8)
func NeSameIterB(a []bool, b []bool, ait Iterator, bit Iterator) (err error)
func NeSameIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)
func NeSameIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)
func NeSameIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)
func NeSameIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)
func NeSameIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)
func NeSameIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)
func NeSameIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)
func NeSameIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)
func NeSameIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)
func NeSameIterSVB(a bool, b []bool, bit Iterator) (err error)
func NeSameIterSVC128(a complex128, b []complex128, bit Iterator) (err error)
func NeSameIterSVC64(a complex64, b []complex64, bit Iterator) (err error)
func NeSameIterSVF32(a float32, b []float32, bit Iterator) (err error)
func NeSameIterSVF64(a float64, b []float64, bit Iterator) (err error)
func NeSameIterSVI(a int, b []int, bit Iterator) (err error)
func NeSameIterSVI16(a int16, b []int16, bit Iterator) (err error)
func NeSameIterSVI32(a int32, b []int32, bit Iterator) (err error)
func NeSameIterSVI64(a int64, b []int64, bit Iterator) (err error)
func NeSameIterSVI8(a int8, b []int8, bit Iterator) (err error)
func NeSameIterSVStr(a string, b []string, bit Iterator) (err error)
func NeSameIterSVU(a uint, b []uint, bit Iterator) (err error)
func NeSameIterSVU16(a uint16, b []uint16, bit Iterator) (err error)
func NeSameIterSVU32(a uint32, b []uint32, bit Iterator) (err error)
func NeSameIterSVU64(a uint64, b []uint64, bit Iterator) (err error)
func NeSameIterSVU8(a uint8, b []uint8, bit Iterator) (err error)
func NeSameIterSVUintptr(a uintptr, b []uintptr, bit Iterator) (err error)
func NeSameIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)
func NeSameIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)
func NeSameIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)
func NeSameIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)
func NeSameIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)
func NeSameIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)
func NeSameIterUintptr(a []uintptr, b []uintptr, ait Iterator, bit Iterator) (err error)
func NeSameIterVSB(a []bool, b bool, ait Iterator) (err error)
func NeSameIterVSC128(a []complex128, b complex128, ait Iterator) (err error)
func NeSameIterVSC64(a []complex64, b complex64, ait Iterator) (err error)
func NeSameIterVSF32(a []float32, b float32, ait Iterator) (err error)
func NeSameIterVSF64(a []float64, b float64, ait Iterator) (err error)
func NeSameIterVSI(a []int, b int, ait Iterator) (err error)
func NeSameIterVSI16(a []int16, b int16, ait Iterator) (err error)
func NeSameIterVSI32(a []int32, b int32, ait Iterator) (err error)
func NeSameIterVSI64(a []int64, b int64, ait Iterator) (err error)
func NeSameIterVSI8(a []int8, b int8, ait Iterator) (err error)
func NeSameIterVSStr(a []string, b string, ait Iterator) (err error)
func NeSameIterVSU(a []uint, b uint, ait Iterator) (err error)
func NeSameIterVSU16(a []uint16, b uint16, ait Iterator) (err error)
func NeSameIterVSU32(a []uint32, b uint32, ait Iterator) (err error)
func NeSameIterVSU64(a []uint64, b uint64, ait Iterator) (err error)
func NeSameIterVSU8(a []uint8, b uint8, ait Iterator) (err error)
func NeSameIterVSUintptr(a []uintptr, b uintptr, ait Iterator) (err error)
func NeSameSVB(a bool, b []bool)
func NeSameSVC128(a complex128, b []complex128)
func NeSameSVC64(a complex64, b []complex64)
func NeSameSVF32(a float32, b []float32)
func NeSameSVF64(a float64, b []float64)
func NeSameSVI(a int, b []int)
func NeSameSVI16(a int16, b []int16)
func NeSameSVI32(a int32, b []int32)
func NeSameSVI64(a int64, b []int64)
func NeSameSVI8(a int8, b []int8)
func NeSameSVStr(a string, b []string)
func NeSameSVU(a uint, b []uint)
func NeSameSVU16(a uint16, b []uint16)
func NeSameSVU32(a uint32, b []uint32)
func NeSameSVU64(a uint64, b []uint64)
func NeSameSVU8(a uint8, b []uint8)
func NeSameSVUintptr(a uintptr, b []uintptr)
func NeSameStr(a []string, b []string)
func NeSameU(a []uint, b []uint)
func NeSameU16(a []uint16, b []uint16)
func NeSameU32(a []uint32, b []uint32)
func NeSameU64(a []uint64, b []uint64)
func NeSameU8(a []uint8, b []uint8)
func NeSameUintptr(a []uintptr, b []uintptr)
func NeSameVSB(a []bool, b bool)
func NeSameVSC128(a []complex128, b complex128)
func NeSameVSC64(a []complex64, b complex64)
func NeSameVSF32(a []float32, b float32)
func NeSameVSF64(a []float64, b float64)
func NeSameVSI(a []int, b int)
func NeSameVSI16(a []int16, b int16)
func NeSameVSI32(a []int32, b int32)
func NeSameVSI64(a []int64, b int64)
func NeSameVSI8(a []int8, b int8)
func NeSameVSStr(a []string, b string)
func NeSameVSU(a []uint, b uint)
func NeSameVSU16(a []uint16, b uint16)
func NeSameVSU32(a []uint32, b uint32)
func NeSameVSU64(a []uint64, b uint64)
func NeSameVSU8(a []uint8, b uint8)
func NeSameVSUintptr(a []uintptr, b uintptr)
func NeStr(a []string, b []string, retVal []bool)
func NeU(a []uint, b []uint, retVal []bool)
func NeU16(a []uint16, b []uint16, retVal []bool)
func NeU32(a []uint32, b []uint32, retVal []bool)
func NeU64(a []uint64, b []uint64, retVal []bool)
func NeU8(a []uint8, b []uint8, retVal []bool)
func NeUintptr(a []uintptr, b []uintptr, retVal []bool)
func NeUnsafePointer(a []unsafe.Pointer, b []unsafe.Pointer, retVal []bool)
func NeVSB(a []bool, b bool, retVal []bool)
func NeVSC128(a []complex128, b complex128, retVal []bool)
func NeVSC64(a []complex64, b complex64, retVal []bool)
func NeVSF32(a []float32, b float32, retVal []bool)
func NeVSF64(a []float64, b float64, retVal []bool)
func NeVSI(a []int, b int, retVal []bool)
func NeVSI16(a []int16, b int16, retVal []bool)
func NeVSI32(a []int32, b int32, retVal []bool)
func NeVSI64(a []int64, b int64, retVal []bool)
func NeVSI8(a []int8, b int8, retVal []bool)
func NeVSStr(a []string, b string, retVal []bool)
func NeVSU(a []uint, b uint, retVal []bool)
func NeVSU16(a []uint16, b uint16, retVal []bool)
func NeVSU32(a []uint32, b uint32, retVal []bool)
func NeVSU64(a []uint64, b uint64, retVal []bool)
func NeVSU8(a []uint8, b uint8, retVal []bool)
func NeVSUintptr(a []uintptr, b uintptr, retVal []bool)
func NeVSUnsafePointer(a []unsafe.Pointer, b unsafe.Pointer, retVal []bool)
func NegC128(a []complex128)
func NegC64(a []complex64)
func NegF32(a []float32)
func NegF64(a []float64)
func NegI(a []int)
func NegI16(a []int16)
func NegI32(a []int32)
func NegI64(a []int64)
func NegI8(a []int8)
func NegIterC128(a []complex128, ait Iterator) (err error)
func NegIterC64(a []complex64, ait Iterator) (err error)
func NegIterF32(a []float32, ait Iterator) (err error)
func NegIterF64(a []float64, ait Iterator) (err error)
func NegIterI(a []int, ait Iterator) (err error)
func NegIterI16(a []int16, ait Iterator) (err error)
func NegIterI32(a []int32, ait Iterator) (err error)
func NegIterI64(a []int64, ait Iterator) (err error)
func NegIterI8(a []int8, ait Iterator) (err error)
func NegIterU(a []uint, ait Iterator) (err error)
func NegIterU16(a []uint16, ait Iterator) (err error)
func NegIterU32(a []uint32, ait Iterator) (err error)
func NegIterU64(a []uint64, ait Iterator) (err error)
func NegIterU8(a []uint8, ait Iterator) (err error)
func NegU(a []uint)
func NegU16(a []uint16)
func NegU32(a []uint32)
func NegU64(a []uint64)
func NegU8(a []uint8)
func PowC128(a complex128, b complex128) complex128
func PowC64(a complex64, b complex64) complex64
func PowF32(a float32, b float32) float32
func PowF64(a float64, b float64) float64
func PowIncrC128(a []complex128, b []complex128, incr []complex128)
func PowIncrC64(a []complex64, b []complex64, incr []complex64)
func PowIncrF32(a []float32, b []float32, incr []float32)
func PowIncrF64(a []float64, b []float64, incr []float64)
func PowIncrSVC128(a complex128, b []complex128, incr []complex128)
func PowIncrSVC64(a complex64, b []complex64, incr []complex64)
func PowIncrSVF32(a float32, b []float32, incr []float32)
func PowIncrSVF64(a float64, b []float64, incr []float64)
func PowIncrVSC128(a []complex128, b complex128, incr []complex128)
func PowIncrVSC64(a []complex64, b complex64, incr []complex64)
func PowIncrVSF32(a []float32, b float32, incr []float32)
func PowIncrVSF64(a []float64, b float64, incr []float64)
func PowIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)
func PowIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)
func PowIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)
func PowIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)
func PowIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, ...) (err error)
func PowIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, ...) (err error)
func PowIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, ...) (err error)
func PowIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, ...) (err error)
func PowIterIncrSVC128(a complex128, b []complex128, incr []complex128, bit Iterator, iit Iterator) (err error)
func PowIterIncrSVC64(a complex64, b []complex64, incr []complex64, bit Iterator, iit Iterator) (err error)
func PowIterIncrSVF32(a float32, b []float32, incr []float32, bit Iterator, iit Iterator) (err error)
func PowIterIncrSVF64(a float64, b []float64, incr []float64, bit Iterator, iit Iterator) (err error)
func PowIterIncrVSC128(a []complex128, b complex128, incr []complex128, ait Iterator, iit Iterator) (err error)
func PowIterIncrVSC64(a []complex64, b complex64, incr []complex64, ait Iterator, iit Iterator) (err error)
func PowIterIncrVSF32(a []float32, b float32, incr []float32, ait Iterator, iit Iterator) (err error)
func PowIterIncrVSF64(a []float64, b float64, incr []float64, ait Iterator, iit Iterator) (err error)
func PowIterSVC128(a complex128, b []complex128, bit Iterator) (err error)
func PowIterSVC64(a complex64, b []complex64, bit Iterator) (err error)
func PowIterSVF32(a float32, b []float32, bit Iterator) (err error)
func PowIterSVF64(a float64, b []float64, bit Iterator) (err error)
func PowIterVSC128(a []complex128, b complex128, ait Iterator) (err error)
func PowIterVSC64(a []complex64, b complex64, ait Iterator) (err error)
func PowIterVSF32(a []float32, b float32, ait Iterator) (err error)
func PowIterVSF64(a []float64, b float64, ait Iterator) (err error)
func PowSVC128(a complex128, b []complex128)
func PowSVC64(a complex64, b []complex64)
func PowSVF32(a float32, b []float32)
func PowSVF64(a float64, b []float64)
func PowVSC128(a []complex128, b complex128)
func PowVSC64(a []complex64, b complex64)
func PowVSF32(a []float32, b float32)
func PowVSF64(a []float64, b float64)
func ProdC128(a []complex128) complex128
func ProdC64(a []complex64) complex64
func ProdF32(a []float32) float32
func ProdF64(a []float64) float64
func ProdI(a []int) int
func ProdI16(a []int16) int16
func ProdI32(a []int32) int32
func ProdI64(a []int64) int64
func ProdI8(a []int8) int8
func ProdU(a []uint) uint
func ProdU16(a []uint16) uint16
func ProdU32(a []uint32) uint32
func ProdU64(a []uint64) uint64
func ProdU8(a []uint8) uint8
func ReduceB(f func(a, b bool) bool, def bool, l ...bool) (retVal bool)
func ReduceC128(f func(a, b complex128) complex128, def complex128, l ...complex128) (retVal complex128)
func ReduceC64(f func(a, b complex64) complex64, def complex64, l ...complex64) (retVal complex64)
func ReduceF32(f func(a, b float32) float32, def float32, l ...float32) (retVal float32)
func ReduceF64(f func(a, b float64) float64, def float64, l ...float64) (retVal float64)
func ReduceI(f func(a, b int) int, def int, l ...int) (retVal int)
func ReduceI16(f func(a, b int16) int16, def int16, l ...int16) (retVal int16)
func ReduceI32(f func(a, b int32) int32, def int32, l ...int32) (retVal int32)
func ReduceI64(f func(a, b int64) int64, def int64, l ...int64) (retVal int64)
func ReduceI8(f func(a, b int8) int8, def int8, l ...int8) (retVal int8)
func ReduceStr(f func(a, b string) string, def string, l ...string) (retVal string)
func ReduceU(f func(a, b uint) uint, def uint, l ...uint) (retVal uint)
func ReduceU16(f func(a, b uint16) uint16, def uint16, l ...uint16) (retVal uint16)
func ReduceU32(f func(a, b uint32) uint32, def uint32, l ...uint32) (retVal uint32)
func ReduceU64(f func(a, b uint64) uint64, def uint64, l ...uint64) (retVal uint64)
func ReduceU8(f func(a, b uint8) uint8, def uint8, l ...uint8) (retVal uint8)
func ReduceUintptr(f func(a, b uintptr) uintptr, def uintptr, l ...uintptr) (retVal uintptr)
func ReduceUnsafePointer(f func(a, b unsafe.Pointer) unsafe.Pointer, def unsafe.Pointer, ...) (retVal unsafe.Pointer)
func SignF32(a []float32)
func SignF64(a []float64)
func SignI(a []int)
func SignI16(a []int16)
func SignI32(a []int32)
func SignI64(a []int64)
func SignI8(a []int8)
func SignIterF32(a []float32, ait Iterator) (err error)
func SignIterF64(a []float64, ait Iterator) (err error)
func SignIterI(a []int, ait Iterator) (err error)
func SignIterI16(a []int16, ait Iterator) (err error)
func SignIterI32(a []int32, ait Iterator) (err error)
func SignIterI64(a []int64, ait Iterator) (err error)
func SignIterI8(a []int8, ait Iterator) (err error)
func SliceMaxF32(a []float32) float32
func SliceMaxF64(a []float64) float64
func SliceMaxI(a []int) int
func SliceMaxI16(a []int16) int16
func SliceMaxI32(a []int32) int32
func SliceMaxI64(a []int64) int64
func SliceMaxI8(a []int8) int8
func SliceMaxU(a []uint) uint
func SliceMaxU16(a []uint16) uint16
func SliceMaxU32(a []uint32) uint32
func SliceMaxU64(a []uint64) uint64
func SliceMaxU8(a []uint8) uint8
func SliceMinF32(a []float32) float32
func SliceMinF64(a []float64) float64
func SliceMinI(a []int) int
func SliceMinI16(a []int16) int16
func SliceMinI32(a []int32) int32
func SliceMinI64(a []int64) int64
func SliceMinI8(a []int8) int8
func SliceMinU(a []uint) uint
func SliceMinU16(a []uint16) uint16
func SliceMinU32(a []uint32) uint32
func SliceMinU64(a []uint64) uint64
func SliceMinU8(a []uint8) uint8
func SqrtC128(a []complex128)
func SqrtC64(a []complex64)
func SqrtF32(a []float32)
func SqrtF64(a []float64)
func SqrtIterC128(a []complex128, ait Iterator) (err error)
func SqrtIterC64(a []complex64, ait Iterator) (err error)
func SqrtIterF32(a []float32, ait Iterator) (err error)
func SqrtIterF64(a []float64, ait Iterator) (err error)
func SquareC128(a []complex128)
func SquareC64(a []complex64)
func SquareF32(a []float32)
func SquareF64(a []float64)
func SquareI(a []int)
func SquareI16(a []int16)
func SquareI32(a []int32)
func SquareI64(a []int64)
func SquareI8(a []int8)
func SquareIterC128(a []complex128, ait Iterator) (err error)
func SquareIterC64(a []complex64, ait Iterator) (err error)
func SquareIterF32(a []float32, ait Iterator) (err error)
func SquareIterF64(a []float64, ait Iterator) (err error)
func SquareIterI(a []int, ait Iterator) (err error)
func SquareIterI16(a []int16, ait Iterator) (err error)
func SquareIterI32(a []int32, ait Iterator) (err error)
func SquareIterI64(a []int64, ait Iterator) (err error)
func SquareIterI8(a []int8, ait Iterator) (err error)
func SquareIterU(a []uint, ait Iterator) (err error)
func SquareIterU16(a []uint16, ait Iterator) (err error)
func SquareIterU32(a []uint32, ait Iterator) (err error)
func SquareIterU64(a []uint64, ait Iterator) (err error)
func SquareIterU8(a []uint8, ait Iterator) (err error)
func SquareU(a []uint)
func SquareU16(a []uint16)
func SquareU32(a []uint32)
func SquareU64(a []uint64)
func SquareU8(a []uint8)
func SubC128(a complex128, b complex128) complex128
func SubC64(a complex64, b complex64) complex64
func SubF32(a float32, b float32) float32
func SubF64(a float64, b float64) float64
func SubI(a int, b int) int
func SubI16(a int16, b int16) int16
func SubI32(a int32, b int32) int32
func SubI64(a int64, b int64) int64
func SubI8(a int8, b int8) int8
func SubIncrC128(a []complex128, b []complex128, incr []complex128)
func SubIncrC64(a []complex64, b []complex64, incr []complex64)
func SubIncrF32(a []float32, b []float32, incr []float32)
func SubIncrF64(a []float64, b []float64, incr []float64)
func SubIncrI(a []int, b []int, incr []int)
func SubIncrI16(a []int16, b []int16, incr []int16)
func SubIncrI32(a []int32, b []int32, incr []int32)
func SubIncrI64(a []int64, b []int64, incr []int64)
func SubIncrI8(a []int8, b []int8, incr []int8)
func SubIncrSVC128(a complex128, b []complex128, incr []complex128)
func SubIncrSVC64(a complex64, b []complex64, incr []complex64)
func SubIncrSVF32(a float32, b []float32, incr []float32)
func SubIncrSVF64(a float64, b []float64, incr []float64)
func SubIncrSVI(a int, b []int, incr []int)
func SubIncrSVI16(a int16, b []int16, incr []int16)
func SubIncrSVI32(a int32, b []int32, incr []int32)
func SubIncrSVI64(a int64, b []int64, incr []int64)
func SubIncrSVI8(a int8, b []int8, incr []int8)
func SubIncrSVU(a uint, b []uint, incr []uint)
func SubIncrSVU16(a uint16, b []uint16, incr []uint16)
func SubIncrSVU32(a uint32, b []uint32, incr []uint32)
func SubIncrSVU64(a uint64, b []uint64, incr []uint64)
func SubIncrSVU8(a uint8, b []uint8, incr []uint8)
func SubIncrU(a []uint, b []uint, incr []uint)
func SubIncrU16(a []uint16, b []uint16, incr []uint16)
func SubIncrU32(a []uint32, b []uint32, incr []uint32)
func SubIncrU64(a []uint64, b []uint64, incr []uint64)
func SubIncrU8(a []uint8, b []uint8, incr []uint8)
func SubIncrVSC128(a []complex128, b complex128, incr []complex128)
func SubIncrVSC64(a []complex64, b complex64, incr []complex64)
func SubIncrVSF32(a []float32, b float32, incr []float32)
func SubIncrVSF64(a []float64, b float64, incr []float64)
func SubIncrVSI(a []int, b int, incr []int)
func SubIncrVSI16(a []int16, b int16, incr []int16)
func SubIncrVSI32(a []int32, b int32, incr []int32)
func SubIncrVSI64(a []int64, b int64, incr []int64)
func SubIncrVSI8(a []int8, b int8, incr []int8)
func SubIncrVSU(a []uint, b uint, incr []uint)
func SubIncrVSU16(a []uint16, b uint16, incr []uint16)
func SubIncrVSU32(a []uint32, b uint32, incr []uint32)
func SubIncrVSU64(a []uint64, b uint64, incr []uint64)
func SubIncrVSU8(a []uint8, b uint8, incr []uint8)
func SubIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)
func SubIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)
func SubIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)
func SubIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)
func SubIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)
func SubIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)
func SubIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)
func SubIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)
func SubIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)
func SubIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, ...) (err error)
func SubIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, ...) (err error)
func SubIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, ...) (err error)
func SubIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, ...) (err error)
func SubIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error)
func SubIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error)
func SubIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error)
func SubIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error)
func SubIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVC128(a complex128, b []complex128, incr []complex128, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVC64(a complex64, b []complex64, incr []complex64, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVF32(a float32, b []float32, incr []float32, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVF64(a float64, b []float64, incr []float64, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVI(a int, b []int, incr []int, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVI16(a int16, b []int16, incr []int16, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVI32(a int32, b []int32, incr []int32, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVI64(a int64, b []int64, incr []int64, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVI8(a int8, b []int8, incr []int8, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVU(a uint, b []uint, incr []uint, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVU16(a uint16, b []uint16, incr []uint16, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVU32(a uint32, b []uint32, incr []uint32, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVU64(a uint64, b []uint64, incr []uint64, bit Iterator, iit Iterator) (err error)
func SubIterIncrSVU8(a uint8, b []uint8, incr []uint8, bit Iterator, iit Iterator) (err error)
func SubIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error)
func SubIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, ...) (err error)
func SubIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, ...) (err error)
func SubIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, ...) (err error)
func SubIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error)
func SubIterIncrVSC128(a []complex128, b complex128, incr []complex128, ait Iterator, iit Iterator) (err error)
func SubIterIncrVSC64(a []complex64, b complex64, incr []complex64, ait Iterator, iit Iterator) (err error)
func SubIterIncrVSF32(a []float32, b float32, incr []float32, ait Iterator, iit Iterator) (err error)
func SubIterIncrVSF64(a []float64, b float64, incr []float64, ait Iterator, iit Iterator) (err error)
func SubIterIncrVSI(a []int, b int, incr []int, ait Iterator, iit Iterator) (err error)
func SubIterIncrVSI16(a []int16, b int16, incr []int16, ait Iterator, iit Iterator) (err error)
func SubIterIncrVSI32(a []int32, b int32, incr []int32, ait Iterator, iit Iterator) (err error)
func SubIterIncrVSI64(a []int64, b int64, incr []int64, ait Iterator, iit Iterator) (err error)
func SubIterIncrVSI8(a []int8, b int8, incr []int8, ait Iterator, iit Iterator) (err error)
func SubIterIncrVSU(a []uint, b uint, incr []uint, ait Iterator, iit Iterator) (err error)
func SubIterIncrVSU16(a []uint16, b uint16, incr []uint16, ait Iterator, iit Iterator) (err error)
func SubIterIncrVSU32(a []uint32, b uint32, incr []uint32, ait Iterator, iit Iterator) (err error)
func SubIterIncrVSU64(a []uint64, b uint64, incr []uint64, ait Iterator, iit Iterator) (err error)
func SubIterIncrVSU8(a []uint8, b uint8, incr []uint8, ait Iterator, iit Iterator) (err error)
func SubIterSVC128(a complex128, b []complex128, bit Iterator) (err error)
func SubIterSVC64(a complex64, b []complex64, bit Iterator) (err error)
func SubIterSVF32(a float32, b []float32, bit Iterator) (err error)
func SubIterSVF64(a float64, b []float64, bit Iterator) (err error)
func SubIterSVI(a int, b []int, bit Iterator) (err error)
func SubIterSVI16(a int16, b []int16, bit Iterator) (err error)
func SubIterSVI32(a int32, b []int32, bit Iterator) (err error)
func SubIterSVI64(a int64, b []int64, bit Iterator) (err error)
func SubIterSVI8(a int8, b []int8, bit Iterator) (err error)
func SubIterSVU(a uint, b []uint, bit Iterator) (err error)
func SubIterSVU16(a uint16, b []uint16, bit Iterator) (err error)
func SubIterSVU32(a uint32, b []uint32, bit Iterator) (err error)
func SubIterSVU64(a uint64, b []uint64, bit Iterator) (err error)
func SubIterSVU8(a uint8, b []uint8, bit Iterator) (err error)
func SubIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)
func SubIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)
func SubIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)
func SubIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)
func SubIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)
func SubIterVSC128(a []complex128, b complex128, ait Iterator) (err error)
func SubIterVSC64(a []complex64, b complex64, ait Iterator) (err error)
func SubIterVSF32(a []float32, b float32, ait Iterator) (err error)
func SubIterVSF64(a []float64, b float64, ait Iterator) (err error)
func SubIterVSI(a []int, b int, ait Iterator) (err error)
func SubIterVSI16(a []int16, b int16, ait Iterator) (err error)
func SubIterVSI32(a []int32, b int32, ait Iterator) (err error)
func SubIterVSI64(a []int64, b int64, ait Iterator) (err error)
func SubIterVSI8(a []int8, b int8, ait Iterator) (err error)
func SubIterVSU(a []uint, b uint, ait Iterator) (err error)
func SubIterVSU16(a []uint16, b uint16, ait Iterator) (err error)
func SubIterVSU32(a []uint32, b uint32, ait Iterator) (err error)
func SubIterVSU64(a []uint64, b uint64, ait Iterator) (err error)
func SubIterVSU8(a []uint8, b uint8, ait Iterator) (err error)
func SubSVC128(a complex128, b []complex128)
func SubSVC64(a complex64, b []complex64)
func SubSVF32(a float32, b []float32)
func SubSVF64(a float64, b []float64)
func SubSVI(a int, b []int)
func SubSVI16(a int16, b []int16)
func SubSVI32(a int32, b []int32)
func SubSVI64(a int64, b []int64)
func SubSVI8(a int8, b []int8)
func SubSVU(a uint, b []uint)
func SubSVU16(a uint16, b []uint16)
func SubSVU32(a uint32, b []uint32)
func SubSVU64(a uint64, b []uint64)
func SubSVU8(a uint8, b []uint8)
func SubU(a uint, b uint) uint
func SubU16(a uint16, b uint16) uint16
func SubU32(a uint32, b uint32) uint32
func SubU64(a uint64, b uint64) uint64
func SubU8(a uint8, b uint8) uint8
func SubVSC128(a []complex128, b complex128)
func SubVSC64(a []complex64, b complex64)
func SubVSF32(a []float32, b float32)
func SubVSF64(a []float64, b float64)
func SubVSI(a []int, b int)
func SubVSI16(a []int16, b int16)
func SubVSI32(a []int32, b int32)
func SubVSI64(a []int64, b int64)
func SubVSI8(a []int8, b int8)
func SubVSU(a []uint, b uint)
func SubVSU16(a []uint16, b uint16)
func SubVSU32(a []uint32, b uint32)
func SubVSU64(a []uint64, b uint64)
func SubVSU8(a []uint8, b uint8)
func SumC128(a []complex128) complex128
func SumC64(a []complex64) complex64
func SumF32(a []float32) float32
func SumF64(a []float64) float64
func SumI(a []int) int
func SumI16(a []int16) int16
func SumI32(a []int32) int32
func SumI64(a []int64) int64
func SumI8(a []int8) int8
func SumMethods(t reflect.Type) (firstFn, lasFn, defaultFn interface{}, err error)
func SumU(a []uint) uint
func SumU16(a []uint16) uint16
func SumU32(a []uint32) uint32
func SumU64(a []uint64) uint64
func SumU8(a []uint8) uint8
func TanhC128(a []complex128)
func TanhC64(a []complex64)
func TanhF32(a []float32)
func TanhF64(a []float64)
func TanhIterC128(a []complex128, ait Iterator) (err error)
func TanhIterC64(a []complex64, ait Iterator) (err error)
func TanhIterF32(a []float32, ait Iterator) (err error)
func TanhIterF64(a []float64, ait Iterator) (err error)
func VecAddC128(a []complex128, b []complex128)
func VecAddC64(a []complex64, b []complex64)
func VecAddF32(a []float32, b []float32)
func VecAddF64(a []float64, b []float64)
func VecAddI(a []int, b []int)
func VecAddI16(a []int16, b []int16)
func VecAddI32(a []int32, b []int32)
func VecAddI64(a []int64, b []int64)
func VecAddI8(a []int8, b []int8)
func VecAddStr(a []string, b []string)
func VecAddU(a []uint, b []uint)
func VecAddU16(a []uint16, b []uint16)
func VecAddU32(a []uint32, b []uint32)
func VecAddU64(a []uint64, b []uint64)
func VecAddU8(a []uint8, b []uint8)
func VecDivC128(a []complex128, b []complex128)
func VecDivC64(a []complex64, b []complex64)
func VecDivF32(a []float32, b []float32)
func VecDivF64(a []float64, b []float64)
func VecDivI(a []int, b []int) (err error)
func VecDivI16(a []int16, b []int16) (err error)
func VecDivI32(a []int32, b []int32) (err error)
func VecDivI64(a []int64, b []int64) (err error)
func VecDivI8(a []int8, b []int8) (err error)
func VecDivU(a []uint, b []uint) (err error)
func VecDivU16(a []uint16, b []uint16) (err error)
func VecDivU32(a []uint32, b []uint32) (err error)
func VecDivU64(a []uint64, b []uint64) (err error)
func VecDivU8(a []uint8, b []uint8) (err error)
func VecMaxF32(a, b []float32)
func VecMaxF64(a, b []float64)
func VecMaxI(a, b []int)
func VecMaxI16(a, b []int16)
func VecMaxI32(a, b []int32)
func VecMaxI64(a, b []int64)
func VecMaxI8(a, b []int8)
func VecMaxStr(a, b []string)
func VecMaxU(a, b []uint)
func VecMaxU16(a, b []uint16)
func VecMaxU32(a, b []uint32)
func VecMaxU64(a, b []uint64)
func VecMaxU8(a, b []uint8)
func VecMinF32(a, b []float32)
func VecMinF64(a, b []float64)
func VecMinI(a, b []int)
func VecMinI16(a, b []int16)
func VecMinI32(a, b []int32)
func VecMinI64(a, b []int64)
func VecMinI8(a, b []int8)
func VecMinStr(a, b []string)
func VecMinU(a, b []uint)
func VecMinU16(a, b []uint16)
func VecMinU32(a, b []uint32)
func VecMinU64(a, b []uint64)
func VecMinU8(a, b []uint8)
func VecModF32(a []float32, b []float32)
func VecModF64(a []float64, b []float64)
func VecModI(a []int, b []int)
func VecModI16(a []int16, b []int16)
func VecModI32(a []int32, b []int32)
func VecModI64(a []int64, b []int64)
func VecModI8(a []int8, b []int8)
func VecModU(a []uint, b []uint)
func VecModU16(a []uint16, b []uint16)
func VecModU32(a []uint32, b []uint32)
func VecModU64(a []uint64, b []uint64)
func VecModU8(a []uint8, b []uint8)
func VecMulC128(a []complex128, b []complex128)
func VecMulC64(a []complex64, b []complex64)
func VecMulF32(a []float32, b []float32)
func VecMulF64(a []float64, b []float64)
func VecMulI(a []int, b []int)
func VecMulI16(a []int16, b []int16)
func VecMulI32(a []int32, b []int32)
func VecMulI64(a []int64, b []int64)
func VecMulI8(a []int8, b []int8)
func VecMulU(a []uint, b []uint)
func VecMulU16(a []uint16, b []uint16)
func VecMulU32(a []uint32, b []uint32)
func VecMulU64(a []uint64, b []uint64)
func VecMulU8(a []uint8, b []uint8)
func VecPowC128(a []complex128, b []complex128)
func VecPowC64(a []complex64, b []complex64)
func VecPowF32(a []float32, b []float32)
func VecPowF64(a []float64, b []float64)
func VecSubC128(a []complex128, b []complex128)
func VecSubC64(a []complex64, b []complex64)
func VecSubF32(a []float32, b []float32)
func VecSubF64(a []float64, b []float64)
func VecSubI(a []int, b []int)
func VecSubI16(a []int16, b []int16)
func VecSubI32(a []int32, b []int32)
func VecSubI64(a []int64, b []int64)
func VecSubI8(a []int8, b []int8)
func VecSubU(a []uint, b []uint)
func VecSubU16(a []uint16, b []uint16)
func VecSubU32(a []uint32, b []uint32)
func VecSubU64(a []uint64, b []uint64)
func VecSubU8(a []uint8, b []uint8)
type E
- func (e E) Abs(t reflect.Type, a *storage.Header) (err error)
- func (e E) AbsIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
- func (e E) Add(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) AddIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header) (err error)
- func (e E) AddIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, ...) (err error)
- func (e E) AddIterIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header, ...) (err error)
- func (e E) AddSliced(t reflect.Type, dataA *storage.Header, dstStart, dstEnd int, ...) (err error)
- func (e E) ArgmaxFlat(t reflect.Type, a *storage.Header) (retVal int)
- func (e E) ArgmaxFlatMasked(t reflect.Type, a *storage.Header, mask []bool) (retVal int)
- func (e E) ArgmaxIter(t reflect.Type, a *storage.Header, it Iterator, lastSize int) (indices []int, err error)
- func (e E) ArgmaxIterMasked(t reflect.Type, a *storage.Header, mask []bool, it Iterator, lastSize int) (indices []int, err error)
- func (e E) ArgminFlat(t reflect.Type, a *storage.Header) (retVal int)
- func (e E) ArgminFlatMasked(t reflect.Type, a *storage.Header, mask []bool) (retVal int)
- func (e E) ArgminIter(t reflect.Type, a *storage.Header, it Iterator, lastSize int) (indices []int, err error)
- func (e E) ArgminIterMasked(t reflect.Type, a *storage.Header, mask []bool, it Iterator, lastSize int) (indices []int, err error)
- func (e E) Cbrt(t reflect.Type, a *storage.Header) (err error)
- func (e E) CbrtIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
- func (e E) Clamp(t reflect.Type, a *storage.Header, minVal interface{}, maxVal interface{}) (err error)
- func (e E) ClampIter(t reflect.Type, a *storage.Header, ait Iterator, minVal interface{}, ...) (err error)
- func (e E) Cube(t reflect.Type, a *storage.Header) (err error)
- func (e E) CubeIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
- func (e E) Div(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) DivIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header) (err error)
- func (e E) DivIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, ...) (err error)
- func (e E) DivIterIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header, ...) (err error)
- func (e E) Eq(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header) (err error)
- func (e E) EqIter(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header, ...) (err error)
- func (e E) EqSame(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) EqSameIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, ...) (err error)
- func (e E) Exp(t reflect.Type, a *storage.Header) (err error)
- func (e E) ExpIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
- func (e E) Gt(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header) (err error)
- func (e E) GtIter(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header, ...) (err error)
- func (e E) GtSame(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) GtSameIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, ...) (err error)
- func (e E) Gte(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header) (err error)
- func (e E) GteIter(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header, ...) (err error)
- func (e E) GteSame(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) GteSameIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, ...) (err error)
- func (e E) Inv(t reflect.Type, a *storage.Header) (err error)
- func (e E) InvIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
- func (e E) InvSqrt(t reflect.Type, a *storage.Header) (err error)
- func (e E) InvSqrtIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
- func (e E) Log(t reflect.Type, a *storage.Header) (err error)
- func (e E) Log10(t reflect.Type, a *storage.Header) (err error)
- func (e E) Log10Iter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
- func (e E) Log2(t reflect.Type, a *storage.Header) (err error)
- func (e E) Log2Iter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
- func (e E) LogIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
- func (e E) Lt(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header) (err error)
- func (e E) LtIter(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header, ...) (err error)
- func (e E) LtSame(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) LtSameIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, ...) (err error)
- func (e E) Lte(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header) (err error)
- func (e E) LteIter(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header, ...) (err error)
- func (e E) LteSame(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) LteSameIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, ...) (err error)
- func (e E) Map(t reflect.Type, fn interface{}, a *storage.Header, incr bool) (err error)
- func (e E) MapIter(t reflect.Type, fn interface{}, a *storage.Header, incr bool, ait Iterator) (err error)
- func (e E) Mod(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) ModIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header) (err error)
- func (e E) ModIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, ...) (err error)
- func (e E) ModIterIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header, ...) (err error)
- func (e E) Mul(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) MulIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header) (err error)
- func (e E) MulIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, ...) (err error)
- func (e E) MulIterIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header, ...) (err error)
- func (e E) Ne(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header) (err error)
- func (e E) NeIter(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header, ...) (err error)
- func (e E) NeSame(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) NeSameIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, ...) (err error)
- func (e E) Neg(t reflect.Type, a *storage.Header) (err error)
- func (e E) NegIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
- func (e E) Pow(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) PowIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header) (err error)
- func (e E) PowIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, ...) (err error)
- func (e E) PowIterIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header, ...) (err error)
- func (e E) Reduce(t reflect.Type, a *storage.Header, defaultValue interface{}, fn interface{}) (retVal interface{}, err error)
- func (e E) ReduceDefault(t reflect.Type, data *storage.Header, retVal *storage.Header, dim0 int, ...) (err error)
- func (e E) ReduceFirst(t reflect.Type, data *storage.Header, retVal *storage.Header, split int, ...) (err error)
- func (e E) ReduceLast(t reflect.Type, data *storage.Header, retVal *storage.Header, dimSize int, ...) (err error)
- func (e E) Sign(t reflect.Type, a *storage.Header) (err error)
- func (e E) SignIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
- func (e E) Sqrt(t reflect.Type, a *storage.Header) (err error)
- func (e E) SqrtIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
- func (e E) Square(t reflect.Type, a *storage.Header) (err error)
- func (e E) SquareIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
- func (e E) Sub(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) SubIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header) (err error)
- func (e E) SubIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, ...) (err error)
- func (e E) SubIterIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header, ...) (err error)
- func (e E) Tanh(t reflect.Type, a *storage.Header) (err error)
- func (e E) TanhIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)
type Iterator
type NoOpError

Constants ¶

This section is empty.

Variables ¶

View Source

var (
	Bool       = reflect.TypeOf(true)
	Int        = reflect.TypeOf(int(1))
	Int8       = reflect.TypeOf(int8(1))
	Int16      = reflect.TypeOf(int16(1))
	Int32      = reflect.TypeOf(int32(1))
	Int64      = reflect.TypeOf(int64(1))
	Uint       = reflect.TypeOf(uint(1))
	Uint8      = reflect.TypeOf(uint8(1))
	Uint16     = reflect.TypeOf(uint16(1))
	Uint32     = reflect.TypeOf(uint32(1))
	Uint64     = reflect.TypeOf(uint64(1))
	Float32    = reflect.TypeOf(float32(1))
	Float64    = reflect.TypeOf(float64(1))
	Complex64  = reflect.TypeOf(complex64(1))
	Complex128 = reflect.TypeOf(complex128(1))
	String     = reflect.TypeOf("")

	// aliases
	Byte = Uint8

	// extras
	Uintptr       = reflect.TypeOf(uintptr(0))
	UnsafePointer = reflect.TypeOf(unsafe.Pointer(&Uintptr))
)

basic types supported.

Functions ¶

func AbsF32 ¶

func AbsF32(a []float32)

func AbsF64 ¶

func AbsF64(a []float64)

func AbsI ¶

func AbsI(a []int)

func AbsI16 ¶

func AbsI16(a []int16)

func AbsI32 ¶

func AbsI32(a []int32)

func AbsI64 ¶

func AbsI64(a []int64)

func AbsI8 ¶

func AbsI8(a []int8)

func AbsIterF32 ¶

func AbsIterF32(a []float32, ait Iterator) (err error)

func AbsIterF64 ¶

func AbsIterF64(a []float64, ait Iterator) (err error)

func AbsIterI ¶

func AbsIterI(a []int, ait Iterator) (err error)

func AbsIterI16 ¶

func AbsIterI16(a []int16, ait Iterator) (err error)

func AbsIterI32 ¶

func AbsIterI32(a []int32, ait Iterator) (err error)

func AbsIterI64 ¶

func AbsIterI64(a []int64, ait Iterator) (err error)

func AbsIterI8 ¶

func AbsIterI8(a []int8, ait Iterator) (err error)

func AddC128 ¶

func AddC128(a complex128, b complex128) complex128

func AddC64 ¶

func AddC64(a complex64, b complex64) complex64

func AddF32 ¶

func AddF32(a float32, b float32) float32

func AddF64 ¶

func AddF64(a float64, b float64) float64

func AddI ¶

func AddI(a int, b int) int

func AddI16 ¶

func AddI16(a int16, b int16) int16

func AddI32 ¶

func AddI32(a int32, b int32) int32

func AddI64 ¶

func AddI64(a int64, b int64) int64

func AddI8 ¶

func AddI8(a int8, b int8) int8

func AddIncrC128 ¶

func AddIncrC128(a []complex128, b []complex128, incr []complex128)

func AddIncrC64 ¶

func AddIncrC64(a []complex64, b []complex64, incr []complex64)

func AddIncrF32 ¶

func AddIncrF32(a []float32, b []float32, incr []float32)

func AddIncrF64 ¶

func AddIncrF64(a []float64, b []float64, incr []float64)

func AddIncrI ¶

func AddIncrI(a []int, b []int, incr []int)

func AddIncrI16 ¶

func AddIncrI16(a []int16, b []int16, incr []int16)

func AddIncrI32 ¶

func AddIncrI32(a []int32, b []int32, incr []int32)

func AddIncrI64 ¶

func AddIncrI64(a []int64, b []int64, incr []int64)

func AddIncrI8 ¶

func AddIncrI8(a []int8, b []int8, incr []int8)

func AddIncrSVC128 ¶

func AddIncrSVC128(a complex128, b []complex128, incr []complex128)

func AddIncrSVC64 ¶

func AddIncrSVC64(a complex64, b []complex64, incr []complex64)

func AddIncrSVF32 ¶

func AddIncrSVF32(a float32, b []float32, incr []float32)

func AddIncrSVF64 ¶

func AddIncrSVF64(a float64, b []float64, incr []float64)

func AddIncrSVI ¶

func AddIncrSVI(a int, b []int, incr []int)

func AddIncrSVI16 ¶

func AddIncrSVI16(a int16, b []int16, incr []int16)

func AddIncrSVI32 ¶

func AddIncrSVI32(a int32, b []int32, incr []int32)

func AddIncrSVI64 ¶

func AddIncrSVI64(a int64, b []int64, incr []int64)

func AddIncrSVI8 ¶

func AddIncrSVI8(a int8, b []int8, incr []int8)

func AddIncrSVStr ¶

func AddIncrSVStr(a string, b []string, incr []string)

func AddIncrSVU ¶

func AddIncrSVU(a uint, b []uint, incr []uint)

func AddIncrSVU16 ¶

func AddIncrSVU16(a uint16, b []uint16, incr []uint16)

func AddIncrSVU32 ¶

func AddIncrSVU32(a uint32, b []uint32, incr []uint32)

func AddIncrSVU64 ¶

func AddIncrSVU64(a uint64, b []uint64, incr []uint64)

func AddIncrSVU8 ¶

func AddIncrSVU8(a uint8, b []uint8, incr []uint8)

func AddIncrStr ¶

func AddIncrStr(a []string, b []string, incr []string)

func AddIncrU ¶

func AddIncrU(a []uint, b []uint, incr []uint)

func AddIncrU16 ¶

func AddIncrU16(a []uint16, b []uint16, incr []uint16)

func AddIncrU32 ¶

func AddIncrU32(a []uint32, b []uint32, incr []uint32)

func AddIncrU64 ¶

func AddIncrU64(a []uint64, b []uint64, incr []uint64)

func AddIncrU8 ¶

func AddIncrU8(a []uint8, b []uint8, incr []uint8)

func AddIncrVSC128 ¶

func AddIncrVSC128(a []complex128, b complex128, incr []complex128)

func AddIncrVSC64 ¶

func AddIncrVSC64(a []complex64, b complex64, incr []complex64)

func AddIncrVSF32 ¶

func AddIncrVSF32(a []float32, b float32, incr []float32)

func AddIncrVSF64 ¶

func AddIncrVSF64(a []float64, b float64, incr []float64)

func AddIncrVSI ¶

func AddIncrVSI(a []int, b int, incr []int)

func AddIncrVSI16 ¶

func AddIncrVSI16(a []int16, b int16, incr []int16)

func AddIncrVSI32 ¶

func AddIncrVSI32(a []int32, b int32, incr []int32)

func AddIncrVSI64 ¶

func AddIncrVSI64(a []int64, b int64, incr []int64)

func AddIncrVSI8 ¶

func AddIncrVSI8(a []int8, b int8, incr []int8)

func AddIncrVSStr ¶

func AddIncrVSStr(a []string, b string, incr []string)

func AddIncrVSU ¶

func AddIncrVSU(a []uint, b uint, incr []uint)

func AddIncrVSU16 ¶

func AddIncrVSU16(a []uint16, b uint16, incr []uint16)

func AddIncrVSU32 ¶

func AddIncrVSU32(a []uint32, b uint32, incr []uint32)

func AddIncrVSU64 ¶

func AddIncrVSU64(a []uint64, b uint64, incr []uint64)

func AddIncrVSU8 ¶

func AddIncrVSU8(a []uint8, b uint8, incr []uint8)

func AddIterC128 ¶

func AddIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)

func AddIterC64 ¶

func AddIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)

func AddIterF32 ¶

func AddIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)

func AddIterF64 ¶

func AddIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)

func AddIterI ¶

func AddIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)

func AddIterI16 ¶

func AddIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)

func AddIterI32 ¶

func AddIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)

func AddIterI64 ¶

func AddIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)

func AddIterI8 ¶

func AddIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)

func AddIterIncrC128 ¶

func AddIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrC64 ¶

func AddIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrF32 ¶

func AddIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrF64 ¶

func AddIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrI ¶

func AddIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrI16 ¶

func AddIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrI32 ¶

func AddIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrI64 ¶

func AddIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrI8 ¶

func AddIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVC128 ¶

func AddIterIncrSVC128(a complex128, b []complex128, incr []complex128, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVC64 ¶

func AddIterIncrSVC64(a complex64, b []complex64, incr []complex64, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVF32 ¶

func AddIterIncrSVF32(a float32, b []float32, incr []float32, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVF64 ¶

func AddIterIncrSVF64(a float64, b []float64, incr []float64, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVI ¶

func AddIterIncrSVI(a int, b []int, incr []int, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVI16 ¶

func AddIterIncrSVI16(a int16, b []int16, incr []int16, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVI32 ¶

func AddIterIncrSVI32(a int32, b []int32, incr []int32, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVI64 ¶

func AddIterIncrSVI64(a int64, b []int64, incr []int64, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVI8 ¶

func AddIterIncrSVI8(a int8, b []int8, incr []int8, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVStr ¶

func AddIterIncrSVStr(a string, b []string, incr []string, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVU ¶

func AddIterIncrSVU(a uint, b []uint, incr []uint, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVU16 ¶

func AddIterIncrSVU16(a uint16, b []uint16, incr []uint16, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVU32 ¶

func AddIterIncrSVU32(a uint32, b []uint32, incr []uint32, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVU64 ¶

func AddIterIncrSVU64(a uint64, b []uint64, incr []uint64, bit Iterator, iit Iterator) (err error)

func AddIterIncrSVU8 ¶

func AddIterIncrSVU8(a uint8, b []uint8, incr []uint8, bit Iterator, iit Iterator) (err error)

func AddIterIncrStr ¶

func AddIterIncrStr(a []string, b []string, incr []string, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrU ¶

func AddIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrU16 ¶

func AddIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrU32 ¶

func AddIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrU64 ¶

func AddIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrU8 ¶

func AddIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error)

func AddIterIncrVSC128 ¶

func AddIterIncrVSC128(a []complex128, b complex128, incr []complex128, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSC64 ¶

func AddIterIncrVSC64(a []complex64, b complex64, incr []complex64, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSF32 ¶

func AddIterIncrVSF32(a []float32, b float32, incr []float32, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSF64 ¶

func AddIterIncrVSF64(a []float64, b float64, incr []float64, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSI ¶

func AddIterIncrVSI(a []int, b int, incr []int, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSI16 ¶

func AddIterIncrVSI16(a []int16, b int16, incr []int16, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSI32 ¶

func AddIterIncrVSI32(a []int32, b int32, incr []int32, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSI64 ¶

func AddIterIncrVSI64(a []int64, b int64, incr []int64, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSI8 ¶

func AddIterIncrVSI8(a []int8, b int8, incr []int8, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSStr ¶

func AddIterIncrVSStr(a []string, b string, incr []string, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSU ¶

func AddIterIncrVSU(a []uint, b uint, incr []uint, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSU16 ¶

func AddIterIncrVSU16(a []uint16, b uint16, incr []uint16, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSU32 ¶

func AddIterIncrVSU32(a []uint32, b uint32, incr []uint32, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSU64 ¶

func AddIterIncrVSU64(a []uint64, b uint64, incr []uint64, ait Iterator, iit Iterator) (err error)

func AddIterIncrVSU8 ¶

func AddIterIncrVSU8(a []uint8, b uint8, incr []uint8, ait Iterator, iit Iterator) (err error)

func AddIterSVC128 ¶

func AddIterSVC128(a complex128, b []complex128, bit Iterator) (err error)

func AddIterSVC64 ¶

func AddIterSVC64(a complex64, b []complex64, bit Iterator) (err error)

func AddIterSVF32 ¶

func AddIterSVF32(a float32, b []float32, bit Iterator) (err error)

func AddIterSVF64 ¶

func AddIterSVF64(a float64, b []float64, bit Iterator) (err error)

func AddIterSVI ¶

func AddIterSVI(a int, b []int, bit Iterator) (err error)

func AddIterSVI16 ¶

func AddIterSVI16(a int16, b []int16, bit Iterator) (err error)

func AddIterSVI32 ¶

func AddIterSVI32(a int32, b []int32, bit Iterator) (err error)

func AddIterSVI64 ¶

func AddIterSVI64(a int64, b []int64, bit Iterator) (err error)

func AddIterSVI8 ¶

func AddIterSVI8(a int8, b []int8, bit Iterator) (err error)

func AddIterSVStr ¶

func AddIterSVStr(a string, b []string, bit Iterator) (err error)

func AddIterSVU ¶

func AddIterSVU(a uint, b []uint, bit Iterator) (err error)

func AddIterSVU16 ¶

func AddIterSVU16(a uint16, b []uint16, bit Iterator) (err error)

func AddIterSVU32 ¶

func AddIterSVU32(a uint32, b []uint32, bit Iterator) (err error)

func AddIterSVU64 ¶

func AddIterSVU64(a uint64, b []uint64, bit Iterator) (err error)

func AddIterSVU8 ¶

func AddIterSVU8(a uint8, b []uint8, bit Iterator) (err error)

func AddIterStr ¶

func AddIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)

func AddIterU ¶

func AddIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)

func AddIterU16 ¶

func AddIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)

func AddIterU32 ¶

func AddIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)

func AddIterU64 ¶

func AddIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)

func AddIterU8 ¶

func AddIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)

func AddIterVSC128 ¶

func AddIterVSC128(a []complex128, b complex128, ait Iterator) (err error)

func AddIterVSC64 ¶

func AddIterVSC64(a []complex64, b complex64, ait Iterator) (err error)

func AddIterVSF32 ¶

func AddIterVSF32(a []float32, b float32, ait Iterator) (err error)

func AddIterVSF64 ¶

func AddIterVSF64(a []float64, b float64, ait Iterator) (err error)

func AddIterVSI ¶

func AddIterVSI(a []int, b int, ait Iterator) (err error)

func AddIterVSI16 ¶

func AddIterVSI16(a []int16, b int16, ait Iterator) (err error)

func AddIterVSI32 ¶

func AddIterVSI32(a []int32, b int32, ait Iterator) (err error)

func AddIterVSI64 ¶

func AddIterVSI64(a []int64, b int64, ait Iterator) (err error)

func AddIterVSI8 ¶

func AddIterVSI8(a []int8, b int8, ait Iterator) (err error)

func AddIterVSStr ¶

func AddIterVSStr(a []string, b string, ait Iterator) (err error)

func AddIterVSU ¶

func AddIterVSU(a []uint, b uint, ait Iterator) (err error)

func AddIterVSU16 ¶

func AddIterVSU16(a []uint16, b uint16, ait Iterator) (err error)

func AddIterVSU32 ¶

func AddIterVSU32(a []uint32, b uint32, ait Iterator) (err error)

func AddIterVSU64 ¶

func AddIterVSU64(a []uint64, b uint64, ait Iterator) (err error)

func AddIterVSU8 ¶

func AddIterVSU8(a []uint8, b uint8, ait Iterator) (err error)

func AddSVC128 ¶

func AddSVC128(a complex128, b []complex128)

func AddSVC64 ¶

func AddSVC64(a complex64, b []complex64)

func AddSVF32 ¶

func AddSVF32(a float32, b []float32)

func AddSVF64 ¶

func AddSVF64(a float64, b []float64)

func AddSVI ¶

func AddSVI(a int, b []int)

func AddSVI16 ¶

func AddSVI16(a int16, b []int16)

func AddSVI32 ¶

func AddSVI32(a int32, b []int32)

func AddSVI64 ¶

func AddSVI64(a int64, b []int64)

func AddSVI8 ¶

func AddSVI8(a int8, b []int8)

func AddSVStr ¶

func AddSVStr(a string, b []string)

func AddSVU ¶

func AddSVU(a uint, b []uint)

func AddSVU16 ¶

func AddSVU16(a uint16, b []uint16)

func AddSVU32 ¶

func AddSVU32(a uint32, b []uint32)

func AddSVU64 ¶

func AddSVU64(a uint64, b []uint64)

func AddSVU8 ¶

func AddSVU8(a uint8, b []uint8)

func AddStr ¶

func AddStr(a string, b string) string

func AddU ¶

func AddU(a uint, b uint) uint

func AddU16 ¶

func AddU16(a uint16, b uint16) uint16

func AddU32 ¶

func AddU32(a uint32, b uint32) uint32

func AddU64 ¶

func AddU64(a uint64, b uint64) uint64

func AddU8 ¶

func AddU8(a uint8, b uint8) uint8

func AddVSC128 ¶

func AddVSC128(a []complex128, b complex128)

func AddVSC64 ¶

func AddVSC64(a []complex64, b complex64)

func AddVSF32 ¶

func AddVSF32(a []float32, b float32)

func AddVSF64 ¶

func AddVSF64(a []float64, b float64)

func AddVSI ¶

func AddVSI(a []int, b int)

func AddVSI16 ¶

func AddVSI16(a []int16, b int16)

func AddVSI32 ¶

func AddVSI32(a []int32, b int32)

func AddVSI64 ¶

func AddVSI64(a []int64, b int64)

func AddVSI8 ¶

func AddVSI8(a []int8, b int8)

func AddVSStr ¶

func AddVSStr(a []string, b string)

func AddVSU ¶

func AddVSU(a []uint, b uint)

func AddVSU16 ¶

func AddVSU16(a []uint16, b uint16)

func AddVSU32 ¶

func AddVSU32(a []uint32, b uint32)

func AddVSU64 ¶

func AddVSU64(a []uint64, b uint64)

func AddVSU8 ¶

func AddVSU8(a []uint8, b uint8)

func ArgmaxF32 ¶

func ArgmaxF32(a []float32) int

func ArgmaxF64 ¶

func ArgmaxF64(a []float64) int

func ArgmaxI ¶

func ArgmaxI(a []int) int

func ArgmaxI16 ¶

func ArgmaxI16(a []int16) int

func ArgmaxI32 ¶

func ArgmaxI32(a []int32) int

func ArgmaxI64 ¶

func ArgmaxI64(a []int64) int

func ArgmaxI8 ¶

func ArgmaxI8(a []int8) int

func ArgmaxMaskedF32 ¶

func ArgmaxMaskedF32(a []float32, mask []bool) int

func ArgmaxMaskedF64 ¶

func ArgmaxMaskedF64(a []float64, mask []bool) int

func ArgmaxMaskedI ¶

func ArgmaxMaskedI(a []int, mask []bool) int

func ArgmaxMaskedI16 ¶

func ArgmaxMaskedI16(a []int16, mask []bool) int

func ArgmaxMaskedI32 ¶

func ArgmaxMaskedI32(a []int32, mask []bool) int

func ArgmaxMaskedI64 ¶

func ArgmaxMaskedI64(a []int64, mask []bool) int

func ArgmaxMaskedI8 ¶

func ArgmaxMaskedI8(a []int8, mask []bool) int

func ArgmaxMaskedStr ¶

func ArgmaxMaskedStr(a []string, mask []bool) int

func ArgmaxMaskedU ¶

func ArgmaxMaskedU(a []uint, mask []bool) int

func ArgmaxMaskedU16 ¶

func ArgmaxMaskedU16(a []uint16, mask []bool) int

func ArgmaxMaskedU32 ¶

func ArgmaxMaskedU32(a []uint32, mask []bool) int

func ArgmaxMaskedU64 ¶

func ArgmaxMaskedU64(a []uint64, mask []bool) int

func ArgmaxMaskedU8 ¶

func ArgmaxMaskedU8(a []uint8, mask []bool) int

func ArgmaxStr ¶

func ArgmaxStr(a []string) int

func ArgmaxU ¶

func ArgmaxU(a []uint) int

func ArgmaxU16 ¶

func ArgmaxU16(a []uint16) int

func ArgmaxU32 ¶

func ArgmaxU32(a []uint32) int

func ArgmaxU64 ¶

func ArgmaxU64(a []uint64) int

func ArgmaxU8 ¶

func ArgmaxU8(a []uint8) int

func ArgminF32 ¶

func ArgminF32(a []float32) int

func ArgminF64 ¶

func ArgminF64(a []float64) int

func ArgminI ¶

func ArgminI(a []int) int

func ArgminI16 ¶

func ArgminI16(a []int16) int

func ArgminI32 ¶

func ArgminI32(a []int32) int

func ArgminI64 ¶

func ArgminI64(a []int64) int

func ArgminI8 ¶

func ArgminI8(a []int8) int

func ArgminMaskedF32 ¶

func ArgminMaskedF32(a []float32, mask []bool) int

func ArgminMaskedF64 ¶

func ArgminMaskedF64(a []float64, mask []bool) int

func ArgminMaskedI ¶

func ArgminMaskedI(a []int, mask []bool) int

func ArgminMaskedI16 ¶

func ArgminMaskedI16(a []int16, mask []bool) int

func ArgminMaskedI32 ¶

func ArgminMaskedI32(a []int32, mask []bool) int

func ArgminMaskedI64 ¶

func ArgminMaskedI64(a []int64, mask []bool) int

func ArgminMaskedI8 ¶

func ArgminMaskedI8(a []int8, mask []bool) int

func ArgminMaskedStr ¶

func ArgminMaskedStr(a []string, mask []bool) int

func ArgminMaskedU ¶

func ArgminMaskedU(a []uint, mask []bool) int

func ArgminMaskedU16 ¶

func ArgminMaskedU16(a []uint16, mask []bool) int

func ArgminMaskedU32 ¶

func ArgminMaskedU32(a []uint32, mask []bool) int

func ArgminMaskedU64 ¶

func ArgminMaskedU64(a []uint64, mask []bool) int

func ArgminMaskedU8 ¶

func ArgminMaskedU8(a []uint8, mask []bool) int

func ArgminStr ¶

func ArgminStr(a []string) int

func ArgminU ¶

func ArgminU(a []uint) int

func ArgminU16 ¶

func ArgminU16(a []uint16) int

func ArgminU32 ¶

func ArgminU32(a []uint32) int

func ArgminU64 ¶

func ArgminU64(a []uint64) int

func ArgminU8 ¶

func ArgminU8(a []uint8) int

func CbrtF32 ¶

func CbrtF32(a []float32)

func CbrtF64 ¶

func CbrtF64(a []float64)

func CbrtIterF32 ¶

func CbrtIterF32(a []float32, ait Iterator) (err error)

func CbrtIterF64 ¶

func CbrtIterF64(a []float64, ait Iterator) (err error)

func ClampF32 ¶

func ClampF32(a []float32, min float32, max float32)

func ClampF64 ¶

func ClampF64(a []float64, min float64, max float64)

func ClampI ¶

func ClampI(a []int, min int, max int)

func ClampI16 ¶

func ClampI16(a []int16, min int16, max int16)

func ClampI32 ¶

func ClampI32(a []int32, min int32, max int32)

func ClampI64 ¶

func ClampI64(a []int64, min int64, max int64)

func ClampI8 ¶

func ClampI8(a []int8, min int8, max int8)

func ClampIterF32 ¶

func ClampIterF32(a []float32, ait Iterator, min float32, max float32) (err error)

func ClampIterF64 ¶

func ClampIterF64(a []float64, ait Iterator, min float64, max float64) (err error)

func ClampIterI ¶

func ClampIterI(a []int, ait Iterator, min int, max int) (err error)

func ClampIterI16 ¶

func ClampIterI16(a []int16, ait Iterator, min int16, max int16) (err error)

func ClampIterI32 ¶

func ClampIterI32(a []int32, ait Iterator, min int32, max int32) (err error)

func ClampIterI64 ¶

func ClampIterI64(a []int64, ait Iterator, min int64, max int64) (err error)

func ClampIterI8 ¶

func ClampIterI8(a []int8, ait Iterator, min int8, max int8) (err error)

func ClampIterU ¶

func ClampIterU(a []uint, ait Iterator, min uint, max uint) (err error)

func ClampIterU16 ¶

func ClampIterU16(a []uint16, ait Iterator, min uint16, max uint16) (err error)

func ClampIterU32 ¶

func ClampIterU32(a []uint32, ait Iterator, min uint32, max uint32) (err error)

func ClampIterU64 ¶

func ClampIterU64(a []uint64, ait Iterator, min uint64, max uint64) (err error)

func ClampIterU8 ¶

func ClampIterU8(a []uint8, ait Iterator, min uint8, max uint8) (err error)

func ClampU ¶

func ClampU(a []uint, min uint, max uint)

func ClampU16 ¶

func ClampU16(a []uint16, min uint16, max uint16)

func ClampU32 ¶

func ClampU32(a []uint32, min uint32, max uint32)

func ClampU64 ¶

func ClampU64(a []uint64, min uint64, max uint64)

func ClampU8 ¶

func ClampU8(a []uint8, min uint8, max uint8)

func CubeC128 ¶

func CubeC128(a []complex128)

func CubeC64 ¶

func CubeC64(a []complex64)

func CubeF32 ¶

func CubeF32(a []float32)

func CubeF64 ¶

func CubeF64(a []float64)

func CubeI ¶

func CubeI(a []int)

func CubeI16 ¶

func CubeI16(a []int16)

func CubeI32 ¶

func CubeI32(a []int32)

func CubeI64 ¶

func CubeI64(a []int64)

func CubeI8 ¶

func CubeI8(a []int8)

func CubeIterC128 ¶

func CubeIterC128(a []complex128, ait Iterator) (err error)

func CubeIterC64 ¶

func CubeIterC64(a []complex64, ait Iterator) (err error)

func CubeIterF32 ¶

func CubeIterF32(a []float32, ait Iterator) (err error)

func CubeIterF64 ¶

func CubeIterF64(a []float64, ait Iterator) (err error)

func CubeIterI ¶

func CubeIterI(a []int, ait Iterator) (err error)

func CubeIterI16 ¶

func CubeIterI16(a []int16, ait Iterator) (err error)

func CubeIterI32 ¶

func CubeIterI32(a []int32, ait Iterator) (err error)

func CubeIterI64 ¶

func CubeIterI64(a []int64, ait Iterator) (err error)

func CubeIterI8 ¶

func CubeIterI8(a []int8, ait Iterator) (err error)

func CubeIterU ¶

func CubeIterU(a []uint, ait Iterator) (err error)

func CubeIterU16 ¶

func CubeIterU16(a []uint16, ait Iterator) (err error)

func CubeIterU32 ¶

func CubeIterU32(a []uint32, ait Iterator) (err error)

func CubeIterU64 ¶

func CubeIterU64(a []uint64, ait Iterator) (err error)

func CubeIterU8 ¶

func CubeIterU8(a []uint8, ait Iterator) (err error)

func CubeU ¶

func CubeU(a []uint)

func CubeU16 ¶

func CubeU16(a []uint16)

func CubeU32 ¶

func CubeU32(a []uint32)

func CubeU64 ¶

func CubeU64(a []uint64)

func CubeU8 ¶

func CubeU8(a []uint8)

func DivC128 ¶

func DivC128(a complex128, b complex128) complex128

func DivC64 ¶

func DivC64(a complex64, b complex64) complex64

func DivF32 ¶

func DivF32(a float32, b float32) float32

func DivF64 ¶

func DivF64(a float64, b float64) float64

func DivI ¶

func DivI(a int, b int) int

func DivI16 ¶

func DivI16(a int16, b int16) int16

func DivI32 ¶

func DivI32(a int32, b int32) int32

func DivI64 ¶

func DivI64(a int64, b int64) int64

func DivI8 ¶

func DivI8(a int8, b int8) int8

func DivIncrC128 ¶

func DivIncrC128(a []complex128, b []complex128, incr []complex128)

func DivIncrC64 ¶

func DivIncrC64(a []complex64, b []complex64, incr []complex64)

func DivIncrF32 ¶

func DivIncrF32(a []float32, b []float32, incr []float32)

func DivIncrF64 ¶

func DivIncrF64(a []float64, b []float64, incr []float64)

func DivIncrI ¶

func DivIncrI(a []int, b []int, incr []int) (err error)

func DivIncrI16 ¶

func DivIncrI16(a []int16, b []int16, incr []int16) (err error)

func DivIncrI32 ¶

func DivIncrI32(a []int32, b []int32, incr []int32) (err error)

func DivIncrI64 ¶

func DivIncrI64(a []int64, b []int64, incr []int64) (err error)

func DivIncrI8 ¶

func DivIncrI8(a []int8, b []int8, incr []int8) (err error)

func DivIncrSVC128 ¶

func DivIncrSVC128(a complex128, b []complex128, incr []complex128)

func DivIncrSVC64 ¶

func DivIncrSVC64(a complex64, b []complex64, incr []complex64)

func DivIncrSVF32 ¶

func DivIncrSVF32(a float32, b []float32, incr []float32)

func DivIncrSVF64 ¶

func DivIncrSVF64(a float64, b []float64, incr []float64)

func DivIncrSVI ¶

func DivIncrSVI(a int, b []int, incr []int) (err error)

func DivIncrSVI16 ¶

func DivIncrSVI16(a int16, b []int16, incr []int16) (err error)

func DivIncrSVI32 ¶

func DivIncrSVI32(a int32, b []int32, incr []int32) (err error)

func DivIncrSVI64 ¶

func DivIncrSVI64(a int64, b []int64, incr []int64) (err error)

func DivIncrSVI8 ¶

func DivIncrSVI8(a int8, b []int8, incr []int8) (err error)

func DivIncrSVU ¶

func DivIncrSVU(a uint, b []uint, incr []uint) (err error)

func DivIncrSVU16 ¶

func DivIncrSVU16(a uint16, b []uint16, incr []uint16) (err error)

func DivIncrSVU32 ¶

func DivIncrSVU32(a uint32, b []uint32, incr []uint32) (err error)

func DivIncrSVU64 ¶

func DivIncrSVU64(a uint64, b []uint64, incr []uint64) (err error)

func DivIncrSVU8 ¶

func DivIncrSVU8(a uint8, b []uint8, incr []uint8) (err error)

func DivIncrU ¶

func DivIncrU(a []uint, b []uint, incr []uint) (err error)

func DivIncrU16 ¶

func DivIncrU16(a []uint16, b []uint16, incr []uint16) (err error)

func DivIncrU32 ¶

func DivIncrU32(a []uint32, b []uint32, incr []uint32) (err error)

func DivIncrU64 ¶

func DivIncrU64(a []uint64, b []uint64, incr []uint64) (err error)

func DivIncrU8 ¶

func DivIncrU8(a []uint8, b []uint8, incr []uint8) (err error)

func DivIncrVSC128 ¶

func DivIncrVSC128(a []complex128, b complex128, incr []complex128)

func DivIncrVSC64 ¶

func DivIncrVSC64(a []complex64, b complex64, incr []complex64)

func DivIncrVSF32 ¶

func DivIncrVSF32(a []float32, b float32, incr []float32)

func DivIncrVSF64 ¶

func DivIncrVSF64(a []float64, b float64, incr []float64)

func DivIncrVSI ¶

func DivIncrVSI(a []int, b int, incr []int) (err error)

func DivIncrVSI16 ¶

func DivIncrVSI16(a []int16, b int16, incr []int16) (err error)

func DivIncrVSI32 ¶

func DivIncrVSI32(a []int32, b int32, incr []int32) (err error)

func DivIncrVSI64 ¶

func DivIncrVSI64(a []int64, b int64, incr []int64) (err error)

func DivIncrVSI8 ¶

func DivIncrVSI8(a []int8, b int8, incr []int8) (err error)

func DivIncrVSU ¶

func DivIncrVSU(a []uint, b uint, incr []uint) (err error)

func DivIncrVSU16 ¶

func DivIncrVSU16(a []uint16, b uint16, incr []uint16) (err error)

func DivIncrVSU32 ¶

func DivIncrVSU32(a []uint32, b uint32, incr []uint32) (err error)

func DivIncrVSU64 ¶

func DivIncrVSU64(a []uint64, b uint64, incr []uint64) (err error)

func DivIncrVSU8 ¶

func DivIncrVSU8(a []uint8, b uint8, incr []uint8) (err error)

func DivIterC128 ¶

func DivIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)

func DivIterC64 ¶

func DivIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)

func DivIterF32 ¶

func DivIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)

func DivIterF64 ¶

func DivIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)

func DivIterI ¶

func DivIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)

func DivIterI16 ¶

func DivIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)

func DivIterI32 ¶

func DivIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)

func DivIterI64 ¶

func DivIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)

func DivIterI8 ¶

func DivIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)

func DivIterIncrC128 ¶

func DivIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrC64 ¶

func DivIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrF32 ¶

func DivIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrF64 ¶

func DivIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrI ¶

func DivIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrI16 ¶

func DivIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrI32 ¶

func DivIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrI64 ¶

func DivIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrI8 ¶

func DivIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVC128 ¶

func DivIterIncrSVC128(a complex128, b []complex128, incr []complex128, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVC64 ¶

func DivIterIncrSVC64(a complex64, b []complex64, incr []complex64, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVF32 ¶

func DivIterIncrSVF32(a float32, b []float32, incr []float32, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVF64 ¶

func DivIterIncrSVF64(a float64, b []float64, incr []float64, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVI ¶

func DivIterIncrSVI(a int, b []int, incr []int, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVI16 ¶

func DivIterIncrSVI16(a int16, b []int16, incr []int16, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVI32 ¶

func DivIterIncrSVI32(a int32, b []int32, incr []int32, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVI64 ¶

func DivIterIncrSVI64(a int64, b []int64, incr []int64, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVI8 ¶

func DivIterIncrSVI8(a int8, b []int8, incr []int8, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVU ¶

func DivIterIncrSVU(a uint, b []uint, incr []uint, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVU16 ¶

func DivIterIncrSVU16(a uint16, b []uint16, incr []uint16, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVU32 ¶

func DivIterIncrSVU32(a uint32, b []uint32, incr []uint32, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVU64 ¶

func DivIterIncrSVU64(a uint64, b []uint64, incr []uint64, bit Iterator, iit Iterator) (err error)

func DivIterIncrSVU8 ¶

func DivIterIncrSVU8(a uint8, b []uint8, incr []uint8, bit Iterator, iit Iterator) (err error)

func DivIterIncrU ¶

func DivIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrU16 ¶

func DivIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrU32 ¶

func DivIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrU64 ¶

func DivIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrU8 ¶

func DivIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error)

func DivIterIncrVSC128 ¶

func DivIterIncrVSC128(a []complex128, b complex128, incr []complex128, ait Iterator, iit Iterator) (err error)

func DivIterIncrVSC64 ¶

func DivIterIncrVSC64(a []complex64, b complex64, incr []complex64, ait Iterator, iit Iterator) (err error)

func DivIterIncrVSF32 ¶

func DivIterIncrVSF32(a []float32, b float32, incr []float32, ait Iterator, iit Iterator) (err error)

func DivIterIncrVSF64 ¶

func DivIterIncrVSF64(a []float64, b float64, incr []float64, ait Iterator, iit Iterator) (err error)

func DivIterIncrVSI ¶

func DivIterIncrVSI(a []int, b int, incr []int, ait Iterator, iit Iterator) (err error)

func DivIterIncrVSI16 ¶

func DivIterIncrVSI16(a []int16, b int16, incr []int16, ait Iterator, iit Iterator) (err error)

func DivIterIncrVSI32 ¶

func DivIterIncrVSI32(a []int32, b int32, incr []int32, ait Iterator, iit Iterator) (err error)

func DivIterIncrVSI64 ¶

func DivIterIncrVSI64(a []int64, b int64, incr []int64, ait Iterator, iit Iterator) (err error)

func DivIterIncrVSI8 ¶

func DivIterIncrVSI8(a []int8, b int8, incr []int8, ait Iterator, iit Iterator) (err error)

func DivIterIncrVSU ¶

func DivIterIncrVSU(a []uint, b uint, incr []uint, ait Iterator, iit Iterator) (err error)

func DivIterIncrVSU16 ¶

func DivIterIncrVSU16(a []uint16, b uint16, incr []uint16, ait Iterator, iit Iterator) (err error)

func DivIterIncrVSU32 ¶

func DivIterIncrVSU32(a []uint32, b uint32, incr []uint32, ait Iterator, iit Iterator) (err error)

func DivIterIncrVSU64 ¶

func DivIterIncrVSU64(a []uint64, b uint64, incr []uint64, ait Iterator, iit Iterator) (err error)

func DivIterIncrVSU8 ¶

func DivIterIncrVSU8(a []uint8, b uint8, incr []uint8, ait Iterator, iit Iterator) (err error)

func DivIterSVC128 ¶

func DivIterSVC128(a complex128, b []complex128, bit Iterator) (err error)

func DivIterSVC64 ¶

func DivIterSVC64(a complex64, b []complex64, bit Iterator) (err error)

func DivIterSVF32 ¶

func DivIterSVF32(a float32, b []float32, bit Iterator) (err error)

func DivIterSVF64 ¶

func DivIterSVF64(a float64, b []float64, bit Iterator) (err error)

func DivIterSVI ¶

func DivIterSVI(a int, b []int, bit Iterator) (err error)

func DivIterSVI16 ¶

func DivIterSVI16(a int16, b []int16, bit Iterator) (err error)

func DivIterSVI32 ¶

func DivIterSVI32(a int32, b []int32, bit Iterator) (err error)

func DivIterSVI64 ¶

func DivIterSVI64(a int64, b []int64, bit Iterator) (err error)

func DivIterSVI8 ¶

func DivIterSVI8(a int8, b []int8, bit Iterator) (err error)

func DivIterSVU ¶

func DivIterSVU(a uint, b []uint, bit Iterator) (err error)

func DivIterSVU16 ¶

func DivIterSVU16(a uint16, b []uint16, bit Iterator) (err error)

func DivIterSVU32 ¶

func DivIterSVU32(a uint32, b []uint32, bit Iterator) (err error)

func DivIterSVU64 ¶

func DivIterSVU64(a uint64, b []uint64, bit Iterator) (err error)

func DivIterSVU8 ¶

func DivIterSVU8(a uint8, b []uint8, bit Iterator) (err error)

func DivIterU ¶

func DivIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)

func DivIterU16 ¶

func DivIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)

func DivIterU32 ¶

func DivIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)

func DivIterU64 ¶

func DivIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)

func DivIterU8 ¶

func DivIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)

func DivIterVSC128 ¶

func DivIterVSC128(a []complex128, b complex128, ait Iterator) (err error)

func DivIterVSC64 ¶

func DivIterVSC64(a []complex64, b complex64, ait Iterator) (err error)

func DivIterVSF32 ¶

func DivIterVSF32(a []float32, b float32, ait Iterator) (err error)

func DivIterVSF64 ¶

func DivIterVSF64(a []float64, b float64, ait Iterator) (err error)

func DivIterVSI ¶

func DivIterVSI(a []int, b int, ait Iterator) (err error)

func DivIterVSI16 ¶

func DivIterVSI16(a []int16, b int16, ait Iterator) (err error)

func DivIterVSI32 ¶

func DivIterVSI32(a []int32, b int32, ait Iterator) (err error)

func DivIterVSI64 ¶

func DivIterVSI64(a []int64, b int64, ait Iterator) (err error)

func DivIterVSI8 ¶

func DivIterVSI8(a []int8, b int8, ait Iterator) (err error)

func DivIterVSU ¶

func DivIterVSU(a []uint, b uint, ait Iterator) (err error)

func DivIterVSU16 ¶

func DivIterVSU16(a []uint16, b uint16, ait Iterator) (err error)

func DivIterVSU32 ¶

func DivIterVSU32(a []uint32, b uint32, ait Iterator) (err error)

func DivIterVSU64 ¶

func DivIterVSU64(a []uint64, b uint64, ait Iterator) (err error)

func DivIterVSU8 ¶

func DivIterVSU8(a []uint8, b uint8, ait Iterator) (err error)

func DivSVC128 ¶

func DivSVC128(a complex128, b []complex128)

func DivSVC64 ¶

func DivSVC64(a complex64, b []complex64)

func DivSVF32 ¶

func DivSVF32(a float32, b []float32)

func DivSVF64 ¶

func DivSVF64(a float64, b []float64)

func DivSVI ¶

func DivSVI(a int, b []int) (err error)

func DivSVI16 ¶

func DivSVI16(a int16, b []int16) (err error)

func DivSVI32 ¶

func DivSVI32(a int32, b []int32) (err error)

func DivSVI64 ¶

func DivSVI64(a int64, b []int64) (err error)

func DivSVI8 ¶

func DivSVI8(a int8, b []int8) (err error)

func DivSVU ¶

func DivSVU(a uint, b []uint) (err error)

func DivSVU16 ¶

func DivSVU16(a uint16, b []uint16) (err error)

func DivSVU32 ¶

func DivSVU32(a uint32, b []uint32) (err error)

func DivSVU64 ¶

func DivSVU64(a uint64, b []uint64) (err error)

func DivSVU8 ¶

func DivSVU8(a uint8, b []uint8) (err error)

func DivU ¶

func DivU(a uint, b uint) uint

func DivU16 ¶

func DivU16(a uint16, b uint16) uint16

func DivU32 ¶

func DivU32(a uint32, b uint32) uint32

func DivU64 ¶

func DivU64(a uint64, b uint64) uint64

func DivU8 ¶

func DivU8(a uint8, b uint8) uint8

func DivVSC128 ¶

func DivVSC128(a []complex128, b complex128)

func DivVSC64 ¶

func DivVSC64(a []complex64, b complex64)

func DivVSF32 ¶

func DivVSF32(a []float32, b float32)

func DivVSF64 ¶

func DivVSF64(a []float64, b float64)

func DivVSI ¶

func DivVSI(a []int, b int) (err error)

func DivVSI16 ¶

func DivVSI16(a []int16, b int16) (err error)

func DivVSI32 ¶

func DivVSI32(a []int32, b int32) (err error)

func DivVSI64 ¶

func DivVSI64(a []int64, b int64) (err error)

func DivVSI8 ¶

func DivVSI8(a []int8, b int8) (err error)

func DivVSU ¶

func DivVSU(a []uint, b uint) (err error)

func DivVSU16 ¶

func DivVSU16(a []uint16, b uint16) (err error)

func DivVSU32 ¶

func DivVSU32(a []uint32, b uint32) (err error)

func DivVSU64 ¶

func DivVSU64(a []uint64, b uint64) (err error)

func DivVSU8 ¶

func DivVSU8(a []uint8, b uint8) (err error)

func EqB ¶

func EqB(a []bool, b []bool, retVal []bool)

func EqC128 ¶

func EqC128(a []complex128, b []complex128, retVal []bool)

func EqC64 ¶

func EqC64(a []complex64, b []complex64, retVal []bool)

func EqF32 ¶

func EqF32(a []float32, b []float32, retVal []bool)

func EqF64 ¶

func EqF64(a []float64, b []float64, retVal []bool)

func EqI ¶

func EqI(a []int, b []int, retVal []bool)

func EqI16 ¶

func EqI16(a []int16, b []int16, retVal []bool)

func EqI32 ¶

func EqI32(a []int32, b []int32, retVal []bool)

func EqI64 ¶

func EqI64(a []int64, b []int64, retVal []bool)

func EqI8 ¶

func EqI8(a []int8, b []int8, retVal []bool)

func EqIterB ¶

func EqIterB(a []bool, b []bool, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterC128 ¶

func EqIterC128(a []complex128, b []complex128, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterC64 ¶

func EqIterC64(a []complex64, b []complex64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterF32 ¶

func EqIterF32(a []float32, b []float32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterF64 ¶

func EqIterF64(a []float64, b []float64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterI ¶

func EqIterI(a []int, b []int, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterI16 ¶

func EqIterI16(a []int16, b []int16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterI32 ¶

func EqIterI32(a []int32, b []int32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterI64 ¶

func EqIterI64(a []int64, b []int64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterI8 ¶

func EqIterI8(a []int8, b []int8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterSVB ¶

func EqIterSVB(a bool, b []bool, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVC128 ¶

func EqIterSVC128(a complex128, b []complex128, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVC64 ¶

func EqIterSVC64(a complex64, b []complex64, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVF32 ¶

func EqIterSVF32(a float32, b []float32, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVF64 ¶

func EqIterSVF64(a float64, b []float64, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVI ¶

func EqIterSVI(a int, b []int, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVI16 ¶

func EqIterSVI16(a int16, b []int16, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVI32 ¶

func EqIterSVI32(a int32, b []int32, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVI64 ¶

func EqIterSVI64(a int64, b []int64, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVI8 ¶

func EqIterSVI8(a int8, b []int8, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVStr ¶

func EqIterSVStr(a string, b []string, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVU ¶

func EqIterSVU(a uint, b []uint, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVU16 ¶

func EqIterSVU16(a uint16, b []uint16, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVU32 ¶

func EqIterSVU32(a uint32, b []uint32, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVU64 ¶

func EqIterSVU64(a uint64, b []uint64, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVU8 ¶

func EqIterSVU8(a uint8, b []uint8, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVUintptr ¶

func EqIterSVUintptr(a uintptr, b []uintptr, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterSVUnsafePointer ¶

func EqIterSVUnsafePointer(a unsafe.Pointer, b []unsafe.Pointer, retVal []bool, bit Iterator, rit Iterator) (err error)

func EqIterStr ¶

func EqIterStr(a []string, b []string, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterU ¶

func EqIterU(a []uint, b []uint, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterU16 ¶

func EqIterU16(a []uint16, b []uint16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterU32 ¶

func EqIterU32(a []uint32, b []uint32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterU64 ¶

func EqIterU64(a []uint64, b []uint64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterU8 ¶

func EqIterU8(a []uint8, b []uint8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterUintptr ¶

func EqIterUintptr(a []uintptr, b []uintptr, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterUnsafePointer ¶

func EqIterUnsafePointer(a []unsafe.Pointer, b []unsafe.Pointer, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func EqIterVSB ¶

func EqIterVSB(a []bool, b bool, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSC128 ¶

func EqIterVSC128(a []complex128, b complex128, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSC64 ¶

func EqIterVSC64(a []complex64, b complex64, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSF32 ¶

func EqIterVSF32(a []float32, b float32, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSF64 ¶

func EqIterVSF64(a []float64, b float64, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSI ¶

func EqIterVSI(a []int, b int, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSI16 ¶

func EqIterVSI16(a []int16, b int16, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSI32 ¶

func EqIterVSI32(a []int32, b int32, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSI64 ¶

func EqIterVSI64(a []int64, b int64, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSI8 ¶

func EqIterVSI8(a []int8, b int8, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSStr ¶

func EqIterVSStr(a []string, b string, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSU ¶

func EqIterVSU(a []uint, b uint, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSU16 ¶

func EqIterVSU16(a []uint16, b uint16, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSU32 ¶

func EqIterVSU32(a []uint32, b uint32, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSU64 ¶

func EqIterVSU64(a []uint64, b uint64, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSU8 ¶

func EqIterVSU8(a []uint8, b uint8, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSUintptr ¶

func EqIterVSUintptr(a []uintptr, b uintptr, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqIterVSUnsafePointer ¶

func EqIterVSUnsafePointer(a []unsafe.Pointer, b unsafe.Pointer, retVal []bool, ait Iterator, rit Iterator) (err error)

func EqSVB ¶

func EqSVB(a bool, b []bool, retVal []bool)

func EqSVC128 ¶

func EqSVC128(a complex128, b []complex128, retVal []bool)

func EqSVC64 ¶

func EqSVC64(a complex64, b []complex64, retVal []bool)

func EqSVF32 ¶

func EqSVF32(a float32, b []float32, retVal []bool)

func EqSVF64 ¶

func EqSVF64(a float64, b []float64, retVal []bool)

func EqSVI ¶

func EqSVI(a int, b []int, retVal []bool)

func EqSVI16 ¶

func EqSVI16(a int16, b []int16, retVal []bool)

func EqSVI32 ¶

func EqSVI32(a int32, b []int32, retVal []bool)

func EqSVI64 ¶

func EqSVI64(a int64, b []int64, retVal []bool)

func EqSVI8 ¶

func EqSVI8(a int8, b []int8, retVal []bool)

func EqSVStr ¶

func EqSVStr(a string, b []string, retVal []bool)

func EqSVU ¶

func EqSVU(a uint, b []uint, retVal []bool)

func EqSVU16 ¶

func EqSVU16(a uint16, b []uint16, retVal []bool)

func EqSVU32 ¶

func EqSVU32(a uint32, b []uint32, retVal []bool)

func EqSVU64 ¶

func EqSVU64(a uint64, b []uint64, retVal []bool)

func EqSVU8 ¶

func EqSVU8(a uint8, b []uint8, retVal []bool)

func EqSVUintptr ¶

func EqSVUintptr(a uintptr, b []uintptr, retVal []bool)

func EqSVUnsafePointer ¶

func EqSVUnsafePointer(a unsafe.Pointer, b []unsafe.Pointer, retVal []bool)

func EqSameB ¶

func EqSameB(a []bool, b []bool)

func EqSameC128 ¶

func EqSameC128(a []complex128, b []complex128)

func EqSameC64 ¶

func EqSameC64(a []complex64, b []complex64)

func EqSameF32 ¶

func EqSameF32(a []float32, b []float32)

func EqSameF64 ¶

func EqSameF64(a []float64, b []float64)

func EqSameI ¶

func EqSameI(a []int, b []int)

func EqSameI16 ¶

func EqSameI16(a []int16, b []int16)

func EqSameI32 ¶

func EqSameI32(a []int32, b []int32)

func EqSameI64 ¶

func EqSameI64(a []int64, b []int64)

func EqSameI8 ¶

func EqSameI8(a []int8, b []int8)

func EqSameIterB ¶

func EqSameIterB(a []bool, b []bool, ait Iterator, bit Iterator) (err error)

func EqSameIterC128 ¶

func EqSameIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)

func EqSameIterC64 ¶

func EqSameIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)

func EqSameIterF32 ¶

func EqSameIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)

func EqSameIterF64 ¶

func EqSameIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)

func EqSameIterI ¶

func EqSameIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)

func EqSameIterI16 ¶

func EqSameIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)

func EqSameIterI32 ¶

func EqSameIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)

func EqSameIterI64 ¶

func EqSameIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)

func EqSameIterI8 ¶

func EqSameIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)

func EqSameIterSVB ¶

func EqSameIterSVB(a bool, b []bool, bit Iterator) (err error)

func EqSameIterSVC128 ¶

func EqSameIterSVC128(a complex128, b []complex128, bit Iterator) (err error)

func EqSameIterSVC64 ¶

func EqSameIterSVC64(a complex64, b []complex64, bit Iterator) (err error)

func EqSameIterSVF32 ¶

func EqSameIterSVF32(a float32, b []float32, bit Iterator) (err error)

func EqSameIterSVF64 ¶

func EqSameIterSVF64(a float64, b []float64, bit Iterator) (err error)

func EqSameIterSVI ¶

func EqSameIterSVI(a int, b []int, bit Iterator) (err error)

func EqSameIterSVI16 ¶

func EqSameIterSVI16(a int16, b []int16, bit Iterator) (err error)

func EqSameIterSVI32 ¶

func EqSameIterSVI32(a int32, b []int32, bit Iterator) (err error)

func EqSameIterSVI64 ¶

func EqSameIterSVI64(a int64, b []int64, bit Iterator) (err error)

func EqSameIterSVI8 ¶

func EqSameIterSVI8(a int8, b []int8, bit Iterator) (err error)

func EqSameIterSVStr ¶

func EqSameIterSVStr(a string, b []string, bit Iterator) (err error)

func EqSameIterSVU ¶

func EqSameIterSVU(a uint, b []uint, bit Iterator) (err error)

func EqSameIterSVU16 ¶

func EqSameIterSVU16(a uint16, b []uint16, bit Iterator) (err error)

func EqSameIterSVU32 ¶

func EqSameIterSVU32(a uint32, b []uint32, bit Iterator) (err error)

func EqSameIterSVU64 ¶

func EqSameIterSVU64(a uint64, b []uint64, bit Iterator) (err error)

func EqSameIterSVU8 ¶

func EqSameIterSVU8(a uint8, b []uint8, bit Iterator) (err error)

func EqSameIterSVUintptr ¶

func EqSameIterSVUintptr(a uintptr, b []uintptr, bit Iterator) (err error)

func EqSameIterStr ¶

func EqSameIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)

func EqSameIterU ¶

func EqSameIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)

func EqSameIterU16 ¶

func EqSameIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)

func EqSameIterU32 ¶

func EqSameIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)

func EqSameIterU64 ¶

func EqSameIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)

func EqSameIterU8 ¶

func EqSameIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)

func EqSameIterUintptr ¶

func EqSameIterUintptr(a []uintptr, b []uintptr, ait Iterator, bit Iterator) (err error)

func EqSameIterVSB ¶

func EqSameIterVSB(a []bool, b bool, ait Iterator) (err error)

func EqSameIterVSC128 ¶

func EqSameIterVSC128(a []complex128, b complex128, ait Iterator) (err error)

func EqSameIterVSC64 ¶

func EqSameIterVSC64(a []complex64, b complex64, ait Iterator) (err error)

func EqSameIterVSF32 ¶

func EqSameIterVSF32(a []float32, b float32, ait Iterator) (err error)

func EqSameIterVSF64 ¶

func EqSameIterVSF64(a []float64, b float64, ait Iterator) (err error)

func EqSameIterVSI ¶

func EqSameIterVSI(a []int, b int, ait Iterator) (err error)

func EqSameIterVSI16 ¶

func EqSameIterVSI16(a []int16, b int16, ait Iterator) (err error)

func EqSameIterVSI32 ¶

func EqSameIterVSI32(a []int32, b int32, ait Iterator) (err error)

func EqSameIterVSI64 ¶

func EqSameIterVSI64(a []int64, b int64, ait Iterator) (err error)

func EqSameIterVSI8 ¶

func EqSameIterVSI8(a []int8, b int8, ait Iterator) (err error)

func EqSameIterVSStr ¶

func EqSameIterVSStr(a []string, b string, ait Iterator) (err error)

func EqSameIterVSU ¶

func EqSameIterVSU(a []uint, b uint, ait Iterator) (err error)

func EqSameIterVSU16 ¶

func EqSameIterVSU16(a []uint16, b uint16, ait Iterator) (err error)

func EqSameIterVSU32 ¶

func EqSameIterVSU32(a []uint32, b uint32, ait Iterator) (err error)

func EqSameIterVSU64 ¶

func EqSameIterVSU64(a []uint64, b uint64, ait Iterator) (err error)

func EqSameIterVSU8 ¶

func EqSameIterVSU8(a []uint8, b uint8, ait Iterator) (err error)

func EqSameIterVSUintptr ¶

func EqSameIterVSUintptr(a []uintptr, b uintptr, ait Iterator) (err error)

func EqSameSVB ¶

func EqSameSVB(a bool, b []bool)

func EqSameSVC128 ¶

func EqSameSVC128(a complex128, b []complex128)

func EqSameSVC64 ¶

func EqSameSVC64(a complex64, b []complex64)

func EqSameSVF32 ¶

func EqSameSVF32(a float32, b []float32)

func EqSameSVF64 ¶

func EqSameSVF64(a float64, b []float64)

func EqSameSVI ¶

func EqSameSVI(a int, b []int)

func EqSameSVI16 ¶

func EqSameSVI16(a int16, b []int16)

func EqSameSVI32 ¶

func EqSameSVI32(a int32, b []int32)

func EqSameSVI64 ¶

func EqSameSVI64(a int64, b []int64)

func EqSameSVI8 ¶

func EqSameSVI8(a int8, b []int8)

func EqSameSVStr ¶

func EqSameSVStr(a string, b []string)

func EqSameSVU ¶

func EqSameSVU(a uint, b []uint)

func EqSameSVU16 ¶

func EqSameSVU16(a uint16, b []uint16)

func EqSameSVU32 ¶

func EqSameSVU32(a uint32, b []uint32)

func EqSameSVU64 ¶

func EqSameSVU64(a uint64, b []uint64)

func EqSameSVU8 ¶

func EqSameSVU8(a uint8, b []uint8)

func EqSameSVUintptr ¶

func EqSameSVUintptr(a uintptr, b []uintptr)

func EqSameStr ¶

func EqSameStr(a []string, b []string)

func EqSameU ¶

func EqSameU(a []uint, b []uint)

func EqSameU16 ¶

func EqSameU16(a []uint16, b []uint16)

func EqSameU32 ¶

func EqSameU32(a []uint32, b []uint32)

func EqSameU64 ¶

func EqSameU64(a []uint64, b []uint64)

func EqSameU8 ¶

func EqSameU8(a []uint8, b []uint8)

func EqSameUintptr ¶

func EqSameUintptr(a []uintptr, b []uintptr)

func EqSameVSB ¶

func EqSameVSB(a []bool, b bool)

func EqSameVSC128 ¶

func EqSameVSC128(a []complex128, b complex128)

func EqSameVSC64 ¶

func EqSameVSC64(a []complex64, b complex64)

func EqSameVSF32 ¶

func EqSameVSF32(a []float32, b float32)

func EqSameVSF64 ¶

func EqSameVSF64(a []float64, b float64)

func EqSameVSI ¶

func EqSameVSI(a []int, b int)

func EqSameVSI16 ¶

func EqSameVSI16(a []int16, b int16)

func EqSameVSI32 ¶

func EqSameVSI32(a []int32, b int32)

func EqSameVSI64 ¶

func EqSameVSI64(a []int64, b int64)

func EqSameVSI8 ¶

func EqSameVSI8(a []int8, b int8)

func EqSameVSStr ¶

func EqSameVSStr(a []string, b string)

func EqSameVSU ¶

func EqSameVSU(a []uint, b uint)

func EqSameVSU16 ¶

func EqSameVSU16(a []uint16, b uint16)

func EqSameVSU32 ¶

func EqSameVSU32(a []uint32, b uint32)

func EqSameVSU64 ¶

func EqSameVSU64(a []uint64, b uint64)

func EqSameVSU8 ¶

func EqSameVSU8(a []uint8, b uint8)

func EqSameVSUintptr ¶

func EqSameVSUintptr(a []uintptr, b uintptr)

func EqStr ¶

func EqStr(a []string, b []string, retVal []bool)

func EqU ¶

func EqU(a []uint, b []uint, retVal []bool)

func EqU16 ¶

func EqU16(a []uint16, b []uint16, retVal []bool)

func EqU32 ¶

func EqU32(a []uint32, b []uint32, retVal []bool)

func EqU64 ¶

func EqU64(a []uint64, b []uint64, retVal []bool)

func EqU8 ¶

func EqU8(a []uint8, b []uint8, retVal []bool)

func EqUintptr ¶

func EqUintptr(a []uintptr, b []uintptr, retVal []bool)

func EqUnsafePointer ¶

func EqUnsafePointer(a []unsafe.Pointer, b []unsafe.Pointer, retVal []bool)

func EqVSB ¶

func EqVSB(a []bool, b bool, retVal []bool)

func EqVSC128 ¶

func EqVSC128(a []complex128, b complex128, retVal []bool)

func EqVSC64 ¶

func EqVSC64(a []complex64, b complex64, retVal []bool)

func EqVSF32 ¶

func EqVSF32(a []float32, b float32, retVal []bool)

func EqVSF64 ¶

func EqVSF64(a []float64, b float64, retVal []bool)

func EqVSI ¶

func EqVSI(a []int, b int, retVal []bool)

func EqVSI16 ¶

func EqVSI16(a []int16, b int16, retVal []bool)

func EqVSI32 ¶

func EqVSI32(a []int32, b int32, retVal []bool)

func EqVSI64 ¶

func EqVSI64(a []int64, b int64, retVal []bool)

func EqVSI8 ¶

func EqVSI8(a []int8, b int8, retVal []bool)

func EqVSStr ¶

func EqVSStr(a []string, b string, retVal []bool)

func EqVSU ¶

func EqVSU(a []uint, b uint, retVal []bool)

func EqVSU16 ¶

func EqVSU16(a []uint16, b uint16, retVal []bool)

func EqVSU32 ¶

func EqVSU32(a []uint32, b uint32, retVal []bool)

func EqVSU64 ¶

func EqVSU64(a []uint64, b uint64, retVal []bool)

func EqVSU8 ¶

func EqVSU8(a []uint8, b uint8, retVal []bool)

func EqVSUintptr ¶

func EqVSUintptr(a []uintptr, b uintptr, retVal []bool)

func EqVSUnsafePointer ¶

func EqVSUnsafePointer(a []unsafe.Pointer, b unsafe.Pointer, retVal []bool)

func ExpC128 ¶

func ExpC128(a []complex128)

func ExpC64 ¶

func ExpC64(a []complex64)

func ExpF32 ¶

func ExpF32(a []float32)

func ExpF64 ¶

func ExpF64(a []float64)

func ExpIterC128 ¶

func ExpIterC128(a []complex128, ait Iterator) (err error)

func ExpIterC64 ¶

func ExpIterC64(a []complex64, ait Iterator) (err error)

func ExpIterF32 ¶

func ExpIterF32(a []float32, ait Iterator) (err error)

func ExpIterF64 ¶

func ExpIterF64(a []float64, ait Iterator) (err error)

func GtF32 ¶

func GtF32(a []float32, b []float32, retVal []bool)

func GtF64 ¶

func GtF64(a []float64, b []float64, retVal []bool)

func GtI ¶

func GtI(a []int, b []int, retVal []bool)

func GtI16 ¶

func GtI16(a []int16, b []int16, retVal []bool)

func GtI32 ¶

func GtI32(a []int32, b []int32, retVal []bool)

func GtI64 ¶

func GtI64(a []int64, b []int64, retVal []bool)

func GtI8 ¶

func GtI8(a []int8, b []int8, retVal []bool)

func GtIterF32 ¶

func GtIterF32(a []float32, b []float32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GtIterF64 ¶

func GtIterF64(a []float64, b []float64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GtIterI ¶

func GtIterI(a []int, b []int, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GtIterI16 ¶

func GtIterI16(a []int16, b []int16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GtIterI32 ¶

func GtIterI32(a []int32, b []int32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GtIterI64 ¶

func GtIterI64(a []int64, b []int64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GtIterI8 ¶

func GtIterI8(a []int8, b []int8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GtIterSVF32 ¶

func GtIterSVF32(a float32, b []float32, retVal []bool, bit Iterator, rit Iterator) (err error)

func GtIterSVF64 ¶

func GtIterSVF64(a float64, b []float64, retVal []bool, bit Iterator, rit Iterator) (err error)

func GtIterSVI ¶

func GtIterSVI(a int, b []int, retVal []bool, bit Iterator, rit Iterator) (err error)

func GtIterSVI16 ¶

func GtIterSVI16(a int16, b []int16, retVal []bool, bit Iterator, rit Iterator) (err error)

func GtIterSVI32 ¶

func GtIterSVI32(a int32, b []int32, retVal []bool, bit Iterator, rit Iterator) (err error)

func GtIterSVI64 ¶

func GtIterSVI64(a int64, b []int64, retVal []bool, bit Iterator, rit Iterator) (err error)

func GtIterSVI8 ¶

func GtIterSVI8(a int8, b []int8, retVal []bool, bit Iterator, rit Iterator) (err error)

func GtIterSVStr ¶

func GtIterSVStr(a string, b []string, retVal []bool, bit Iterator, rit Iterator) (err error)

func GtIterSVU ¶

func GtIterSVU(a uint, b []uint, retVal []bool, bit Iterator, rit Iterator) (err error)

func GtIterSVU16 ¶

func GtIterSVU16(a uint16, b []uint16, retVal []bool, bit Iterator, rit Iterator) (err error)

func GtIterSVU32 ¶

func GtIterSVU32(a uint32, b []uint32, retVal []bool, bit Iterator, rit Iterator) (err error)

func GtIterSVU64 ¶

func GtIterSVU64(a uint64, b []uint64, retVal []bool, bit Iterator, rit Iterator) (err error)

func GtIterSVU8 ¶

func GtIterSVU8(a uint8, b []uint8, retVal []bool, bit Iterator, rit Iterator) (err error)

func GtIterStr ¶

func GtIterStr(a []string, b []string, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GtIterU ¶

func GtIterU(a []uint, b []uint, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GtIterU16 ¶

func GtIterU16(a []uint16, b []uint16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GtIterU32 ¶

func GtIterU32(a []uint32, b []uint32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GtIterU64 ¶

func GtIterU64(a []uint64, b []uint64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GtIterU8 ¶

func GtIterU8(a []uint8, b []uint8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GtIterVSF32 ¶

func GtIterVSF32(a []float32, b float32, retVal []bool, ait Iterator, rit Iterator) (err error)

func GtIterVSF64 ¶

func GtIterVSF64(a []float64, b float64, retVal []bool, ait Iterator, rit Iterator) (err error)

func GtIterVSI ¶

func GtIterVSI(a []int, b int, retVal []bool, ait Iterator, rit Iterator) (err error)

func GtIterVSI16 ¶

func GtIterVSI16(a []int16, b int16, retVal []bool, ait Iterator, rit Iterator) (err error)

func GtIterVSI32 ¶

func GtIterVSI32(a []int32, b int32, retVal []bool, ait Iterator, rit Iterator) (err error)

func GtIterVSI64 ¶

func GtIterVSI64(a []int64, b int64, retVal []bool, ait Iterator, rit Iterator) (err error)

func GtIterVSI8 ¶

func GtIterVSI8(a []int8, b int8, retVal []bool, ait Iterator, rit Iterator) (err error)

func GtIterVSStr ¶

func GtIterVSStr(a []string, b string, retVal []bool, ait Iterator, rit Iterator) (err error)

func GtIterVSU ¶

func GtIterVSU(a []uint, b uint, retVal []bool, ait Iterator, rit Iterator) (err error)

func GtIterVSU16 ¶

func GtIterVSU16(a []uint16, b uint16, retVal []bool, ait Iterator, rit Iterator) (err error)

func GtIterVSU32 ¶

func GtIterVSU32(a []uint32, b uint32, retVal []bool, ait Iterator, rit Iterator) (err error)

func GtIterVSU64 ¶

func GtIterVSU64(a []uint64, b uint64, retVal []bool, ait Iterator, rit Iterator) (err error)

func GtIterVSU8 ¶

func GtIterVSU8(a []uint8, b uint8, retVal []bool, ait Iterator, rit Iterator) (err error)

func GtSVF32 ¶

func GtSVF32(a float32, b []float32, retVal []bool)

func GtSVF64 ¶

func GtSVF64(a float64, b []float64, retVal []bool)

func GtSVI ¶

func GtSVI(a int, b []int, retVal []bool)

func GtSVI16 ¶

func GtSVI16(a int16, b []int16, retVal []bool)

func GtSVI32 ¶

func GtSVI32(a int32, b []int32, retVal []bool)

func GtSVI64 ¶

func GtSVI64(a int64, b []int64, retVal []bool)

func GtSVI8 ¶

func GtSVI8(a int8, b []int8, retVal []bool)

func GtSVStr ¶

func GtSVStr(a string, b []string, retVal []bool)

func GtSVU ¶

func GtSVU(a uint, b []uint, retVal []bool)

func GtSVU16 ¶

func GtSVU16(a uint16, b []uint16, retVal []bool)

func GtSVU32 ¶

func GtSVU32(a uint32, b []uint32, retVal []bool)

func GtSVU64 ¶

func GtSVU64(a uint64, b []uint64, retVal []bool)

func GtSVU8 ¶

func GtSVU8(a uint8, b []uint8, retVal []bool)

func GtSameF32 ¶

func GtSameF32(a []float32, b []float32)

func GtSameF64 ¶

func GtSameF64(a []float64, b []float64)

func GtSameI ¶

func GtSameI(a []int, b []int)

func GtSameI16 ¶

func GtSameI16(a []int16, b []int16)

func GtSameI32 ¶

func GtSameI32(a []int32, b []int32)

func GtSameI64 ¶

func GtSameI64(a []int64, b []int64)

func GtSameI8 ¶

func GtSameI8(a []int8, b []int8)

func GtSameIterF32 ¶

func GtSameIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)

func GtSameIterF64 ¶

func GtSameIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)

func GtSameIterI ¶

func GtSameIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)

func GtSameIterI16 ¶

func GtSameIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)

func GtSameIterI32 ¶

func GtSameIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)

func GtSameIterI64 ¶

func GtSameIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)

func GtSameIterI8 ¶

func GtSameIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)

func GtSameIterSVF32 ¶

func GtSameIterSVF32(a float32, b []float32, bit Iterator) (err error)

func GtSameIterSVF64 ¶

func GtSameIterSVF64(a float64, b []float64, bit Iterator) (err error)

func GtSameIterSVI ¶

func GtSameIterSVI(a int, b []int, bit Iterator) (err error)

func GtSameIterSVI16 ¶

func GtSameIterSVI16(a int16, b []int16, bit Iterator) (err error)

func GtSameIterSVI32 ¶

func GtSameIterSVI32(a int32, b []int32, bit Iterator) (err error)

func GtSameIterSVI64 ¶

func GtSameIterSVI64(a int64, b []int64, bit Iterator) (err error)

func GtSameIterSVI8 ¶

func GtSameIterSVI8(a int8, b []int8, bit Iterator) (err error)

func GtSameIterSVStr ¶

func GtSameIterSVStr(a string, b []string, bit Iterator) (err error)

func GtSameIterSVU ¶

func GtSameIterSVU(a uint, b []uint, bit Iterator) (err error)

func GtSameIterSVU16 ¶

func GtSameIterSVU16(a uint16, b []uint16, bit Iterator) (err error)

func GtSameIterSVU32 ¶

func GtSameIterSVU32(a uint32, b []uint32, bit Iterator) (err error)

func GtSameIterSVU64 ¶

func GtSameIterSVU64(a uint64, b []uint64, bit Iterator) (err error)

func GtSameIterSVU8 ¶

func GtSameIterSVU8(a uint8, b []uint8, bit Iterator) (err error)

func GtSameIterStr ¶

func GtSameIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)

func GtSameIterU ¶

func GtSameIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)

func GtSameIterU16 ¶

func GtSameIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)

func GtSameIterU32 ¶

func GtSameIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)

func GtSameIterU64 ¶

func GtSameIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)

func GtSameIterU8 ¶

func GtSameIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)

func GtSameIterVSF32 ¶

func GtSameIterVSF32(a []float32, b float32, ait Iterator) (err error)

func GtSameIterVSF64 ¶

func GtSameIterVSF64(a []float64, b float64, ait Iterator) (err error)

func GtSameIterVSI ¶

func GtSameIterVSI(a []int, b int, ait Iterator) (err error)

func GtSameIterVSI16 ¶

func GtSameIterVSI16(a []int16, b int16, ait Iterator) (err error)

func GtSameIterVSI32 ¶

func GtSameIterVSI32(a []int32, b int32, ait Iterator) (err error)

func GtSameIterVSI64 ¶

func GtSameIterVSI64(a []int64, b int64, ait Iterator) (err error)

func GtSameIterVSI8 ¶

func GtSameIterVSI8(a []int8, b int8, ait Iterator) (err error)

func GtSameIterVSStr ¶

func GtSameIterVSStr(a []string, b string, ait Iterator) (err error)

func GtSameIterVSU ¶

func GtSameIterVSU(a []uint, b uint, ait Iterator) (err error)

func GtSameIterVSU16 ¶

func GtSameIterVSU16(a []uint16, b uint16, ait Iterator) (err error)

func GtSameIterVSU32 ¶

func GtSameIterVSU32(a []uint32, b uint32, ait Iterator) (err error)

func GtSameIterVSU64 ¶

func GtSameIterVSU64(a []uint64, b uint64, ait Iterator) (err error)

func GtSameIterVSU8 ¶

func GtSameIterVSU8(a []uint8, b uint8, ait Iterator) (err error)

func GtSameSVF32 ¶

func GtSameSVF32(a float32, b []float32)

func GtSameSVF64 ¶

func GtSameSVF64(a float64, b []float64)

func GtSameSVI ¶

func GtSameSVI(a int, b []int)

func GtSameSVI16 ¶

func GtSameSVI16(a int16, b []int16)

func GtSameSVI32 ¶

func GtSameSVI32(a int32, b []int32)

func GtSameSVI64 ¶

func GtSameSVI64(a int64, b []int64)

func GtSameSVI8 ¶

func GtSameSVI8(a int8, b []int8)

func GtSameSVStr ¶

func GtSameSVStr(a string, b []string)

func GtSameSVU ¶

func GtSameSVU(a uint, b []uint)

func GtSameSVU16 ¶

func GtSameSVU16(a uint16, b []uint16)

func GtSameSVU32 ¶

func GtSameSVU32(a uint32, b []uint32)

func GtSameSVU64 ¶

func GtSameSVU64(a uint64, b []uint64)

func GtSameSVU8 ¶

func GtSameSVU8(a uint8, b []uint8)

func GtSameStr ¶

func GtSameStr(a []string, b []string)

func GtSameU ¶

func GtSameU(a []uint, b []uint)

func GtSameU16 ¶

func GtSameU16(a []uint16, b []uint16)

func GtSameU32 ¶

func GtSameU32(a []uint32, b []uint32)

func GtSameU64 ¶

func GtSameU64(a []uint64, b []uint64)

func GtSameU8 ¶

func GtSameU8(a []uint8, b []uint8)

func GtSameVSF32 ¶

func GtSameVSF32(a []float32, b float32)

func GtSameVSF64 ¶

func GtSameVSF64(a []float64, b float64)

func GtSameVSI ¶

func GtSameVSI(a []int, b int)

func GtSameVSI16 ¶

func GtSameVSI16(a []int16, b int16)

func GtSameVSI32 ¶

func GtSameVSI32(a []int32, b int32)

func GtSameVSI64 ¶

func GtSameVSI64(a []int64, b int64)

func GtSameVSI8 ¶

func GtSameVSI8(a []int8, b int8)

func GtSameVSStr ¶

func GtSameVSStr(a []string, b string)

func GtSameVSU ¶

func GtSameVSU(a []uint, b uint)

func GtSameVSU16 ¶

func GtSameVSU16(a []uint16, b uint16)

func GtSameVSU32 ¶

func GtSameVSU32(a []uint32, b uint32)

func GtSameVSU64 ¶

func GtSameVSU64(a []uint64, b uint64)

func GtSameVSU8 ¶

func GtSameVSU8(a []uint8, b uint8)

func GtStr ¶

func GtStr(a []string, b []string, retVal []bool)

func GtU ¶

func GtU(a []uint, b []uint, retVal []bool)

func GtU16 ¶

func GtU16(a []uint16, b []uint16, retVal []bool)

func GtU32 ¶

func GtU32(a []uint32, b []uint32, retVal []bool)

func GtU64 ¶

func GtU64(a []uint64, b []uint64, retVal []bool)

func GtU8 ¶

func GtU8(a []uint8, b []uint8, retVal []bool)

func GtVSF32 ¶

func GtVSF32(a []float32, b float32, retVal []bool)

func GtVSF64 ¶

func GtVSF64(a []float64, b float64, retVal []bool)

func GtVSI ¶

func GtVSI(a []int, b int, retVal []bool)

func GtVSI16 ¶

func GtVSI16(a []int16, b int16, retVal []bool)

func GtVSI32 ¶

func GtVSI32(a []int32, b int32, retVal []bool)

func GtVSI64 ¶

func GtVSI64(a []int64, b int64, retVal []bool)

func GtVSI8 ¶

func GtVSI8(a []int8, b int8, retVal []bool)

func GtVSStr ¶

func GtVSStr(a []string, b string, retVal []bool)

func GtVSU ¶

func GtVSU(a []uint, b uint, retVal []bool)

func GtVSU16 ¶

func GtVSU16(a []uint16, b uint16, retVal []bool)

func GtVSU32 ¶

func GtVSU32(a []uint32, b uint32, retVal []bool)

func GtVSU64 ¶

func GtVSU64(a []uint64, b uint64, retVal []bool)

func GtVSU8 ¶

func GtVSU8(a []uint8, b uint8, retVal []bool)

func GteF32 ¶

func GteF32(a []float32, b []float32, retVal []bool)

func GteF64 ¶

func GteF64(a []float64, b []float64, retVal []bool)

func GteI ¶

func GteI(a []int, b []int, retVal []bool)

func GteI16 ¶

func GteI16(a []int16, b []int16, retVal []bool)

func GteI32 ¶

func GteI32(a []int32, b []int32, retVal []bool)

func GteI64 ¶

func GteI64(a []int64, b []int64, retVal []bool)

func GteI8 ¶

func GteI8(a []int8, b []int8, retVal []bool)

func GteIterF32 ¶

func GteIterF32(a []float32, b []float32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GteIterF64 ¶

func GteIterF64(a []float64, b []float64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GteIterI ¶

func GteIterI(a []int, b []int, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GteIterI16 ¶

func GteIterI16(a []int16, b []int16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GteIterI32 ¶

func GteIterI32(a []int32, b []int32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GteIterI64 ¶

func GteIterI64(a []int64, b []int64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GteIterI8 ¶

func GteIterI8(a []int8, b []int8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GteIterSVF32 ¶

func GteIterSVF32(a float32, b []float32, retVal []bool, bit Iterator, rit Iterator) (err error)

func GteIterSVF64 ¶

func GteIterSVF64(a float64, b []float64, retVal []bool, bit Iterator, rit Iterator) (err error)

func GteIterSVI ¶

func GteIterSVI(a int, b []int, retVal []bool, bit Iterator, rit Iterator) (err error)

func GteIterSVI16 ¶

func GteIterSVI16(a int16, b []int16, retVal []bool, bit Iterator, rit Iterator) (err error)

func GteIterSVI32 ¶

func GteIterSVI32(a int32, b []int32, retVal []bool, bit Iterator, rit Iterator) (err error)

func GteIterSVI64 ¶

func GteIterSVI64(a int64, b []int64, retVal []bool, bit Iterator, rit Iterator) (err error)

func GteIterSVI8 ¶

func GteIterSVI8(a int8, b []int8, retVal []bool, bit Iterator, rit Iterator) (err error)

func GteIterSVStr ¶

func GteIterSVStr(a string, b []string, retVal []bool, bit Iterator, rit Iterator) (err error)

func GteIterSVU ¶

func GteIterSVU(a uint, b []uint, retVal []bool, bit Iterator, rit Iterator) (err error)

func GteIterSVU16 ¶

func GteIterSVU16(a uint16, b []uint16, retVal []bool, bit Iterator, rit Iterator) (err error)

func GteIterSVU32 ¶

func GteIterSVU32(a uint32, b []uint32, retVal []bool, bit Iterator, rit Iterator) (err error)

func GteIterSVU64 ¶

func GteIterSVU64(a uint64, b []uint64, retVal []bool, bit Iterator, rit Iterator) (err error)

func GteIterSVU8 ¶

func GteIterSVU8(a uint8, b []uint8, retVal []bool, bit Iterator, rit Iterator) (err error)

func GteIterStr ¶

func GteIterStr(a []string, b []string, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GteIterU ¶

func GteIterU(a []uint, b []uint, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GteIterU16 ¶

func GteIterU16(a []uint16, b []uint16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GteIterU32 ¶

func GteIterU32(a []uint32, b []uint32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GteIterU64 ¶

func GteIterU64(a []uint64, b []uint64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GteIterU8 ¶

func GteIterU8(a []uint8, b []uint8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func GteIterVSF32 ¶

func GteIterVSF32(a []float32, b float32, retVal []bool, ait Iterator, rit Iterator) (err error)

func GteIterVSF64 ¶

func GteIterVSF64(a []float64, b float64, retVal []bool, ait Iterator, rit Iterator) (err error)

func GteIterVSI ¶

func GteIterVSI(a []int, b int, retVal []bool, ait Iterator, rit Iterator) (err error)

func GteIterVSI16 ¶

func GteIterVSI16(a []int16, b int16, retVal []bool, ait Iterator, rit Iterator) (err error)

func GteIterVSI32 ¶

func GteIterVSI32(a []int32, b int32, retVal []bool, ait Iterator, rit Iterator) (err error)

func GteIterVSI64 ¶

func GteIterVSI64(a []int64, b int64, retVal []bool, ait Iterator, rit Iterator) (err error)

func GteIterVSI8 ¶

func GteIterVSI8(a []int8, b int8, retVal []bool, ait Iterator, rit Iterator) (err error)

func GteIterVSStr ¶

func GteIterVSStr(a []string, b string, retVal []bool, ait Iterator, rit Iterator) (err error)

func GteIterVSU ¶

func GteIterVSU(a []uint, b uint, retVal []bool, ait Iterator, rit Iterator) (err error)

func GteIterVSU16 ¶

func GteIterVSU16(a []uint16, b uint16, retVal []bool, ait Iterator, rit Iterator) (err error)

func GteIterVSU32 ¶

func GteIterVSU32(a []uint32, b uint32, retVal []bool, ait Iterator, rit Iterator) (err error)

func GteIterVSU64 ¶

func GteIterVSU64(a []uint64, b uint64, retVal []bool, ait Iterator, rit Iterator) (err error)

func GteIterVSU8 ¶

func GteIterVSU8(a []uint8, b uint8, retVal []bool, ait Iterator, rit Iterator) (err error)

func GteSVF32 ¶

func GteSVF32(a float32, b []float32, retVal []bool)

func GteSVF64 ¶

func GteSVF64(a float64, b []float64, retVal []bool)

func GteSVI ¶

func GteSVI(a int, b []int, retVal []bool)

func GteSVI16 ¶

func GteSVI16(a int16, b []int16, retVal []bool)

func GteSVI32 ¶

func GteSVI32(a int32, b []int32, retVal []bool)

func GteSVI64 ¶

func GteSVI64(a int64, b []int64, retVal []bool)

func GteSVI8 ¶

func GteSVI8(a int8, b []int8, retVal []bool)

func GteSVStr ¶

func GteSVStr(a string, b []string, retVal []bool)

func GteSVU ¶

func GteSVU(a uint, b []uint, retVal []bool)

func GteSVU16 ¶

func GteSVU16(a uint16, b []uint16, retVal []bool)

func GteSVU32 ¶

func GteSVU32(a uint32, b []uint32, retVal []bool)

func GteSVU64 ¶

func GteSVU64(a uint64, b []uint64, retVal []bool)

func GteSVU8 ¶

func GteSVU8(a uint8, b []uint8, retVal []bool)

func GteSameF32 ¶

func GteSameF32(a []float32, b []float32)

func GteSameF64 ¶

func GteSameF64(a []float64, b []float64)

func GteSameI ¶

func GteSameI(a []int, b []int)

func GteSameI16 ¶

func GteSameI16(a []int16, b []int16)

func GteSameI32 ¶

func GteSameI32(a []int32, b []int32)

func GteSameI64 ¶

func GteSameI64(a []int64, b []int64)

func GteSameI8 ¶

func GteSameI8(a []int8, b []int8)

func GteSameIterF32 ¶

func GteSameIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)

func GteSameIterF64 ¶

func GteSameIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)

func GteSameIterI ¶

func GteSameIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)

func GteSameIterI16 ¶

func GteSameIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)

func GteSameIterI32 ¶

func GteSameIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)

func GteSameIterI64 ¶

func GteSameIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)

func GteSameIterI8 ¶

func GteSameIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)

func GteSameIterSVF32 ¶

func GteSameIterSVF32(a float32, b []float32, bit Iterator) (err error)

func GteSameIterSVF64 ¶

func GteSameIterSVF64(a float64, b []float64, bit Iterator) (err error)

func GteSameIterSVI ¶

func GteSameIterSVI(a int, b []int, bit Iterator) (err error)

func GteSameIterSVI16 ¶

func GteSameIterSVI16(a int16, b []int16, bit Iterator) (err error)

func GteSameIterSVI32 ¶

func GteSameIterSVI32(a int32, b []int32, bit Iterator) (err error)

func GteSameIterSVI64 ¶

func GteSameIterSVI64(a int64, b []int64, bit Iterator) (err error)

func GteSameIterSVI8 ¶

func GteSameIterSVI8(a int8, b []int8, bit Iterator) (err error)

func GteSameIterSVStr ¶

func GteSameIterSVStr(a string, b []string, bit Iterator) (err error)

func GteSameIterSVU ¶

func GteSameIterSVU(a uint, b []uint, bit Iterator) (err error)

func GteSameIterSVU16 ¶

func GteSameIterSVU16(a uint16, b []uint16, bit Iterator) (err error)

func GteSameIterSVU32 ¶

func GteSameIterSVU32(a uint32, b []uint32, bit Iterator) (err error)

func GteSameIterSVU64 ¶

func GteSameIterSVU64(a uint64, b []uint64, bit Iterator) (err error)

func GteSameIterSVU8 ¶

func GteSameIterSVU8(a uint8, b []uint8, bit Iterator) (err error)

func GteSameIterStr ¶

func GteSameIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)

func GteSameIterU ¶

func GteSameIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)

func GteSameIterU16 ¶

func GteSameIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)

func GteSameIterU32 ¶

func GteSameIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)

func GteSameIterU64 ¶

func GteSameIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)

func GteSameIterU8 ¶

func GteSameIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)

func GteSameIterVSF32 ¶

func GteSameIterVSF32(a []float32, b float32, ait Iterator) (err error)

func GteSameIterVSF64 ¶

func GteSameIterVSF64(a []float64, b float64, ait Iterator) (err error)

func GteSameIterVSI ¶

func GteSameIterVSI(a []int, b int, ait Iterator) (err error)

func GteSameIterVSI16 ¶

func GteSameIterVSI16(a []int16, b int16, ait Iterator) (err error)

func GteSameIterVSI32 ¶

func GteSameIterVSI32(a []int32, b int32, ait Iterator) (err error)

func GteSameIterVSI64 ¶

func GteSameIterVSI64(a []int64, b int64, ait Iterator) (err error)

func GteSameIterVSI8 ¶

func GteSameIterVSI8(a []int8, b int8, ait Iterator) (err error)

func GteSameIterVSStr ¶

func GteSameIterVSStr(a []string, b string, ait Iterator) (err error)

func GteSameIterVSU ¶

func GteSameIterVSU(a []uint, b uint, ait Iterator) (err error)

func GteSameIterVSU16 ¶

func GteSameIterVSU16(a []uint16, b uint16, ait Iterator) (err error)

func GteSameIterVSU32 ¶

func GteSameIterVSU32(a []uint32, b uint32, ait Iterator) (err error)

func GteSameIterVSU64 ¶

func GteSameIterVSU64(a []uint64, b uint64, ait Iterator) (err error)

func GteSameIterVSU8 ¶

func GteSameIterVSU8(a []uint8, b uint8, ait Iterator) (err error)

func GteSameSVF32 ¶

func GteSameSVF32(a float32, b []float32)

func GteSameSVF64 ¶

func GteSameSVF64(a float64, b []float64)

func GteSameSVI ¶

func GteSameSVI(a int, b []int)

func GteSameSVI16 ¶

func GteSameSVI16(a int16, b []int16)

func GteSameSVI32 ¶

func GteSameSVI32(a int32, b []int32)

func GteSameSVI64 ¶

func GteSameSVI64(a int64, b []int64)

func GteSameSVI8 ¶

func GteSameSVI8(a int8, b []int8)

func GteSameSVStr ¶

func GteSameSVStr(a string, b []string)

func GteSameSVU ¶

func GteSameSVU(a uint, b []uint)

func GteSameSVU16 ¶

func GteSameSVU16(a uint16, b []uint16)

func GteSameSVU32 ¶

func GteSameSVU32(a uint32, b []uint32)

func GteSameSVU64 ¶

func GteSameSVU64(a uint64, b []uint64)

func GteSameSVU8 ¶

func GteSameSVU8(a uint8, b []uint8)

func GteSameStr ¶

func GteSameStr(a []string, b []string)

func GteSameU ¶

func GteSameU(a []uint, b []uint)

func GteSameU16 ¶

func GteSameU16(a []uint16, b []uint16)

func GteSameU32 ¶

func GteSameU32(a []uint32, b []uint32)

func GteSameU64 ¶

func GteSameU64(a []uint64, b []uint64)

func GteSameU8 ¶

func GteSameU8(a []uint8, b []uint8)

func GteSameVSF32 ¶

func GteSameVSF32(a []float32, b float32)

func GteSameVSF64 ¶

func GteSameVSF64(a []float64, b float64)

func GteSameVSI ¶

func GteSameVSI(a []int, b int)

func GteSameVSI16 ¶

func GteSameVSI16(a []int16, b int16)

func GteSameVSI32 ¶

func GteSameVSI32(a []int32, b int32)

func GteSameVSI64 ¶

func GteSameVSI64(a []int64, b int64)

func GteSameVSI8 ¶

func GteSameVSI8(a []int8, b int8)

func GteSameVSStr ¶

func GteSameVSStr(a []string, b string)

func GteSameVSU ¶

func GteSameVSU(a []uint, b uint)

func GteSameVSU16 ¶

func GteSameVSU16(a []uint16, b uint16)

func GteSameVSU32 ¶

func GteSameVSU32(a []uint32, b uint32)

func GteSameVSU64 ¶

func GteSameVSU64(a []uint64, b uint64)

func GteSameVSU8 ¶

func GteSameVSU8(a []uint8, b uint8)

func GteStr ¶

func GteStr(a []string, b []string, retVal []bool)

func GteU ¶

func GteU(a []uint, b []uint, retVal []bool)

func GteU16 ¶

func GteU16(a []uint16, b []uint16, retVal []bool)

func GteU32 ¶

func GteU32(a []uint32, b []uint32, retVal []bool)

func GteU64 ¶

func GteU64(a []uint64, b []uint64, retVal []bool)

func GteU8 ¶

func GteU8(a []uint8, b []uint8, retVal []bool)

func GteVSF32 ¶

func GteVSF32(a []float32, b float32, retVal []bool)

func GteVSF64 ¶

func GteVSF64(a []float64, b float64, retVal []bool)

func GteVSI ¶

func GteVSI(a []int, b int, retVal []bool)

func GteVSI16 ¶

func GteVSI16(a []int16, b int16, retVal []bool)

func GteVSI32 ¶

func GteVSI32(a []int32, b int32, retVal []bool)

func GteVSI64 ¶

func GteVSI64(a []int64, b int64, retVal []bool)

func GteVSI8 ¶

func GteVSI8(a []int8, b int8, retVal []bool)

func GteVSStr ¶

func GteVSStr(a []string, b string, retVal []bool)

func GteVSU ¶

func GteVSU(a []uint, b uint, retVal []bool)

func GteVSU16 ¶

func GteVSU16(a []uint16, b uint16, retVal []bool)

func GteVSU32 ¶

func GteVSU32(a []uint32, b uint32, retVal []bool)

func GteVSU64 ¶

func GteVSU64(a []uint64, b uint64, retVal []bool)

func GteVSU8 ¶

func GteVSU8(a []uint8, b uint8, retVal []bool)

func InvC128 ¶

func InvC128(a []complex128)

func InvC64 ¶

func InvC64(a []complex64)

func InvF32 ¶

func InvF32(a []float32)

func InvF64 ¶

func InvF64(a []float64)

func InvI ¶

func InvI(a []int)

func InvI16 ¶

func InvI16(a []int16)

func InvI32 ¶

func InvI32(a []int32)

func InvI64 ¶

func InvI64(a []int64)

func InvI8 ¶

func InvI8(a []int8)

func InvIterC128 ¶

func InvIterC128(a []complex128, ait Iterator) (err error)

func InvIterC64 ¶

func InvIterC64(a []complex64, ait Iterator) (err error)

func InvIterF32 ¶

func InvIterF32(a []float32, ait Iterator) (err error)

func InvIterF64 ¶

func InvIterF64(a []float64, ait Iterator) (err error)

func InvIterI ¶

func InvIterI(a []int, ait Iterator) (err error)

func InvIterI16 ¶

func InvIterI16(a []int16, ait Iterator) (err error)

func InvIterI32 ¶

func InvIterI32(a []int32, ait Iterator) (err error)

func InvIterI64 ¶

func InvIterI64(a []int64, ait Iterator) (err error)

func InvIterI8 ¶

func InvIterI8(a []int8, ait Iterator) (err error)

func InvIterU ¶

func InvIterU(a []uint, ait Iterator) (err error)

func InvIterU16 ¶

func InvIterU16(a []uint16, ait Iterator) (err error)

func InvIterU32 ¶

func InvIterU32(a []uint32, ait Iterator) (err error)

func InvIterU64 ¶

func InvIterU64(a []uint64, ait Iterator) (err error)

func InvIterU8 ¶

func InvIterU8(a []uint8, ait Iterator) (err error)

func InvSqrtF32 ¶

func InvSqrtF32(a []float32)

func InvSqrtF64 ¶

func InvSqrtF64(a []float64)

func InvSqrtIterF32 ¶

func InvSqrtIterF32(a []float32, ait Iterator) (err error)

func InvSqrtIterF64 ¶

func InvSqrtIterF64(a []float64, ait Iterator) (err error)

func InvU ¶

func InvU(a []uint)

func InvU16 ¶

func InvU16(a []uint16)

func InvU32 ¶

func InvU32(a []uint32)

func InvU64 ¶

func InvU64(a []uint64)

func InvU8 ¶

func InvU8(a []uint8)

func Log10C128 ¶

func Log10C128(a []complex128)

func Log10C64 ¶

func Log10C64(a []complex64)

func Log10F32 ¶

func Log10F32(a []float32)

func Log10F64 ¶

func Log10F64(a []float64)

func Log10IterC128 ¶

func Log10IterC128(a []complex128, ait Iterator) (err error)

func Log10IterC64 ¶

func Log10IterC64(a []complex64, ait Iterator) (err error)

func Log10IterF32 ¶

func Log10IterF32(a []float32, ait Iterator) (err error)

func Log10IterF64 ¶

func Log10IterF64(a []float64, ait Iterator) (err error)

func Log2F32 ¶

func Log2F32(a []float32)

func Log2F64 ¶

func Log2F64(a []float64)

func Log2IterF32 ¶

func Log2IterF32(a []float32, ait Iterator) (err error)

func Log2IterF64 ¶

func Log2IterF64(a []float64, ait Iterator) (err error)

func LogC128 ¶

func LogC128(a []complex128)

func LogC64 ¶

func LogC64(a []complex64)

func LogF32 ¶

func LogF32(a []float32)

func LogF64 ¶

func LogF64(a []float64)

func LogIterC128 ¶

func LogIterC128(a []complex128, ait Iterator) (err error)

func LogIterC64 ¶

func LogIterC64(a []complex64, ait Iterator) (err error)

func LogIterF32 ¶

func LogIterF32(a []float32, ait Iterator) (err error)

func LogIterF64 ¶

func LogIterF64(a []float64, ait Iterator) (err error)

func LtF32 ¶

func LtF32(a []float32, b []float32, retVal []bool)

func LtF64 ¶

func LtF64(a []float64, b []float64, retVal []bool)

func LtI ¶

func LtI(a []int, b []int, retVal []bool)

func LtI16 ¶

func LtI16(a []int16, b []int16, retVal []bool)

func LtI32 ¶

func LtI32(a []int32, b []int32, retVal []bool)

func LtI64 ¶

func LtI64(a []int64, b []int64, retVal []bool)

func LtI8 ¶

func LtI8(a []int8, b []int8, retVal []bool)

func LtIterF32 ¶

func LtIterF32(a []float32, b []float32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LtIterF64 ¶

func LtIterF64(a []float64, b []float64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LtIterI ¶

func LtIterI(a []int, b []int, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LtIterI16 ¶

func LtIterI16(a []int16, b []int16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LtIterI32 ¶

func LtIterI32(a []int32, b []int32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LtIterI64 ¶

func LtIterI64(a []int64, b []int64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LtIterI8 ¶

func LtIterI8(a []int8, b []int8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LtIterSVF32 ¶

func LtIterSVF32(a float32, b []float32, retVal []bool, bit Iterator, rit Iterator) (err error)

func LtIterSVF64 ¶

func LtIterSVF64(a float64, b []float64, retVal []bool, bit Iterator, rit Iterator) (err error)

func LtIterSVI ¶

func LtIterSVI(a int, b []int, retVal []bool, bit Iterator, rit Iterator) (err error)

func LtIterSVI16 ¶

func LtIterSVI16(a int16, b []int16, retVal []bool, bit Iterator, rit Iterator) (err error)

func LtIterSVI32 ¶

func LtIterSVI32(a int32, b []int32, retVal []bool, bit Iterator, rit Iterator) (err error)

func LtIterSVI64 ¶

func LtIterSVI64(a int64, b []int64, retVal []bool, bit Iterator, rit Iterator) (err error)

func LtIterSVI8 ¶

func LtIterSVI8(a int8, b []int8, retVal []bool, bit Iterator, rit Iterator) (err error)

func LtIterSVStr ¶

func LtIterSVStr(a string, b []string, retVal []bool, bit Iterator, rit Iterator) (err error)

func LtIterSVU ¶

func LtIterSVU(a uint, b []uint, retVal []bool, bit Iterator, rit Iterator) (err error)

func LtIterSVU16 ¶

func LtIterSVU16(a uint16, b []uint16, retVal []bool, bit Iterator, rit Iterator) (err error)

func LtIterSVU32 ¶

func LtIterSVU32(a uint32, b []uint32, retVal []bool, bit Iterator, rit Iterator) (err error)

func LtIterSVU64 ¶

func LtIterSVU64(a uint64, b []uint64, retVal []bool, bit Iterator, rit Iterator) (err error)

func LtIterSVU8 ¶

func LtIterSVU8(a uint8, b []uint8, retVal []bool, bit Iterator, rit Iterator) (err error)

func LtIterStr ¶

func LtIterStr(a []string, b []string, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LtIterU ¶

func LtIterU(a []uint, b []uint, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LtIterU16 ¶

func LtIterU16(a []uint16, b []uint16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LtIterU32 ¶

func LtIterU32(a []uint32, b []uint32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LtIterU64 ¶

func LtIterU64(a []uint64, b []uint64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LtIterU8 ¶

func LtIterU8(a []uint8, b []uint8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LtIterVSF32 ¶

func LtIterVSF32(a []float32, b float32, retVal []bool, ait Iterator, rit Iterator) (err error)

func LtIterVSF64 ¶

func LtIterVSF64(a []float64, b float64, retVal []bool, ait Iterator, rit Iterator) (err error)

func LtIterVSI ¶

func LtIterVSI(a []int, b int, retVal []bool, ait Iterator, rit Iterator) (err error)

func LtIterVSI16 ¶

func LtIterVSI16(a []int16, b int16, retVal []bool, ait Iterator, rit Iterator) (err error)

func LtIterVSI32 ¶

func LtIterVSI32(a []int32, b int32, retVal []bool, ait Iterator, rit Iterator) (err error)

func LtIterVSI64 ¶

func LtIterVSI64(a []int64, b int64, retVal []bool, ait Iterator, rit Iterator) (err error)

func LtIterVSI8 ¶

func LtIterVSI8(a []int8, b int8, retVal []bool, ait Iterator, rit Iterator) (err error)

func LtIterVSStr ¶

func LtIterVSStr(a []string, b string, retVal []bool, ait Iterator, rit Iterator) (err error)

func LtIterVSU ¶

func LtIterVSU(a []uint, b uint, retVal []bool, ait Iterator, rit Iterator) (err error)

func LtIterVSU16 ¶

func LtIterVSU16(a []uint16, b uint16, retVal []bool, ait Iterator, rit Iterator) (err error)

func LtIterVSU32 ¶

func LtIterVSU32(a []uint32, b uint32, retVal []bool, ait Iterator, rit Iterator) (err error)

func LtIterVSU64 ¶

func LtIterVSU64(a []uint64, b uint64, retVal []bool, ait Iterator, rit Iterator) (err error)

func LtIterVSU8 ¶

func LtIterVSU8(a []uint8, b uint8, retVal []bool, ait Iterator, rit Iterator) (err error)

func LtSVF32 ¶

func LtSVF32(a float32, b []float32, retVal []bool)

func LtSVF64 ¶

func LtSVF64(a float64, b []float64, retVal []bool)

func LtSVI ¶

func LtSVI(a int, b []int, retVal []bool)

func LtSVI16 ¶

func LtSVI16(a int16, b []int16, retVal []bool)

func LtSVI32 ¶

func LtSVI32(a int32, b []int32, retVal []bool)

func LtSVI64 ¶

func LtSVI64(a int64, b []int64, retVal []bool)

func LtSVI8 ¶

func LtSVI8(a int8, b []int8, retVal []bool)

func LtSVStr ¶

func LtSVStr(a string, b []string, retVal []bool)

func LtSVU ¶

func LtSVU(a uint, b []uint, retVal []bool)

func LtSVU16 ¶

func LtSVU16(a uint16, b []uint16, retVal []bool)

func LtSVU32 ¶

func LtSVU32(a uint32, b []uint32, retVal []bool)

func LtSVU64 ¶

func LtSVU64(a uint64, b []uint64, retVal []bool)

func LtSVU8 ¶

func LtSVU8(a uint8, b []uint8, retVal []bool)

func LtSameF32 ¶

func LtSameF32(a []float32, b []float32)

func LtSameF64 ¶

func LtSameF64(a []float64, b []float64)

func LtSameI ¶

func LtSameI(a []int, b []int)

func LtSameI16 ¶

func LtSameI16(a []int16, b []int16)

func LtSameI32 ¶

func LtSameI32(a []int32, b []int32)

func LtSameI64 ¶

func LtSameI64(a []int64, b []int64)

func LtSameI8 ¶

func LtSameI8(a []int8, b []int8)

func LtSameIterF32 ¶

func LtSameIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)

func LtSameIterF64 ¶

func LtSameIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)

func LtSameIterI ¶

func LtSameIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)

func LtSameIterI16 ¶

func LtSameIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)

func LtSameIterI32 ¶

func LtSameIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)

func LtSameIterI64 ¶

func LtSameIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)

func LtSameIterI8 ¶

func LtSameIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)

func LtSameIterSVF32 ¶

func LtSameIterSVF32(a float32, b []float32, bit Iterator) (err error)

func LtSameIterSVF64 ¶

func LtSameIterSVF64(a float64, b []float64, bit Iterator) (err error)

func LtSameIterSVI ¶

func LtSameIterSVI(a int, b []int, bit Iterator) (err error)

func LtSameIterSVI16 ¶

func LtSameIterSVI16(a int16, b []int16, bit Iterator) (err error)

func LtSameIterSVI32 ¶

func LtSameIterSVI32(a int32, b []int32, bit Iterator) (err error)

func LtSameIterSVI64 ¶

func LtSameIterSVI64(a int64, b []int64, bit Iterator) (err error)

func LtSameIterSVI8 ¶

func LtSameIterSVI8(a int8, b []int8, bit Iterator) (err error)

func LtSameIterSVStr ¶

func LtSameIterSVStr(a string, b []string, bit Iterator) (err error)

func LtSameIterSVU ¶

func LtSameIterSVU(a uint, b []uint, bit Iterator) (err error)

func LtSameIterSVU16 ¶

func LtSameIterSVU16(a uint16, b []uint16, bit Iterator) (err error)

func LtSameIterSVU32 ¶

func LtSameIterSVU32(a uint32, b []uint32, bit Iterator) (err error)

func LtSameIterSVU64 ¶

func LtSameIterSVU64(a uint64, b []uint64, bit Iterator) (err error)

func LtSameIterSVU8 ¶

func LtSameIterSVU8(a uint8, b []uint8, bit Iterator) (err error)

func LtSameIterStr ¶

func LtSameIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)

func LtSameIterU ¶

func LtSameIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)

func LtSameIterU16 ¶

func LtSameIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)

func LtSameIterU32 ¶

func LtSameIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)

func LtSameIterU64 ¶

func LtSameIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)

func LtSameIterU8 ¶

func LtSameIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)

func LtSameIterVSF32 ¶

func LtSameIterVSF32(a []float32, b float32, ait Iterator) (err error)

func LtSameIterVSF64 ¶

func LtSameIterVSF64(a []float64, b float64, ait Iterator) (err error)

func LtSameIterVSI ¶

func LtSameIterVSI(a []int, b int, ait Iterator) (err error)

func LtSameIterVSI16 ¶

func LtSameIterVSI16(a []int16, b int16, ait Iterator) (err error)

func LtSameIterVSI32 ¶

func LtSameIterVSI32(a []int32, b int32, ait Iterator) (err error)

func LtSameIterVSI64 ¶

func LtSameIterVSI64(a []int64, b int64, ait Iterator) (err error)

func LtSameIterVSI8 ¶

func LtSameIterVSI8(a []int8, b int8, ait Iterator) (err error)

func LtSameIterVSStr ¶

func LtSameIterVSStr(a []string, b string, ait Iterator) (err error)

func LtSameIterVSU ¶

func LtSameIterVSU(a []uint, b uint, ait Iterator) (err error)

func LtSameIterVSU16 ¶

func LtSameIterVSU16(a []uint16, b uint16, ait Iterator) (err error)

func LtSameIterVSU32 ¶

func LtSameIterVSU32(a []uint32, b uint32, ait Iterator) (err error)

func LtSameIterVSU64 ¶

func LtSameIterVSU64(a []uint64, b uint64, ait Iterator) (err error)

func LtSameIterVSU8 ¶

func LtSameIterVSU8(a []uint8, b uint8, ait Iterator) (err error)

func LtSameSVF32 ¶

func LtSameSVF32(a float32, b []float32)

func LtSameSVF64 ¶

func LtSameSVF64(a float64, b []float64)

func LtSameSVI ¶

func LtSameSVI(a int, b []int)

func LtSameSVI16 ¶

func LtSameSVI16(a int16, b []int16)

func LtSameSVI32 ¶

func LtSameSVI32(a int32, b []int32)

func LtSameSVI64 ¶

func LtSameSVI64(a int64, b []int64)

func LtSameSVI8 ¶

func LtSameSVI8(a int8, b []int8)

func LtSameSVStr ¶

func LtSameSVStr(a string, b []string)

func LtSameSVU ¶

func LtSameSVU(a uint, b []uint)

func LtSameSVU16 ¶

func LtSameSVU16(a uint16, b []uint16)

func LtSameSVU32 ¶

func LtSameSVU32(a uint32, b []uint32)

func LtSameSVU64 ¶

func LtSameSVU64(a uint64, b []uint64)

func LtSameSVU8 ¶

func LtSameSVU8(a uint8, b []uint8)

func LtSameStr ¶

func LtSameStr(a []string, b []string)

func LtSameU ¶

func LtSameU(a []uint, b []uint)

func LtSameU16 ¶

func LtSameU16(a []uint16, b []uint16)

func LtSameU32 ¶

func LtSameU32(a []uint32, b []uint32)

func LtSameU64 ¶

func LtSameU64(a []uint64, b []uint64)

func LtSameU8 ¶

func LtSameU8(a []uint8, b []uint8)

func LtSameVSF32 ¶

func LtSameVSF32(a []float32, b float32)

func LtSameVSF64 ¶

func LtSameVSF64(a []float64, b float64)

func LtSameVSI ¶

func LtSameVSI(a []int, b int)

func LtSameVSI16 ¶

func LtSameVSI16(a []int16, b int16)

func LtSameVSI32 ¶

func LtSameVSI32(a []int32, b int32)

func LtSameVSI64 ¶

func LtSameVSI64(a []int64, b int64)

func LtSameVSI8 ¶

func LtSameVSI8(a []int8, b int8)

func LtSameVSStr ¶

func LtSameVSStr(a []string, b string)

func LtSameVSU ¶

func LtSameVSU(a []uint, b uint)

func LtSameVSU16 ¶

func LtSameVSU16(a []uint16, b uint16)

func LtSameVSU32 ¶

func LtSameVSU32(a []uint32, b uint32)

func LtSameVSU64 ¶

func LtSameVSU64(a []uint64, b uint64)

func LtSameVSU8 ¶

func LtSameVSU8(a []uint8, b uint8)

func LtStr ¶

func LtStr(a []string, b []string, retVal []bool)

func LtU ¶

func LtU(a []uint, b []uint, retVal []bool)

func LtU16 ¶

func LtU16(a []uint16, b []uint16, retVal []bool)

func LtU32 ¶

func LtU32(a []uint32, b []uint32, retVal []bool)

func LtU64 ¶

func LtU64(a []uint64, b []uint64, retVal []bool)

func LtU8 ¶

func LtU8(a []uint8, b []uint8, retVal []bool)

func LtVSF32 ¶

func LtVSF32(a []float32, b float32, retVal []bool)

func LtVSF64 ¶

func LtVSF64(a []float64, b float64, retVal []bool)

func LtVSI ¶

func LtVSI(a []int, b int, retVal []bool)

func LtVSI16 ¶

func LtVSI16(a []int16, b int16, retVal []bool)

func LtVSI32 ¶

func LtVSI32(a []int32, b int32, retVal []bool)

func LtVSI64 ¶

func LtVSI64(a []int64, b int64, retVal []bool)

func LtVSI8 ¶

func LtVSI8(a []int8, b int8, retVal []bool)

func LtVSStr ¶

func LtVSStr(a []string, b string, retVal []bool)

func LtVSU ¶

func LtVSU(a []uint, b uint, retVal []bool)

func LtVSU16 ¶

func LtVSU16(a []uint16, b uint16, retVal []bool)

func LtVSU32 ¶

func LtVSU32(a []uint32, b uint32, retVal []bool)

func LtVSU64 ¶

func LtVSU64(a []uint64, b uint64, retVal []bool)

func LtVSU8 ¶

func LtVSU8(a []uint8, b uint8, retVal []bool)

func LteF32 ¶

func LteF32(a []float32, b []float32, retVal []bool)

func LteF64 ¶

func LteF64(a []float64, b []float64, retVal []bool)

func LteI ¶

func LteI(a []int, b []int, retVal []bool)

func LteI16 ¶

func LteI16(a []int16, b []int16, retVal []bool)

func LteI32 ¶

func LteI32(a []int32, b []int32, retVal []bool)

func LteI64 ¶

func LteI64(a []int64, b []int64, retVal []bool)

func LteI8 ¶

func LteI8(a []int8, b []int8, retVal []bool)

func LteIterF32 ¶

func LteIterF32(a []float32, b []float32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LteIterF64 ¶

func LteIterF64(a []float64, b []float64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LteIterI ¶

func LteIterI(a []int, b []int, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LteIterI16 ¶

func LteIterI16(a []int16, b []int16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LteIterI32 ¶

func LteIterI32(a []int32, b []int32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LteIterI64 ¶

func LteIterI64(a []int64, b []int64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LteIterI8 ¶

func LteIterI8(a []int8, b []int8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LteIterSVF32 ¶

func LteIterSVF32(a float32, b []float32, retVal []bool, bit Iterator, rit Iterator) (err error)

func LteIterSVF64 ¶

func LteIterSVF64(a float64, b []float64, retVal []bool, bit Iterator, rit Iterator) (err error)

func LteIterSVI ¶

func LteIterSVI(a int, b []int, retVal []bool, bit Iterator, rit Iterator) (err error)

func LteIterSVI16 ¶

func LteIterSVI16(a int16, b []int16, retVal []bool, bit Iterator, rit Iterator) (err error)

func LteIterSVI32 ¶

func LteIterSVI32(a int32, b []int32, retVal []bool, bit Iterator, rit Iterator) (err error)

func LteIterSVI64 ¶

func LteIterSVI64(a int64, b []int64, retVal []bool, bit Iterator, rit Iterator) (err error)

func LteIterSVI8 ¶

func LteIterSVI8(a int8, b []int8, retVal []bool, bit Iterator, rit Iterator) (err error)

func LteIterSVStr ¶

func LteIterSVStr(a string, b []string, retVal []bool, bit Iterator, rit Iterator) (err error)

func LteIterSVU ¶

func LteIterSVU(a uint, b []uint, retVal []bool, bit Iterator, rit Iterator) (err error)

func LteIterSVU16 ¶

func LteIterSVU16(a uint16, b []uint16, retVal []bool, bit Iterator, rit Iterator) (err error)

func LteIterSVU32 ¶

func LteIterSVU32(a uint32, b []uint32, retVal []bool, bit Iterator, rit Iterator) (err error)

func LteIterSVU64 ¶

func LteIterSVU64(a uint64, b []uint64, retVal []bool, bit Iterator, rit Iterator) (err error)

func LteIterSVU8 ¶

func LteIterSVU8(a uint8, b []uint8, retVal []bool, bit Iterator, rit Iterator) (err error)

func LteIterStr ¶

func LteIterStr(a []string, b []string, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LteIterU ¶

func LteIterU(a []uint, b []uint, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LteIterU16 ¶

func LteIterU16(a []uint16, b []uint16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LteIterU32 ¶

func LteIterU32(a []uint32, b []uint32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LteIterU64 ¶

func LteIterU64(a []uint64, b []uint64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LteIterU8 ¶

func LteIterU8(a []uint8, b []uint8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func LteIterVSF32 ¶

func LteIterVSF32(a []float32, b float32, retVal []bool, ait Iterator, rit Iterator) (err error)

func LteIterVSF64 ¶

func LteIterVSF64(a []float64, b float64, retVal []bool, ait Iterator, rit Iterator) (err error)

func LteIterVSI ¶

func LteIterVSI(a []int, b int, retVal []bool, ait Iterator, rit Iterator) (err error)

func LteIterVSI16 ¶

func LteIterVSI16(a []int16, b int16, retVal []bool, ait Iterator, rit Iterator) (err error)

func LteIterVSI32 ¶

func LteIterVSI32(a []int32, b int32, retVal []bool, ait Iterator, rit Iterator) (err error)

func LteIterVSI64 ¶

func LteIterVSI64(a []int64, b int64, retVal []bool, ait Iterator, rit Iterator) (err error)

func LteIterVSI8 ¶

func LteIterVSI8(a []int8, b int8, retVal []bool, ait Iterator, rit Iterator) (err error)

func LteIterVSStr ¶

func LteIterVSStr(a []string, b string, retVal []bool, ait Iterator, rit Iterator) (err error)

func LteIterVSU ¶

func LteIterVSU(a []uint, b uint, retVal []bool, ait Iterator, rit Iterator) (err error)

func LteIterVSU16 ¶

func LteIterVSU16(a []uint16, b uint16, retVal []bool, ait Iterator, rit Iterator) (err error)

func LteIterVSU32 ¶

func LteIterVSU32(a []uint32, b uint32, retVal []bool, ait Iterator, rit Iterator) (err error)

func LteIterVSU64 ¶

func LteIterVSU64(a []uint64, b uint64, retVal []bool, ait Iterator, rit Iterator) (err error)

func LteIterVSU8 ¶

func LteIterVSU8(a []uint8, b uint8, retVal []bool, ait Iterator, rit Iterator) (err error)

func LteSVF32 ¶

func LteSVF32(a float32, b []float32, retVal []bool)

func LteSVF64 ¶

func LteSVF64(a float64, b []float64, retVal []bool)

func LteSVI ¶

func LteSVI(a int, b []int, retVal []bool)

func LteSVI16 ¶

func LteSVI16(a int16, b []int16, retVal []bool)

func LteSVI32 ¶

func LteSVI32(a int32, b []int32, retVal []bool)

func LteSVI64 ¶

func LteSVI64(a int64, b []int64, retVal []bool)

func LteSVI8 ¶

func LteSVI8(a int8, b []int8, retVal []bool)

func LteSVStr ¶

func LteSVStr(a string, b []string, retVal []bool)

func LteSVU ¶

func LteSVU(a uint, b []uint, retVal []bool)

func LteSVU16 ¶

func LteSVU16(a uint16, b []uint16, retVal []bool)

func LteSVU32 ¶

func LteSVU32(a uint32, b []uint32, retVal []bool)

func LteSVU64 ¶

func LteSVU64(a uint64, b []uint64, retVal []bool)

func LteSVU8 ¶

func LteSVU8(a uint8, b []uint8, retVal []bool)

func LteSameF32 ¶

func LteSameF32(a []float32, b []float32)

func LteSameF64 ¶

func LteSameF64(a []float64, b []float64)

func LteSameI ¶

func LteSameI(a []int, b []int)

func LteSameI16 ¶

func LteSameI16(a []int16, b []int16)

func LteSameI32 ¶

func LteSameI32(a []int32, b []int32)

func LteSameI64 ¶

func LteSameI64(a []int64, b []int64)

func LteSameI8 ¶

func LteSameI8(a []int8, b []int8)

func LteSameIterF32 ¶

func LteSameIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)

func LteSameIterF64 ¶

func LteSameIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)

func LteSameIterI ¶

func LteSameIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)

func LteSameIterI16 ¶

func LteSameIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)

func LteSameIterI32 ¶

func LteSameIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)

func LteSameIterI64 ¶

func LteSameIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)

func LteSameIterI8 ¶

func LteSameIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)

func LteSameIterSVF32 ¶

func LteSameIterSVF32(a float32, b []float32, bit Iterator) (err error)

func LteSameIterSVF64 ¶

func LteSameIterSVF64(a float64, b []float64, bit Iterator) (err error)

func LteSameIterSVI ¶

func LteSameIterSVI(a int, b []int, bit Iterator) (err error)

func LteSameIterSVI16 ¶

func LteSameIterSVI16(a int16, b []int16, bit Iterator) (err error)

func LteSameIterSVI32 ¶

func LteSameIterSVI32(a int32, b []int32, bit Iterator) (err error)

func LteSameIterSVI64 ¶

func LteSameIterSVI64(a int64, b []int64, bit Iterator) (err error)

func LteSameIterSVI8 ¶

func LteSameIterSVI8(a int8, b []int8, bit Iterator) (err error)

func LteSameIterSVStr ¶

func LteSameIterSVStr(a string, b []string, bit Iterator) (err error)

func LteSameIterSVU ¶

func LteSameIterSVU(a uint, b []uint, bit Iterator) (err error)

func LteSameIterSVU16 ¶

func LteSameIterSVU16(a uint16, b []uint16, bit Iterator) (err error)

func LteSameIterSVU32 ¶

func LteSameIterSVU32(a uint32, b []uint32, bit Iterator) (err error)

func LteSameIterSVU64 ¶

func LteSameIterSVU64(a uint64, b []uint64, bit Iterator) (err error)

func LteSameIterSVU8 ¶

func LteSameIterSVU8(a uint8, b []uint8, bit Iterator) (err error)

func LteSameIterStr ¶

func LteSameIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)

func LteSameIterU ¶

func LteSameIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)

func LteSameIterU16 ¶

func LteSameIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)

func LteSameIterU32 ¶

func LteSameIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)

func LteSameIterU64 ¶

func LteSameIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)

func LteSameIterU8 ¶

func LteSameIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)

func LteSameIterVSF32 ¶

func LteSameIterVSF32(a []float32, b float32, ait Iterator) (err error)

func LteSameIterVSF64 ¶

func LteSameIterVSF64(a []float64, b float64, ait Iterator) (err error)

func LteSameIterVSI ¶

func LteSameIterVSI(a []int, b int, ait Iterator) (err error)

func LteSameIterVSI16 ¶

func LteSameIterVSI16(a []int16, b int16, ait Iterator) (err error)

func LteSameIterVSI32 ¶

func LteSameIterVSI32(a []int32, b int32, ait Iterator) (err error)

func LteSameIterVSI64 ¶

func LteSameIterVSI64(a []int64, b int64, ait Iterator) (err error)

func LteSameIterVSI8 ¶

func LteSameIterVSI8(a []int8, b int8, ait Iterator) (err error)

func LteSameIterVSStr ¶

func LteSameIterVSStr(a []string, b string, ait Iterator) (err error)

func LteSameIterVSU ¶

func LteSameIterVSU(a []uint, b uint, ait Iterator) (err error)

func LteSameIterVSU16 ¶

func LteSameIterVSU16(a []uint16, b uint16, ait Iterator) (err error)

func LteSameIterVSU32 ¶

func LteSameIterVSU32(a []uint32, b uint32, ait Iterator) (err error)

func LteSameIterVSU64 ¶

func LteSameIterVSU64(a []uint64, b uint64, ait Iterator) (err error)

func LteSameIterVSU8 ¶

func LteSameIterVSU8(a []uint8, b uint8, ait Iterator) (err error)

func LteSameSVF32 ¶

func LteSameSVF32(a float32, b []float32)

func LteSameSVF64 ¶

func LteSameSVF64(a float64, b []float64)

func LteSameSVI ¶

func LteSameSVI(a int, b []int)

func LteSameSVI16 ¶

func LteSameSVI16(a int16, b []int16)

func LteSameSVI32 ¶

func LteSameSVI32(a int32, b []int32)

func LteSameSVI64 ¶

func LteSameSVI64(a int64, b []int64)

func LteSameSVI8 ¶

func LteSameSVI8(a int8, b []int8)

func LteSameSVStr ¶

func LteSameSVStr(a string, b []string)

func LteSameSVU ¶

func LteSameSVU(a uint, b []uint)

func LteSameSVU16 ¶

func LteSameSVU16(a uint16, b []uint16)

func LteSameSVU32 ¶

func LteSameSVU32(a uint32, b []uint32)

func LteSameSVU64 ¶

func LteSameSVU64(a uint64, b []uint64)

func LteSameSVU8 ¶

func LteSameSVU8(a uint8, b []uint8)

func LteSameStr ¶

func LteSameStr(a []string, b []string)

func LteSameU ¶

func LteSameU(a []uint, b []uint)

func LteSameU16 ¶

func LteSameU16(a []uint16, b []uint16)

func LteSameU32 ¶

func LteSameU32(a []uint32, b []uint32)

func LteSameU64 ¶

func LteSameU64(a []uint64, b []uint64)

func LteSameU8 ¶

func LteSameU8(a []uint8, b []uint8)

func LteSameVSF32 ¶

func LteSameVSF32(a []float32, b float32)

func LteSameVSF64 ¶

func LteSameVSF64(a []float64, b float64)

func LteSameVSI ¶

func LteSameVSI(a []int, b int)

func LteSameVSI16 ¶

func LteSameVSI16(a []int16, b int16)

func LteSameVSI32 ¶

func LteSameVSI32(a []int32, b int32)

func LteSameVSI64 ¶

func LteSameVSI64(a []int64, b int64)

func LteSameVSI8 ¶

func LteSameVSI8(a []int8, b int8)

func LteSameVSStr ¶

func LteSameVSStr(a []string, b string)

func LteSameVSU ¶

func LteSameVSU(a []uint, b uint)

func LteSameVSU16 ¶

func LteSameVSU16(a []uint16, b uint16)

func LteSameVSU32 ¶

func LteSameVSU32(a []uint32, b uint32)

func LteSameVSU64 ¶

func LteSameVSU64(a []uint64, b uint64)

func LteSameVSU8 ¶

func LteSameVSU8(a []uint8, b uint8)

func LteStr ¶

func LteStr(a []string, b []string, retVal []bool)

func LteU ¶

func LteU(a []uint, b []uint, retVal []bool)

func LteU16 ¶

func LteU16(a []uint16, b []uint16, retVal []bool)

func LteU32 ¶

func LteU32(a []uint32, b []uint32, retVal []bool)

func LteU64 ¶

func LteU64(a []uint64, b []uint64, retVal []bool)

func LteU8 ¶

func LteU8(a []uint8, b []uint8, retVal []bool)

func LteVSF32 ¶

func LteVSF32(a []float32, b float32, retVal []bool)

func LteVSF64 ¶

func LteVSF64(a []float64, b float64, retVal []bool)

func LteVSI ¶

func LteVSI(a []int, b int, retVal []bool)

func LteVSI16 ¶

func LteVSI16(a []int16, b int16, retVal []bool)

func LteVSI32 ¶

func LteVSI32(a []int32, b int32, retVal []bool)

func LteVSI64 ¶

func LteVSI64(a []int64, b int64, retVal []bool)

func LteVSI8 ¶

func LteVSI8(a []int8, b int8, retVal []bool)

func LteVSStr ¶

func LteVSStr(a []string, b string, retVal []bool)

func LteVSU ¶

func LteVSU(a []uint, b uint, retVal []bool)

func LteVSU16 ¶

func LteVSU16(a []uint16, b uint16, retVal []bool)

func LteVSU32 ¶

func LteVSU32(a []uint32, b uint32, retVal []bool)

func LteVSU64 ¶

func LteVSU64(a []uint64, b uint64, retVal []bool)

func LteVSU8 ¶

func LteVSU8(a []uint8, b uint8, retVal []bool)

func MapB ¶

func MapB(fn func(bool) bool, a []bool)

func MapC128 ¶

func MapC128(fn func(complex128) complex128, a []complex128)

func MapC64 ¶

func MapC64(fn func(complex64) complex64, a []complex64)

func MapErrB ¶

func MapErrB(fn func(bool) (bool, error), a []bool) (err error)

func MapErrC128 ¶

func MapErrC128(fn func(complex128) (complex128, error), a []complex128) (err error)

func MapErrC64 ¶

func MapErrC64(fn func(complex64) (complex64, error), a []complex64) (err error)

func MapErrF32 ¶

func MapErrF32(fn func(float32) (float32, error), a []float32) (err error)

func MapErrF64 ¶

func MapErrF64(fn func(float64) (float64, error), a []float64) (err error)

func MapErrI ¶

func MapErrI(fn func(int) (int, error), a []int) (err error)

func MapErrI16 ¶

func MapErrI16(fn func(int16) (int16, error), a []int16) (err error)

func MapErrI32 ¶

func MapErrI32(fn func(int32) (int32, error), a []int32) (err error)

func MapErrI64 ¶

func MapErrI64(fn func(int64) (int64, error), a []int64) (err error)

func MapErrI8 ¶

func MapErrI8(fn func(int8) (int8, error), a []int8) (err error)

func MapErrStr ¶

func MapErrStr(fn func(string) (string, error), a []string) (err error)

func MapErrU ¶

func MapErrU(fn func(uint) (uint, error), a []uint) (err error)

func MapErrU16 ¶

func MapErrU16(fn func(uint16) (uint16, error), a []uint16) (err error)

func MapErrU32 ¶

func MapErrU32(fn func(uint32) (uint32, error), a []uint32) (err error)

func MapErrU64 ¶

func MapErrU64(fn func(uint64) (uint64, error), a []uint64) (err error)

func MapErrU8 ¶

func MapErrU8(fn func(uint8) (uint8, error), a []uint8) (err error)

func MapErrUintptr ¶

func MapErrUintptr(fn func(uintptr) (uintptr, error), a []uintptr) (err error)

func MapErrUnsafePointer ¶

func MapErrUnsafePointer(fn func(unsafe.Pointer) (unsafe.Pointer, error), a []unsafe.Pointer) (err error)

func MapF32 ¶

func MapF32(fn func(float32) float32, a []float32)

func MapF64 ¶

func MapF64(fn func(float64) float64, a []float64)

func MapI ¶

func MapI(fn func(int) int, a []int)

func MapI16 ¶

func MapI16(fn func(int16) int16, a []int16)

func MapI32 ¶

func MapI32(fn func(int32) int32, a []int32)

func MapI64 ¶

func MapI64(fn func(int64) int64, a []int64)

func MapI8 ¶

func MapI8(fn func(int8) int8, a []int8)

func MapIncrC128 ¶

func MapIncrC128(fn func(complex128) complex128, a []complex128)

func MapIncrC64 ¶

func MapIncrC64(fn func(complex64) complex64, a []complex64)

func MapIncrErrC128 ¶

func MapIncrErrC128(fn func(complex128) (complex128, error), a []complex128) (err error)

func MapIncrErrC64 ¶

func MapIncrErrC64(fn func(complex64) (complex64, error), a []complex64) (err error)

func MapIncrErrF32 ¶

func MapIncrErrF32(fn func(float32) (float32, error), a []float32) (err error)

func MapIncrErrF64 ¶

func MapIncrErrF64(fn func(float64) (float64, error), a []float64) (err error)

func MapIncrErrI ¶

func MapIncrErrI(fn func(int) (int, error), a []int) (err error)

func MapIncrErrI16 ¶

func MapIncrErrI16(fn func(int16) (int16, error), a []int16) (err error)

func MapIncrErrI32 ¶

func MapIncrErrI32(fn func(int32) (int32, error), a []int32) (err error)

func MapIncrErrI64 ¶

func MapIncrErrI64(fn func(int64) (int64, error), a []int64) (err error)

func MapIncrErrI8 ¶

func MapIncrErrI8(fn func(int8) (int8, error), a []int8) (err error)

func MapIncrErrStr ¶

func MapIncrErrStr(fn func(string) (string, error), a []string) (err error)

func MapIncrErrU ¶

func MapIncrErrU(fn func(uint) (uint, error), a []uint) (err error)

func MapIncrErrU16 ¶

func MapIncrErrU16(fn func(uint16) (uint16, error), a []uint16) (err error)

func MapIncrErrU32 ¶

func MapIncrErrU32(fn func(uint32) (uint32, error), a []uint32) (err error)

func MapIncrErrU64 ¶

func MapIncrErrU64(fn func(uint64) (uint64, error), a []uint64) (err error)

func MapIncrErrU8 ¶

func MapIncrErrU8(fn func(uint8) (uint8, error), a []uint8) (err error)

func MapIncrF32 ¶

func MapIncrF32(fn func(float32) float32, a []float32)

func MapIncrF64 ¶

func MapIncrF64(fn func(float64) float64, a []float64)

func MapIncrI ¶

func MapIncrI(fn func(int) int, a []int)

func MapIncrI16 ¶

func MapIncrI16(fn func(int16) int16, a []int16)

func MapIncrI32 ¶

func MapIncrI32(fn func(int32) int32, a []int32)

func MapIncrI64 ¶

func MapIncrI64(fn func(int64) int64, a []int64)

func MapIncrI8 ¶

func MapIncrI8(fn func(int8) int8, a []int8)

func MapIncrStr ¶

func MapIncrStr(fn func(string) string, a []string)

func MapIncrU ¶

func MapIncrU(fn func(uint) uint, a []uint)

func MapIncrU16 ¶

func MapIncrU16(fn func(uint16) uint16, a []uint16)

func MapIncrU32 ¶

func MapIncrU32(fn func(uint32) uint32, a []uint32)

func MapIncrU64 ¶

func MapIncrU64(fn func(uint64) uint64, a []uint64)

func MapIncrU8 ¶

func MapIncrU8(fn func(uint8) uint8, a []uint8)

func MapIterB ¶

func MapIterB(fn func(bool) bool, a []bool, ait Iterator) (err error)

func MapIterC128 ¶

func MapIterC128(fn func(complex128) complex128, a []complex128, ait Iterator) (err error)

func MapIterC64 ¶

func MapIterC64(fn func(complex64) complex64, a []complex64, ait Iterator) (err error)

func MapIterErrB ¶

func MapIterErrB(fn func(bool) (bool, error), a []bool, ait Iterator) (err error)

func MapIterErrC128 ¶

func MapIterErrC128(fn func(complex128) (complex128, error), a []complex128, ait Iterator) (err error)

func MapIterErrC64 ¶

func MapIterErrC64(fn func(complex64) (complex64, error), a []complex64, ait Iterator) (err error)

func MapIterErrF32 ¶

func MapIterErrF32(fn func(float32) (float32, error), a []float32, ait Iterator) (err error)

func MapIterErrF64 ¶

func MapIterErrF64(fn func(float64) (float64, error), a []float64, ait Iterator) (err error)

func MapIterErrI ¶

func MapIterErrI(fn func(int) (int, error), a []int, ait Iterator) (err error)

func MapIterErrI16 ¶

func MapIterErrI16(fn func(int16) (int16, error), a []int16, ait Iterator) (err error)

func MapIterErrI32 ¶

func MapIterErrI32(fn func(int32) (int32, error), a []int32, ait Iterator) (err error)

func MapIterErrI64 ¶

func MapIterErrI64(fn func(int64) (int64, error), a []int64, ait Iterator) (err error)

func MapIterErrI8 ¶

func MapIterErrI8(fn func(int8) (int8, error), a []int8, ait Iterator) (err error)

func MapIterErrStr ¶

func MapIterErrStr(fn func(string) (string, error), a []string, ait Iterator) (err error)

func MapIterErrU ¶

func MapIterErrU(fn func(uint) (uint, error), a []uint, ait Iterator) (err error)

func MapIterErrU16 ¶

func MapIterErrU16(fn func(uint16) (uint16, error), a []uint16, ait Iterator) (err error)

func MapIterErrU32 ¶

func MapIterErrU32(fn func(uint32) (uint32, error), a []uint32, ait Iterator) (err error)

func MapIterErrU64 ¶

func MapIterErrU64(fn func(uint64) (uint64, error), a []uint64, ait Iterator) (err error)

func MapIterErrU8 ¶

func MapIterErrU8(fn func(uint8) (uint8, error), a []uint8, ait Iterator) (err error)

func MapIterErrUintptr ¶

func MapIterErrUintptr(fn func(uintptr) (uintptr, error), a []uintptr, ait Iterator) (err error)

func MapIterErrUnsafePointer ¶

func MapIterErrUnsafePointer(fn func(unsafe.Pointer) (unsafe.Pointer, error), a []unsafe.Pointer, ait Iterator) (err error)

func MapIterF32 ¶

func MapIterF32(fn func(float32) float32, a []float32, ait Iterator) (err error)

func MapIterF64 ¶

func MapIterF64(fn func(float64) float64, a []float64, ait Iterator) (err error)

func MapIterI ¶

func MapIterI(fn func(int) int, a []int, ait Iterator) (err error)

func MapIterI16 ¶

func MapIterI16(fn func(int16) int16, a []int16, ait Iterator) (err error)

func MapIterI32 ¶

func MapIterI32(fn func(int32) int32, a []int32, ait Iterator) (err error)

func MapIterI64 ¶

func MapIterI64(fn func(int64) int64, a []int64, ait Iterator) (err error)

func MapIterI8 ¶

func MapIterI8(fn func(int8) int8, a []int8, ait Iterator) (err error)

func MapIterIncrC128 ¶

func MapIterIncrC128(fn func(complex128) complex128, a []complex128, ait Iterator) (err error)

func MapIterIncrC64 ¶

func MapIterIncrC64(fn func(complex64) complex64, a []complex64, ait Iterator) (err error)

func MapIterIncrErrC128 ¶

func MapIterIncrErrC128(fn func(complex128) (complex128, error), a []complex128, ait Iterator) (err error)

func MapIterIncrErrC64 ¶

func MapIterIncrErrC64(fn func(complex64) (complex64, error), a []complex64, ait Iterator) (err error)

func MapIterIncrErrF32 ¶

func MapIterIncrErrF32(fn func(float32) (float32, error), a []float32, ait Iterator) (err error)

func MapIterIncrErrF64 ¶

func MapIterIncrErrF64(fn func(float64) (float64, error), a []float64, ait Iterator) (err error)

func MapIterIncrErrI ¶

func MapIterIncrErrI(fn func(int) (int, error), a []int, ait Iterator) (err error)

func MapIterIncrErrI16 ¶

func MapIterIncrErrI16(fn func(int16) (int16, error), a []int16, ait Iterator) (err error)

func MapIterIncrErrI32 ¶

func MapIterIncrErrI32(fn func(int32) (int32, error), a []int32, ait Iterator) (err error)

func MapIterIncrErrI64 ¶

func MapIterIncrErrI64(fn func(int64) (int64, error), a []int64, ait Iterator) (err error)

func MapIterIncrErrI8 ¶

func MapIterIncrErrI8(fn func(int8) (int8, error), a []int8, ait Iterator) (err error)

func MapIterIncrErrStr ¶

func MapIterIncrErrStr(fn func(string) (string, error), a []string, ait Iterator) (err error)

func MapIterIncrErrU ¶

func MapIterIncrErrU(fn func(uint) (uint, error), a []uint, ait Iterator) (err error)

func MapIterIncrErrU16 ¶

func MapIterIncrErrU16(fn func(uint16) (uint16, error), a []uint16, ait Iterator) (err error)

func MapIterIncrErrU32 ¶

func MapIterIncrErrU32(fn func(uint32) (uint32, error), a []uint32, ait Iterator) (err error)

func MapIterIncrErrU64 ¶

func MapIterIncrErrU64(fn func(uint64) (uint64, error), a []uint64, ait Iterator) (err error)

func MapIterIncrErrU8 ¶

func MapIterIncrErrU8(fn func(uint8) (uint8, error), a []uint8, ait Iterator) (err error)

func MapIterIncrF32 ¶

func MapIterIncrF32(fn func(float32) float32, a []float32, ait Iterator) (err error)

func MapIterIncrF64 ¶

func MapIterIncrF64(fn func(float64) float64, a []float64, ait Iterator) (err error)

func MapIterIncrI ¶

func MapIterIncrI(fn func(int) int, a []int, ait Iterator) (err error)

func MapIterIncrI16 ¶

func MapIterIncrI16(fn func(int16) int16, a []int16, ait Iterator) (err error)

func MapIterIncrI32 ¶

func MapIterIncrI32(fn func(int32) int32, a []int32, ait Iterator) (err error)

func MapIterIncrI64 ¶

func MapIterIncrI64(fn func(int64) int64, a []int64, ait Iterator) (err error)

func MapIterIncrI8 ¶

func MapIterIncrI8(fn func(int8) int8, a []int8, ait Iterator) (err error)

func MapIterIncrStr ¶

func MapIterIncrStr(fn func(string) string, a []string, ait Iterator) (err error)

func MapIterIncrU ¶

func MapIterIncrU(fn func(uint) uint, a []uint, ait Iterator) (err error)

func MapIterIncrU16 ¶

func MapIterIncrU16(fn func(uint16) uint16, a []uint16, ait Iterator) (err error)

func MapIterIncrU32 ¶

func MapIterIncrU32(fn func(uint32) uint32, a []uint32, ait Iterator) (err error)

func MapIterIncrU64 ¶

func MapIterIncrU64(fn func(uint64) uint64, a []uint64, ait Iterator) (err error)

func MapIterIncrU8 ¶

func MapIterIncrU8(fn func(uint8) uint8, a []uint8, ait Iterator) (err error)

func MapIterStr ¶

func MapIterStr(fn func(string) string, a []string, ait Iterator) (err error)

func MapIterU ¶

func MapIterU(fn func(uint) uint, a []uint, ait Iterator) (err error)

func MapIterU16 ¶

func MapIterU16(fn func(uint16) uint16, a []uint16, ait Iterator) (err error)

func MapIterU32 ¶

func MapIterU32(fn func(uint32) uint32, a []uint32, ait Iterator) (err error)

func MapIterU64 ¶

func MapIterU64(fn func(uint64) uint64, a []uint64, ait Iterator) (err error)

func MapIterU8 ¶

func MapIterU8(fn func(uint8) uint8, a []uint8, ait Iterator) (err error)

func MapIterUintptr ¶

func MapIterUintptr(fn func(uintptr) uintptr, a []uintptr, ait Iterator) (err error)

func MapIterUnsafePointer ¶

func MapIterUnsafePointer(fn func(unsafe.Pointer) unsafe.Pointer, a []unsafe.Pointer, ait Iterator) (err error)

func MapStr ¶

func MapStr(fn func(string) string, a []string)

func MapU ¶

func MapU(fn func(uint) uint, a []uint)

func MapU16 ¶

func MapU16(fn func(uint16) uint16, a []uint16)

func MapU32 ¶

func MapU32(fn func(uint32) uint32, a []uint32)

func MapU64 ¶

func MapU64(fn func(uint64) uint64, a []uint64)

func MapU8 ¶

func MapU8(fn func(uint8) uint8, a []uint8)

func MapUintptr ¶

func MapUintptr(fn func(uintptr) uintptr, a []uintptr)

func MapUnsafePointer ¶

func MapUnsafePointer(fn func(unsafe.Pointer) unsafe.Pointer, a []unsafe.Pointer)

func MaxF32 ¶

func MaxF32(a, b float32) (c float32)

func MaxF64 ¶

func MaxF64(a, b float64) (c float64)

func MaxI ¶

func MaxI(a, b int) (c int)

func MaxI16 ¶

func MaxI16(a, b int16) (c int16)

func MaxI32 ¶

func MaxI32(a, b int32) (c int32)

func MaxI64 ¶

func MaxI64(a, b int64) (c int64)

func MaxI8 ¶

func MaxI8(a, b int8) (c int8)

func MaxMethods ¶

func MaxMethods(t reflect.Type) (firstFn, lasFn, defaultFn interface{}, err error)

func MaxStr ¶

func MaxStr(a, b string) (c string)

func MaxU ¶

func MaxU(a, b uint) (c uint)

func MaxU16 ¶

func MaxU16(a, b uint16) (c uint16)

func MaxU32 ¶

func MaxU32(a, b uint32) (c uint32)

func MaxU64 ¶

func MaxU64(a, b uint64) (c uint64)

func MaxU8 ¶

func MaxU8(a, b uint8) (c uint8)

func MinF32 ¶

func MinF32(a, b float32) (c float32)

func MinF64 ¶

func MinF64(a, b float64) (c float64)

func MinI ¶

func MinI(a, b int) (c int)

func MinI16 ¶

func MinI16(a, b int16) (c int16)

func MinI32 ¶

func MinI32(a, b int32) (c int32)

func MinI64 ¶

func MinI64(a, b int64) (c int64)

func MinI8 ¶

func MinI8(a, b int8) (c int8)

func MinMethods ¶

func MinMethods(t reflect.Type) (firstFn, lasFn, defaultFn interface{}, err error)

func MinStr ¶

func MinStr(a, b string) (c string)

func MinU ¶

func MinU(a, b uint) (c uint)

func MinU16 ¶

func MinU16(a, b uint16) (c uint16)

func MinU32 ¶

func MinU32(a, b uint32) (c uint32)

func MinU64 ¶

func MinU64(a, b uint64) (c uint64)

func MinU8 ¶

func MinU8(a, b uint8) (c uint8)

func ModF32 ¶

func ModF32(a float32, b float32) float32

func ModF64 ¶

func ModF64(a float64, b float64) float64

func ModI ¶

func ModI(a int, b int) int

func ModI16 ¶

func ModI16(a int16, b int16) int16

func ModI32 ¶

func ModI32(a int32, b int32) int32

func ModI64 ¶

func ModI64(a int64, b int64) int64

func ModI8 ¶

func ModI8(a int8, b int8) int8

func ModIncrF32 ¶

func ModIncrF32(a []float32, b []float32, incr []float32)

func ModIncrF64 ¶

func ModIncrF64(a []float64, b []float64, incr []float64)

func ModIncrI ¶

func ModIncrI(a []int, b []int, incr []int)

func ModIncrI16 ¶

func ModIncrI16(a []int16, b []int16, incr []int16)

func ModIncrI32 ¶

func ModIncrI32(a []int32, b []int32, incr []int32)

func ModIncrI64 ¶

func ModIncrI64(a []int64, b []int64, incr []int64)

func ModIncrI8 ¶

func ModIncrI8(a []int8, b []int8, incr []int8)

func ModIncrSVF32 ¶

func ModIncrSVF32(a float32, b []float32, incr []float32)

func ModIncrSVF64 ¶

func ModIncrSVF64(a float64, b []float64, incr []float64)

func ModIncrSVI ¶

func ModIncrSVI(a int, b []int, incr []int)

func ModIncrSVI16 ¶

func ModIncrSVI16(a int16, b []int16, incr []int16)

func ModIncrSVI32 ¶

func ModIncrSVI32(a int32, b []int32, incr []int32)

func ModIncrSVI64 ¶

func ModIncrSVI64(a int64, b []int64, incr []int64)

func ModIncrSVI8 ¶

func ModIncrSVI8(a int8, b []int8, incr []int8)

func ModIncrSVU ¶

func ModIncrSVU(a uint, b []uint, incr []uint)

func ModIncrSVU16 ¶

func ModIncrSVU16(a uint16, b []uint16, incr []uint16)

func ModIncrSVU32 ¶

func ModIncrSVU32(a uint32, b []uint32, incr []uint32)

func ModIncrSVU64 ¶

func ModIncrSVU64(a uint64, b []uint64, incr []uint64)

func ModIncrSVU8 ¶

func ModIncrSVU8(a uint8, b []uint8, incr []uint8)

func ModIncrU ¶

func ModIncrU(a []uint, b []uint, incr []uint)

func ModIncrU16 ¶

func ModIncrU16(a []uint16, b []uint16, incr []uint16)

func ModIncrU32 ¶

func ModIncrU32(a []uint32, b []uint32, incr []uint32)

func ModIncrU64 ¶

func ModIncrU64(a []uint64, b []uint64, incr []uint64)

func ModIncrU8 ¶

func ModIncrU8(a []uint8, b []uint8, incr []uint8)

func ModIncrVSF32 ¶

func ModIncrVSF32(a []float32, b float32, incr []float32)

func ModIncrVSF64 ¶

func ModIncrVSF64(a []float64, b float64, incr []float64)

func ModIncrVSI ¶

func ModIncrVSI(a []int, b int, incr []int)

func ModIncrVSI16 ¶

func ModIncrVSI16(a []int16, b int16, incr []int16)

func ModIncrVSI32 ¶

func ModIncrVSI32(a []int32, b int32, incr []int32)

func ModIncrVSI64 ¶

func ModIncrVSI64(a []int64, b int64, incr []int64)

func ModIncrVSI8 ¶

func ModIncrVSI8(a []int8, b int8, incr []int8)

func ModIncrVSU ¶

func ModIncrVSU(a []uint, b uint, incr []uint)

func ModIncrVSU16 ¶

func ModIncrVSU16(a []uint16, b uint16, incr []uint16)

func ModIncrVSU32 ¶

func ModIncrVSU32(a []uint32, b uint32, incr []uint32)

func ModIncrVSU64 ¶

func ModIncrVSU64(a []uint64, b uint64, incr []uint64)

func ModIncrVSU8 ¶

func ModIncrVSU8(a []uint8, b uint8, incr []uint8)

func ModIterF32 ¶

func ModIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)

func ModIterF64 ¶

func ModIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)

func ModIterI ¶

func ModIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)

func ModIterI16 ¶

func ModIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)

func ModIterI32 ¶

func ModIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)

func ModIterI64 ¶

func ModIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)

func ModIterI8 ¶

func ModIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)

func ModIterIncrF32 ¶

func ModIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, iit Iterator) (err error)

func ModIterIncrF64 ¶

func ModIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, iit Iterator) (err error)

func ModIterIncrI ¶

func ModIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error)

func ModIterIncrI16 ¶

func ModIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error)

func ModIterIncrI32 ¶

func ModIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error)

func ModIterIncrI64 ¶

func ModIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error)

func ModIterIncrI8 ¶

func ModIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error)

func ModIterIncrSVF32 ¶

func ModIterIncrSVF32(a float32, b []float32, incr []float32, bit Iterator, iit Iterator) (err error)

func ModIterIncrSVF64 ¶

func ModIterIncrSVF64(a float64, b []float64, incr []float64, bit Iterator, iit Iterator) (err error)

func ModIterIncrSVI ¶

func ModIterIncrSVI(a int, b []int, incr []int, bit Iterator, iit Iterator) (err error)

func ModIterIncrSVI16 ¶

func ModIterIncrSVI16(a int16, b []int16, incr []int16, bit Iterator, iit Iterator) (err error)

func ModIterIncrSVI32 ¶

func ModIterIncrSVI32(a int32, b []int32, incr []int32, bit Iterator, iit Iterator) (err error)

func ModIterIncrSVI64 ¶

func ModIterIncrSVI64(a int64, b []int64, incr []int64, bit Iterator, iit Iterator) (err error)

func ModIterIncrSVI8 ¶

func ModIterIncrSVI8(a int8, b []int8, incr []int8, bit Iterator, iit Iterator) (err error)

func ModIterIncrSVU ¶

func ModIterIncrSVU(a uint, b []uint, incr []uint, bit Iterator, iit Iterator) (err error)

func ModIterIncrSVU16 ¶

func ModIterIncrSVU16(a uint16, b []uint16, incr []uint16, bit Iterator, iit Iterator) (err error)

func ModIterIncrSVU32 ¶

func ModIterIncrSVU32(a uint32, b []uint32, incr []uint32, bit Iterator, iit Iterator) (err error)

func ModIterIncrSVU64 ¶

func ModIterIncrSVU64(a uint64, b []uint64, incr []uint64, bit Iterator, iit Iterator) (err error)

func ModIterIncrSVU8 ¶

func ModIterIncrSVU8(a uint8, b []uint8, incr []uint8, bit Iterator, iit Iterator) (err error)

func ModIterIncrU ¶

func ModIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error)

func ModIterIncrU16 ¶

func ModIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, iit Iterator) (err error)

func ModIterIncrU32 ¶

func ModIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, iit Iterator) (err error)

func ModIterIncrU64 ¶

func ModIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, iit Iterator) (err error)

func ModIterIncrU8 ¶

func ModIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error)

func ModIterIncrVSF32 ¶

func ModIterIncrVSF32(a []float32, b float32, incr []float32, ait Iterator, iit Iterator) (err error)

func ModIterIncrVSF64 ¶

func ModIterIncrVSF64(a []float64, b float64, incr []float64, ait Iterator, iit Iterator) (err error)

func ModIterIncrVSI ¶

func ModIterIncrVSI(a []int, b int, incr []int, ait Iterator, iit Iterator) (err error)

func ModIterIncrVSI16 ¶

func ModIterIncrVSI16(a []int16, b int16, incr []int16, ait Iterator, iit Iterator) (err error)

func ModIterIncrVSI32 ¶

func ModIterIncrVSI32(a []int32, b int32, incr []int32, ait Iterator, iit Iterator) (err error)

func ModIterIncrVSI64 ¶

func ModIterIncrVSI64(a []int64, b int64, incr []int64, ait Iterator, iit Iterator) (err error)

func ModIterIncrVSI8 ¶

func ModIterIncrVSI8(a []int8, b int8, incr []int8, ait Iterator, iit Iterator) (err error)

func ModIterIncrVSU ¶

func ModIterIncrVSU(a []uint, b uint, incr []uint, ait Iterator, iit Iterator) (err error)

func ModIterIncrVSU16 ¶

func ModIterIncrVSU16(a []uint16, b uint16, incr []uint16, ait Iterator, iit Iterator) (err error)

func ModIterIncrVSU32 ¶

func ModIterIncrVSU32(a []uint32, b uint32, incr []uint32, ait Iterator, iit Iterator) (err error)

func ModIterIncrVSU64 ¶

func ModIterIncrVSU64(a []uint64, b uint64, incr []uint64, ait Iterator, iit Iterator) (err error)

func ModIterIncrVSU8 ¶

func ModIterIncrVSU8(a []uint8, b uint8, incr []uint8, ait Iterator, iit Iterator) (err error)

func ModIterSVF32 ¶

func ModIterSVF32(a float32, b []float32, bit Iterator) (err error)

func ModIterSVF64 ¶

func ModIterSVF64(a float64, b []float64, bit Iterator) (err error)

func ModIterSVI ¶

func ModIterSVI(a int, b []int, bit Iterator) (err error)

func ModIterSVI16 ¶

func ModIterSVI16(a int16, b []int16, bit Iterator) (err error)

func ModIterSVI32 ¶

func ModIterSVI32(a int32, b []int32, bit Iterator) (err error)

func ModIterSVI64 ¶

func ModIterSVI64(a int64, b []int64, bit Iterator) (err error)

func ModIterSVI8 ¶

func ModIterSVI8(a int8, b []int8, bit Iterator) (err error)

func ModIterSVU ¶

func ModIterSVU(a uint, b []uint, bit Iterator) (err error)

func ModIterSVU16 ¶

func ModIterSVU16(a uint16, b []uint16, bit Iterator) (err error)

func ModIterSVU32 ¶

func ModIterSVU32(a uint32, b []uint32, bit Iterator) (err error)

func ModIterSVU64 ¶

func ModIterSVU64(a uint64, b []uint64, bit Iterator) (err error)

func ModIterSVU8 ¶

func ModIterSVU8(a uint8, b []uint8, bit Iterator) (err error)

func ModIterU ¶

func ModIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)

func ModIterU16 ¶

func ModIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)

func ModIterU32 ¶

func ModIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)

func ModIterU64 ¶

func ModIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)

func ModIterU8 ¶

func ModIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)

func ModIterVSF32 ¶

func ModIterVSF32(a []float32, b float32, ait Iterator) (err error)

func ModIterVSF64 ¶

func ModIterVSF64(a []float64, b float64, ait Iterator) (err error)

func ModIterVSI ¶

func ModIterVSI(a []int, b int, ait Iterator) (err error)

func ModIterVSI16 ¶

func ModIterVSI16(a []int16, b int16, ait Iterator) (err error)

func ModIterVSI32 ¶

func ModIterVSI32(a []int32, b int32, ait Iterator) (err error)

func ModIterVSI64 ¶

func ModIterVSI64(a []int64, b int64, ait Iterator) (err error)

func ModIterVSI8 ¶

func ModIterVSI8(a []int8, b int8, ait Iterator) (err error)

func ModIterVSU ¶

func ModIterVSU(a []uint, b uint, ait Iterator) (err error)

func ModIterVSU16 ¶

func ModIterVSU16(a []uint16, b uint16, ait Iterator) (err error)

func ModIterVSU32 ¶

func ModIterVSU32(a []uint32, b uint32, ait Iterator) (err error)

func ModIterVSU64 ¶

func ModIterVSU64(a []uint64, b uint64, ait Iterator) (err error)

func ModIterVSU8 ¶

func ModIterVSU8(a []uint8, b uint8, ait Iterator) (err error)

func ModSVF32 ¶

func ModSVF32(a float32, b []float32)

func ModSVF64 ¶

func ModSVF64(a float64, b []float64)

func ModSVI ¶

func ModSVI(a int, b []int)

func ModSVI16 ¶

func ModSVI16(a int16, b []int16)

func ModSVI32 ¶

func ModSVI32(a int32, b []int32)

func ModSVI64 ¶

func ModSVI64(a int64, b []int64)

func ModSVI8 ¶

func ModSVI8(a int8, b []int8)

func ModSVU ¶

func ModSVU(a uint, b []uint)

func ModSVU16 ¶

func ModSVU16(a uint16, b []uint16)

func ModSVU32 ¶

func ModSVU32(a uint32, b []uint32)

func ModSVU64 ¶

func ModSVU64(a uint64, b []uint64)

func ModSVU8 ¶

func ModSVU8(a uint8, b []uint8)

func ModU ¶

func ModU(a uint, b uint) uint

func ModU16 ¶

func ModU16(a uint16, b uint16) uint16

func ModU32 ¶

func ModU32(a uint32, b uint32) uint32

func ModU64 ¶

func ModU64(a uint64, b uint64) uint64

func ModU8 ¶

func ModU8(a uint8, b uint8) uint8

func ModVSF32 ¶

func ModVSF32(a []float32, b float32)

func ModVSF64 ¶

func ModVSF64(a []float64, b float64)

func ModVSI ¶

func ModVSI(a []int, b int)

func ModVSI16 ¶

func ModVSI16(a []int16, b int16)

func ModVSI32 ¶

func ModVSI32(a []int32, b int32)

func ModVSI64 ¶

func ModVSI64(a []int64, b int64)

func ModVSI8 ¶

func ModVSI8(a []int8, b int8)

func ModVSU ¶

func ModVSU(a []uint, b uint)

func ModVSU16 ¶

func ModVSU16(a []uint16, b uint16)

func ModVSU32 ¶

func ModVSU32(a []uint32, b uint32)

func ModVSU64 ¶

func ModVSU64(a []uint64, b uint64)

func ModVSU8 ¶

func ModVSU8(a []uint8, b uint8)

func MonotonicMax ¶

func MonotonicMax(t reflect.Type, a *storage.Header) (retVal interface{}, err error)

func MonotonicMin ¶

func MonotonicMin(t reflect.Type, a *storage.Header) (retVal interface{}, err error)

func MonotonicSum ¶

func MonotonicSum(t reflect.Type, a *storage.Header) (retVal interface{}, err error)

func MulC128 ¶

func MulC128(a complex128, b complex128) complex128

func MulC64 ¶

func MulC64(a complex64, b complex64) complex64

func MulF32 ¶

func MulF32(a float32, b float32) float32

func MulF64 ¶

func MulF64(a float64, b float64) float64

func MulI ¶

func MulI(a int, b int) int

func MulI16 ¶

func MulI16(a int16, b int16) int16

func MulI32 ¶

func MulI32(a int32, b int32) int32

func MulI64 ¶

func MulI64(a int64, b int64) int64

func MulI8 ¶

func MulI8(a int8, b int8) int8

func MulIncrC128 ¶

func MulIncrC128(a []complex128, b []complex128, incr []complex128)

func MulIncrC64 ¶

func MulIncrC64(a []complex64, b []complex64, incr []complex64)

func MulIncrF32 ¶

func MulIncrF32(a []float32, b []float32, incr []float32)

func MulIncrF64 ¶

func MulIncrF64(a []float64, b []float64, incr []float64)

func MulIncrI ¶

func MulIncrI(a []int, b []int, incr []int)

func MulIncrI16 ¶

func MulIncrI16(a []int16, b []int16, incr []int16)

func MulIncrI32 ¶

func MulIncrI32(a []int32, b []int32, incr []int32)

func MulIncrI64 ¶

func MulIncrI64(a []int64, b []int64, incr []int64)

func MulIncrI8 ¶

func MulIncrI8(a []int8, b []int8, incr []int8)

func MulIncrSVC128 ¶

func MulIncrSVC128(a complex128, b []complex128, incr []complex128)

func MulIncrSVC64 ¶

func MulIncrSVC64(a complex64, b []complex64, incr []complex64)

func MulIncrSVF32 ¶

func MulIncrSVF32(a float32, b []float32, incr []float32)

func MulIncrSVF64 ¶

func MulIncrSVF64(a float64, b []float64, incr []float64)

func MulIncrSVI ¶

func MulIncrSVI(a int, b []int, incr []int)

func MulIncrSVI16 ¶

func MulIncrSVI16(a int16, b []int16, incr []int16)

func MulIncrSVI32 ¶

func MulIncrSVI32(a int32, b []int32, incr []int32)

func MulIncrSVI64 ¶

func MulIncrSVI64(a int64, b []int64, incr []int64)

func MulIncrSVI8 ¶

func MulIncrSVI8(a int8, b []int8, incr []int8)

func MulIncrSVU ¶

func MulIncrSVU(a uint, b []uint, incr []uint)

func MulIncrSVU16 ¶

func MulIncrSVU16(a uint16, b []uint16, incr []uint16)

func MulIncrSVU32 ¶

func MulIncrSVU32(a uint32, b []uint32, incr []uint32)

func MulIncrSVU64 ¶

func MulIncrSVU64(a uint64, b []uint64, incr []uint64)

func MulIncrSVU8 ¶

func MulIncrSVU8(a uint8, b []uint8, incr []uint8)

func MulIncrU ¶

func MulIncrU(a []uint, b []uint, incr []uint)

func MulIncrU16 ¶

func MulIncrU16(a []uint16, b []uint16, incr []uint16)

func MulIncrU32 ¶

func MulIncrU32(a []uint32, b []uint32, incr []uint32)

func MulIncrU64 ¶

func MulIncrU64(a []uint64, b []uint64, incr []uint64)

func MulIncrU8 ¶

func MulIncrU8(a []uint8, b []uint8, incr []uint8)

func MulIncrVSC128 ¶

func MulIncrVSC128(a []complex128, b complex128, incr []complex128)

func MulIncrVSC64 ¶

func MulIncrVSC64(a []complex64, b complex64, incr []complex64)

func MulIncrVSF32 ¶

func MulIncrVSF32(a []float32, b float32, incr []float32)

func MulIncrVSF64 ¶

func MulIncrVSF64(a []float64, b float64, incr []float64)

func MulIncrVSI ¶

func MulIncrVSI(a []int, b int, incr []int)

func MulIncrVSI16 ¶

func MulIncrVSI16(a []int16, b int16, incr []int16)

func MulIncrVSI32 ¶

func MulIncrVSI32(a []int32, b int32, incr []int32)

func MulIncrVSI64 ¶

func MulIncrVSI64(a []int64, b int64, incr []int64)

func MulIncrVSI8 ¶

func MulIncrVSI8(a []int8, b int8, incr []int8)

func MulIncrVSU ¶

func MulIncrVSU(a []uint, b uint, incr []uint)

func MulIncrVSU16 ¶

func MulIncrVSU16(a []uint16, b uint16, incr []uint16)

func MulIncrVSU32 ¶

func MulIncrVSU32(a []uint32, b uint32, incr []uint32)

func MulIncrVSU64 ¶

func MulIncrVSU64(a []uint64, b uint64, incr []uint64)

func MulIncrVSU8 ¶

func MulIncrVSU8(a []uint8, b uint8, incr []uint8)

func MulIterC128 ¶

func MulIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)

func MulIterC64 ¶

func MulIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)

func MulIterF32 ¶

func MulIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)

func MulIterF64 ¶

func MulIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)

func MulIterI ¶

func MulIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)

func MulIterI16 ¶

func MulIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)

func MulIterI32 ¶

func MulIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)

func MulIterI64 ¶

func MulIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)

func MulIterI8 ¶

func MulIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)

func MulIterIncrC128 ¶

func MulIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrC64 ¶

func MulIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrF32 ¶

func MulIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrF64 ¶

func MulIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrI ¶

func MulIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrI16 ¶

func MulIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrI32 ¶

func MulIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrI64 ¶

func MulIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrI8 ¶

func MulIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVC128 ¶

func MulIterIncrSVC128(a complex128, b []complex128, incr []complex128, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVC64 ¶

func MulIterIncrSVC64(a complex64, b []complex64, incr []complex64, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVF32 ¶

func MulIterIncrSVF32(a float32, b []float32, incr []float32, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVF64 ¶

func MulIterIncrSVF64(a float64, b []float64, incr []float64, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVI ¶

func MulIterIncrSVI(a int, b []int, incr []int, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVI16 ¶

func MulIterIncrSVI16(a int16, b []int16, incr []int16, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVI32 ¶

func MulIterIncrSVI32(a int32, b []int32, incr []int32, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVI64 ¶

func MulIterIncrSVI64(a int64, b []int64, incr []int64, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVI8 ¶

func MulIterIncrSVI8(a int8, b []int8, incr []int8, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVU ¶

func MulIterIncrSVU(a uint, b []uint, incr []uint, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVU16 ¶

func MulIterIncrSVU16(a uint16, b []uint16, incr []uint16, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVU32 ¶

func MulIterIncrSVU32(a uint32, b []uint32, incr []uint32, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVU64 ¶

func MulIterIncrSVU64(a uint64, b []uint64, incr []uint64, bit Iterator, iit Iterator) (err error)

func MulIterIncrSVU8 ¶

func MulIterIncrSVU8(a uint8, b []uint8, incr []uint8, bit Iterator, iit Iterator) (err error)

func MulIterIncrU ¶

func MulIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrU16 ¶

func MulIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrU32 ¶

func MulIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrU64 ¶

func MulIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrU8 ¶

func MulIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error)

func MulIterIncrVSC128 ¶

func MulIterIncrVSC128(a []complex128, b complex128, incr []complex128, ait Iterator, iit Iterator) (err error)

func MulIterIncrVSC64 ¶

func MulIterIncrVSC64(a []complex64, b complex64, incr []complex64, ait Iterator, iit Iterator) (err error)

func MulIterIncrVSF32 ¶

func MulIterIncrVSF32(a []float32, b float32, incr []float32, ait Iterator, iit Iterator) (err error)

func MulIterIncrVSF64 ¶

func MulIterIncrVSF64(a []float64, b float64, incr []float64, ait Iterator, iit Iterator) (err error)

func MulIterIncrVSI ¶

func MulIterIncrVSI(a []int, b int, incr []int, ait Iterator, iit Iterator) (err error)

func MulIterIncrVSI16 ¶

func MulIterIncrVSI16(a []int16, b int16, incr []int16, ait Iterator, iit Iterator) (err error)

func MulIterIncrVSI32 ¶

func MulIterIncrVSI32(a []int32, b int32, incr []int32, ait Iterator, iit Iterator) (err error)

func MulIterIncrVSI64 ¶

func MulIterIncrVSI64(a []int64, b int64, incr []int64, ait Iterator, iit Iterator) (err error)

func MulIterIncrVSI8 ¶

func MulIterIncrVSI8(a []int8, b int8, incr []int8, ait Iterator, iit Iterator) (err error)

func MulIterIncrVSU ¶

func MulIterIncrVSU(a []uint, b uint, incr []uint, ait Iterator, iit Iterator) (err error)

func MulIterIncrVSU16 ¶

func MulIterIncrVSU16(a []uint16, b uint16, incr []uint16, ait Iterator, iit Iterator) (err error)

func MulIterIncrVSU32 ¶

func MulIterIncrVSU32(a []uint32, b uint32, incr []uint32, ait Iterator, iit Iterator) (err error)

func MulIterIncrVSU64 ¶

func MulIterIncrVSU64(a []uint64, b uint64, incr []uint64, ait Iterator, iit Iterator) (err error)

func MulIterIncrVSU8 ¶

func MulIterIncrVSU8(a []uint8, b uint8, incr []uint8, ait Iterator, iit Iterator) (err error)

func MulIterSVC128 ¶

func MulIterSVC128(a complex128, b []complex128, bit Iterator) (err error)

func MulIterSVC64 ¶

func MulIterSVC64(a complex64, b []complex64, bit Iterator) (err error)

func MulIterSVF32 ¶

func MulIterSVF32(a float32, b []float32, bit Iterator) (err error)

func MulIterSVF64 ¶

func MulIterSVF64(a float64, b []float64, bit Iterator) (err error)

func MulIterSVI ¶

func MulIterSVI(a int, b []int, bit Iterator) (err error)

func MulIterSVI16 ¶

func MulIterSVI16(a int16, b []int16, bit Iterator) (err error)

func MulIterSVI32 ¶

func MulIterSVI32(a int32, b []int32, bit Iterator) (err error)

func MulIterSVI64 ¶

func MulIterSVI64(a int64, b []int64, bit Iterator) (err error)

func MulIterSVI8 ¶

func MulIterSVI8(a int8, b []int8, bit Iterator) (err error)

func MulIterSVU ¶

func MulIterSVU(a uint, b []uint, bit Iterator) (err error)

func MulIterSVU16 ¶

func MulIterSVU16(a uint16, b []uint16, bit Iterator) (err error)

func MulIterSVU32 ¶

func MulIterSVU32(a uint32, b []uint32, bit Iterator) (err error)

func MulIterSVU64 ¶

func MulIterSVU64(a uint64, b []uint64, bit Iterator) (err error)

func MulIterSVU8 ¶

func MulIterSVU8(a uint8, b []uint8, bit Iterator) (err error)

func MulIterU ¶

func MulIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)

func MulIterU16 ¶

func MulIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)

func MulIterU32 ¶

func MulIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)

func MulIterU64 ¶

func MulIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)

func MulIterU8 ¶

func MulIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)

func MulIterVSC128 ¶

func MulIterVSC128(a []complex128, b complex128, ait Iterator) (err error)

func MulIterVSC64 ¶

func MulIterVSC64(a []complex64, b complex64, ait Iterator) (err error)

func MulIterVSF32 ¶

func MulIterVSF32(a []float32, b float32, ait Iterator) (err error)

func MulIterVSF64 ¶

func MulIterVSF64(a []float64, b float64, ait Iterator) (err error)

func MulIterVSI ¶

func MulIterVSI(a []int, b int, ait Iterator) (err error)

func MulIterVSI16 ¶

func MulIterVSI16(a []int16, b int16, ait Iterator) (err error)

func MulIterVSI32 ¶

func MulIterVSI32(a []int32, b int32, ait Iterator) (err error)

func MulIterVSI64 ¶

func MulIterVSI64(a []int64, b int64, ait Iterator) (err error)

func MulIterVSI8 ¶

func MulIterVSI8(a []int8, b int8, ait Iterator) (err error)

func MulIterVSU ¶

func MulIterVSU(a []uint, b uint, ait Iterator) (err error)

func MulIterVSU16 ¶

func MulIterVSU16(a []uint16, b uint16, ait Iterator) (err error)

func MulIterVSU32 ¶

func MulIterVSU32(a []uint32, b uint32, ait Iterator) (err error)

func MulIterVSU64 ¶

func MulIterVSU64(a []uint64, b uint64, ait Iterator) (err error)

func MulIterVSU8 ¶

func MulIterVSU8(a []uint8, b uint8, ait Iterator) (err error)

func MulSVC128 ¶

func MulSVC128(a complex128, b []complex128)

func MulSVC64 ¶

func MulSVC64(a complex64, b []complex64)

func MulSVF32 ¶

func MulSVF32(a float32, b []float32)

func MulSVF64 ¶

func MulSVF64(a float64, b []float64)

func MulSVI ¶

func MulSVI(a int, b []int)

func MulSVI16 ¶

func MulSVI16(a int16, b []int16)

func MulSVI32 ¶

func MulSVI32(a int32, b []int32)

func MulSVI64 ¶

func MulSVI64(a int64, b []int64)

func MulSVI8 ¶

func MulSVI8(a int8, b []int8)

func MulSVU ¶

func MulSVU(a uint, b []uint)

func MulSVU16 ¶

func MulSVU16(a uint16, b []uint16)

func MulSVU32 ¶

func MulSVU32(a uint32, b []uint32)

func MulSVU64 ¶

func MulSVU64(a uint64, b []uint64)

func MulSVU8 ¶

func MulSVU8(a uint8, b []uint8)

func MulU ¶

func MulU(a uint, b uint) uint

func MulU16 ¶

func MulU16(a uint16, b uint16) uint16

func MulU32 ¶

func MulU32(a uint32, b uint32) uint32

func MulU64 ¶

func MulU64(a uint64, b uint64) uint64

func MulU8 ¶

func MulU8(a uint8, b uint8) uint8

func MulVSC128 ¶

func MulVSC128(a []complex128, b complex128)

func MulVSC64 ¶

func MulVSC64(a []complex64, b complex64)

func MulVSF32 ¶

func MulVSF32(a []float32, b float32)

func MulVSF64 ¶

func MulVSF64(a []float64, b float64)

func MulVSI ¶

func MulVSI(a []int, b int)

func MulVSI16 ¶

func MulVSI16(a []int16, b int16)

func MulVSI32 ¶

func MulVSI32(a []int32, b int32)

func MulVSI64 ¶

func MulVSI64(a []int64, b int64)

func MulVSI8 ¶

func MulVSI8(a []int8, b int8)

func MulVSU ¶

func MulVSU(a []uint, b uint)

func MulVSU16 ¶

func MulVSU16(a []uint16, b uint16)

func MulVSU32 ¶

func MulVSU32(a []uint32, b uint32)

func MulVSU64 ¶

func MulVSU64(a []uint64, b uint64)

func MulVSU8 ¶

func MulVSU8(a []uint8, b uint8)

func NeB ¶

func NeB(a []bool, b []bool, retVal []bool)

func NeC128 ¶

func NeC128(a []complex128, b []complex128, retVal []bool)

func NeC64 ¶

func NeC64(a []complex64, b []complex64, retVal []bool)

func NeF32 ¶

func NeF32(a []float32, b []float32, retVal []bool)

func NeF64 ¶

func NeF64(a []float64, b []float64, retVal []bool)

func NeI ¶

func NeI(a []int, b []int, retVal []bool)

func NeI16 ¶

func NeI16(a []int16, b []int16, retVal []bool)

func NeI32 ¶

func NeI32(a []int32, b []int32, retVal []bool)

func NeI64 ¶

func NeI64(a []int64, b []int64, retVal []bool)

func NeI8 ¶

func NeI8(a []int8, b []int8, retVal []bool)

func NeIterB ¶

func NeIterB(a []bool, b []bool, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterC128 ¶

func NeIterC128(a []complex128, b []complex128, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterC64 ¶

func NeIterC64(a []complex64, b []complex64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterF32 ¶

func NeIterF32(a []float32, b []float32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterF64 ¶

func NeIterF64(a []float64, b []float64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterI ¶

func NeIterI(a []int, b []int, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterI16 ¶

func NeIterI16(a []int16, b []int16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterI32 ¶

func NeIterI32(a []int32, b []int32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterI64 ¶

func NeIterI64(a []int64, b []int64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterI8 ¶

func NeIterI8(a []int8, b []int8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterSVB ¶

func NeIterSVB(a bool, b []bool, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVC128 ¶

func NeIterSVC128(a complex128, b []complex128, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVC64 ¶

func NeIterSVC64(a complex64, b []complex64, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVF32 ¶

func NeIterSVF32(a float32, b []float32, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVF64 ¶

func NeIterSVF64(a float64, b []float64, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVI ¶

func NeIterSVI(a int, b []int, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVI16 ¶

func NeIterSVI16(a int16, b []int16, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVI32 ¶

func NeIterSVI32(a int32, b []int32, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVI64 ¶

func NeIterSVI64(a int64, b []int64, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVI8 ¶

func NeIterSVI8(a int8, b []int8, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVStr ¶

func NeIterSVStr(a string, b []string, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVU ¶

func NeIterSVU(a uint, b []uint, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVU16 ¶

func NeIterSVU16(a uint16, b []uint16, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVU32 ¶

func NeIterSVU32(a uint32, b []uint32, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVU64 ¶

func NeIterSVU64(a uint64, b []uint64, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVU8 ¶

func NeIterSVU8(a uint8, b []uint8, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVUintptr ¶

func NeIterSVUintptr(a uintptr, b []uintptr, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterSVUnsafePointer ¶

func NeIterSVUnsafePointer(a unsafe.Pointer, b []unsafe.Pointer, retVal []bool, bit Iterator, rit Iterator) (err error)

func NeIterStr ¶

func NeIterStr(a []string, b []string, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterU ¶

func NeIterU(a []uint, b []uint, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterU16 ¶

func NeIterU16(a []uint16, b []uint16, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterU32 ¶

func NeIterU32(a []uint32, b []uint32, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterU64 ¶

func NeIterU64(a []uint64, b []uint64, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterU8 ¶

func NeIterU8(a []uint8, b []uint8, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterUintptr ¶

func NeIterUintptr(a []uintptr, b []uintptr, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterUnsafePointer ¶

func NeIterUnsafePointer(a []unsafe.Pointer, b []unsafe.Pointer, retVal []bool, ait Iterator, bit Iterator, rit Iterator) (err error)

func NeIterVSB ¶

func NeIterVSB(a []bool, b bool, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSC128 ¶

func NeIterVSC128(a []complex128, b complex128, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSC64 ¶

func NeIterVSC64(a []complex64, b complex64, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSF32 ¶

func NeIterVSF32(a []float32, b float32, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSF64 ¶

func NeIterVSF64(a []float64, b float64, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSI ¶

func NeIterVSI(a []int, b int, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSI16 ¶

func NeIterVSI16(a []int16, b int16, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSI32 ¶

func NeIterVSI32(a []int32, b int32, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSI64 ¶

func NeIterVSI64(a []int64, b int64, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSI8 ¶

func NeIterVSI8(a []int8, b int8, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSStr ¶

func NeIterVSStr(a []string, b string, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSU ¶

func NeIterVSU(a []uint, b uint, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSU16 ¶

func NeIterVSU16(a []uint16, b uint16, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSU32 ¶

func NeIterVSU32(a []uint32, b uint32, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSU64 ¶

func NeIterVSU64(a []uint64, b uint64, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSU8 ¶

func NeIterVSU8(a []uint8, b uint8, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSUintptr ¶

func NeIterVSUintptr(a []uintptr, b uintptr, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeIterVSUnsafePointer ¶

func NeIterVSUnsafePointer(a []unsafe.Pointer, b unsafe.Pointer, retVal []bool, ait Iterator, rit Iterator) (err error)

func NeSVB ¶

func NeSVB(a bool, b []bool, retVal []bool)

func NeSVC128 ¶

func NeSVC128(a complex128, b []complex128, retVal []bool)

func NeSVC64 ¶

func NeSVC64(a complex64, b []complex64, retVal []bool)

func NeSVF32 ¶

func NeSVF32(a float32, b []float32, retVal []bool)

func NeSVF64 ¶

func NeSVF64(a float64, b []float64, retVal []bool)

func NeSVI ¶

func NeSVI(a int, b []int, retVal []bool)

func NeSVI16 ¶

func NeSVI16(a int16, b []int16, retVal []bool)

func NeSVI32 ¶

func NeSVI32(a int32, b []int32, retVal []bool)

func NeSVI64 ¶

func NeSVI64(a int64, b []int64, retVal []bool)

func NeSVI8 ¶

func NeSVI8(a int8, b []int8, retVal []bool)

func NeSVStr ¶

func NeSVStr(a string, b []string, retVal []bool)

func NeSVU ¶

func NeSVU(a uint, b []uint, retVal []bool)

func NeSVU16 ¶

func NeSVU16(a uint16, b []uint16, retVal []bool)

func NeSVU32 ¶

func NeSVU32(a uint32, b []uint32, retVal []bool)

func NeSVU64 ¶

func NeSVU64(a uint64, b []uint64, retVal []bool)

func NeSVU8 ¶

func NeSVU8(a uint8, b []uint8, retVal []bool)

func NeSVUintptr ¶

func NeSVUintptr(a uintptr, b []uintptr, retVal []bool)

func NeSVUnsafePointer ¶

func NeSVUnsafePointer(a unsafe.Pointer, b []unsafe.Pointer, retVal []bool)

func NeSameB ¶

func NeSameB(a []bool, b []bool)

func NeSameC128 ¶

func NeSameC128(a []complex128, b []complex128)

func NeSameC64 ¶

func NeSameC64(a []complex64, b []complex64)

func NeSameF32 ¶

func NeSameF32(a []float32, b []float32)

func NeSameF64 ¶

func NeSameF64(a []float64, b []float64)

func NeSameI ¶

func NeSameI(a []int, b []int)

func NeSameI16 ¶

func NeSameI16(a []int16, b []int16)

func NeSameI32 ¶

func NeSameI32(a []int32, b []int32)

func NeSameI64 ¶

func NeSameI64(a []int64, b []int64)

func NeSameI8 ¶

func NeSameI8(a []int8, b []int8)

func NeSameIterB ¶

func NeSameIterB(a []bool, b []bool, ait Iterator, bit Iterator) (err error)

func NeSameIterC128 ¶

func NeSameIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)

func NeSameIterC64 ¶

func NeSameIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)

func NeSameIterF32 ¶

func NeSameIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)

func NeSameIterF64 ¶

func NeSameIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)

func NeSameIterI ¶

func NeSameIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)

func NeSameIterI16 ¶

func NeSameIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)

func NeSameIterI32 ¶

func NeSameIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)

func NeSameIterI64 ¶

func NeSameIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)

func NeSameIterI8 ¶

func NeSameIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)

func NeSameIterSVB ¶

func NeSameIterSVB(a bool, b []bool, bit Iterator) (err error)

func NeSameIterSVC128 ¶

func NeSameIterSVC128(a complex128, b []complex128, bit Iterator) (err error)

func NeSameIterSVC64 ¶

func NeSameIterSVC64(a complex64, b []complex64, bit Iterator) (err error)

func NeSameIterSVF32 ¶

func NeSameIterSVF32(a float32, b []float32, bit Iterator) (err error)

func NeSameIterSVF64 ¶

func NeSameIterSVF64(a float64, b []float64, bit Iterator) (err error)

func NeSameIterSVI ¶

func NeSameIterSVI(a int, b []int, bit Iterator) (err error)

func NeSameIterSVI16 ¶

func NeSameIterSVI16(a int16, b []int16, bit Iterator) (err error)

func NeSameIterSVI32 ¶

func NeSameIterSVI32(a int32, b []int32, bit Iterator) (err error)

func NeSameIterSVI64 ¶

func NeSameIterSVI64(a int64, b []int64, bit Iterator) (err error)

func NeSameIterSVI8 ¶

func NeSameIterSVI8(a int8, b []int8, bit Iterator) (err error)

func NeSameIterSVStr ¶

func NeSameIterSVStr(a string, b []string, bit Iterator) (err error)

func NeSameIterSVU ¶

func NeSameIterSVU(a uint, b []uint, bit Iterator) (err error)

func NeSameIterSVU16 ¶

func NeSameIterSVU16(a uint16, b []uint16, bit Iterator) (err error)

func NeSameIterSVU32 ¶

func NeSameIterSVU32(a uint32, b []uint32, bit Iterator) (err error)

func NeSameIterSVU64 ¶

func NeSameIterSVU64(a uint64, b []uint64, bit Iterator) (err error)

func NeSameIterSVU8 ¶

func NeSameIterSVU8(a uint8, b []uint8, bit Iterator) (err error)

func NeSameIterSVUintptr ¶

func NeSameIterSVUintptr(a uintptr, b []uintptr, bit Iterator) (err error)

func NeSameIterStr ¶

func NeSameIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error)

func NeSameIterU ¶

func NeSameIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)

func NeSameIterU16 ¶

func NeSameIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)

func NeSameIterU32 ¶

func NeSameIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)

func NeSameIterU64 ¶

func NeSameIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)

func NeSameIterU8 ¶

func NeSameIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)

func NeSameIterUintptr ¶

func NeSameIterUintptr(a []uintptr, b []uintptr, ait Iterator, bit Iterator) (err error)

func NeSameIterVSB ¶

func NeSameIterVSB(a []bool, b bool, ait Iterator) (err error)

func NeSameIterVSC128 ¶

func NeSameIterVSC128(a []complex128, b complex128, ait Iterator) (err error)

func NeSameIterVSC64 ¶

func NeSameIterVSC64(a []complex64, b complex64, ait Iterator) (err error)

func NeSameIterVSF32 ¶

func NeSameIterVSF32(a []float32, b float32, ait Iterator) (err error)

func NeSameIterVSF64 ¶

func NeSameIterVSF64(a []float64, b float64, ait Iterator) (err error)

func NeSameIterVSI ¶

func NeSameIterVSI(a []int, b int, ait Iterator) (err error)

func NeSameIterVSI16 ¶

func NeSameIterVSI16(a []int16, b int16, ait Iterator) (err error)

func NeSameIterVSI32 ¶

func NeSameIterVSI32(a []int32, b int32, ait Iterator) (err error)

func NeSameIterVSI64 ¶

func NeSameIterVSI64(a []int64, b int64, ait Iterator) (err error)

func NeSameIterVSI8 ¶

func NeSameIterVSI8(a []int8, b int8, ait Iterator) (err error)

func NeSameIterVSStr ¶

func NeSameIterVSStr(a []string, b string, ait Iterator) (err error)

func NeSameIterVSU ¶

func NeSameIterVSU(a []uint, b uint, ait Iterator) (err error)

func NeSameIterVSU16 ¶

func NeSameIterVSU16(a []uint16, b uint16, ait Iterator) (err error)

func NeSameIterVSU32 ¶

func NeSameIterVSU32(a []uint32, b uint32, ait Iterator) (err error)

func NeSameIterVSU64 ¶

func NeSameIterVSU64(a []uint64, b uint64, ait Iterator) (err error)

func NeSameIterVSU8 ¶

func NeSameIterVSU8(a []uint8, b uint8, ait Iterator) (err error)

func NeSameIterVSUintptr ¶

func NeSameIterVSUintptr(a []uintptr, b uintptr, ait Iterator) (err error)

func NeSameSVB ¶

func NeSameSVB(a bool, b []bool)

func NeSameSVC128 ¶

func NeSameSVC128(a complex128, b []complex128)

func NeSameSVC64 ¶

func NeSameSVC64(a complex64, b []complex64)

func NeSameSVF32 ¶

func NeSameSVF32(a float32, b []float32)

func NeSameSVF64 ¶

func NeSameSVF64(a float64, b []float64)

func NeSameSVI ¶

func NeSameSVI(a int, b []int)

func NeSameSVI16 ¶

func NeSameSVI16(a int16, b []int16)

func NeSameSVI32 ¶

func NeSameSVI32(a int32, b []int32)

func NeSameSVI64 ¶

func NeSameSVI64(a int64, b []int64)

func NeSameSVI8 ¶

func NeSameSVI8(a int8, b []int8)

func NeSameSVStr ¶

func NeSameSVStr(a string, b []string)

func NeSameSVU ¶

func NeSameSVU(a uint, b []uint)

func NeSameSVU16 ¶

func NeSameSVU16(a uint16, b []uint16)

func NeSameSVU32 ¶

func NeSameSVU32(a uint32, b []uint32)

func NeSameSVU64 ¶

func NeSameSVU64(a uint64, b []uint64)

func NeSameSVU8 ¶

func NeSameSVU8(a uint8, b []uint8)

func NeSameSVUintptr ¶

func NeSameSVUintptr(a uintptr, b []uintptr)

func NeSameStr ¶

func NeSameStr(a []string, b []string)

func NeSameU ¶

func NeSameU(a []uint, b []uint)

func NeSameU16 ¶

func NeSameU16(a []uint16, b []uint16)

func NeSameU32 ¶

func NeSameU32(a []uint32, b []uint32)

func NeSameU64 ¶

func NeSameU64(a []uint64, b []uint64)

func NeSameU8 ¶

func NeSameU8(a []uint8, b []uint8)

func NeSameUintptr ¶

func NeSameUintptr(a []uintptr, b []uintptr)

func NeSameVSB ¶

func NeSameVSB(a []bool, b bool)

func NeSameVSC128 ¶

func NeSameVSC128(a []complex128, b complex128)

func NeSameVSC64 ¶

func NeSameVSC64(a []complex64, b complex64)

func NeSameVSF32 ¶

func NeSameVSF32(a []float32, b float32)

func NeSameVSF64 ¶

func NeSameVSF64(a []float64, b float64)

func NeSameVSI ¶

func NeSameVSI(a []int, b int)

func NeSameVSI16 ¶

func NeSameVSI16(a []int16, b int16)

func NeSameVSI32 ¶

func NeSameVSI32(a []int32, b int32)

func NeSameVSI64 ¶

func NeSameVSI64(a []int64, b int64)

func NeSameVSI8 ¶

func NeSameVSI8(a []int8, b int8)

func NeSameVSStr ¶

func NeSameVSStr(a []string, b string)

func NeSameVSU ¶

func NeSameVSU(a []uint, b uint)

func NeSameVSU16 ¶

func NeSameVSU16(a []uint16, b uint16)

func NeSameVSU32 ¶

func NeSameVSU32(a []uint32, b uint32)

func NeSameVSU64 ¶

func NeSameVSU64(a []uint64, b uint64)

func NeSameVSU8 ¶

func NeSameVSU8(a []uint8, b uint8)

func NeSameVSUintptr ¶

func NeSameVSUintptr(a []uintptr, b uintptr)

func NeStr ¶

func NeStr(a []string, b []string, retVal []bool)

func NeU ¶

func NeU(a []uint, b []uint, retVal []bool)

func NeU16 ¶

func NeU16(a []uint16, b []uint16, retVal []bool)

func NeU32 ¶

func NeU32(a []uint32, b []uint32, retVal []bool)

func NeU64 ¶

func NeU64(a []uint64, b []uint64, retVal []bool)

func NeU8 ¶

func NeU8(a []uint8, b []uint8, retVal []bool)

func NeUintptr ¶

func NeUintptr(a []uintptr, b []uintptr, retVal []bool)

func NeUnsafePointer ¶

func NeUnsafePointer(a []unsafe.Pointer, b []unsafe.Pointer, retVal []bool)

func NeVSB ¶

func NeVSB(a []bool, b bool, retVal []bool)

func NeVSC128 ¶

func NeVSC128(a []complex128, b complex128, retVal []bool)

func NeVSC64 ¶

func NeVSC64(a []complex64, b complex64, retVal []bool)

func NeVSF32 ¶

func NeVSF32(a []float32, b float32, retVal []bool)

func NeVSF64 ¶

func NeVSF64(a []float64, b float64, retVal []bool)

func NeVSI ¶

func NeVSI(a []int, b int, retVal []bool)

func NeVSI16 ¶

func NeVSI16(a []int16, b int16, retVal []bool)

func NeVSI32 ¶

func NeVSI32(a []int32, b int32, retVal []bool)

func NeVSI64 ¶

func NeVSI64(a []int64, b int64, retVal []bool)

func NeVSI8 ¶

func NeVSI8(a []int8, b int8, retVal []bool)

func NeVSStr ¶

func NeVSStr(a []string, b string, retVal []bool)

func NeVSU ¶

func NeVSU(a []uint, b uint, retVal []bool)

func NeVSU16 ¶

func NeVSU16(a []uint16, b uint16, retVal []bool)

func NeVSU32 ¶

func NeVSU32(a []uint32, b uint32, retVal []bool)

func NeVSU64 ¶

func NeVSU64(a []uint64, b uint64, retVal []bool)

func NeVSU8 ¶

func NeVSU8(a []uint8, b uint8, retVal []bool)

func NeVSUintptr ¶

func NeVSUintptr(a []uintptr, b uintptr, retVal []bool)

func NeVSUnsafePointer ¶

func NeVSUnsafePointer(a []unsafe.Pointer, b unsafe.Pointer, retVal []bool)

func NegC128 ¶

func NegC128(a []complex128)

func NegC64 ¶

func NegC64(a []complex64)

func NegF32 ¶

func NegF32(a []float32)

func NegF64 ¶

func NegF64(a []float64)

func NegI ¶

func NegI(a []int)

func NegI16 ¶

func NegI16(a []int16)

func NegI32 ¶

func NegI32(a []int32)

func NegI64 ¶

func NegI64(a []int64)

func NegI8 ¶

func NegI8(a []int8)

func NegIterC128 ¶

func NegIterC128(a []complex128, ait Iterator) (err error)

func NegIterC64 ¶

func NegIterC64(a []complex64, ait Iterator) (err error)

func NegIterF32 ¶

func NegIterF32(a []float32, ait Iterator) (err error)

func NegIterF64 ¶

func NegIterF64(a []float64, ait Iterator) (err error)

func NegIterI ¶

func NegIterI(a []int, ait Iterator) (err error)

func NegIterI16 ¶

func NegIterI16(a []int16, ait Iterator) (err error)

func NegIterI32 ¶

func NegIterI32(a []int32, ait Iterator) (err error)

func NegIterI64 ¶

func NegIterI64(a []int64, ait Iterator) (err error)

func NegIterI8 ¶

func NegIterI8(a []int8, ait Iterator) (err error)

func NegIterU ¶

func NegIterU(a []uint, ait Iterator) (err error)

func NegIterU16 ¶

func NegIterU16(a []uint16, ait Iterator) (err error)

func NegIterU32 ¶

func NegIterU32(a []uint32, ait Iterator) (err error)

func NegIterU64 ¶

func NegIterU64(a []uint64, ait Iterator) (err error)

func NegIterU8 ¶

func NegIterU8(a []uint8, ait Iterator) (err error)

func NegU ¶

func NegU(a []uint)

func NegU16 ¶

func NegU16(a []uint16)

func NegU32 ¶

func NegU32(a []uint32)

func NegU64 ¶

func NegU64(a []uint64)

func NegU8 ¶

func NegU8(a []uint8)

func PowC128 ¶

func PowC128(a complex128, b complex128) complex128

func PowC64 ¶

func PowC64(a complex64, b complex64) complex64

func PowF32 ¶

func PowF32(a float32, b float32) float32

func PowF64 ¶

func PowF64(a float64, b float64) float64

func PowIncrC128 ¶

func PowIncrC128(a []complex128, b []complex128, incr []complex128)

func PowIncrC64 ¶

func PowIncrC64(a []complex64, b []complex64, incr []complex64)

func PowIncrF32 ¶

func PowIncrF32(a []float32, b []float32, incr []float32)

func PowIncrF64 ¶

func PowIncrF64(a []float64, b []float64, incr []float64)

func PowIncrSVC128 ¶

func PowIncrSVC128(a complex128, b []complex128, incr []complex128)

func PowIncrSVC64 ¶

func PowIncrSVC64(a complex64, b []complex64, incr []complex64)

func PowIncrSVF32 ¶

func PowIncrSVF32(a float32, b []float32, incr []float32)

func PowIncrSVF64 ¶

func PowIncrSVF64(a float64, b []float64, incr []float64)

func PowIncrVSC128 ¶

func PowIncrVSC128(a []complex128, b complex128, incr []complex128)

func PowIncrVSC64 ¶

func PowIncrVSC64(a []complex64, b complex64, incr []complex64)

func PowIncrVSF32 ¶

func PowIncrVSF32(a []float32, b float32, incr []float32)

func PowIncrVSF64 ¶

func PowIncrVSF64(a []float64, b float64, incr []float64)

func PowIterC128 ¶

func PowIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)

func PowIterC64 ¶

func PowIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)

func PowIterF32 ¶

func PowIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)

func PowIterF64 ¶

func PowIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)

func PowIterIncrC128 ¶

func PowIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, iit Iterator) (err error)

func PowIterIncrC64 ¶

func PowIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, iit Iterator) (err error)

func PowIterIncrF32 ¶

func PowIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, iit Iterator) (err error)

func PowIterIncrF64 ¶

func PowIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, iit Iterator) (err error)

func PowIterIncrSVC128 ¶

func PowIterIncrSVC128(a complex128, b []complex128, incr []complex128, bit Iterator, iit Iterator) (err error)

func PowIterIncrSVC64 ¶

func PowIterIncrSVC64(a complex64, b []complex64, incr []complex64, bit Iterator, iit Iterator) (err error)

func PowIterIncrSVF32 ¶

func PowIterIncrSVF32(a float32, b []float32, incr []float32, bit Iterator, iit Iterator) (err error)

func PowIterIncrSVF64 ¶

func PowIterIncrSVF64(a float64, b []float64, incr []float64, bit Iterator, iit Iterator) (err error)

func PowIterIncrVSC128 ¶

func PowIterIncrVSC128(a []complex128, b complex128, incr []complex128, ait Iterator, iit Iterator) (err error)

func PowIterIncrVSC64 ¶

func PowIterIncrVSC64(a []complex64, b complex64, incr []complex64, ait Iterator, iit Iterator) (err error)

func PowIterIncrVSF32 ¶

func PowIterIncrVSF32(a []float32, b float32, incr []float32, ait Iterator, iit Iterator) (err error)

func PowIterIncrVSF64 ¶

func PowIterIncrVSF64(a []float64, b float64, incr []float64, ait Iterator, iit Iterator) (err error)

func PowIterSVC128 ¶

func PowIterSVC128(a complex128, b []complex128, bit Iterator) (err error)

func PowIterSVC64 ¶

func PowIterSVC64(a complex64, b []complex64, bit Iterator) (err error)

func PowIterSVF32 ¶

func PowIterSVF32(a float32, b []float32, bit Iterator) (err error)

func PowIterSVF64 ¶

func PowIterSVF64(a float64, b []float64, bit Iterator) (err error)

func PowIterVSC128 ¶

func PowIterVSC128(a []complex128, b complex128, ait Iterator) (err error)

func PowIterVSC64 ¶

func PowIterVSC64(a []complex64, b complex64, ait Iterator) (err error)

func PowIterVSF32 ¶

func PowIterVSF32(a []float32, b float32, ait Iterator) (err error)

func PowIterVSF64 ¶

func PowIterVSF64(a []float64, b float64, ait Iterator) (err error)

func PowSVC128 ¶

func PowSVC128(a complex128, b []complex128)

func PowSVC64 ¶

func PowSVC64(a complex64, b []complex64)

func PowSVF32 ¶

func PowSVF32(a float32, b []float32)

func PowSVF64 ¶

func PowSVF64(a float64, b []float64)

func PowVSC128 ¶

func PowVSC128(a []complex128, b complex128)

func PowVSC64 ¶

func PowVSC64(a []complex64, b complex64)

func PowVSF32 ¶

func PowVSF32(a []float32, b float32)

func PowVSF64 ¶

func PowVSF64(a []float64, b float64)

func ProdC128 ¶

func ProdC128(a []complex128) complex128

func ProdC64 ¶

func ProdC64(a []complex64) complex64

func ProdF32 ¶

func ProdF32(a []float32) float32

func ProdF64 ¶

func ProdF64(a []float64) float64

func ProdI ¶

func ProdI(a []int) int

func ProdI16 ¶

func ProdI16(a []int16) int16

func ProdI32 ¶

func ProdI32(a []int32) int32

func ProdI64 ¶

func ProdI64(a []int64) int64

func ProdI8 ¶

func ProdI8(a []int8) int8

func ProdU ¶

func ProdU(a []uint) uint

func ProdU16 ¶

func ProdU16(a []uint16) uint16

func ProdU32 ¶

func ProdU32(a []uint32) uint32

func ProdU64 ¶

func ProdU64(a []uint64) uint64

func ProdU8 ¶

func ProdU8(a []uint8) uint8

func ReduceB ¶

func ReduceB(f func(a, b bool) bool, def bool, l ...bool) (retVal bool)

func ReduceC128 ¶

func ReduceC128(f func(a, b complex128) complex128, def complex128, l ...complex128) (retVal complex128)

func ReduceC64 ¶

func ReduceC64(f func(a, b complex64) complex64, def complex64, l ...complex64) (retVal complex64)

func ReduceF32 ¶

func ReduceF32(f func(a, b float32) float32, def float32, l ...float32) (retVal float32)

func ReduceF64 ¶

func ReduceF64(f func(a, b float64) float64, def float64, l ...float64) (retVal float64)

func ReduceI ¶

func ReduceI(f func(a, b int) int, def int, l ...int) (retVal int)

func ReduceI16 ¶

func ReduceI16(f func(a, b int16) int16, def int16, l ...int16) (retVal int16)

func ReduceI32 ¶

func ReduceI32(f func(a, b int32) int32, def int32, l ...int32) (retVal int32)

func ReduceI64 ¶

func ReduceI64(f func(a, b int64) int64, def int64, l ...int64) (retVal int64)

func ReduceI8 ¶

func ReduceI8(f func(a, b int8) int8, def int8, l ...int8) (retVal int8)

func ReduceStr ¶

func ReduceStr(f func(a, b string) string, def string, l ...string) (retVal string)

func ReduceU ¶

func ReduceU(f func(a, b uint) uint, def uint, l ...uint) (retVal uint)

func ReduceU16 ¶

func ReduceU16(f func(a, b uint16) uint16, def uint16, l ...uint16) (retVal uint16)

func ReduceU32 ¶

func ReduceU32(f func(a, b uint32) uint32, def uint32, l ...uint32) (retVal uint32)

func ReduceU64 ¶

func ReduceU64(f func(a, b uint64) uint64, def uint64, l ...uint64) (retVal uint64)

func ReduceU8 ¶

func ReduceU8(f func(a, b uint8) uint8, def uint8, l ...uint8) (retVal uint8)

func ReduceUintptr ¶

func ReduceUintptr(f func(a, b uintptr) uintptr, def uintptr, l ...uintptr) (retVal uintptr)

func ReduceUnsafePointer ¶

func ReduceUnsafePointer(f func(a, b unsafe.Pointer) unsafe.Pointer, def unsafe.Pointer, l ...unsafe.Pointer) (retVal unsafe.Pointer)

func SignF32 ¶

func SignF32(a []float32)

func SignF64 ¶

func SignF64(a []float64)

func SignI ¶

func SignI(a []int)

func SignI16 ¶

func SignI16(a []int16)

func SignI32 ¶

func SignI32(a []int32)

func SignI64 ¶

func SignI64(a []int64)

func SignI8 ¶

func SignI8(a []int8)

func SignIterF32 ¶

func SignIterF32(a []float32, ait Iterator) (err error)

func SignIterF64 ¶

func SignIterF64(a []float64, ait Iterator) (err error)

func SignIterI ¶

func SignIterI(a []int, ait Iterator) (err error)

func SignIterI16 ¶

func SignIterI16(a []int16, ait Iterator) (err error)

func SignIterI32 ¶

func SignIterI32(a []int32, ait Iterator) (err error)

func SignIterI64 ¶

func SignIterI64(a []int64, ait Iterator) (err error)

func SignIterI8 ¶

func SignIterI8(a []int8, ait Iterator) (err error)

func SliceMaxF32 ¶

func SliceMaxF32(a []float32) float32

func SliceMaxF64 ¶

func SliceMaxF64(a []float64) float64

func SliceMaxI ¶

func SliceMaxI(a []int) int

func SliceMaxI16 ¶

func SliceMaxI16(a []int16) int16

func SliceMaxI32 ¶

func SliceMaxI32(a []int32) int32

func SliceMaxI64 ¶

func SliceMaxI64(a []int64) int64

func SliceMaxI8 ¶

func SliceMaxI8(a []int8) int8

func SliceMaxU ¶

func SliceMaxU(a []uint) uint

func SliceMaxU16 ¶

func SliceMaxU16(a []uint16) uint16

func SliceMaxU32 ¶

func SliceMaxU32(a []uint32) uint32

func SliceMaxU64 ¶

func SliceMaxU64(a []uint64) uint64

func SliceMaxU8 ¶

func SliceMaxU8(a []uint8) uint8

func SliceMinF32 ¶

func SliceMinF32(a []float32) float32

func SliceMinF64 ¶

func SliceMinF64(a []float64) float64

func SliceMinI ¶

func SliceMinI(a []int) int

func SliceMinI16 ¶

func SliceMinI16(a []int16) int16

func SliceMinI32 ¶

func SliceMinI32(a []int32) int32

func SliceMinI64 ¶

func SliceMinI64(a []int64) int64

func SliceMinI8 ¶

func SliceMinI8(a []int8) int8

func SliceMinU ¶

func SliceMinU(a []uint) uint

func SliceMinU16 ¶

func SliceMinU16(a []uint16) uint16

func SliceMinU32 ¶

func SliceMinU32(a []uint32) uint32

func SliceMinU64 ¶

func SliceMinU64(a []uint64) uint64

func SliceMinU8 ¶

func SliceMinU8(a []uint8) uint8

func SqrtC128 ¶

func SqrtC128(a []complex128)

func SqrtC64 ¶

func SqrtC64(a []complex64)

func SqrtF32 ¶

func SqrtF32(a []float32)

func SqrtF64 ¶

func SqrtF64(a []float64)

func SqrtIterC128 ¶

func SqrtIterC128(a []complex128, ait Iterator) (err error)

func SqrtIterC64 ¶

func SqrtIterC64(a []complex64, ait Iterator) (err error)

func SqrtIterF32 ¶

func SqrtIterF32(a []float32, ait Iterator) (err error)

func SqrtIterF64 ¶

func SqrtIterF64(a []float64, ait Iterator) (err error)

func SquareC128 ¶

func SquareC128(a []complex128)

func SquareC64 ¶

func SquareC64(a []complex64)

func SquareF32 ¶

func SquareF32(a []float32)

func SquareF64 ¶

func SquareF64(a []float64)

func SquareI ¶

func SquareI(a []int)

func SquareI16 ¶

func SquareI16(a []int16)

func SquareI32 ¶

func SquareI32(a []int32)

func SquareI64 ¶

func SquareI64(a []int64)

func SquareI8 ¶

func SquareI8(a []int8)

func SquareIterC128 ¶

func SquareIterC128(a []complex128, ait Iterator) (err error)

func SquareIterC64 ¶

func SquareIterC64(a []complex64, ait Iterator) (err error)

func SquareIterF32 ¶

func SquareIterF32(a []float32, ait Iterator) (err error)

func SquareIterF64 ¶

func SquareIterF64(a []float64, ait Iterator) (err error)

func SquareIterI ¶

func SquareIterI(a []int, ait Iterator) (err error)

func SquareIterI16 ¶

func SquareIterI16(a []int16, ait Iterator) (err error)

func SquareIterI32 ¶

func SquareIterI32(a []int32, ait Iterator) (err error)

func SquareIterI64 ¶

func SquareIterI64(a []int64, ait Iterator) (err error)

func SquareIterI8 ¶

func SquareIterI8(a []int8, ait Iterator) (err error)

func SquareIterU ¶

func SquareIterU(a []uint, ait Iterator) (err error)

func SquareIterU16 ¶

func SquareIterU16(a []uint16, ait Iterator) (err error)

func SquareIterU32 ¶

func SquareIterU32(a []uint32, ait Iterator) (err error)

func SquareIterU64 ¶

func SquareIterU64(a []uint64, ait Iterator) (err error)

func SquareIterU8 ¶

func SquareIterU8(a []uint8, ait Iterator) (err error)

func SquareU ¶

func SquareU(a []uint)

func SquareU16 ¶

func SquareU16(a []uint16)

func SquareU32 ¶

func SquareU32(a []uint32)

func SquareU64 ¶

func SquareU64(a []uint64)

func SquareU8 ¶

func SquareU8(a []uint8)

func SubC128 ¶

func SubC128(a complex128, b complex128) complex128

func SubC64 ¶

func SubC64(a complex64, b complex64) complex64

func SubF32 ¶

func SubF32(a float32, b float32) float32

func SubF64 ¶

func SubF64(a float64, b float64) float64

func SubI ¶

func SubI(a int, b int) int

func SubI16 ¶

func SubI16(a int16, b int16) int16

func SubI32 ¶

func SubI32(a int32, b int32) int32

func SubI64 ¶

func SubI64(a int64, b int64) int64

func SubI8 ¶

func SubI8(a int8, b int8) int8

func SubIncrC128 ¶

func SubIncrC128(a []complex128, b []complex128, incr []complex128)

func SubIncrC64 ¶

func SubIncrC64(a []complex64, b []complex64, incr []complex64)

func SubIncrF32 ¶

func SubIncrF32(a []float32, b []float32, incr []float32)

func SubIncrF64 ¶

func SubIncrF64(a []float64, b []float64, incr []float64)

func SubIncrI ¶

func SubIncrI(a []int, b []int, incr []int)

func SubIncrI16 ¶

func SubIncrI16(a []int16, b []int16, incr []int16)

func SubIncrI32 ¶

func SubIncrI32(a []int32, b []int32, incr []int32)

func SubIncrI64 ¶

func SubIncrI64(a []int64, b []int64, incr []int64)

func SubIncrI8 ¶

func SubIncrI8(a []int8, b []int8, incr []int8)

func SubIncrSVC128 ¶

func SubIncrSVC128(a complex128, b []complex128, incr []complex128)

func SubIncrSVC64 ¶

func SubIncrSVC64(a complex64, b []complex64, incr []complex64)

func SubIncrSVF32 ¶

func SubIncrSVF32(a float32, b []float32, incr []float32)

func SubIncrSVF64 ¶

func SubIncrSVF64(a float64, b []float64, incr []float64)

func SubIncrSVI ¶

func SubIncrSVI(a int, b []int, incr []int)

func SubIncrSVI16 ¶

func SubIncrSVI16(a int16, b []int16, incr []int16)

func SubIncrSVI32 ¶

func SubIncrSVI32(a int32, b []int32, incr []int32)

func SubIncrSVI64 ¶

func SubIncrSVI64(a int64, b []int64, incr []int64)

func SubIncrSVI8 ¶

func SubIncrSVI8(a int8, b []int8, incr []int8)

func SubIncrSVU ¶

func SubIncrSVU(a uint, b []uint, incr []uint)

func SubIncrSVU16 ¶

func SubIncrSVU16(a uint16, b []uint16, incr []uint16)

func SubIncrSVU32 ¶

func SubIncrSVU32(a uint32, b []uint32, incr []uint32)

func SubIncrSVU64 ¶

func SubIncrSVU64(a uint64, b []uint64, incr []uint64)

func SubIncrSVU8 ¶

func SubIncrSVU8(a uint8, b []uint8, incr []uint8)

func SubIncrU ¶

func SubIncrU(a []uint, b []uint, incr []uint)

func SubIncrU16 ¶

func SubIncrU16(a []uint16, b []uint16, incr []uint16)

func SubIncrU32 ¶

func SubIncrU32(a []uint32, b []uint32, incr []uint32)

func SubIncrU64 ¶

func SubIncrU64(a []uint64, b []uint64, incr []uint64)

func SubIncrU8 ¶

func SubIncrU8(a []uint8, b []uint8, incr []uint8)

func SubIncrVSC128 ¶

func SubIncrVSC128(a []complex128, b complex128, incr []complex128)

func SubIncrVSC64 ¶

func SubIncrVSC64(a []complex64, b complex64, incr []complex64)

func SubIncrVSF32 ¶

func SubIncrVSF32(a []float32, b float32, incr []float32)

func SubIncrVSF64 ¶

func SubIncrVSF64(a []float64, b float64, incr []float64)

func SubIncrVSI ¶

func SubIncrVSI(a []int, b int, incr []int)

func SubIncrVSI16 ¶

func SubIncrVSI16(a []int16, b int16, incr []int16)

func SubIncrVSI32 ¶

func SubIncrVSI32(a []int32, b int32, incr []int32)

func SubIncrVSI64 ¶

func SubIncrVSI64(a []int64, b int64, incr []int64)

func SubIncrVSI8 ¶

func SubIncrVSI8(a []int8, b int8, incr []int8)

func SubIncrVSU ¶

func SubIncrVSU(a []uint, b uint, incr []uint)

func SubIncrVSU16 ¶

func SubIncrVSU16(a []uint16, b uint16, incr []uint16)

func SubIncrVSU32 ¶

func SubIncrVSU32(a []uint32, b uint32, incr []uint32)

func SubIncrVSU64 ¶

func SubIncrVSU64(a []uint64, b uint64, incr []uint64)

func SubIncrVSU8 ¶

func SubIncrVSU8(a []uint8, b uint8, incr []uint8)

func SubIterC128 ¶

func SubIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error)

func SubIterC64 ¶

func SubIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error)

func SubIterF32 ¶

func SubIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error)

func SubIterF64 ¶

func SubIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error)

func SubIterI ¶

func SubIterI(a []int, b []int, ait Iterator, bit Iterator) (err error)

func SubIterI16 ¶

func SubIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error)

func SubIterI32 ¶

func SubIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error)

func SubIterI64 ¶

func SubIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error)

func SubIterI8 ¶

func SubIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error)

func SubIterIncrC128 ¶

func SubIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrC64 ¶

func SubIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrF32 ¶

func SubIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrF64 ¶

func SubIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrI ¶

func SubIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrI16 ¶

func SubIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrI32 ¶

func SubIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrI64 ¶

func SubIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrI8 ¶

func SubIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVC128 ¶

func SubIterIncrSVC128(a complex128, b []complex128, incr []complex128, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVC64 ¶

func SubIterIncrSVC64(a complex64, b []complex64, incr []complex64, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVF32 ¶

func SubIterIncrSVF32(a float32, b []float32, incr []float32, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVF64 ¶

func SubIterIncrSVF64(a float64, b []float64, incr []float64, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVI ¶

func SubIterIncrSVI(a int, b []int, incr []int, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVI16 ¶

func SubIterIncrSVI16(a int16, b []int16, incr []int16, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVI32 ¶

func SubIterIncrSVI32(a int32, b []int32, incr []int32, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVI64 ¶

func SubIterIncrSVI64(a int64, b []int64, incr []int64, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVI8 ¶

func SubIterIncrSVI8(a int8, b []int8, incr []int8, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVU ¶

func SubIterIncrSVU(a uint, b []uint, incr []uint, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVU16 ¶

func SubIterIncrSVU16(a uint16, b []uint16, incr []uint16, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVU32 ¶

func SubIterIncrSVU32(a uint32, b []uint32, incr []uint32, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVU64 ¶

func SubIterIncrSVU64(a uint64, b []uint64, incr []uint64, bit Iterator, iit Iterator) (err error)

func SubIterIncrSVU8 ¶

func SubIterIncrSVU8(a uint8, b []uint8, incr []uint8, bit Iterator, iit Iterator) (err error)

func SubIterIncrU ¶

func SubIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrU16 ¶

func SubIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrU32 ¶

func SubIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrU64 ¶

func SubIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrU8 ¶

func SubIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error)

func SubIterIncrVSC128 ¶

func SubIterIncrVSC128(a []complex128, b complex128, incr []complex128, ait Iterator, iit Iterator) (err error)

func SubIterIncrVSC64 ¶

func SubIterIncrVSC64(a []complex64, b complex64, incr []complex64, ait Iterator, iit Iterator) (err error)

func SubIterIncrVSF32 ¶

func SubIterIncrVSF32(a []float32, b float32, incr []float32, ait Iterator, iit Iterator) (err error)

func SubIterIncrVSF64 ¶

func SubIterIncrVSF64(a []float64, b float64, incr []float64, ait Iterator, iit Iterator) (err error)

func SubIterIncrVSI ¶

func SubIterIncrVSI(a []int, b int, incr []int, ait Iterator, iit Iterator) (err error)

func SubIterIncrVSI16 ¶

func SubIterIncrVSI16(a []int16, b int16, incr []int16, ait Iterator, iit Iterator) (err error)

func SubIterIncrVSI32 ¶

func SubIterIncrVSI32(a []int32, b int32, incr []int32, ait Iterator, iit Iterator) (err error)

func SubIterIncrVSI64 ¶

func SubIterIncrVSI64(a []int64, b int64, incr []int64, ait Iterator, iit Iterator) (err error)

func SubIterIncrVSI8 ¶

func SubIterIncrVSI8(a []int8, b int8, incr []int8, ait Iterator, iit Iterator) (err error)

func SubIterIncrVSU ¶

func SubIterIncrVSU(a []uint, b uint, incr []uint, ait Iterator, iit Iterator) (err error)

func SubIterIncrVSU16 ¶

func SubIterIncrVSU16(a []uint16, b uint16, incr []uint16, ait Iterator, iit Iterator) (err error)

func SubIterIncrVSU32 ¶

func SubIterIncrVSU32(a []uint32, b uint32, incr []uint32, ait Iterator, iit Iterator) (err error)

func SubIterIncrVSU64 ¶

func SubIterIncrVSU64(a []uint64, b uint64, incr []uint64, ait Iterator, iit Iterator) (err error)

func SubIterIncrVSU8 ¶

func SubIterIncrVSU8(a []uint8, b uint8, incr []uint8, ait Iterator, iit Iterator) (err error)

func SubIterSVC128 ¶

func SubIterSVC128(a complex128, b []complex128, bit Iterator) (err error)

func SubIterSVC64 ¶

func SubIterSVC64(a complex64, b []complex64, bit Iterator) (err error)

func SubIterSVF32 ¶

func SubIterSVF32(a float32, b []float32, bit Iterator) (err error)

func SubIterSVF64 ¶

func SubIterSVF64(a float64, b []float64, bit Iterator) (err error)

func SubIterSVI ¶

func SubIterSVI(a int, b []int, bit Iterator) (err error)

func SubIterSVI16 ¶

func SubIterSVI16(a int16, b []int16, bit Iterator) (err error)

func SubIterSVI32 ¶

func SubIterSVI32(a int32, b []int32, bit Iterator) (err error)

func SubIterSVI64 ¶

func SubIterSVI64(a int64, b []int64, bit Iterator) (err error)

func SubIterSVI8 ¶

func SubIterSVI8(a int8, b []int8, bit Iterator) (err error)

func SubIterSVU ¶

func SubIterSVU(a uint, b []uint, bit Iterator) (err error)

func SubIterSVU16 ¶

func SubIterSVU16(a uint16, b []uint16, bit Iterator) (err error)

func SubIterSVU32 ¶

func SubIterSVU32(a uint32, b []uint32, bit Iterator) (err error)

func SubIterSVU64 ¶

func SubIterSVU64(a uint64, b []uint64, bit Iterator) (err error)

func SubIterSVU8 ¶

func SubIterSVU8(a uint8, b []uint8, bit Iterator) (err error)

func SubIterU ¶

func SubIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error)

func SubIterU16 ¶

func SubIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error)

func SubIterU32 ¶

func SubIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error)

func SubIterU64 ¶

func SubIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error)

func SubIterU8 ¶

func SubIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error)

func SubIterVSC128 ¶

func SubIterVSC128(a []complex128, b complex128, ait Iterator) (err error)

func SubIterVSC64 ¶

func SubIterVSC64(a []complex64, b complex64, ait Iterator) (err error)

func SubIterVSF32 ¶

func SubIterVSF32(a []float32, b float32, ait Iterator) (err error)

func SubIterVSF64 ¶

func SubIterVSF64(a []float64, b float64, ait Iterator) (err error)

func SubIterVSI ¶

func SubIterVSI(a []int, b int, ait Iterator) (err error)

func SubIterVSI16 ¶

func SubIterVSI16(a []int16, b int16, ait Iterator) (err error)

func SubIterVSI32 ¶

func SubIterVSI32(a []int32, b int32, ait Iterator) (err error)

func SubIterVSI64 ¶

func SubIterVSI64(a []int64, b int64, ait Iterator) (err error)

func SubIterVSI8 ¶

func SubIterVSI8(a []int8, b int8, ait Iterator) (err error)

func SubIterVSU ¶

func SubIterVSU(a []uint, b uint, ait Iterator) (err error)

func SubIterVSU16 ¶

func SubIterVSU16(a []uint16, b uint16, ait Iterator) (err error)

func SubIterVSU32 ¶

func SubIterVSU32(a []uint32, b uint32, ait Iterator) (err error)

func SubIterVSU64 ¶

func SubIterVSU64(a []uint64, b uint64, ait Iterator) (err error)

func SubIterVSU8 ¶

func SubIterVSU8(a []uint8, b uint8, ait Iterator) (err error)

func SubSVC128 ¶

func SubSVC128(a complex128, b []complex128)

func SubSVC64 ¶

func SubSVC64(a complex64, b []complex64)

func SubSVF32 ¶

func SubSVF32(a float32, b []float32)

func SubSVF64 ¶

func SubSVF64(a float64, b []float64)

func SubSVI ¶

func SubSVI(a int, b []int)

func SubSVI16 ¶

func SubSVI16(a int16, b []int16)

func SubSVI32 ¶

func SubSVI32(a int32, b []int32)

func SubSVI64 ¶

func SubSVI64(a int64, b []int64)

func SubSVI8 ¶

func SubSVI8(a int8, b []int8)

func SubSVU ¶

func SubSVU(a uint, b []uint)

func SubSVU16 ¶

func SubSVU16(a uint16, b []uint16)

func SubSVU32 ¶

func SubSVU32(a uint32, b []uint32)

func SubSVU64 ¶

func SubSVU64(a uint64, b []uint64)

func SubSVU8 ¶

func SubSVU8(a uint8, b []uint8)

func SubU ¶

func SubU(a uint, b uint) uint

func SubU16 ¶

func SubU16(a uint16, b uint16) uint16

func SubU32 ¶

func SubU32(a uint32, b uint32) uint32

func SubU64 ¶

func SubU64(a uint64, b uint64) uint64

func SubU8 ¶

func SubU8(a uint8, b uint8) uint8

func SubVSC128 ¶

func SubVSC128(a []complex128, b complex128)

func SubVSC64 ¶

func SubVSC64(a []complex64, b complex64)

func SubVSF32 ¶

func SubVSF32(a []float32, b float32)

func SubVSF64 ¶

func SubVSF64(a []float64, b float64)

func SubVSI ¶

func SubVSI(a []int, b int)

func SubVSI16 ¶

func SubVSI16(a []int16, b int16)

func SubVSI32 ¶

func SubVSI32(a []int32, b int32)

func SubVSI64 ¶

func SubVSI64(a []int64, b int64)

func SubVSI8 ¶

func SubVSI8(a []int8, b int8)

func SubVSU ¶

func SubVSU(a []uint, b uint)

func SubVSU16 ¶

func SubVSU16(a []uint16, b uint16)

func SubVSU32 ¶

func SubVSU32(a []uint32, b uint32)

func SubVSU64 ¶

func SubVSU64(a []uint64, b uint64)

func SubVSU8 ¶

func SubVSU8(a []uint8, b uint8)

func SumC128 ¶

func SumC128(a []complex128) complex128

func SumC64 ¶

func SumC64(a []complex64) complex64

func SumF32 ¶

func SumF32(a []float32) float32

func SumF64 ¶

func SumF64(a []float64) float64

func SumI ¶

func SumI(a []int) int

func SumI16 ¶

func SumI16(a []int16) int16

func SumI32 ¶

func SumI32(a []int32) int32

func SumI64 ¶

func SumI64(a []int64) int64

func SumI8 ¶

func SumI8(a []int8) int8

func SumMethods ¶

func SumMethods(t reflect.Type) (firstFn, lasFn, defaultFn interface{}, err error)

func SumU ¶

func SumU(a []uint) uint

func SumU16 ¶

func SumU16(a []uint16) uint16

func SumU32 ¶

func SumU32(a []uint32) uint32

func SumU64 ¶

func SumU64(a []uint64) uint64

func SumU8 ¶

func SumU8(a []uint8) uint8

func TanhC128 ¶

func TanhC128(a []complex128)

func TanhC64 ¶

func TanhC64(a []complex64)

func TanhF32 ¶

func TanhF32(a []float32)

func TanhF64 ¶

func TanhF64(a []float64)

func TanhIterC128 ¶

func TanhIterC128(a []complex128, ait Iterator) (err error)

func TanhIterC64 ¶

func TanhIterC64(a []complex64, ait Iterator) (err error)

func TanhIterF32 ¶

func TanhIterF32(a []float32, ait Iterator) (err error)

func TanhIterF64 ¶

func TanhIterF64(a []float64, ait Iterator) (err error)

func VecAddC128 ¶

func VecAddC128(a []complex128, b []complex128)

func VecAddC64 ¶

func VecAddC64(a []complex64, b []complex64)

func VecAddF32 ¶

func VecAddF32(a []float32, b []float32)

func VecAddF64 ¶

func VecAddF64(a []float64, b []float64)

func VecAddI ¶

func VecAddI(a []int, b []int)

func VecAddI16 ¶

func VecAddI16(a []int16, b []int16)

func VecAddI32 ¶

func VecAddI32(a []int32, b []int32)

func VecAddI64 ¶

func VecAddI64(a []int64, b []int64)

func VecAddI8 ¶

func VecAddI8(a []int8, b []int8)

func VecAddStr ¶

func VecAddStr(a []string, b []string)

func VecAddU ¶

func VecAddU(a []uint, b []uint)

func VecAddU16 ¶

func VecAddU16(a []uint16, b []uint16)

func VecAddU32 ¶

func VecAddU32(a []uint32, b []uint32)

func VecAddU64 ¶

func VecAddU64(a []uint64, b []uint64)

func VecAddU8 ¶

func VecAddU8(a []uint8, b []uint8)

func VecDivC128 ¶

func VecDivC128(a []complex128, b []complex128)

func VecDivC64 ¶

func VecDivC64(a []complex64, b []complex64)

func VecDivF32 ¶

func VecDivF32(a []float32, b []float32)

func VecDivF64 ¶

func VecDivF64(a []float64, b []float64)

func VecDivI ¶

func VecDivI(a []int, b []int) (err error)

func VecDivI16 ¶

func VecDivI16(a []int16, b []int16) (err error)

func VecDivI32 ¶

func VecDivI32(a []int32, b []int32) (err error)

func VecDivI64 ¶

func VecDivI64(a []int64, b []int64) (err error)

func VecDivI8 ¶

func VecDivI8(a []int8, b []int8) (err error)

func VecDivU ¶

func VecDivU(a []uint, b []uint) (err error)

func VecDivU16 ¶

func VecDivU16(a []uint16, b []uint16) (err error)

func VecDivU32 ¶

func VecDivU32(a []uint32, b []uint32) (err error)

func VecDivU64 ¶

func VecDivU64(a []uint64, b []uint64) (err error)

func VecDivU8 ¶

func VecDivU8(a []uint8, b []uint8) (err error)

func VecMaxF32 ¶

func VecMaxF32(a, b []float32)

func VecMaxF64 ¶

func VecMaxF64(a, b []float64)

func VecMaxI ¶

func VecMaxI(a, b []int)

func VecMaxI16 ¶

func VecMaxI16(a, b []int16)

func VecMaxI32 ¶

func VecMaxI32(a, b []int32)

func VecMaxI64 ¶

func VecMaxI64(a, b []int64)

func VecMaxI8 ¶

func VecMaxI8(a, b []int8)

func VecMaxStr ¶

func VecMaxStr(a, b []string)

func VecMaxU ¶

func VecMaxU(a, b []uint)

func VecMaxU16 ¶

func VecMaxU16(a, b []uint16)

func VecMaxU32 ¶

func VecMaxU32(a, b []uint32)

func VecMaxU64 ¶

func VecMaxU64(a, b []uint64)

func VecMaxU8 ¶

func VecMaxU8(a, b []uint8)

func VecMinF32 ¶

func VecMinF32(a, b []float32)

func VecMinF64 ¶

func VecMinF64(a, b []float64)

func VecMinI ¶

func VecMinI(a, b []int)

func VecMinI16 ¶

func VecMinI16(a, b []int16)

func VecMinI32 ¶

func VecMinI32(a, b []int32)

func VecMinI64 ¶

func VecMinI64(a, b []int64)

func VecMinI8 ¶

func VecMinI8(a, b []int8)

func VecMinStr ¶

func VecMinStr(a, b []string)

func VecMinU ¶

func VecMinU(a, b []uint)

func VecMinU16 ¶

func VecMinU16(a, b []uint16)

func VecMinU32 ¶

func VecMinU32(a, b []uint32)

func VecMinU64 ¶

func VecMinU64(a, b []uint64)

func VecMinU8 ¶

func VecMinU8(a, b []uint8)

func VecModF32 ¶

func VecModF32(a []float32, b []float32)

func VecModF64 ¶

func VecModF64(a []float64, b []float64)

func VecModI ¶

func VecModI(a []int, b []int)

func VecModI16 ¶

func VecModI16(a []int16, b []int16)

func VecModI32 ¶

func VecModI32(a []int32, b []int32)

func VecModI64 ¶

func VecModI64(a []int64, b []int64)

func VecModI8 ¶

func VecModI8(a []int8, b []int8)

func VecModU ¶

func VecModU(a []uint, b []uint)

func VecModU16 ¶

func VecModU16(a []uint16, b []uint16)

func VecModU32 ¶

func VecModU32(a []uint32, b []uint32)

func VecModU64 ¶

func VecModU64(a []uint64, b []uint64)

func VecModU8 ¶

func VecModU8(a []uint8, b []uint8)

func VecMulC128 ¶

func VecMulC128(a []complex128, b []complex128)

func VecMulC64 ¶

func VecMulC64(a []complex64, b []complex64)

func VecMulF32 ¶

func VecMulF32(a []float32, b []float32)

func VecMulF64 ¶

func VecMulF64(a []float64, b []float64)

func VecMulI ¶

func VecMulI(a []int, b []int)

func VecMulI16 ¶

func VecMulI16(a []int16, b []int16)

func VecMulI32 ¶

func VecMulI32(a []int32, b []int32)

func VecMulI64 ¶

func VecMulI64(a []int64, b []int64)

func VecMulI8 ¶

func VecMulI8(a []int8, b []int8)

func VecMulU ¶

func VecMulU(a []uint, b []uint)

func VecMulU16 ¶

func VecMulU16(a []uint16, b []uint16)

func VecMulU32 ¶

func VecMulU32(a []uint32, b []uint32)

func VecMulU64 ¶

func VecMulU64(a []uint64, b []uint64)

func VecMulU8 ¶

func VecMulU8(a []uint8, b []uint8)

func VecPowC128 ¶

func VecPowC128(a []complex128, b []complex128)

func VecPowC64 ¶

func VecPowC64(a []complex64, b []complex64)

func VecPowF32 ¶

func VecPowF32(a []float32, b []float32)

func VecPowF64 ¶

func VecPowF64(a []float64, b []float64)

func VecSubC128 ¶

func VecSubC128(a []complex128, b []complex128)

func VecSubC64 ¶

func VecSubC64(a []complex64, b []complex64)

func VecSubF32 ¶

func VecSubF32(a []float32, b []float32)

func VecSubF64 ¶

func VecSubF64(a []float64, b []float64)

func VecSubI ¶

func VecSubI(a []int, b []int)

func VecSubI16 ¶

func VecSubI16(a []int16, b []int16)

func VecSubI32 ¶

func VecSubI32(a []int32, b []int32)

func VecSubI64 ¶

func VecSubI64(a []int64, b []int64)

func VecSubI8 ¶

func VecSubI8(a []int8, b []int8)

func VecSubU ¶

func VecSubU(a []uint, b []uint)

func VecSubU16 ¶

func VecSubU16(a []uint16, b []uint16)

func VecSubU32 ¶

func VecSubU32(a []uint32, b []uint32)

func VecSubU64 ¶

func VecSubU64(a []uint64, b []uint64)

func VecSubU8 ¶

func VecSubU8(a []uint8, b []uint8)

Types ¶

type E ¶

type E struct{}

E is the standard engine. It's to be embedded in package tensor

func (E) Abs ¶

func (e E) Abs(t reflect.Type, a *storage.Header) (err error)

func (E) AbsIter ¶

func (e E) AbsIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

func (E) Add ¶

func (e E) Add(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) AddIncr ¶

func (e E) AddIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header) (err error)

func (E) AddIter ¶

func (e E) AddIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit Iterator) (err error)

func (E) AddIterIncr ¶

func (e E) AddIterIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header, ait Iterator, bit Iterator, iit Iterator) (err error)

func (E) AddSliced ¶ added in v0.9.15

func (e E) AddSliced(t reflect.Type, dataA *storage.Header, dstStart, dstEnd int, dataB *storage.Header, srcStart, srcEnd int) (err error)

func (E) ArgmaxFlat ¶

func (e E) ArgmaxFlat(t reflect.Type, a *storage.Header) (retVal int)

func (E) ArgmaxFlatMasked ¶

func (e E) ArgmaxFlatMasked(t reflect.Type, a *storage.Header, mask []bool) (retVal int)

func (E) ArgmaxIter ¶

func (e E) ArgmaxIter(t reflect.Type, a *storage.Header, it Iterator, lastSize int) (indices []int, err error)

func (E) ArgmaxIterMasked ¶

func (e E) ArgmaxIterMasked(t reflect.Type, a *storage.Header, mask []bool, it Iterator, lastSize int) (indices []int, err error)

func (E) ArgminFlat ¶

func (e E) ArgminFlat(t reflect.Type, a *storage.Header) (retVal int)

func (E) ArgminFlatMasked ¶

func (e E) ArgminFlatMasked(t reflect.Type, a *storage.Header, mask []bool) (retVal int)

func (E) ArgminIter ¶

func (e E) ArgminIter(t reflect.Type, a *storage.Header, it Iterator, lastSize int) (indices []int, err error)

func (E) ArgminIterMasked ¶

func (e E) ArgminIterMasked(t reflect.Type, a *storage.Header, mask []bool, it Iterator, lastSize int) (indices []int, err error)

func (E) Cbrt ¶

func (e E) Cbrt(t reflect.Type, a *storage.Header) (err error)

func (E) CbrtIter ¶

func (e E) CbrtIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

func (E) Clamp ¶

func (e E) Clamp(t reflect.Type, a *storage.Header, minVal interface{}, maxVal interface{}) (err error)

func (E) ClampIter ¶

func (e E) ClampIter(t reflect.Type, a *storage.Header, ait Iterator, minVal interface{}, maxVal interface{}) (err error)

func (E) Cube ¶

func (e E) Cube(t reflect.Type, a *storage.Header) (err error)

func (E) CubeIter ¶

func (e E) CubeIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

func (E) Div ¶

func (e E) Div(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) DivIncr ¶

func (e E) DivIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header) (err error)

func (E) DivIter ¶

func (e E) DivIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit Iterator) (err error)

func (E) DivIterIncr ¶

func (e E) DivIterIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header, ait Iterator, bit Iterator, iit Iterator) (err error)

func (E) Eq ¶

func (e E) Eq(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header) (err error)

func (E) EqIter ¶

func (e E) EqIter(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header, ait Iterator, bit Iterator, rit Iterator) (err error)

func (E) EqSame ¶

func (e E) EqSame(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) EqSameIter ¶

func (e E) EqSameIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit Iterator) (err error)

func (E) Exp ¶

func (e E) Exp(t reflect.Type, a *storage.Header) (err error)

func (E) ExpIter ¶

func (e E) ExpIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

func (E) Gt ¶

func (e E) Gt(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header) (err error)

func (E) GtIter ¶

func (e E) GtIter(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header, ait Iterator, bit Iterator, rit Iterator) (err error)

func (E) GtSame ¶

func (e E) GtSame(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) GtSameIter ¶

func (e E) GtSameIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit Iterator) (err error)

func (E) Gte ¶

func (e E) Gte(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header) (err error)

func (E) GteIter ¶

func (e E) GteIter(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header, ait Iterator, bit Iterator, rit Iterator) (err error)

func (E) GteSame ¶

func (e E) GteSame(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) GteSameIter ¶

func (e E) GteSameIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit Iterator) (err error)

func (E) Inv ¶

func (e E) Inv(t reflect.Type, a *storage.Header) (err error)

func (E) InvIter ¶

func (e E) InvIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

func (E) InvSqrt ¶

func (e E) InvSqrt(t reflect.Type, a *storage.Header) (err error)

func (E) InvSqrtIter ¶

func (e E) InvSqrtIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

func (E) Log ¶

func (e E) Log(t reflect.Type, a *storage.Header) (err error)

func (E) Log10 ¶

func (e E) Log10(t reflect.Type, a *storage.Header) (err error)

func (E) Log10Iter ¶

func (e E) Log10Iter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

func (E) Log2 ¶

func (e E) Log2(t reflect.Type, a *storage.Header) (err error)

func (E) Log2Iter ¶

func (e E) Log2Iter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

func (E) LogIter ¶

func (e E) LogIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

func (E) Lt ¶

func (e E) Lt(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header) (err error)

func (E) LtIter ¶

func (e E) LtIter(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header, ait Iterator, bit Iterator, rit Iterator) (err error)

func (E) LtSame ¶

func (e E) LtSame(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) LtSameIter ¶

func (e E) LtSameIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit Iterator) (err error)

func (E) Lte ¶

func (e E) Lte(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header) (err error)

func (E) LteIter ¶

func (e E) LteIter(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header, ait Iterator, bit Iterator, rit Iterator) (err error)

func (E) LteSame ¶

func (e E) LteSame(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) LteSameIter ¶

func (e E) LteSameIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit Iterator) (err error)

func (E) Map ¶

func (e E) Map(t reflect.Type, fn interface{}, a *storage.Header, incr bool) (err error)

func (E) MapIter ¶

func (e E) MapIter(t reflect.Type, fn interface{}, a *storage.Header, incr bool, ait Iterator) (err error)

func (E) Mod ¶

func (e E) Mod(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) ModIncr ¶

func (e E) ModIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header) (err error)

func (E) ModIter ¶

func (e E) ModIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit Iterator) (err error)

func (E) ModIterIncr ¶

func (e E) ModIterIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header, ait Iterator, bit Iterator, iit Iterator) (err error)

func (E) Mul ¶

func (e E) Mul(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) MulIncr ¶

func (e E) MulIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header) (err error)

func (E) MulIter ¶

func (e E) MulIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit Iterator) (err error)

func (E) MulIterIncr ¶

func (e E) MulIterIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header, ait Iterator, bit Iterator, iit Iterator) (err error)

func (E) Ne ¶

func (e E) Ne(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header) (err error)

func (E) NeIter ¶

func (e E) NeIter(t reflect.Type, a *storage.Header, b *storage.Header, retVal *storage.Header, ait Iterator, bit Iterator, rit Iterator) (err error)

func (E) NeSame ¶

func (e E) NeSame(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) NeSameIter ¶

func (e E) NeSameIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit Iterator) (err error)

func (E) Neg ¶

func (e E) Neg(t reflect.Type, a *storage.Header) (err error)

func (E) NegIter ¶

func (e E) NegIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

func (E) Pow ¶

func (e E) Pow(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) PowIncr ¶

func (e E) PowIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header) (err error)

func (E) PowIter ¶

func (e E) PowIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit Iterator) (err error)

func (E) PowIterIncr ¶

func (e E) PowIterIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header, ait Iterator, bit Iterator, iit Iterator) (err error)

func (E) Reduce ¶

func (e E) Reduce(t reflect.Type, a *storage.Header, defaultValue interface{}, fn interface{}) (retVal interface{}, err error)

func (E) ReduceDefault ¶

func (e E) ReduceDefault(t reflect.Type, data *storage.Header, retVal *storage.Header, dim0 int, dimSize int, outerStride int, stride int, expected int, fn interface{}) (err error)

func (E) ReduceFirst ¶

func (e E) ReduceFirst(t reflect.Type, data *storage.Header, retVal *storage.Header, split int, size int, fn interface{}) (err error)

func (E) ReduceLast ¶

func (e E) ReduceLast(t reflect.Type, data *storage.Header, retVal *storage.Header, dimSize int, defaultValue interface{}, fn interface{}) (err error)

func (E) Sign ¶

func (e E) Sign(t reflect.Type, a *storage.Header) (err error)

func (E) SignIter ¶

func (e E) SignIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

func (E) Sqrt ¶

func (e E) Sqrt(t reflect.Type, a *storage.Header) (err error)

func (E) SqrtIter ¶

func (e E) SqrtIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

func (E) Square ¶

func (e E) Square(t reflect.Type, a *storage.Header) (err error)

func (E) SquareIter ¶

func (e E) SquareIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

func (E) Sub ¶

func (e E) Sub(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) SubIncr ¶

func (e E) SubIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header) (err error)

func (E) SubIter ¶

func (e E) SubIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit Iterator) (err error)

func (E) SubIterIncr ¶

func (e E) SubIterIncr(t reflect.Type, a *storage.Header, b *storage.Header, incr *storage.Header, ait Iterator, bit Iterator, iit Iterator) (err error)

func (E) Tanh ¶

func (e E) Tanh(t reflect.Type, a *storage.Header) (err error)

func (E) TanhIter ¶

func (e E) TanhIter(t reflect.Type, a *storage.Header, ait Iterator) (err error)

type Iterator ¶

type Iterator interface {
	Start() (int, error)
	Next() (int, error)
	NextValidity() (int, bool, error)
	NextValid() (int, int, error)
	NextInvalid() (int, int, error)
	Reset()
	SetReverse()
	SetForward()
	Coord() []int
	Done() bool
}

Iterator is the generic iterator interface

type NoOpError ¶

type NoOpError interface {
	NoOp() bool
}

NoOpError is a useful for operations that have no op.

Source Files ¶

View all Source files

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