@ttsc/win32-arm64 0.33.1 → 0.34.0

package/bin/go/src/simd/tofrom_arm64.go

@@ -0,0 +1,290 @@
+// Code generated by 'go run -C $GOROOT/src/simd/archsimd/_gen/midway'; DO NOT EDIT.
+
+//go:build goexperiment.simd && arm64
+
+package simd
+
+import (
+	"simd/archsimd"
+	"simd/internal/bridge"
+)
+
+func (x Int8s) ToArch() any
+
+type archSimdInt8s interface {
+	archsimd.Int8x16
+}
+
+func Int8sFromArch[T archSimdInt8s](x T) Int8s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Int8s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Int8x16:
+		var t bridge.Int8x16 = bridge.Int8x16(a)
+		return (any(t)).(Int8s)
+	}
+	panic("wrong type")
+}
+
+func (x Int16s) ToArch() any
+
+type archSimdInt16s interface {
+	archsimd.Int16x8
+}
+
+func Int16sFromArch[T archSimdInt16s](x T) Int16s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Int16s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Int16x8:
+		var t bridge.Int16x8 = bridge.Int16x8(a)
+		return (any(t)).(Int16s)
+	}
+	panic("wrong type")
+}
+
+func (x Int32s) ToArch() any
+
+type archSimdInt32s interface {
+	archsimd.Int32x4
+}
+
+func Int32sFromArch[T archSimdInt32s](x T) Int32s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Int32s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Int32x4:
+		var t bridge.Int32x4 = bridge.Int32x4(a)
+		return (any(t)).(Int32s)
+	}
+	panic("wrong type")
+}
+
+func (x Int64s) ToArch() any
+
+type archSimdInt64s interface {
+	archsimd.Int64x2
+}
+
+func Int64sFromArch[T archSimdInt64s](x T) Int64s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Int64s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Int64x2:
+		var t bridge.Int64x2 = bridge.Int64x2(a)
+		return (any(t)).(Int64s)
+	}
+	panic("wrong type")
+}
+
+func (x Uint8s) ToArch() any
+
+type archSimdUint8s interface {
+	archsimd.Uint8x16
+}
+
+func Uint8sFromArch[T archSimdUint8s](x T) Uint8s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Uint8s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Uint8x16:
+		var t bridge.Uint8x16 = bridge.Uint8x16(a)
+		return (any(t)).(Uint8s)
+	}
+	panic("wrong type")
+}
+
+func (x Uint16s) ToArch() any
+
+type archSimdUint16s interface {
+	archsimd.Uint16x8
+}
+
+func Uint16sFromArch[T archSimdUint16s](x T) Uint16s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Uint16s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Uint16x8:
+		var t bridge.Uint16x8 = bridge.Uint16x8(a)
+		return (any(t)).(Uint16s)
+	}
+	panic("wrong type")
+}
+
+func (x Uint32s) ToArch() any
+
+type archSimdUint32s interface {
+	archsimd.Uint32x4
+}
+
+func Uint32sFromArch[T archSimdUint32s](x T) Uint32s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Uint32s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Uint32x4:
+		var t bridge.Uint32x4 = bridge.Uint32x4(a)
+		return (any(t)).(Uint32s)
+	}
+	panic("wrong type")
+}
+
+func (x Uint64s) ToArch() any
+
+type archSimdUint64s interface {
+	archsimd.Uint64x2
+}
+
+func Uint64sFromArch[T archSimdUint64s](x T) Uint64s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Uint64s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Uint64x2:
+		var t bridge.Uint64x2 = bridge.Uint64x2(a)
+		return (any(t)).(Uint64s)
+	}
+	panic("wrong type")
+}
+
+func (x Float32s) ToArch() any
+
+type archSimdFloat32s interface {
+	archsimd.Float32x4
+}
+
+func Float32sFromArch[T archSimdFloat32s](x T) Float32s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Float32s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Float32x4:
+		var t bridge.Float32x4 = bridge.Float32x4(a)
+		return (any(t)).(Float32s)
+	}
+	panic("wrong type")
+}
+
+func (x Float64s) ToArch() any
+
+type archSimdFloat64s interface {
+	archsimd.Float64x2
+}
+
+func Float64sFromArch[T archSimdFloat64s](x T) Float64s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Float64s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Float64x2:
+		var t bridge.Float64x2 = bridge.Float64x2(a)
+		return (any(t)).(Float64s)
+	}
+	panic("wrong type")
+}
+
+func (x Mask8s) ToArch() any
+
+type archSimdMask8s interface {
+	archsimd.Mask8x16
+}
+
+func Mask8sFromArch[T archSimdMask8s](x T) Mask8s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Mask8s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Mask8x16:
+		var t bridge.Mask8x16 = bridge.Mask8x16(a)
+		return (any(t)).(Mask8s)
+	}
+	panic("wrong type")
+}
+
+func (x Mask16s) ToArch() any
+
+type archSimdMask16s interface {
+	archsimd.Mask16x8
+}
+
+func Mask16sFromArch[T archSimdMask16s](x T) Mask16s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Mask16s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Mask16x8:
+		var t bridge.Mask16x8 = bridge.Mask16x8(a)
+		return (any(t)).(Mask16s)
+	}
+	panic("wrong type")
+}
+
+func (x Mask32s) ToArch() any
+
+type archSimdMask32s interface {
+	archsimd.Mask32x4
+}
+
+func Mask32sFromArch[T archSimdMask32s](x T) Mask32s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Mask32s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Mask32x4:
+		var t bridge.Mask32x4 = bridge.Mask32x4(a)
+		return (any(t)).(Mask32s)
+	}
+	panic("wrong type")
+}
+
+func (x Mask64s) ToArch() any
+
+type archSimdMask64s interface {
+	archsimd.Mask64x2
+}
+
+func Mask64sFromArch[T archSimdMask64s](x T) Mask64s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Mask64s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Mask64x2:
+		var t bridge.Mask64x2 = bridge.Mask64x2(a)
+		return (any(t)).(Mask64s)
+	}
+	panic("wrong type")
+}

package/bin/go/src/simd/tofrom_wasm.go

@@ -0,0 +1,290 @@
+// Code generated by 'go run -C $GOROOT/src/simd/archsimd/_gen/midway'; DO NOT EDIT.
+
+//go:build goexperiment.simd && wasm
+
+package simd
+
+import (
+	"simd/archsimd"
+	"simd/internal/bridge"
+)
+
+func (x Int8s) ToArch() any
+
+type archSimdInt8s interface {
+	archsimd.Int8x16
+}
+
+func Int8sFromArch[T archSimdInt8s](x T) Int8s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Int8s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Int8x16:
+		var t bridge.Int8x16 = bridge.Int8x16(a)
+		return (any(t)).(Int8s)
+	}
+	panic("wrong type")
+}
+
+func (x Int16s) ToArch() any
+
+type archSimdInt16s interface {
+	archsimd.Int16x8
+}
+
+func Int16sFromArch[T archSimdInt16s](x T) Int16s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Int16s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Int16x8:
+		var t bridge.Int16x8 = bridge.Int16x8(a)
+		return (any(t)).(Int16s)
+	}
+	panic("wrong type")
+}
+
+func (x Int32s) ToArch() any
+
+type archSimdInt32s interface {
+	archsimd.Int32x4
+}
+
+func Int32sFromArch[T archSimdInt32s](x T) Int32s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Int32s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Int32x4:
+		var t bridge.Int32x4 = bridge.Int32x4(a)
+		return (any(t)).(Int32s)
+	}
+	panic("wrong type")
+}
+
+func (x Int64s) ToArch() any
+
+type archSimdInt64s interface {
+	archsimd.Int64x2
+}
+
+func Int64sFromArch[T archSimdInt64s](x T) Int64s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Int64s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Int64x2:
+		var t bridge.Int64x2 = bridge.Int64x2(a)
+		return (any(t)).(Int64s)
+	}
+	panic("wrong type")
+}
+
+func (x Uint8s) ToArch() any
+
+type archSimdUint8s interface {
+	archsimd.Uint8x16
+}
+
+func Uint8sFromArch[T archSimdUint8s](x T) Uint8s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Uint8s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Uint8x16:
+		var t bridge.Uint8x16 = bridge.Uint8x16(a)
+		return (any(t)).(Uint8s)
+	}
+	panic("wrong type")
+}
+
+func (x Uint16s) ToArch() any
+
+type archSimdUint16s interface {
+	archsimd.Uint16x8
+}
+
+func Uint16sFromArch[T archSimdUint16s](x T) Uint16s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Uint16s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Uint16x8:
+		var t bridge.Uint16x8 = bridge.Uint16x8(a)
+		return (any(t)).(Uint16s)
+	}
+	panic("wrong type")
+}
+
+func (x Uint32s) ToArch() any
+
+type archSimdUint32s interface {
+	archsimd.Uint32x4
+}
+
+func Uint32sFromArch[T archSimdUint32s](x T) Uint32s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Uint32s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Uint32x4:
+		var t bridge.Uint32x4 = bridge.Uint32x4(a)
+		return (any(t)).(Uint32s)
+	}
+	panic("wrong type")
+}
+
+func (x Uint64s) ToArch() any
+
+type archSimdUint64s interface {
+	archsimd.Uint64x2
+}
+
+func Uint64sFromArch[T archSimdUint64s](x T) Uint64s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Uint64s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Uint64x2:
+		var t bridge.Uint64x2 = bridge.Uint64x2(a)
+		return (any(t)).(Uint64s)
+	}
+	panic("wrong type")
+}
+
+func (x Float32s) ToArch() any
+
+type archSimdFloat32s interface {
+	archsimd.Float32x4
+}
+
+func Float32sFromArch[T archSimdFloat32s](x T) Float32s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Float32s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Float32x4:
+		var t bridge.Float32x4 = bridge.Float32x4(a)
+		return (any(t)).(Float32s)
+	}
+	panic("wrong type")
+}
+
+func (x Float64s) ToArch() any
+
+type archSimdFloat64s interface {
+	archsimd.Float64x2
+}
+
+func Float64sFromArch[T archSimdFloat64s](x T) Float64s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Float64s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Float64x2:
+		var t bridge.Float64x2 = bridge.Float64x2(a)
+		return (any(t)).(Float64s)
+	}
+	panic("wrong type")
+}
+
+func (x Mask8s) ToArch() any
+
+type archSimdMask8s interface {
+	archsimd.Mask8x16
+}
+
+func Mask8sFromArch[T archSimdMask8s](x T) Mask8s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Mask8s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Mask8x16:
+		var t bridge.Mask8x16 = bridge.Mask8x16(a)
+		return (any(t)).(Mask8s)
+	}
+	panic("wrong type")
+}
+
+func (x Mask16s) ToArch() any
+
+type archSimdMask16s interface {
+	archsimd.Mask16x8
+}
+
+func Mask16sFromArch[T archSimdMask16s](x T) Mask16s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Mask16s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Mask16x8:
+		var t bridge.Mask16x8 = bridge.Mask16x8(a)
+		return (any(t)).(Mask16s)
+	}
+	panic("wrong type")
+}
+
+func (x Mask32s) ToArch() any
+
+type archSimdMask32s interface {
+	archsimd.Mask32x4
+}
+
+func Mask32sFromArch[T archSimdMask32s](x T) Mask32s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Mask32s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Mask32x4:
+		var t bridge.Mask32x4 = bridge.Mask32x4(a)
+		return (any(t)).(Mask32s)
+	}
+	panic("wrong type")
+}
+
+func (x Mask64s) ToArch() any
+
+type archSimdMask64s interface {
+	archsimd.Mask64x2
+}
+
+func Mask64sFromArch[T archSimdMask64s](x T) Mask64s {
+	switch a := any(x).(type) {
+	// The return expression is written this way because the code will be rewritten
+	// with Mask64s replaced by one of the arch types, and without the any-assert
+	// hack the rewritten code would not pass type checking.
+	// The backend of the compiler will eat this and turn it into no code at all,
+	// assuming it inlines.
+	case archsimd.Mask64x2:
+		var t bridge.Mask64x2 = bridge.Mask64x2(a)
+		return (any(t)).(Mask64s)
+	}
+	panic("wrong type")
+}

package/bin/go/src/slices/slices.go

@@ -120,12 +120,13 @@ func Contains[S ~[]E, E comparable](s S, v E) bool {
 
 // ContainsFunc reports whether at least one
 // element e of s satisfies f(e).
+// It stops as soon as a call to f returns true.
 func ContainsFunc[S ~[]E, E any](s S, f func(E) bool) bool {
 	return IndexFunc(s, f) >= 0
 }
 
-// Insert inserts the values v... into s at index i,
-// returning the modified slice.
+// Insert modifies s in place by inserting the values v... at index i,
+// and returns the modified slice.
 // The elements at s[i:] are shifted up to make room.
 // In the returned slice r, r[i] == v[0],
 // and, if i < len(s), r[i+len(v)] == value originally at s[i].
@@ -213,7 +214,8 @@ func Insert[S ~[]E, E any](s S, i int, v ...E) S {
 	return s
 }
 
-// Delete removes the elements s[i:j] from s, returning the modified slice.
+// Delete modifies s in place by removing the elements s[i:j],
+// and returns the modified slice.
 // Delete panics if j > len(s) or s[i:j] is not a valid slice of s.
 // Delete is O(len(s)-i), so if many items must be deleted, it is better to
 // make a single call deleting them all together than to delete one at a time.
@@ -232,8 +234,8 @@ func Delete[S ~[]E, E any](s S, i, j int) S {
 	return s
 }
 
-// DeleteFunc removes any elements from s for which del returns true,
-// returning the modified slice.
+// DeleteFunc modifies s in place by removing any elements for which del returns true,
+// and returns the modified slice.
 // DeleteFunc zeroes the elements between the new length and the original length.
 // If the result is empty, it has the same nilness as s.
 func DeleteFunc[S ~[]E, E any](s S, del func(E) bool) S {
@@ -252,8 +254,8 @@ func DeleteFunc[S ~[]E, E any](s S, del func(E) bool) S {
 	return s[:i]
 }
 
-// Replace replaces the elements s[i:j] by the given v, and returns the
-// modified slice.
+// Replace modifies s in place by replacing the elements s[i:j] with the given v,
+// and returns the modified slice.
 // Replace panics if j > len(s) or s[i:j] is not a valid slice of s.
 // When len(v) < (j-i), Replace zeroes the elements between the new length and the original length.
 // If the result is empty, it has the same nilness as s.