Rotating Tensors/Denses, similar to numpy implementation

[BryceBeagle]

Numpy has a way to rotate matrices by increments of 90 degrees using their rot90 method that uses transposes and flips.

There is a transpose method for Tensors, but no way of flipping the Tensor that I see.

Is there a way of properly rotating a Tensor/Dense currently, other than through manual iteration over the data? If not, should this be added?

[chewxy]

This is what was used for my AlphaGo reimplementation:

func RotateBoard(board []float32, m, n int) ([]float32, error) {
    if m != n {
        return nil, errors.Errorf("Cannot handle m %d, n %d. This function only takes square boards", m, n)
    }
    copied := make([]float32, len(board))
    copy(copied, board)
    it := MakeIterator(copied, m, n)
    for i := 0; i < m/2; i++ {
        mi1 := m - i - 1
        for j := i; j < mi1; j++ {
            mj1 := m - j - 1
            tmp := it[i][j]
            // right to top
            it[i][j] = it[j][mi1]

            // bottom to right
            it[j][mi1] = it[mi1][mj1]

            // left to bottom
            it[mi1][mj1] = it[mj1][i]

            // tmp is left
            it[mj1][i] = tmp
        }
    }
    ReturnIterator(m, n, it)
    return copied, nil
}

func ReturnIterator(m, n int, it [][]float32) {
    if d, ok := iterPool[m]; ok {
        if _, ok := d[n]; ok {
            iterPool[m][n].Put(it)
        } else {
            iterPool[m][n] = &sync.Pool{
                New: func() interface{} {
                    retVal := make([][]float32, m)
                    for i := range retVal {
                        retVal[i] = make([]float32, n)
                    }
                    return retVal
                },
            }
            iterPool[m][n].Put(it)
        }
    } else {
        iterPool[m] = make(map[int]*sync.Pool)
        iterPool[m][n] = &sync.Pool{
            New: func() interface{} {
                retVal := make([][]float32, m)
                for i := range retVal {
                    retVal[i] = make([]float32, n)
                }
                return retVal
            },
        }
        iterPool[m][n].Put(it)
    }
}

func MakeIterator(board []float32, m, n int) (retVal [][]float32) {
    retVal = borrowIterator(m, n)
    for i := range retVal {
        start := i * int(m)
        hdr := (*reflect.SliceHeader)(unsafe.Pointer(&retVal[i]))
        hdr.Data = uintptr(unsafe.Pointer(&board[start]))
        hdr.Len = int(n)
        hdr.Cap = int(n)
    }
    return

}

func borrowIterator(m, n int) [][]float32 {
    if d, ok := iterPool[m]; ok {
        if d2, ok := d[n]; ok {
            return d2.Get().([][]float32)
        }
    }
    retVal := make([][]float32, m)
    for i := range retVal {
        retVal[i] = make([]float32, n)
    }
    return retVal
}

I agree it needs to be added. I don't quite have the bandwidth right now but these two snippets may be useful

[omarsamhan-zz]

I can take this issue. I am a newbie in terms of open-source collaboration so please bear with me :)

I might start with dense matrices first and then move on to tensors.

The rotate function can be implemented in dense_matop_memmove.go and/or dense_matop.go by allocating a new matrix and/or performing an "in-place" transformation, respectively.

Which implementation should I aim for first?

Note: The use of the term "in-place" is a slight abuse of notation

[chewxy]

safety first, so memmove - i.e. allocating a new matrix fist. then a unsafe version (i.e. in place).

Send PR :)