mat: s/mat64/mat/g
MODIFY
mat/cholesky.go
mat/cholesky.go
@@ -14,8 +14,8 @@ import (
)
const (
- badTriangle = "mat64: invalid triangle"
- badCholesky = "mat64: invalid Cholesky factorization"
+ badTriangle = "mat: invalid triangle"
+ badCholesky = "mat: invalid Cholesky factorization"
)
// Cholesky is a type for creating and using the Cholesky factorization of a

MODIFY
mat/dense.go
mat/dense.go
@@ -67,8 +67,8 @@ func NewDense(r, c int, data []float64) *Dense {
// reuseAs must be kept in sync with reuseAsZeroed.
func (m *Dense) reuseAs(r, c int) {
if m.mat.Rows > m.capRows || m.mat.Cols > m.capCols {
- // Panic as a string, not a mat64.Error.
- panic("mat64: caps not correctly set")
+ // Panic as a string, not a mat.Error.
+ panic("mat: caps not correctly set")
}
if m.isZero() {
m.mat = blas64.General{
@@ -93,8 +93,8 @@ func (m *Dense) reuseAs(r, c int) {
// reuseAsZeroed must be kept in sync with reuseAs.
func (m *Dense) reuseAsZeroed(r, c int) {
if m.mat.Rows > m.capRows || m.mat.Cols > m.capCols {
- // Panic as a string, not a mat64.Error.
- panic("mat64: caps not correctly set")
+ // Panic as a string, not a mat.Error.
+ panic("mat: caps not correctly set")
}
if m.isZero() {
m.mat = blas64.General{

MODIFY
mat/dense_arithmetic.go
mat/dense_arithmetic.go
@@ -693,8 +693,8 @@ func (m *Dense) Outer(alpha float64, x, y *Vector) {
// TODO(kortschak): Factor out into reuseZeroedAs if
// we find another case that needs it.
if m.mat.Rows > m.capRows || m.mat.Cols > m.capCols {
- // Panic as a string, not a mat64.Error.
- panic("mat64: caps not correctly set")
+ // Panic as a string, not a mat.Error.
+ panic("mat: caps not correctly set")
}
if m.isZero() {
m.mat = blas64.General{

MODIFY
mat/doc.go
mat/doc.go
// for i := range data {
// data[i] = rand.NormFloat64()
// }
-// a := mat64.NewDense(6, 6, data)
+// a := mat.NewDense(6, 6, data)
// Operations involving matrix data are implemented as functions when the values
// of the matrix remain unchanged
-// tr := mat64.Trace(a)
+// tr := mat.Trace(a)
// and are implemented as methods when the operation modifies the receiver.
// zero.Copy(a)
//
// Matrix factorizations, such as the LU decomposition, typically have their own
// specific data storage, and so are each implemented as a specific type. The
// factorization can be computed through a call to Factorize
-// var lu mat64.LU
+// var lu mat.LU
// lu.Factorize(a)
// The elements of the factorization can be extracted through methods on the
// factorized type, i.e. *LU.UTo. The factorization types can also be used directly,
//
// This prohibition is to help avoid subtle mistakes when the method needs to read
// from and write to the same data region. There are ways to make mistakes using the
-// mat64 API, and mat64 functions will detect and complain about those.
-// There are many ways to make mistakes by excursion from the mat64 API via
+// mat API, and mat functions will detect and complain about those.
+// There are many ways to make mistakes by excursion from the mat API via
// interaction with raw matrix values.
//
// If you need to read the rest of this section to understand the behavior of

MODIFY
mat/eigen.go
mat/eigen.go
@@ -11,8 +11,8 @@ import (
)
const (
- badFact = "mat64: use without successful factorization"
- badNoVect = "mat64: eigenvectors not computed"
+ badFact = "mat: use without successful factorization"
+ badNoVect = "mat: eigenvectors not computed"
)
// EigenSym is a type for creating and manipulating the Eigen decomposition of

MODIFY
mat/errors.go
mat/errors.go
@@ -44,7 +44,7 @@ const (
const stackTraceBufferSize = 1 << 20
-// Maybe will recover a panic with a type mat64.Error from fn, and return this error
+// Maybe will recover a panic with a type mat.Error from fn, and return this error
// as the Err field of an ErrorStack. The stack trace for the panicking function will be
// recovered and placed in the StackTrace field. Any other error is re-panicked.
func Maybe(fn func()) (err error) {
@@ -52,7 +52,7 @@ func Maybe(fn func()) (err error) {
if r := recover(); r != nil {
if e, ok := r.(Error); ok {
if e.string == "" {
- panic("mat64: invalid error")
+ panic("mat: invalid error")
}
buf := make([]byte, stackTraceBufferSize)
n := runtime.Stack(buf, false)
@@ -66,7 +66,7 @@ func Maybe(fn func()) (err error) {
return
}
-// MaybeFloat will recover a panic with a type mat64.Error from fn, and return this error
+// MaybeFloat will recover a panic with a type mat.Error from fn, and return this error
// as the Err field of an ErrorStack. The stack trace for the panicking function will be
// recovered and placed in the StackTrace field. Any other error is re-panicked.
func MaybeFloat(fn func() float64) (f float64, err error) {
@@ -74,7 +74,7 @@ func MaybeFloat(fn func() float64) (f float64, err error) {
if r := recover(); r != nil {
if e, ok := r.(Error); ok {
if e.string == "" {
- panic("mat64: invalid error")
+ panic("mat: invalid error")
}
buf := make([]byte, stackTraceBufferSize)
n := runtime.Stack(buf, false)
@@ -87,7 +87,7 @@ func MaybeFloat(fn func() float64) (f float64, err error) {
return fn(), nil
}
-// MaybeComplex will recover a panic with a type mat64.Error from fn, and return this error
+// MaybeComplex will recover a panic with a type mat.Error from fn, and return this error
// as the Err field of an ErrorStack. The stack trace for the panicking function will be
// recovered and placed in the StackTrace field. Any other error is re-panicked.
func MaybeComplex(fn func() complex128) (f complex128, err error) {
@@ -95,7 +95,7 @@ func MaybeComplex(fn func() complex128) (f complex128, err error) {
if r := recover(); r != nil {
if e, ok := r.(Error); ok {
if e.string == "" {
- panic("mat64: invalid error")
+ panic("mat: invalid error")
}
buf := make([]byte, stackTraceBufferSize)
n := runtime.Stack(buf, false)

MODIFY
mat/gsvd.go
mat/gsvd.go
@@ -300,7 +300,7 @@ func (gsvd *GSVD) SigmaBTo(dst *Dense) *Dense {
// UTo will panic if the receiver does not contain a successful factorization.
func (gsvd *GSVD) UTo(dst *Dense) *Dense {
if gsvd.kind&GSVDU == 0 {
- panic("mat64: improper GSVD kind")
+ panic("mat: improper GSVD kind")
}
r := gsvd.u.Rows
c := gsvd.u.Cols
@@ -326,7 +326,7 @@ func (gsvd *GSVD) UTo(dst *Dense) *Dense {
// VTo will panic if the receiver does not contain a successful factorization.
func (gsvd *GSVD) VTo(dst *Dense) *Dense {
if gsvd.kind&GSVDV == 0 {
- panic("mat64: improper GSVD kind")
+ panic("mat: improper GSVD kind")
}
r := gsvd.v.Rows
c := gsvd.v.Cols
@@ -352,7 +352,7 @@ func (gsvd *GSVD) VTo(dst *Dense) *Dense {
// QTo will panic if the receiver does not contain a successful factorization.
func (gsvd *GSVD) QTo(dst *Dense) *Dense {
if gsvd.kind&GSVDQ == 0 {
- panic("mat64: improper GSVD kind")
+ panic("mat: improper GSVD kind")
}
r := gsvd.q.Rows
c := gsvd.q.Cols

MODIFY
mat/inner.go
mat/inner.go
@@ -33,7 +33,7 @@ func Inner(x *Vector, A Matrix, y *Vector) float64 {
case RawSymmetricer:
bmat := b.RawSymmetric()
if bmat.Uplo != blas.Upper {
- // Panic as a string not a mat64.Error.
+ // Panic as a string not a mat.Error.
panic(badSymTriangle)
}
for i := 0; i < x.Len(); i++ {

MODIFY
mat/io.go
mat/io.go
@@ -20,10 +20,10 @@ var (
sizeInt64 = binary.Size(int64(0))
sizeFloat64 = binary.Size(float64(0))
- errTooBig = errors.New("mat64: resulting data slice too big")
- errTooSmall = errors.New("mat64: input slice too small")
- errBadBuffer = errors.New("mat64: data buffer size mismatch")
- errBadSize = errors.New("mat64: invalid dimension")
+ errTooBig = errors.New("mat: resulting data slice too big")
+ errTooSmall = errors.New("mat: input slice too small")
+ errBadBuffer = errors.New("mat: data buffer size mismatch")
+ errBadSize = errors.New("mat: invalid dimension")
)
// MarshalBinary encodes the receiver into a binary form and returns the result.
@@ -110,7 +110,7 @@ func (m Dense) MarshalBinaryTo(w io.Writer) (int, error) {
// it should not be used on untrusted data.
func (m *Dense) UnmarshalBinary(data []byte) error {
if !m.isZero() {
- panic("mat64: unmarshal into non-zero matrix")
+ panic("mat: unmarshal into non-zero matrix")
}
if len(data) < 2*sizeInt64 {
@@ -159,7 +159,7 @@ func (m *Dense) UnmarshalBinary(data []byte) error {
// it should not be used on untrusted data.
func (m *Dense) UnmarshalBinaryFrom(r io.Reader) (int, error) {
if !m.isZero() {
- panic("mat64: unmarshal into non-zero matrix")
+ panic("mat: unmarshal into non-zero matrix")
}
var (
@@ -269,7 +269,7 @@ func (v Vector) MarshalBinaryTo(w io.Writer) (int, error) {
// it should not be used on untrusted data.
func (v *Vector) UnmarshalBinary(data []byte) error {
if !v.isZero() {
- panic("mat64: unmarshal into non-zero vector")
+ panic("mat: unmarshal into non-zero vector")
}
p := 0
@@ -302,7 +302,7 @@ func (v *Vector) UnmarshalBinary(data []byte) error {
// See UnmarshalBinary for the list of sanity checks performed on the input.
func (v *Vector) UnmarshalBinaryFrom(r io.Reader) (int, error) {
if !v.isZero() {
- panic("mat64: unmarshal into non-zero vector")
+ panic("mat: unmarshal into non-zero vector")
}
var (

MODIFY
mat/lu.go
mat/lu.go
@@ -13,7 +13,7 @@ import (
"gonum.org/v1/gonum/lapack/lapack64"
)
-const badSliceLength = "mat64: improper slice length"
+const badSliceLength = "mat: improper slice length"
// LU is a type for creating and using the LU factorization of a matrix.
type LU struct {

MODIFY
mat/matrix.go
mat/matrix.go
@@ -68,7 +68,7 @@ func (t Transpose) Untranspose() Matrix {
// Untransposer is a type that can undo an implicit transpose.
type Untransposer interface {
// Note: This interface is needed to unify all of the Transpose types. In
- // the mat64 methods, we need to test if the Matrix has been implicitly
+ // the mat methods, we need to test if the Matrix has been implicitly
// transposed. If this is checked by testing for the specific Transpose type
// then the behavior will be different if the user uses T() or TTri() for a
// triangular matrix.
@@ -274,7 +274,7 @@ func Cond(a Matrix, norm float64) float64 {
var lnorm lapack.MatrixNorm
switch norm {
default:
- panic("mat64: bad norm value")
+ panic("mat: bad norm value")
case 1:
lnorm = lapack.MaxColumnSum
case 2:

MODIFY
mat/shadow.go
mat/shadow.go
@@ -12,15 +12,15 @@ import (
const (
// regionOverlap is the panic string used for the general case
// of a matrix region overlap between a source and destination.
- regionOverlap = "mat64: bad region: overlap"
+ regionOverlap = "mat: bad region: overlap"
// regionIdentity is the panic string used for the specific
// case of complete agreement between a source and a destination.
- regionIdentity = "mat64: bad region: identical"
+ regionIdentity = "mat: bad region: identical"
// mismatchedStrides is the panic string used for overlapping
// data slices with differing strides.
- mismatchedStrides = "mat64: bad region: different strides"
+ mismatchedStrides = "mat: bad region: different strides"
)
// checkOverlap returns false if the receiver does not overlap data elements

MODIFY
mat/svd.go
mat/svd.go
@@ -144,7 +144,7 @@ func (svd *SVD) Values(s []float64) []float64 {
func (svd *SVD) UTo(dst *Dense) *Dense {
kind := svd.kind
if kind != SVDFull && kind != SVDThin {
- panic("mat64: improper SVD kind")
+ panic("mat: improper SVD kind")
}
r := svd.u.Rows
c := svd.u.Cols
@@ -170,7 +170,7 @@ func (svd *SVD) UTo(dst *Dense) *Dense {
func (svd *SVD) VTo(dst *Dense) *Dense {
kind := svd.kind
if kind != SVDFull && kind != SVDThin {
- panic("mat64: improper SVD kind")
+ panic("mat: improper SVD kind")
}
r := svd.vt.Rows
c := svd.vt.Cols

MODIFY
mat/symmetric.go
mat/symmetric.go
@@ -21,8 +21,8 @@ var (
)
const (
- badSymTriangle = "mat64: blas64.Symmetric not upper"
- badSymCap = "mat64: bad capacity for SymDense"
+ badSymTriangle = "mat: blas64.Symmetric not upper"
+ badSymCap = "mat: bad capacity for SymDense"
)
// SymDense is a symmetric matrix that uses dense storage. SymDense
@@ -60,7 +60,7 @@ type MutableSymmetric interface {
// Only the values in the upper triangular portion of the matrix are used.
func NewSymDense(n int, data []float64) *SymDense {
if n < 0 {
- panic("mat64: negative dimension")
+ panic("mat: negative dimension")
}
if data != nil && n*n != len(data) {
panic(ErrShape)

MODIFY
mat/triangular.go
mat/triangular.go
@@ -15,7 +15,7 @@ var (
_ RawTriangular = triDense
)
-const badTriCap = "mat64: bad capacity for TriDense"
+const badTriCap = "mat: bad capacity for TriDense"
// TriDense represents an upper or lower triangular matrix in dense storage
// format.
@@ -100,7 +100,7 @@ func (t TransposeTri) UntransposeTri() Triangular {
// Only the values in the triangular portion corresponding to kind are used.
func NewTriDense(n int, kind TriKind, data []float64) *TriDense {
if n < 0 {
- panic("mat64: negative dimension")
+ panic("mat: negative dimension")
}
if data != nil && len(data) != n*n {
panic(ErrShape)
@@ -159,7 +159,7 @@ func isUpperUplo(u blas.Uplo) bool {
// be upper triangular.
func (t *TriDense) asSymBlas() blas64.Symmetric {
if t.mat.Diag == blas.Unit {
- panic("mat64: cannot convert unit TriDense into blas64.Symmetric")
+ panic("mat: cannot convert unit TriDense into blas64.Symmetric")
}
return blas64.Symmetric{
N: t.mat.N,
@@ -402,7 +402,7 @@ func copySymIntoTriangle(t *TriDense, s Symmetric) {
n, upper := t.Triangle()
ns := s.Symmetric()
if n != ns {
- panic("mat64: triangle size mismatch")
+ panic("mat: triangle size mismatch")
}
ts := t.mat.Stride
if rs, ok := s.(RawSymmetricer); ok {

MODIFY
mat/vector.go
mat/vector.go
@@ -23,7 +23,7 @@ type Vector struct {
mat blas64.Vector
n int
// A BLAS vector can have a negative increment, but allowing this
- // in the mat64 type complicates a lot of code, and doesn't gain anything.
+ // in the mat type complicates a lot of code, and doesn't gain anything.
// Vector must have positive increment in this package.
}

mat: s/mat64/mat/g