execution

package

v0.9.24 Latest Latest Go to latest Published: Jul 14, 2022 License: Apache-2.0 Imports: 10 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/wzzhu/tensor

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 AddRecvC128(a []complex128, b []complex128, recv []complex128)
func AddRecvC64(a []complex64, b []complex64, recv []complex64)
func AddRecvF32(a []float32, b []float32, recv []float32)
func AddRecvF64(a []float64, b []float64, recv []float64)
func AddRecvI(a []int, b []int, recv []int)
func AddRecvI16(a []int16, b []int16, recv []int16)
func AddRecvI32(a []int32, b []int32, recv []int32)
func AddRecvI64(a []int64, b []int64, recv []int64)
func AddRecvI8(a []int8, b []int8, recv []int8)
func AddRecvStr(a []string, b []string, recv []string)
func AddRecvU(a []uint, b []uint, recv []uint)
func AddRecvU16(a []uint16, b []uint16, recv []uint16)
func AddRecvU32(a []uint32, b []uint32, recv []uint32)
func AddRecvU64(a []uint64, b []uint64, recv []uint64)
func AddRecvU8(a []uint8, b []uint8, recv []uint8)
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 DivRecvC128(a []complex128, b []complex128, recv []complex128)
func DivRecvC64(a []complex64, b []complex64, recv []complex64)
func DivRecvF32(a []float32, b []float32, recv []float32)
func DivRecvF64(a []float64, b []float64, recv []float64)
func DivRecvI(a []int, b []int, recv []int) (err error)
func DivRecvI16(a []int16, b []int16, recv []int16) (err error)
func DivRecvI32(a []int32, b []int32, recv []int32) (err error)
func DivRecvI64(a []int64, b []int64, recv []int64) (err error)
func DivRecvI8(a []int8, b []int8, recv []int8) (err error)
func DivRecvU(a []uint, b []uint, recv []uint) (err error)
func DivRecvU16(a []uint16, b []uint16, recv []uint16) (err error)
func DivRecvU32(a []uint32, b []uint32, recv []uint32) (err error)
func DivRecvU64(a []uint64, b []uint64, recv []uint64) (err error)
func DivRecvU8(a []uint8, b []uint8, recv []uint8) (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 MaxIterSVF32(a float32, b []float32, bit Iterator) (err error)
func MaxIterSVF64(a float64, b []float64, bit Iterator) (err error)
func MaxIterSVI(a int, b []int, bit Iterator) (err error)
func MaxIterSVI16(a int16, b []int16, bit Iterator) (err error)
func MaxIterSVI32(a int32, b []int32, bit Iterator) (err error)
func MaxIterSVI64(a int64, b []int64, bit Iterator) (err error)
func MaxIterSVI8(a int8, b []int8, bit Iterator) (err error)
func MaxIterSVStr(a string, b []string, bit Iterator) (err error)
func MaxIterSVU(a uint, b []uint, bit Iterator) (err error)
func MaxIterSVU16(a uint16, b []uint16, bit Iterator) (err error)
func MaxIterSVU32(a uint32, b []uint32, bit Iterator) (err error)
func MaxIterSVU64(a uint64, b []uint64, bit Iterator) (err error)
func MaxIterSVU8(a uint8, b []uint8, bit Iterator) (err error)
func MaxIterVSF32(a []float32, b float32, ait Iterator) (err error)
func MaxIterVSF64(a []float64, b float64, ait Iterator) (err error)
func MaxIterVSI(a []int, b int, ait Iterator) (err error)
func MaxIterVSI16(a []int16, b int16, ait Iterator) (err error)
func MaxIterVSI32(a []int32, b int32, ait Iterator) (err error)
func MaxIterVSI64(a []int64, b int64, ait Iterator) (err error)
func MaxIterVSI8(a []int8, b int8, ait Iterator) (err error)
func MaxIterVSStr(a []string, b string, ait Iterator) (err error)
func MaxIterVSU(a []uint, b uint, ait Iterator) (err error)
func MaxIterVSU16(a []uint16, b uint16, ait Iterator) (err error)
func MaxIterVSU32(a []uint32, b uint32, ait Iterator) (err error)
func MaxIterVSU64(a []uint64, b uint64, ait Iterator) (err error)
func MaxIterVSU8(a []uint8, b uint8, ait Iterator) (err error)
func MaxMethods(t reflect.Type) (firstFn, lasFn, defaultFn interface{}, err error)
func MaxSVF32(a float32, b []float32)
func MaxSVF64(a float64, b []float64)
func MaxSVI(a int, b []int)
func MaxSVI16(a int16, b []int16)
func MaxSVI32(a int32, b []int32)
func MaxSVI64(a int64, b []int64)
func MaxSVI8(a int8, b []int8)
func MaxSVStr(a string, b []string)
func MaxSVU(a uint, b []uint)
func MaxSVU16(a uint16, b []uint16)
func MaxSVU32(a uint32, b []uint32)
func MaxSVU64(a uint64, b []uint64)
func MaxSVU8(a uint8, b []uint8)
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 MaxVSF32(a []float32, b float32)
func MaxVSF64(a []float64, b float64)
func MaxVSI(a []int, b int)
func MaxVSI16(a []int16, b int16)
func MaxVSI32(a []int32, b int32)
func MaxVSI64(a []int64, b int64)
func MaxVSI8(a []int8, b int8)
func MaxVSStr(a []string, b string)
func MaxVSU(a []uint, b uint)
func MaxVSU16(a []uint16, b uint16)
func MaxVSU32(a []uint32, b uint32)
func MaxVSU64(a []uint64, b uint64)
func MaxVSU8(a []uint8, b 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 MinIterSVF32(a float32, b []float32, bit Iterator) (err error)
func MinIterSVF64(a float64, b []float64, bit Iterator) (err error)
func MinIterSVI(a int, b []int, bit Iterator) (err error)
func MinIterSVI16(a int16, b []int16, bit Iterator) (err error)
func MinIterSVI32(a int32, b []int32, bit Iterator) (err error)
func MinIterSVI64(a int64, b []int64, bit Iterator) (err error)
func MinIterSVI8(a int8, b []int8, bit Iterator) (err error)
func MinIterSVStr(a string, b []string, bit Iterator) (err error)
func MinIterSVU(a uint, b []uint, bit Iterator) (err error)
func MinIterSVU16(a uint16, b []uint16, bit Iterator) (err error)
func MinIterSVU32(a uint32, b []uint32, bit Iterator) (err error)
func MinIterSVU64(a uint64, b []uint64, bit Iterator) (err error)
func MinIterSVU8(a uint8, b []uint8, bit Iterator) (err error)
func MinIterVSF32(a []float32, b float32, ait Iterator) (err error)
func MinIterVSF64(a []float64, b float64, ait Iterator) (err error)
func MinIterVSI(a []int, b int, ait Iterator) (err error)
func MinIterVSI16(a []int16, b int16, ait Iterator) (err error)
func MinIterVSI32(a []int32, b int32, ait Iterator) (err error)
func MinIterVSI64(a []int64, b int64, ait Iterator) (err error)
func MinIterVSI8(a []int8, b int8, ait Iterator) (err error)
func MinIterVSStr(a []string, b string, ait Iterator) (err error)
func MinIterVSU(a []uint, b uint, ait Iterator) (err error)
func MinIterVSU16(a []uint16, b uint16, ait Iterator) (err error)
func MinIterVSU32(a []uint32, b uint32, ait Iterator) (err error)
func MinIterVSU64(a []uint64, b uint64, ait Iterator) (err error)
func MinIterVSU8(a []uint8, b uint8, ait Iterator) (err error)
func MinMethods(t reflect.Type) (firstFn, lasFn, defaultFn interface{}, err error)
func MinSVF32(a float32, b []float32)
func MinSVF64(a float64, b []float64)
func MinSVI(a int, b []int)
func MinSVI16(a int16, b []int16)
func MinSVI32(a int32, b []int32)
func MinSVI64(a int64, b []int64)
func MinSVI8(a int8, b []int8)
func MinSVStr(a string, b []string)
func MinSVU(a uint, b []uint)
func MinSVU16(a uint16, b []uint16)
func MinSVU32(a uint32, b []uint32)
func MinSVU64(a uint64, b []uint64)
func MinSVU8(a uint8, b []uint8)
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 MinVSF32(a []float32, b float32)
func MinVSF64(a []float64, b float64)
func MinVSI(a []int, b int)
func MinVSI16(a []int16, b int16)
func MinVSI32(a []int32, b int32)
func MinVSI64(a []int64, b int64)
func MinVSI8(a []int8, b int8)
func MinVSStr(a []string, b string)
func MinVSU(a []uint, b uint)
func MinVSU16(a []uint16, b uint16)
func MinVSU32(a []uint32, b uint32)
func MinVSU64(a []uint64, b uint64)
func MinVSU8(a []uint8, b 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 ModRecvF32(a []float32, b []float32, recv []float32)
func ModRecvF64(a []float64, b []float64, recv []float64)
func ModRecvI(a []int, b []int, recv []int)
func ModRecvI16(a []int16, b []int16, recv []int16)
func ModRecvI32(a []int32, b []int32, recv []int32)
func ModRecvI64(a []int64, b []int64, recv []int64)
func ModRecvI8(a []int8, b []int8, recv []int8)
func ModRecvU(a []uint, b []uint, recv []uint)
func ModRecvU16(a []uint16, b []uint16, recv []uint16)
func ModRecvU32(a []uint32, b []uint32, recv []uint32)
func ModRecvU64(a []uint64, b []uint64, recv []uint64)
func ModRecvU8(a []uint8, b []uint8, recv []uint8)
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 MulRecvC128(a []complex128, b []complex128, recv []complex128)
func MulRecvC64(a []complex64, b []complex64, recv []complex64)
func MulRecvF32(a []float32, b []float32, recv []float32)
func MulRecvF64(a []float64, b []float64, recv []float64)
func MulRecvI(a []int, b []int, recv []int)
func MulRecvI16(a []int16, b []int16, recv []int16)
func MulRecvI32(a []int32, b []int32, recv []int32)
func MulRecvI64(a []int64, b []int64, recv []int64)
func MulRecvI8(a []int8, b []int8, recv []int8)
func MulRecvU(a []uint, b []uint, recv []uint)
func MulRecvU16(a []uint16, b []uint16, recv []uint16)
func MulRecvU32(a []uint32, b []uint32, recv []uint32)
func MulRecvU64(a []uint64, b []uint64, recv []uint64)
func MulRecvU8(a []uint8, b []uint8, recv []uint8)
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 PowRecvC128(a []complex128, b []complex128, recv []complex128)
func PowRecvC64(a []complex64, b []complex64, recv []complex64)
func PowRecvF32(a []float32, b []float32, recv []float32)
func PowRecvF64(a []float64, b []float64, recv []float64)
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 SubRecvC128(a []complex128, b []complex128, recv []complex128)
func SubRecvC64(a []complex64, b []complex64, recv []complex64)
func SubRecvF32(a []float32, b []float32, recv []float32)
func SubRecvF64(a []float64, b []float64, recv []float64)
func SubRecvI(a []int, b []int, recv []int)
func SubRecvI16(a []int16, b []int16, recv []int16)
func SubRecvI32(a []int32, b []int32, recv []int32)
func SubRecvI64(a []int64, b []int64, recv []int64)
func SubRecvI8(a []int8, b []int8, recv []int8)
func SubRecvU(a []uint, b []uint, recv []uint)
func SubRecvU16(a []uint16, b []uint16, recv []uint16)
func SubRecvU32(a []uint32, b []uint32, recv []uint32)
func SubRecvU64(a []uint64, b []uint64, recv []uint64)
func SubRecvU8(a []uint8, b []uint8, recv []uint8)
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 VecMaxIterF32(a, b []float32, ait, bit Iterator) (err error)
func VecMaxIterF64(a, b []float64, ait, bit Iterator) (err error)
func VecMaxIterI(a, b []int, ait, bit Iterator) (err error)
func VecMaxIterI16(a, b []int16, ait, bit Iterator) (err error)
func VecMaxIterI32(a, b []int32, ait, bit Iterator) (err error)
func VecMaxIterI64(a, b []int64, ait, bit Iterator) (err error)
func VecMaxIterI8(a, b []int8, ait, bit Iterator) (err error)
func VecMaxIterStr(a, b []string, ait, bit Iterator) (err error)
func VecMaxIterU(a, b []uint, ait, bit Iterator) (err error)
func VecMaxIterU16(a, b []uint16, ait, bit Iterator) (err error)
func VecMaxIterU32(a, b []uint32, ait, bit Iterator) (err error)
func VecMaxIterU64(a, b []uint64, ait, bit Iterator) (err error)
func VecMaxIterU8(a, b []uint8, ait, bit Iterator) (err error)
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 VecMinIterF32(a, b []float32, ait, bit Iterator) (err error)
func VecMinIterF64(a, b []float64, ait, bit Iterator) (err error)
func VecMinIterI(a, b []int, ait, bit Iterator) (err error)
func VecMinIterI16(a, b []int16, ait, bit Iterator) (err error)
func VecMinIterI32(a, b []int32, ait, bit Iterator) (err error)
func VecMinIterI64(a, b []int64, ait, bit Iterator) (err error)
func VecMinIterI8(a, b []int8, ait, bit Iterator) (err error)
func VecMinIterStr(a, b []string, ait, bit Iterator) (err error)
func VecMinIterU(a, b []uint, ait, bit Iterator) (err error)
func VecMinIterU16(a, b []uint16, ait, bit Iterator) (err error)
func VecMinIterU32(a, b []uint32, ait, bit Iterator) (err error)
func VecMinIterU64(a, b []uint64, ait, bit Iterator) (err error)
func VecMinIterU8(a, b []uint8, ait, bit Iterator) (err error)
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) AddRecv(t reflect.Type, a *storage.Header, b *storage.Header, recv *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) DivRecv(t reflect.Type, a *storage.Header, b *storage.Header, recv *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) MaxBetween(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) MaxBetweenIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, ...) (err error)
- func (e E) MinBetween(t reflect.Type, a *storage.Header, b *storage.Header) (err error)
- func (e E) MinBetweenIter(t reflect.Type, a *storage.Header, b *storage.Header, 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) ModRecv(t reflect.Type, a *storage.Header, b *storage.Header, recv *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) MulRecv(t reflect.Type, a *storage.Header, b *storage.Header, recv *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) PowRecv(t reflect.Type, a *storage.Header, b *storage.Header, recv *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) SubRecv(t reflect.Type, a *storage.Header, b *storage.Header, recv *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 AddRecvC128 ¶

func AddRecvC128(a []complex128, b []complex128, recv []complex128)

func AddRecvC64 ¶

func AddRecvC64(a []complex64, b []complex64, recv []complex64)

func AddRecvF32 ¶

func AddRecvF32(a []float32, b []float32, recv []float32)

func AddRecvF64 ¶

func AddRecvF64(a []float64, b []float64, recv []float64)

func AddRecvI ¶

func AddRecvI(a []int, b []int, recv []int)

func AddRecvI16 ¶

func AddRecvI16(a []int16, b []int16, recv []int16)

func AddRecvI32 ¶

func AddRecvI32(a []int32, b []int32, recv []int32)

func AddRecvI64 ¶

func AddRecvI64(a []int64, b []int64, recv []int64)

func AddRecvI8 ¶

func AddRecvI8(a []int8, b []int8, recv []int8)

func AddRecvStr ¶

func AddRecvStr(a []string, b []string, recv []string)

func AddRecvU ¶

func AddRecvU(a []uint, b []uint, recv []uint)

func AddRecvU16 ¶

func AddRecvU16(a []uint16, b []uint16, recv []uint16)

func AddRecvU32 ¶

func AddRecvU32(a []uint32, b []uint32, recv []uint32)

func AddRecvU64 ¶

func AddRecvU64(a []uint64, b []uint64, recv []uint64)

func AddRecvU8 ¶

func AddRecvU8(a []uint8, b []uint8, recv []uint8)

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 DivRecvC128 ¶

func DivRecvC128(a []complex128, b []complex128, recv []complex128)

func DivRecvC64 ¶

func DivRecvC64(a []complex64, b []complex64, recv []complex64)

func DivRecvF32 ¶

func DivRecvF32(a []float32, b []float32, recv []float32)

func DivRecvF64 ¶

func DivRecvF64(a []float64, b []float64, recv []float64)

func DivRecvI ¶

func DivRecvI(a []int, b []int, recv []int) (err error)

func DivRecvI16 ¶

func DivRecvI16(a []int16, b []int16, recv []int16) (err error)

func DivRecvI32 ¶

func DivRecvI32(a []int32, b []int32, recv []int32) (err error)

func DivRecvI64 ¶

func DivRecvI64(a []int64, b []int64, recv []int64) (err error)

func DivRecvI8 ¶

func DivRecvI8(a []int8, b []int8, recv []int8) (err error)

func DivRecvU ¶

func DivRecvU(a []uint, b []uint, recv []uint) (err error)

func DivRecvU16 ¶

func DivRecvU16(a []uint16, b []uint16, recv []uint16) (err error)

func DivRecvU32 ¶

func DivRecvU32(a []uint32, b []uint32, recv []uint32) (err error)

func DivRecvU64 ¶

func DivRecvU64(a []uint64, b []uint64, recv []uint64) (err error)

func DivRecvU8 ¶

func DivRecvU8(a []uint8, b []uint8, recv []uint8) (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 MaxIterSVF32 ¶

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

func MaxIterSVF64 ¶

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

func MaxIterSVI ¶

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

func MaxIterSVI16 ¶

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

func MaxIterSVI32 ¶

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

func MaxIterSVI64 ¶

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

func MaxIterSVI8 ¶

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

func MaxIterSVStr ¶

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

func MaxIterSVU ¶

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

func MaxIterSVU16 ¶

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

func MaxIterSVU32 ¶

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

func MaxIterSVU64 ¶

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

func MaxIterSVU8 ¶

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

func MaxIterVSF32 ¶

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

func MaxIterVSF64 ¶

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

func MaxIterVSI ¶

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

func MaxIterVSI16 ¶

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

func MaxIterVSI32 ¶

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

func MaxIterVSI64 ¶

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

func MaxIterVSI8 ¶

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

func MaxIterVSStr ¶

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

func MaxIterVSU ¶

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

func MaxIterVSU16 ¶

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

func MaxIterVSU32 ¶

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

func MaxIterVSU64 ¶

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

func MaxIterVSU8 ¶

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

func MaxMethods ¶

func MaxMethods(t reflect.Type) (firstFn, lasFn, defaultFn interface{}, err error)

func MaxSVF32 ¶

func MaxSVF32(a float32, b []float32)

func MaxSVF64 ¶

func MaxSVF64(a float64, b []float64)

func MaxSVI ¶

func MaxSVI(a int, b []int)

func MaxSVI16 ¶

func MaxSVI16(a int16, b []int16)

func MaxSVI32 ¶

func MaxSVI32(a int32, b []int32)

func MaxSVI64 ¶

func MaxSVI64(a int64, b []int64)

func MaxSVI8 ¶

func MaxSVI8(a int8, b []int8)

func MaxSVStr ¶

func MaxSVStr(a string, b []string)

func MaxSVU ¶

func MaxSVU(a uint, b []uint)

func MaxSVU16 ¶

func MaxSVU16(a uint16, b []uint16)

func MaxSVU32 ¶

func MaxSVU32(a uint32, b []uint32)

func MaxSVU64 ¶

func MaxSVU64(a uint64, b []uint64)

func MaxSVU8 ¶

func MaxSVU8(a uint8, b []uint8)

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 MaxVSF32 ¶

func MaxVSF32(a []float32, b float32)

func MaxVSF64 ¶

func MaxVSF64(a []float64, b float64)

func MaxVSI ¶

func MaxVSI(a []int, b int)

func MaxVSI16 ¶

func MaxVSI16(a []int16, b int16)

func MaxVSI32 ¶

func MaxVSI32(a []int32, b int32)

func MaxVSI64 ¶

func MaxVSI64(a []int64, b int64)

func MaxVSI8 ¶

func MaxVSI8(a []int8, b int8)

func MaxVSStr ¶

func MaxVSStr(a []string, b string)

func MaxVSU ¶

func MaxVSU(a []uint, b uint)

func MaxVSU16 ¶

func MaxVSU16(a []uint16, b uint16)

func MaxVSU32 ¶

func MaxVSU32(a []uint32, b uint32)

func MaxVSU64 ¶

func MaxVSU64(a []uint64, b uint64)

func MaxVSU8 ¶

func MaxVSU8(a []uint8, b 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 MinIterSVF32 ¶

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

func MinIterSVF64 ¶

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

func MinIterSVI ¶

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

func MinIterSVI16 ¶

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

func MinIterSVI32 ¶

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

func MinIterSVI64 ¶

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

func MinIterSVI8 ¶

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

func MinIterSVStr ¶

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

func MinIterSVU ¶

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

func MinIterSVU16 ¶

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

func MinIterSVU32 ¶

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

func MinIterSVU64 ¶

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

func MinIterSVU8 ¶

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

func MinIterVSF32 ¶

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

func MinIterVSF64 ¶

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

func MinIterVSI ¶

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

func MinIterVSI16 ¶

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

func MinIterVSI32 ¶

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

func MinIterVSI64 ¶

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

func MinIterVSI8 ¶

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

func MinIterVSStr ¶

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

func MinIterVSU ¶

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

func MinIterVSU16 ¶

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

func MinIterVSU32 ¶

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

func MinIterVSU64 ¶

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

func MinIterVSU8 ¶

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

func MinMethods ¶

func MinMethods(t reflect.Type) (firstFn, lasFn, defaultFn interface{}, err error)

func MinSVF32 ¶

func MinSVF32(a float32, b []float32)

func MinSVF64 ¶

func MinSVF64(a float64, b []float64)

func MinSVI ¶

func MinSVI(a int, b []int)

func MinSVI16 ¶

func MinSVI16(a int16, b []int16)

func MinSVI32 ¶

func MinSVI32(a int32, b []int32)

func MinSVI64 ¶

func MinSVI64(a int64, b []int64)

func MinSVI8 ¶

func MinSVI8(a int8, b []int8)

func MinSVStr ¶

func MinSVStr(a string, b []string)

func MinSVU ¶

func MinSVU(a uint, b []uint)

func MinSVU16 ¶

func MinSVU16(a uint16, b []uint16)

func MinSVU32 ¶

func MinSVU32(a uint32, b []uint32)

func MinSVU64 ¶

func MinSVU64(a uint64, b []uint64)

func MinSVU8 ¶

func MinSVU8(a uint8, b []uint8)

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 MinVSF32 ¶

func MinVSF32(a []float32, b float32)

func MinVSF64 ¶

func MinVSF64(a []float64, b float64)

func MinVSI ¶

func MinVSI(a []int, b int)

func MinVSI16 ¶

func MinVSI16(a []int16, b int16)

func MinVSI32 ¶

func MinVSI32(a []int32, b int32)

func MinVSI64 ¶

func MinVSI64(a []int64, b int64)

func MinVSI8 ¶

func MinVSI8(a []int8, b int8)

func MinVSStr ¶

func MinVSStr(a []string, b string)

func MinVSU ¶

func MinVSU(a []uint, b uint)

func MinVSU16 ¶

func MinVSU16(a []uint16, b uint16)

func MinVSU32 ¶

func MinVSU32(a []uint32, b uint32)

func MinVSU64 ¶

func MinVSU64(a []uint64, b uint64)

func MinVSU8 ¶

func MinVSU8(a []uint8, b 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 ModRecvF32 ¶

func ModRecvF32(a []float32, b []float32, recv []float32)

func ModRecvF64 ¶

func ModRecvF64(a []float64, b []float64, recv []float64)

func ModRecvI ¶

func ModRecvI(a []int, b []int, recv []int)

func ModRecvI16 ¶

func ModRecvI16(a []int16, b []int16, recv []int16)

func ModRecvI32 ¶

func ModRecvI32(a []int32, b []int32, recv []int32)

func ModRecvI64 ¶

func ModRecvI64(a []int64, b []int64, recv []int64)

func ModRecvI8 ¶

func ModRecvI8(a []int8, b []int8, recv []int8)

func ModRecvU ¶

func ModRecvU(a []uint, b []uint, recv []uint)

func ModRecvU16 ¶

func ModRecvU16(a []uint16, b []uint16, recv []uint16)

func ModRecvU32 ¶

func ModRecvU32(a []uint32, b []uint32, recv []uint32)

func ModRecvU64 ¶

func ModRecvU64(a []uint64, b []uint64, recv []uint64)

func ModRecvU8 ¶

func ModRecvU8(a []uint8, b []uint8, recv []uint8)

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 MulRecvC128 ¶

func MulRecvC128(a []complex128, b []complex128, recv []complex128)

func MulRecvC64 ¶

func MulRecvC64(a []complex64, b []complex64, recv []complex64)

func MulRecvF32 ¶

func MulRecvF32(a []float32, b []float32, recv []float32)

func MulRecvF64 ¶

func MulRecvF64(a []float64, b []float64, recv []float64)

func MulRecvI ¶

func MulRecvI(a []int, b []int, recv []int)

func MulRecvI16 ¶

func MulRecvI16(a []int16, b []int16, recv []int16)

func MulRecvI32 ¶

func MulRecvI32(a []int32, b []int32, recv []int32)

func MulRecvI64 ¶

func MulRecvI64(a []int64, b []int64, recv []int64)

func MulRecvI8 ¶

func MulRecvI8(a []int8, b []int8, recv []int8)

func MulRecvU ¶

func MulRecvU(a []uint, b []uint, recv []uint)

func MulRecvU16 ¶

func MulRecvU16(a []uint16, b []uint16, recv []uint16)

func MulRecvU32 ¶

func MulRecvU32(a []uint32, b []uint32, recv []uint32)

func MulRecvU64 ¶

func MulRecvU64(a []uint64, b []uint64, recv []uint64)

func MulRecvU8 ¶

func MulRecvU8(a []uint8, b []uint8, recv []uint8)

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 PowRecvC128 ¶

func PowRecvC128(a []complex128, b []complex128, recv []complex128)

func PowRecvC64 ¶

func PowRecvC64(a []complex64, b []complex64, recv []complex64)

func PowRecvF32 ¶

func PowRecvF32(a []float32, b []float32, recv []float32)

func PowRecvF64 ¶

func PowRecvF64(a []float64, b []float64, recv []float64)

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 SubRecvC128 ¶

func SubRecvC128(a []complex128, b []complex128, recv []complex128)

func SubRecvC64 ¶

func SubRecvC64(a []complex64, b []complex64, recv []complex64)

func SubRecvF32 ¶

func SubRecvF32(a []float32, b []float32, recv []float32)

func SubRecvF64 ¶

func SubRecvF64(a []float64, b []float64, recv []float64)

func SubRecvI ¶

func SubRecvI(a []int, b []int, recv []int)

func SubRecvI16 ¶

func SubRecvI16(a []int16, b []int16, recv []int16)

func SubRecvI32 ¶

func SubRecvI32(a []int32, b []int32, recv []int32)

func SubRecvI64 ¶

func SubRecvI64(a []int64, b []int64, recv []int64)

func SubRecvI8 ¶

func SubRecvI8(a []int8, b []int8, recv []int8)

func SubRecvU ¶

func SubRecvU(a []uint, b []uint, recv []uint)

func SubRecvU16 ¶

func SubRecvU16(a []uint16, b []uint16, recv []uint16)

func SubRecvU32 ¶

func SubRecvU32(a []uint32, b []uint32, recv []uint32)

func SubRecvU64 ¶

func SubRecvU64(a []uint64, b []uint64, recv []uint64)

func SubRecvU8 ¶

func SubRecvU8(a []uint8, b []uint8, recv []uint8)

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 VecMaxIterF32 ¶

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

func VecMaxIterF64 ¶

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

func VecMaxIterI ¶

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

func VecMaxIterI16 ¶

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

func VecMaxIterI32 ¶

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

func VecMaxIterI64 ¶

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

func VecMaxIterI8 ¶

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

func VecMaxIterStr ¶

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

func VecMaxIterU ¶

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

func VecMaxIterU16 ¶

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

func VecMaxIterU32 ¶

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

func VecMaxIterU64 ¶

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

func VecMaxIterU8 ¶

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

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 VecMinIterF32 ¶

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

func VecMinIterF64 ¶

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

func VecMinIterI ¶

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

func VecMinIterI16 ¶

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

func VecMinIterI32 ¶

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

func VecMinIterI64 ¶

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

func VecMinIterI8 ¶

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

func VecMinIterStr ¶

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

func VecMinIterU ¶

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

func VecMinIterU16 ¶

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

func VecMinIterU32 ¶

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

func VecMinIterU64 ¶

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

func VecMinIterU8 ¶

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

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) AddRecv ¶

func (e E) AddRecv(t reflect.Type, a *storage.Header, b *storage.Header, recv *storage.Header) (err error)

func (E) AddSliced ¶

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) DivRecv ¶

func (e E) DivRecv(t reflect.Type, a *storage.Header, b *storage.Header, recv *storage.Header) (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) MaxBetween ¶

func (e E) MaxBetween(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) MaxBetweenIter ¶

func (e E) MaxBetweenIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit Iterator) (err error)

func (E) MinBetween ¶

func (e E) MinBetween(t reflect.Type, a *storage.Header, b *storage.Header) (err error)

func (E) MinBetweenIter ¶

func (e E) MinBetweenIter(t reflect.Type, a *storage.Header, b *storage.Header, ait Iterator, bit 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) ModRecv ¶

func (e E) ModRecv(t reflect.Type, a *storage.Header, b *storage.Header, recv *storage.Header) (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) MulRecv ¶

func (e E) MulRecv(t reflect.Type, a *storage.Header, b *storage.Header, recv *storage.Header) (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) PowRecv ¶

func (e E) PowRecv(t reflect.Type, a *storage.Header, b *storage.Header, recv *storage.Header) (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) SubRecv ¶

func (e E) SubRecv(t reflect.Type, a *storage.Header, b *storage.Header, recv *storage.Header) (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