func (gp *gpConvexProg) F1(x *matrix.FloatMatrix) (f, Df *matrix.FloatMatrix, err error) { f = nil Df = nil err = nil f = matrix.FloatZeros(gp.mnl+1, 1) Df = matrix.FloatZeros(gp.mnl+1, gp.n) y := gp.g.Copy() blas.GemvFloat(gp.F, x, y, 1.0, 1.0) for i, s := range gp.ind { start := s[0] stop := s[1] // yi := exp(yi) = exp(Fi*x+gi) ymax := maxvec(y.FloatArray()[start:stop]) // ynew = exp(y[start:stop] - ymax) ynew := matrix.Exp(matrix.FloatVector(y.FloatArray()[start:stop]).Add(-ymax)) y.SetIndexesFromArray(ynew.FloatArray(), matrix.Indexes(start, stop)...) // fi = log sum yi = log sum exp(Fi*x+gi) ysum := blas.AsumFloat(y, &la.IOpt{"n", stop - start}, &la.IOpt{"offset", start}) f.SetIndex(i, ymax+math.Log(ysum)) blas.ScalFloat(y, 1.0/ysum, &la.IOpt{"n", stop - start}, &la.IOpt{"offset", start}) blas.GemvFloat(gp.F, y, Df, 1.0, 0.0, la.OptTrans, &la.IOpt{"m", stop - start}, &la.IOpt{"incy", gp.mnl + 1}, &la.IOpt{"offseta", start}, &la.IOpt{"offsetx", start}, &la.IOpt{"offsety", i}) } return }
func _TestMultMVTransA(t *testing.T) { bM := 1000 * M bN := 1000 * N A := matrix.FloatNormal(bN, bM) X := matrix.FloatWithValue(bN, 1, 1.0) Y1 := matrix.FloatZeros(bM, 1) Y0 := matrix.FloatZeros(bM, 1) Ar := A.FloatArray() Xr := X.FloatArray() Y1r := Y1.FloatArray() blas.GemvFloat(A, X, Y0, 1.0, 1.0, linalg.OptTrans) DMultMV(Y1r, Ar, Xr, 1.0, 1.0, TRANSA, 1, A.LeadingIndex(), 1, 0, bN, 0, bM, 4, 4) ok := Y0.AllClose(Y1) t.Logf("Y0 == Y1: %v\n", ok) if !ok { var y1, y0 matrix.FloatMatrix Y1.SubMatrix(&y1, 0, 0, 5, 1) t.Logf("Y1[0:5]:\n%v\n", y1) Y0.SubMatrix(&y0, 0, 0, 5, 1) t.Logf("Y0[0:5]:\n%v\n", y0) } }
func _TestMultMV(t *testing.T) { bM := 100 * M bN := 100 * N A := matrix.FloatNormal(bM, bN) X := matrix.FloatNormal(bN, 1) Y1 := matrix.FloatZeros(bM, 1) Y0 := matrix.FloatZeros(bM, 1) Ar := A.FloatArray() Xr := X.FloatArray() Y1r := Y1.FloatArray() blas.GemvFloat(A, X, Y0, 1.0, 1.0) DMultMV(Y1r, Ar, Xr, 1.0, 1.0, NOTRANS, 1, A.LeadingIndex(), 1, 0, bN, 0, bM, 32, 32) t.Logf("Y0 == Y1: %v\n", Y0.AllClose(Y1)) /* if ! Y0.AllClose(Y1) { y0 := Y0.SubMatrix(0, 0, 2, 1) y1 := Y1.SubMatrix(0, 0, 2, 1) t.Logf("y0=\n%v\n", y0) t.Logf("y1=\n%v\n", y1) } */ }
/* Matrix-vector multiplication. A is a matrix or spmatrix of size (m, n) where N = dims['l'] + sum(dims['q']) + sum( k**2 for k in dims['s'] ) representing a mapping from R^n to S. If trans is 'N': y := alpha*A*x + beta * y (trans = 'N'). x is a vector of length n. y is a vector of length N. If trans is 'T': y := alpha*A'*x + beta * y (trans = 'T'). x is a vector of length N. y is a vector of length n. The 's' components in S are stored in unpacked 'L' storage. */ func sgemv(A, x, y *matrix.FloatMatrix, alpha, beta float64, dims *sets.DimensionSet, opts ...la_.Option) error { m := dims.Sum("l", "q") + dims.SumSquared("s") n := la_.GetIntOpt("n", -1, opts...) if n == -1 { n = A.Cols() } trans := la_.GetIntOpt("trans", int(la_.PNoTrans), opts...) offsetX := la_.GetIntOpt("offsetx", 0, opts...) offsetY := la_.GetIntOpt("offsety", 0, opts...) offsetA := la_.GetIntOpt("offseta", 0, opts...) if trans == int(la_.PTrans) && alpha != 0.0 { trisc(x, dims, offsetX) //fmt.Printf("trisc x=\n%v\n", x.ConvertToString()) } //fmt.Printf("alpha=%.4f beta=%.4f m=%d n=%d\n", alpha, beta, m, n) //fmt.Printf("A=\n%v\nx=\n%v\ny=\n%v\n", A, x.ConvertToString(), y.ConvertToString()) err := blas.GemvFloat(A, x, y, alpha, beta, &la_.IOpt{"trans", trans}, &la_.IOpt{"n", n}, &la_.IOpt{"m", m}, &la_.IOpt{"offseta", offsetA}, &la_.IOpt{"offsetx", offsetX}, &la_.IOpt{"offsety", offsetY}) //fmt.Printf("gemv y=\n%v\n", y.ConvertToString()) if trans == int(la_.PTrans) && alpha != 0.0 { triusc(x, dims, offsetX) } return err }
func CTestGemv(m, n, p int) (fnc func(), A, X, Y *matrix.FloatMatrix) { A = matrix.FloatNormal(m, n) X = matrix.FloatNormal(n, 1) Y = matrix.FloatZeros(m, 1) fnc = func() { blas.GemvFloat(A, X, Y, 1.0, 1.0) } return }
func (gp *gpConvexProg) F2(x, z *matrix.FloatMatrix) (f, Df, H *matrix.FloatMatrix, err error) { err = nil f = matrix.FloatZeros(gp.mnl+1, 1) Df = matrix.FloatZeros(gp.mnl+1, gp.n) H = matrix.FloatZeros(gp.n, gp.n) y := gp.g.Copy() Fsc := matrix.FloatZeros(gp.maxK, gp.n) blas.GemvFloat(gp.F, x, y, 1.0, 1.0) //fmt.Printf("y=\n%v\n", y.ToString("%.3f")) for i, s := range gp.ind { start := s[0] stop := s[1] // yi := exp(yi) = exp(Fi*x+gi) ymax := maxvec(y.FloatArray()[start:stop]) ynew := matrix.Exp(matrix.FloatVector(y.FloatArray()[start:stop]).Add(-ymax)) y.SetIndexesFromArray(ynew.FloatArray(), matrix.Indexes(start, stop)...) // fi = log sum yi = log sum exp(Fi*x+gi) ysum := blas.AsumFloat(y, &la.IOpt{"n", stop - start}, &la.IOpt{"offset", start}) f.SetIndex(i, ymax+math.Log(ysum)) blas.ScalFloat(y, 1.0/ysum, &la.IOpt{"n", stop - start}, &la.IOpt{"offset", start}) blas.GemvFloat(gp.F, y, Df, 1.0, 0.0, la.OptTrans, &la.IOpt{"m", stop - start}, &la.IOpt{"incy", gp.mnl + 1}, &la.IOpt{"offseta", start}, &la.IOpt{"offsetx", start}, &la.IOpt{"offsety", i}) Fsc.SetSubMatrix(0, 0, gp.F.GetSubMatrix(start, 0, stop-start)) for k := start; k < stop; k++ { blas.AxpyFloat(Df, Fsc, -1.0, &la.IOpt{"n", gp.n}, &la.IOpt{"incx", gp.mnl + 1}, &la.IOpt{"incy", Fsc.Rows()}, &la.IOpt{"offsetx", i}, &la.IOpt{"offsety", k - start}) blas.ScalFloat(Fsc, math.Sqrt(y.GetIndex(k)), &la.IOpt{"inc", Fsc.Rows()}, &la.IOpt{"offset", k - start}) } // H += z[i]*Hi = z[i] *Fisc' * Fisc blas.SyrkFloat(Fsc, H, z.GetIndex(i), 1.0, la.OptTrans, &la.IOpt{"k", stop - start}) } return }
func CTestGemvTransA(m, n, p int) (fnc func(), A, X, Y *matrix.FloatMatrix) { A = matrix.FloatNormal(n, m) X = matrix.FloatNormal(n, 1) Y = matrix.FloatZeros(m, 1) A = A.Transpose() fnc = func() { blas.GemvFloat(A, X, Y, 1.0, 1.0, linalg.OptTrans) } return }
func _TestMultMVSmall(t *testing.T) { bM := 5 bN := 4 A := matrix.FloatNormal(bM, bN) X := matrix.FloatVector([]float64{1.0, 2.0, 3.0, 4.0}) Y1 := matrix.FloatZeros(bM, 1) Y0 := matrix.FloatZeros(bM, 1) Ar := A.FloatArray() Xr := X.FloatArray() Y1r := Y1.FloatArray() blas.GemvFloat(A, X, Y0, 1.0, 1.0) DMultMV(Y1r, Ar, Xr, 1.0, 1.0, NOTRANS, 1, A.LeadingIndex(), 1, 0, bN, 0, bM, 4, 4) ok := Y0.AllClose(Y1) t.Logf("Y0 == Y1: %v\n", ok) if !ok { t.Logf("blas: Y=A*X\n%v\n", Y0) t.Logf("Y1: Y1 = A*X\n%v\n", Y1) } }
func TestMultMVTransASmall(t *testing.T) { data6 := [][]float64{ []float64{-1.59e+00, 6.56e-02, 2.14e-01, 6.79e-01, 2.93e-01, 5.24e-01}, []float64{4.28e-01, 1.57e-01, 3.81e-01, 2.19e-01, 2.97e-01, 2.83e-02}, []float64{3.02e-01, 9.70e-02, 3.18e-01, 2.03e-01, 7.53e-01, 1.58e-01}, []float64{1.99e-01, 3.01e-01, 4.69e-01, 3.61e-01, 2.07e-01, 6.07e-01}, []float64{1.93e-01, 5.15e-01, 2.83e-01, 5.71e-01, 8.65e-01, 9.75e-01}, []float64{3.13e-01, 8.14e-01, 2.93e-01, 8.62e-01, 6.97e-01, 7.95e-02}} data5 := [][]float64{ []float64{1.57e-01, 3.81e-01, 2.19e-01, 2.97e-01, 2.83e-02}, []float64{9.70e-02, 3.18e-01, 2.03e-01, 7.53e-01, 1.58e-01}, []float64{3.01e-01, 4.69e-01, 3.61e-01, 2.07e-01, 6.07e-01}, []float64{5.15e-01, 2.83e-01, 5.71e-01, 8.65e-01, 9.75e-01}, []float64{8.14e-01, 2.93e-01, 8.62e-01, 6.97e-01, 7.95e-02}} data2 := []float64{4.28e-01, 3.02e-01, 1.99e-01, 1.93e-01, 3.13e-01} bM := 5 bN := 4 nb := 2 //A := matrix.FloatNormal(bN, bM) //X := matrix.FloatWithValue(bN, 1, 1.0) A := matrix.FloatMatrixFromTable(data5, matrix.RowOrder) X := matrix.FloatNew(5, 1, data2) bM = A.Rows() bN = A.Cols() Ym := matrix.FloatZeros(3, bM) Y1 := matrix.FloatZeros(bM, 1) Y0 := matrix.FloatZeros(bM, 1) Ar := A.FloatArray() Xr := X.FloatArray() Y1r := Y1.FloatArray() blas.GemvFloat(A, X, Y0, 1.0, 1.0, linalg.OptTrans) DMultMV(Y1r, Ar, Xr, 1.0, 1.0, TRANSA, 1, A.LeadingIndex(), 1, 0, bN, 0, bM, nb, nb) ok := Y0.AllClose(Y1) t.Logf("Y0 == Y1: %v\n", ok) if ok || !ok { t.Logf("blas: Y=A.T*X\n%v\n", Y0) t.Logf("Y1: Y1 = A*X\n%v\n", Y1) } // zero Y0, Y1 Y0.Scale(0.0) Y1.Scale(0.0) // test with matrix view; A is view var A0 matrix.FloatMatrix A6 := matrix.FloatMatrixFromTable(data6, matrix.RowOrder) A0.SubMatrixOf(A6, 1, 1) blas.GemvFloat(&A0, X, Y0, 1.0, 1.0, linalg.OptTrans) Ar = A0.FloatArray() DMultMV(Y1r, Ar, Xr, 1.0, 1.0, TRANSA, 1, A0.LeadingIndex(), 1, 0, bN, 0, bM, nb, nb) ok = Y0.AllClose(Y1) t.Logf("lda>rows: Y0 == Y1: %v\n", ok) if ok || !ok { t.Logf("blas: Y=A.T*X\n%v\n", Y0) t.Logf("Y1: Y1 = A*X\n%v\n", Y1) } // Y is view too. Y1.SubMatrixOf(Ym, 0, 0, 1, bM) Y1r = Y1.FloatArray() DMultMV(Y1r, Ar, Xr, 1.0, 1.0, TRANSA, Y1.LeadingIndex(), A0.LeadingIndex(), 1, 0, bN, 0, bM, nb, nb) ok = Y0.AllClose(Y1.Transpose()) t.Logf("Y0 == Y1 row: %v\n", ok) t.Logf("row Y1: %v\n", Y1) }
func CheckTransA(A, X, Y *matrix.FloatMatrix) { blas.GemvFloat(A, X, Y, 1.0, 1.0, linalg.OptTrans) }
func CheckNoTrans(A, X, Y *matrix.FloatMatrix) { blas.GemvFloat(A, X, Y, 1.0, 1.0) }
/* Applies Nesterov-Todd scaling or its inverse. Computes x := W*x (trans is false 'N', inverse = false 'N') x := W^T*x (trans is true 'T', inverse = false 'N') x := W^{-1}*x (trans is false 'N', inverse = true 'T') x := W^{-T}*x (trans is true 'T', inverse = true 'T'). x is a dense float matrix. W is a MatrixSet with entries: - W['dnl']: positive vector - W['dnli']: componentwise inverse of W['dnl'] - W['d']: positive vector - W['di']: componentwise inverse of W['d'] - W['v']: lists of 2nd order cone vectors with unit hyperbolic norms - W['beta']: list of positive numbers - W['r']: list of square matrices - W['rti']: list of square matrices. rti[k] is the inverse transpose of r[k]. The 'dnl' and 'dnli' entries are optional, and only present when the function is called from the nonlinear solver. */ func scale(x *matrix.FloatMatrix, W *sets.FloatMatrixSet, trans, inverse bool) (err error) { /*DEBUGGED*/ var wl []*matrix.FloatMatrix var w *matrix.FloatMatrix ind := 0 err = nil // var minor int = 0 //if ! checkpnt.MinorEmpty() { // minor = checkpnt.MinorTop() //} //fmt.Printf("\n%d.%04d scaling x=\n%v\n", checkpnt.Major(), minor, x.ToString("%.17f")) // Scaling for nonlinear component xk is xk := dnl .* xk; inverse // scaling is xk ./ dnl = dnli .* xk, where dnl = W['dnl'], // dnli = W['dnli']. if wl = W.At("dnl"); wl != nil { if inverse { w = W.At("dnli")[0] } else { w = W.At("dnl")[0] } for k := 0; k < x.Cols(); k++ { err = blas.TbmvFloat(w, x, &la_.IOpt{"n", w.Rows()}, &la_.IOpt{"k", 0}, &la_.IOpt{"lda", 1}, &la_.IOpt{"offsetx", k * x.Rows()}) if err != nil { //fmt.Printf("1. TbmvFloat: %v\n", err) return } } ind += w.Rows() } //if ! checkpnt.MinorEmpty() { // checkpnt.Check("000scale", minor) //} // Scaling for linear 'l' component xk is xk := d .* xk; inverse // scaling is xk ./ d = di .* xk, where d = W['d'], di = W['di']. if inverse { w = W.At("di")[0] } else { w = W.At("d")[0] } for k := 0; k < x.Cols(); k++ { err = blas.TbmvFloat(w, x, &la_.IOpt{"n", w.Rows()}, &la_.IOpt{"k", 0}, &la_.IOpt{"lda", 1}, &la_.IOpt{"offsetx", k*x.Rows() + ind}) if err != nil { //fmt.Printf("2. TbmvFloat: %v\n", err) return } } ind += w.Rows() //if ! checkpnt.MinorEmpty() { // checkpnt.Check("010scale", minor) //} // Scaling for 'q' component is // // xk := beta * (2*v*v' - J) * xk // = beta * (2*v*(xk'*v)' - J*xk) // // where beta = W['beta'][k], v = W['v'][k], J = [1, 0; 0, -I]. // //Inverse scaling is // // xk := 1/beta * (2*J*v*v'*J - J) * xk // = 1/beta * (-J) * (2*v*((-J*xk)'*v)' + xk). //wf := matrix.FloatZeros(x.Cols(), 1) w = matrix.FloatZeros(x.Cols(), 1) for k, v := range W.At("v") { m := v.Rows() if inverse { blas.ScalFloat(x, -1.0, &la_.IOpt{"offset", ind}, &la_.IOpt{"inc", x.Rows()}) } err = blas.GemvFloat(x, v, w, 1.0, 0.0, la_.OptTrans, &la_.IOpt{"m", m}, &la_.IOpt{"n", x.Cols()}, &la_.IOpt{"offsetA", ind}, &la_.IOpt{"lda", x.Rows()}) if err != nil { //fmt.Printf("3. GemvFloat: %v\n", err) return } err = blas.ScalFloat(x, -1.0, &la_.IOpt{"offset", ind}, &la_.IOpt{"inc", x.Rows()}) if err != nil { return } err = blas.GerFloat(v, w, x, 2.0, &la_.IOpt{"m", m}, &la_.IOpt{"n", x.Cols()}, &la_.IOpt{"lda", x.Rows()}, &la_.IOpt{"offsetA", ind}) if err != nil { //fmt.Printf("4. GerFloat: %v\n", err) return } var a float64 if inverse { blas.ScalFloat(x, -1.0, &la_.IOpt{"offset", ind}, &la_.IOpt{"inc", x.Rows()}) // a[i,j] := 1.0/W[i,j] a = 1.0 / W.At("beta")[0].GetIndex(k) } else { a = W.At("beta")[0].GetIndex(k) } for i := 0; i < x.Cols(); i++ { blas.ScalFloat(x, a, &la_.IOpt{"n", m}, &la_.IOpt{"offset", ind + i*x.Rows()}) } ind += m } //if ! checkpnt.MinorEmpty() { // checkpnt.Check("020scale", minor) //} // Scaling for 's' component xk is // // xk := vec( r' * mat(xk) * r ) if trans = 'N' // xk := vec( r * mat(xk) * r' ) if trans = 'T'. // // r is kth element of W['r']. // // Inverse scaling is // // xk := vec( rti * mat(xk) * rti' ) if trans = 'N' // xk := vec( rti' * mat(xk) * rti ) if trans = 'T'. // // rti is kth element of W['rti']. maxn := 0 for _, r := range W.At("r") { if r.Rows() > maxn { maxn = r.Rows() } } a := matrix.FloatZeros(maxn, maxn) for k, v := range W.At("r") { t := trans var r *matrix.FloatMatrix if !inverse { r = v t = !trans } else { r = W.At("rti")[k] } n := r.Rows() for i := 0; i < x.Cols(); i++ { // scale diagonal of xk by 0.5 blas.ScalFloat(x, 0.5, &la_.IOpt{"offset", ind + i*x.Rows()}, &la_.IOpt{"inc", n + 1}, &la_.IOpt{"n", n}) // a = r*tril(x) (t is 'N') or a = tril(x)*r (t is 'T') blas.Copy(r, a) if !t { err = blas.TrmmFloat(x, a, 1.0, la_.OptRight, &la_.IOpt{"m", n}, &la_.IOpt{"n", n}, &la_.IOpt{"lda", n}, &la_.IOpt{"ldb", n}, &la_.IOpt{"offsetA", ind + i*x.Rows()}) if err != nil { //fmt.Printf("5. TrmmFloat: %v\n", err) return } // x := (r*a' + a*r') if t is 'N' err = blas.Syr2kFloat(r, a, x, 1.0, 0.0, la_.OptNoTrans, &la_.IOpt{"n", n}, &la_.IOpt{"k", n}, &la_.IOpt{"ldb", n}, &la_.IOpt{"ldc", n}, &la_.IOpt{"offsetC", ind + i*x.Rows()}) if err != nil { //fmt.Printf("6. Syr2kFloat: %v\n", err) return } } else { err = blas.TrmmFloat(x, a, 1.0, la_.OptLeft, &la_.IOpt{"m", n}, &la_.IOpt{"n", n}, &la_.IOpt{"lda", n}, &la_.IOpt{"ldb", n}, &la_.IOpt{"offsetA", ind + i*x.Rows()}) if err != nil { //fmt.Printf("7. TrmmFloat: %v\n", err) return } // x := (r'*a + a'*r) if t is 'T' err = blas.Syr2kFloat(r, a, x, 1.0, 0.0, la_.OptTrans, &la_.IOpt{"n", n}, &la_.IOpt{"k", n}, &la_.IOpt{"ldb", n}, &la_.IOpt{"ldc", n}, &la_.IOpt{"offsetC", ind + i*x.Rows()}) if err != nil { //fmt.Printf("8. Syr2kFloat: %v\n", err) return } } } ind += n * n } //if ! checkpnt.MinorEmpty() { // checkpnt.Check("030scale", minor) //} return }
func (a *matrixA) Af(x, y *matrix.FloatMatrix, alpha, beta float64, trans la.Option) error { return blas.GemvFloat(a.mA, x, y, alpha, beta, trans) }