// Array returns the elements of the matrix as array pointer.
// The data may be a copy depending on the platform implementation.
494670
func (mat *T) Array() *[9]float32 {
	return &[...]float32{
		mat[0][0], mat[0][1], mat[0][2],
		mat[1][0], mat[1][1], mat[1][2],
		mat[2][0], mat[2][1], mat[2][2],
	}
}
1133174
func Arr() *Array {
	a := arrayPool.Get().(*Array)
	a.buf = a.buf[:0]
	return a
}
1194536
func pcfArray(val []interface{}) (string, error) {
	items := make([]string, len(val))
	for i, el := range val {
		p, err := parsingCanonicalForm(el)
		if err != nil {
			return "", err
		}
		items[i] = p
	}
	return "[" + strings.Join(items, ",") + "]", nil
}
227812
func (d *Drain) Array(p Proxy) []interface{} {
	v, err := p.Array()
	d.put(err)
	return v
}
199542
func (p Property) ArrayType() string {
	if p.Type == arrayType {
		return p.Items.Type
	}
	return strings.TrimSuffix(p.TypeString(), "[]")
}
596779
func NewMatrix(m [][]float32) *Matrix {
	return &Matrix{
		M:    m,
		Rows: uint(len(m)),
		Cols: uint(len(m[0])),
	}
}
295281
func (ss SetString) Array() []string {
	arr := make([]string, 0, len(ss))

	for key := range ss {
		arr = append(arr, key)
	}

	return arr
}
26995
func (m *Matrix) Dimensions() []int {
	r := make([]int, len(m.dims))
	copy(r, m.dims)
	return r
}
95488
func (rb *Bitmap) ToArray() []uint32 {
	array := make([]uint32, rb.GetCardinality())
	pos := 0
	pos2 := 0

	for pos < rb.highlowcontainer.size() {
		hs := uint32(rb.highlowcontainer.getKeyAtIndex(pos)) << 16
		c := rb.highlowcontainer.getContainerAtIndex(pos)
		pos++
		c.fillLeastSignificant16bits(array, pos2, hs)
		pos2 += c.getCardinality()
	}
	return array
}
505461
func arrayLast(input interface{}) interface{} {
	arr := reflect.ValueOf(input)
	return arr.Index(arr.Len() - 1).Interface()
}
305578
func (m *Matrix) Size() (rows, cols int) {
	rows = len(m.elements) / m.stride
	cols = m.stride
	return
}
597036
func (mat *T) Array() *[16]float64 {
	return &[...]float64{
		mat[0][0], mat[0][1], mat[0][2], mat[0][3],
		mat[1][0], mat[1][1], mat[1][2], mat[1][3],
		mat[2][0], mat[2][1], mat[2][2], mat[2][3],
		mat[3][0], mat[3][1], mat[3][2], mat[3][3],
	}
}
927074
func inArray(s byte, list []byte) bool {
	for _, el := range list {
		if el == s {
			return true
		}
	}
	return false
}
63792
func (enc *Encoder) Array(v MarshalerJSONArray) {
	if v.IsNil() {
		enc.grow(3)
		r := enc.getPreviousRune()
		if r != '[' {
			enc.writeByte(',')
		}
		enc.writeByte('[')
		enc.writeByte(']')
		return
	}
	enc.grow(100)
	r := enc.getPreviousRune()
	if r != '[' {
		enc.writeByte(',')
	}
	enc.writeByte('[')
	v.MarshalJSONArray(enc)
	enc.writeByte(']')
}
549895
func PrintArray(m interface{}) string {
	var outputText string

	switch reflect.TypeOf(m).Kind() {
	case reflect.Slice:
		var xs []string

		slice := reflect.ValueOf(m)
		for i := 0; i < slice.Len(); i++ {
			xs = append(xs, fmt.Sprintf("[%d]=%s", i, slice.Index(i)))
		}

		if len(xs) == 0 {
			outputText = "len(array) == 0"
		} else {
			outputText = strings.Join(xs, "\n")
		}
	default:
		outputText = fmt.Sprintf("error while printing array\nreceived a %T\n  %s\n", m, m)
	}

	return outputText
}
314071
func (t Result) Array() []Result {
	if t.Type == Null {
		return []Result{}
	}
	if t.Type != JSON {
		return []Result{t}
	}
	r := t.arrayOrMap('[', false)
	return r.a
}
1154341
func (mat *T) MultMatrix(m *T) *T {
	// iterate over the rows of mat
	for i := range mat {
		row := vec4.T{mat[0][i], mat[1][i], mat[2][i], mat[3][i]}
		mat[0][i] = vec4.Dot4(&row, &m[0])
		mat[1][i] = vec4.Dot4(&row, &m[1])
		mat[2][i] = vec4.Dot4(&row, &m[2])
		mat[3][i] = vec4.Dot4(&row, &m[3])
	}
	return mat
}