func blkReduceTridiagUpper(A, tauq, Y, W *cmat.FloatMatrix, lb int, conf *gomas.Config) { var ATL, ABR cmat.FloatMatrix var A00, A01, A11, A22 cmat.FloatMatrix var YT, YB, Y0, Y1, Y2 cmat.FloatMatrix var tqT, tqB, tq0, tauq1, tq2 cmat.FloatMatrix var v0 float64 util.Partition2x2( &ATL, nil, nil, &ABR, A, 0, 0, util.PBOTTOMRIGHT) util.Partition2x1( &YT, &YB, Y, 0, util.PBOTTOM) util.Partition2x1( &tqT, &tqB, tauq, 1, util.PBOTTOM) for m(&ATL)-lb > 0 { util.Repartition2x2to3x3(&ATL, &A00, &A01, nil, nil, &A11, nil, nil, nil, &A22, A, lb, util.PTOPLEFT) util.Repartition2x1to3x1(&YT, &Y0, &Y1, &Y2, Y, lb, util.PTOP) util.Repartition2x1to3x1(&tqT, &tq0, &tauq1, &tq2, tauq, lb, util.PTOP) // ------------------------------------------------------ unblkBuildTridiagUpper(&ATL, &tauq1, &YT, W) // set subdiagonal entry to unit v0 = A01.Get(-1, 0) A01.Set(-1, 0, 1.0) // A22 := A22 - A01*Y0.T - Y0*A01.T blasd.Update2Sym(&A00, &A01, &Y0, -1.0, 1.0, gomas.UPPER, conf) // restore subdiagonal entry A01.Set(-1, 0, v0) // ------------------------------------------------------ util.Continue3x3to2x2( &ATL, nil, nil, &ABR, &A00, &A11, &A22, A, util.PTOPLEFT) util.Continue3x1to2x1( &YT, &YB, &Y0, &Y1, Y, util.PTOP) util.Continue3x1to2x1( &tqT, &tqB, &tq0, &tauq1, tauq, util.PTOP) } if m(&ATL) > 0 { unblkReduceTridiagUpper(&ATL, &tqT, W, true) } }
/* * Blocked QR decomposition with compact WY transform. * * Compatible with lapack.DGEQRF. */ func blockedQL(A, Tvec, Twork, W *cmat.FloatMatrix, lb int, conf *gomas.Config) { var ATL, ATR, ABL, ABR, AL cmat.FloatMatrix var A00, A01, A10, A11, A22 cmat.FloatMatrix var TT, TB cmat.FloatMatrix var t0, tau, t2 cmat.FloatMatrix var Wrk, w1 cmat.FloatMatrix util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, 0, 0, util.PBOTTOMRIGHT) util.Partition2x1( &TT, &TB, Tvec, 0, util.PBOTTOM) nb := lb for m(&ATL)-nb > 0 && n(&ATL)-nb > 0 { util.Repartition2x2to3x3(&ATL, &A00, &A01, nil, &A10, &A11, nil, nil, nil, &A22, A, nb, util.PTOPLEFT) util.Repartition2x1to3x1(&TT, &t0, &tau, &t2, Tvec, nb, util.PTOP) // current block size cb, rb := A11.Size() if rb < cb { cb = rb } // -------------------------------------------------------- // decompose righ side AL == /A01\ // \A11/ w1.SubMatrix(W, 0, 0, cb, 1) util.Merge2x1(&AL, &A01, &A11) unblockedQL(&AL, &tau, &w1) // build block reflector unblkQLBlockReflector(Twork, &AL, &tau) // update A'tail i.e. A10 and A00 with (I - Y*T*Y.T).T * A'tail // compute: C - Y*(C.T*Y*T).T ar, ac := A10.Size() Wrk.SubMatrix(W, 0, 0, ac, ar) updateQLLeft(&A10, &A00, &A11, &A01, Twork, &Wrk, true, conf) // -------------------------------------------------------- util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &A11, &A22, A, util.PTOPLEFT) util.Continue3x1to2x1( &TT, &TB, &t0, &tau, Tvec, util.PTOP) } // last block with unblocked if m(&ATL) > 0 && n(&ATL) > 0 { w1.SubMatrix(W, 0, 0, n(&ATL), 1) unblockedQL(&ATL, &t0, &w1) } }
/* * Blocked LQ decomposition with compact WY transform. As implemented * in lapack.DGELQF subroutine. */ func blockedLQ(A, Tvec, Twork, W *cmat.FloatMatrix, lb int, conf *gomas.Config) { var ATL, ATR, ABL, ABR, AR cmat.FloatMatrix var A00, A11, A12, A21, A22 cmat.FloatMatrix var TT, TB cmat.FloatMatrix var t0, tau, t2 cmat.FloatMatrix var Wrk, w1 cmat.FloatMatrix util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, 0, 0, util.PTOPLEFT) util.Partition2x1( &TT, &TB, Tvec, 0, util.PTOP) //nb := conf.LB for m(&ABR)-lb > 0 && n(&ABR)-lb > 0 { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, nil, &A11, &A12, nil, &A21, &A22, A, lb, util.PBOTTOMRIGHT) util.Repartition2x1to3x1(&TT, &t0, &tau, &t2, Tvec, lb, util.PBOTTOM) // current block size cb, rb := A11.Size() if rb < cb { cb = rb } // -------------------------------------------------------- // decompose left side AL == /A11\ // \A21/ w1.SubMatrix(W, 0, 0, cb, 1) util.Merge1x2(&AR, &A11, &A12) unblockedLQ(&AR, &tau, &w1) // build block reflector unblkBlockReflectorLQ(Twork, &AR, &tau) // update A'tail i.e. A21 and A22 with A'*(I - Y*T*Y.T).T // compute: C - Y*(C.T*Y*T).T ar, ac := A21.Size() Wrk.SubMatrix(W, 0, 0, ar, ac) updateRightLQ(&A21, &A22, &A11, &A12, Twork, &Wrk, true, conf) // -------------------------------------------------------- util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &A11, &A22, A, util.PBOTTOMRIGHT) util.Continue3x1to2x1( &TT, &TB, &t0, &tau, Tvec, util.PBOTTOM) } // last block with unblocked if m(&ABR) > 0 && n(&ABR) > 0 { w1.SubMatrix(W, 0, 0, m(&ABR), 1) unblockedLQ(&ABR, &t2, &w1) } }
/* * Reduce upper triangular matrix to tridiagonal. * * Elementary reflectors Q = H(n-1)...H(2)H(1) are stored on upper * triangular part of A. Reflector H(n-1) saved at column A(n) and * scalar multiplier to tau[n-1]. If parameter `tail` is true then * this function is used to reduce tail part of partially reduced * matrix and tau-vector partitioning is starting from last position. */ func unblkReduceTridiagUpper(A, tauq, W *cmat.FloatMatrix, tail bool) { var ATL, ABR cmat.FloatMatrix var A00, a01, a11, A22 cmat.FloatMatrix var tqT, tqB, tq0, tauq1, tq2 cmat.FloatMatrix var y21 cmat.FloatMatrix var v0 float64 toff := 1 if tail { toff = 0 } util.Partition2x2( &ATL, nil, nil, &ABR, A, 0, 0, util.PBOTTOMRIGHT) util.Partition2x1( &tqT, &tqB, tauq, toff, util.PBOTTOM) for n(&ATL) > 0 { util.Repartition2x2to3x3(&ATL, &A00, &a01, nil, nil, &a11, nil, nil, nil, &A22, A, 1, util.PTOPLEFT) util.Repartition2x1to3x1(&tqT, &tq0, &tauq1, &tq2, tauq, 1, util.PTOP) // set temp vectors for this round y21.SetBuf(n(&A00), 1, n(&A00), W.Data()) // ------------------------------------------------------ // Compute householder to zero super-diagonal entries computeHouseholderRev(&a01, &tauq1) tauqv := tauq1.Get(0, 0) // set superdiagonal to unit v0 = a01.Get(-1, 0) a01.Set(-1, 0, 1.0) // y21 := A22*a12t blasd.MVMultSym(&y21, &A00, &a01, tauqv, 0.0, gomas.UPPER) // beta := tauq*a12t*y21 beta := tauqv * blasd.Dot(&a01, &y21) // y21 := y21 - 0.5*beta*a125 blasd.Axpy(&y21, &a01, -0.5*beta) // A22 := A22 - a12t*y21.T - y21*a12.T blasd.MVUpdate2Sym(&A00, &a01, &y21, -1.0, gomas.UPPER) // restore superdiagonal value a01.Set(-1, 0, v0) // ------------------------------------------------------ util.Continue3x3to2x2( &ATL, nil, nil, &ABR, &A00, &a11, &A22, A, util.PTOPLEFT) util.Continue3x1to2x1( &tqT, &tqB, &tq0, &tauq1, tauq, util.PTOP) } }
/* * like LAPACK/dlafrt.f * * Build block reflector T from HH reflector stored in TriLU(A) and coefficients * in tau. * * Q = I - Y*T*Y.T; Householder H = I - tau*v*v.T * * T = | T z | z = -tau*T*Y.T*v * | 0 c | c = tau * * Q = H(1)H(2)...H(k) building forward here. */ func unblkBlockReflectorLQ(T, A, tau *cmat.FloatMatrix) { var ATL, ATR, ABL, ABR cmat.FloatMatrix var A00, a01, A02, a11, a12, A22 cmat.FloatMatrix var TTL, TTR, TBL, TBR cmat.FloatMatrix var T00, t01, T02, t11, t12, T22 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2 cmat.FloatMatrix util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, 0, 0, util.PTOPLEFT) util.Partition2x2( &TTL, &TTR, &TBL, &TBR, T, 0, 0, util.PTOPLEFT) util.Partition2x1( &tT, &tB, tau, 0, util.PTOP) for m(&ABR) > 0 && n(&ABR) > 0 { util.Repartition2x2to3x3(&ATL, &A00, &a01, &A02, nil, &a11, &a12, nil, nil, &A22, A, 1, util.PBOTTOMRIGHT) util.Repartition2x2to3x3(&TTL, &T00, &t01, &T02, nil, &t11, &t12, nil, nil, &T22, T, 1, util.PBOTTOMRIGHT) util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2, tau, 1, util.PBOTTOM) // -------------------------------------------------- // t11 := tau tauval := tau1.Get(0, 0) if tauval != 0.0 { t11.Set(0, 0, tauval) // t01 := -tauval*(a01 + A02*a12) blasd.Axpby(&t01, &a01, 1.0, 0.0) blasd.MVMult(&t01, &A02, &a12, -tauval, -tauval, gomas.NONE) // t01 := T00*t01 blasd.MVMultTrm(&t01, &T00, 1.0, gomas.UPPER) } // -------------------------------------------------- util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &a11, &A22, A, util.PBOTTOMRIGHT) util.Continue3x3to2x2( &TTL, &TTR, &TBL, &TBR, &T00, &t11, &T22, T, util.PBOTTOMRIGHT) util.Continue3x1to2x1( &tT, &tB, &t0, &tau1, tau, util.PBOTTOM) } }
/* * like LAPACK/dlafrt.f * * Build block reflector T from HH reflector stored in TriLU(A) and coefficients * in tau. * * Q = I - Y*T*Y.T; Householder H = I - tau*v*v.T * * T = | T 0 | z = -tau*T*Y.T*v * | z c | c = tau * * Q = H(1)H(2)...H(k) building forward here. */ func unblkBlockReflectorRQ(T, A, tau *cmat.FloatMatrix) { var ATL, ABR cmat.FloatMatrix var A00, a10, A20, a11, a21, A22 cmat.FloatMatrix var TTL, TBR cmat.FloatMatrix var T00, t11, t21, T22 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2 cmat.FloatMatrix util.Partition2x2( &ATL, nil, nil, &ABR /**/, A, 0, 0, util.PBOTTOMRIGHT) util.Partition2x2( &TTL, nil, nil, &TBR /**/, T, 0, 0, util.PBOTTOMRIGHT) util.Partition2x1( &tT, &tB /**/, tau, 0, util.PBOTTOM) for m(&ATL) > 0 && n(&ATL) > 0 { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, &a10, &a11, nil, &A20, &a21, &A22 /**/, A, 1, util.PTOPLEFT) util.Repartition2x2to3x3(&TTL, &T00, nil, nil, nil, &t11, nil, nil, &t21, &T22 /**/, T, 1, util.PTOPLEFT) util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2 /**/, tau, 1, util.PTOP) // -------------------------------------------------- // t11 := tau tauval := tau1.Get(0, 0) if tauval != 0.0 { t11.Set(0, 0, tauval) // t21 := -tauval*(a21 + A20*a10) blasd.Axpby(&t21, &a21, 1.0, 0.0) blasd.MVMult(&t21, &A20, &a10, -tauval, -tauval, gomas.NONE) // t21 := T22*t21 blasd.MVMultTrm(&t21, &T22, 1.0, gomas.LOWER) } // -------------------------------------------------- util.Continue3x3to2x2( &ATL, nil, nil, &ABR /**/, &A00, &a11, &A22, A, util.PTOPLEFT) util.Continue3x3to2x2( &TTL, nil, nil, &TBR /**/, &T00, &t11, &T22, T, util.PTOPLEFT) util.Continue3x1to2x1( &tT, &tB /**/, &t0, &tau1, tau, util.PTOP) } }
/* * like LAPACK/dlafrt.f * * Build block reflector T from HH reflector stored in TriLU(A) and coefficients * in tau. * * Q = I - Y*T*Y.T; Householder H = I - tau*v*v.T * * T = | T z | z = -tau*T*Y.T*v * | 0 c | c = tau * * Q = H(1)H(2)...H(k) building forward here. */ func unblkQLBlockReflector(T, A, tau *cmat.FloatMatrix) { var ATL, ABR cmat.FloatMatrix var A00, a01, a11, A02, a12, A22 cmat.FloatMatrix var TTL, TBR cmat.FloatMatrix var T00, t11, t21, T22 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2 cmat.FloatMatrix util.Partition2x2( &ATL, nil, nil, &ABR, A, 0, 0, util.PBOTTOMRIGHT) util.Partition2x2( &TTL, nil, nil, &TBR, T, 0, 0, util.PBOTTOMRIGHT) util.Partition2x1( &tT, &tB, tau, 0, util.PBOTTOM) for m(&ATL) > 0 && n(&ATL) > 0 { util.Repartition2x2to3x3(&ATL, &A00, &a01, &A02, nil, &a11, &a12, nil, nil, &A22, A, 1, util.PTOPLEFT) util.Repartition2x2to3x3(&TTL, &T00, nil, nil, nil, &t11, nil, nil, &t21, &T22, T, 1, util.PTOPLEFT) util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2, tau, 1, util.PTOP) // -------------------------------------------------- // t11 := tau tauval := tau1.Get(0, 0) if tauval != 0.0 { t11.Set(0, 0, tauval) // t21 := -tauval*(a12.T + &A02.T*a12) blasd.Axpby(&t21, &a12, 1.0, 0.0) blasd.MVMult(&t21, &A02, &a01, -tauval, -tauval, gomas.TRANSA) // t21 := T22*t01 blasd.MVMultTrm(&t21, &T22, 1.0, gomas.LOWER) } // -------------------------------------------------- util.Continue3x3to2x2( &ATL, nil, nil, &ABR, &A00, &a11, &A22, A, util.PTOPLEFT) util.Continue3x3to2x2( &TTL, nil, nil, &TBR, &T00, &t11, &T22, T, util.PTOPLEFT) util.Continue3x1to2x1( &tT, &tB, &t0, &tau1, tau, util.PTOP) } }
/* * Blocked RQ decomposition with compact WY transform. As implemented * in lapack.DGERQF subroutine. */ func blockedRQ(A, Tvec, Twork, W *cmat.FloatMatrix, lb int, conf *gomas.Config) { var ATL, ABR, AL cmat.FloatMatrix var A00, A01, A10, A11, A22 cmat.FloatMatrix var TT, TB cmat.FloatMatrix var t0, tau, t2 cmat.FloatMatrix var Wrk, w1 cmat.FloatMatrix util.Partition2x2( &ATL, nil, nil, &ABR /**/, A, 0, 0, util.PBOTTOMRIGHT) util.Partition2x1( &TT, &TB /**/, Tvec, 0, util.PBOTTOM) for m(&ATL)-lb > 0 && n(&ATL)-lb > 0 { util.Repartition2x2to3x3(&ATL, &A00, &A01, nil, &A10, &A11, nil, nil, nil, &A22 /**/, A, lb, util.PTOPLEFT) util.Repartition2x1to3x1(&TT, &t0, &tau, &t2 /**/, Tvec, n(&A11), util.PTOP) // current block size cb, rb := A11.Size() if rb < cb { cb = rb } // -------------------------------------------------------- // decompose left side AL == ( A10 A11 ) w1.SubMatrix(W, 0, 0, cb, 1) util.Merge1x2(&AL, &A10, &A11) unblockedRQ(&AL, &tau, &w1) // build block reflector unblkBlockReflectorRQ(Twork, &AL, &tau) // compute: (A00 A01)(I - Y*T*Y.T) ar, ac := A01.Size() Wrk.SubMatrix(W, 0, 0, ar, ac) updateRightRQ(&A01, &A00, &A11, &A10, Twork, &Wrk, false, conf) // -------------------------------------------------------- util.Continue3x3to2x2( &ATL, nil, nil, &ABR, &A00, &A11, &A22, A, util.PTOPLEFT) util.Continue3x1to2x1( &TT, &TB, &t0, &tau, Tvec, util.PTOP) } // last block with unblocked if m(&ATL) > 0 && n(&ATL) > 0 { w1.SubMatrix(W, 0, 0, m(&ATL), 1) unblockedRQ(&ATL, &TT, &w1) } }
/* * Tridiagonal reduction of LOWER triangular symmetric matrix, zero elements below 1st * subdiagonal: * * A = (1 - tau*u*u.t)*A*(1 - tau*u*u.T) * = (I - tau*( 0 0 )) (a11 a12) (I - tau*( 0 0 )) * ( ( 0 u*u.t)) (a21 A22) ( ( 0 u*u.t)) * * a11, a12, a21 not affected * * from LEFT: * A22 = A22 - tau*u*u.T*A22 * from RIGHT: * A22 = A22 - tau*A22*u.u.T * * LEFT and RIGHT: * A22 = A22 - tau*u*u.T*A22 - tau*(A22 - tau*u*u.T*A22)*u*u.T * = A22 - tau*u*u.T*A22 - tau*A22*u*u.T + tau*tau*u*u.T*A22*u*u.T * [x = tau*A22*u (vector)] (SYMV) * A22 = A22 - u*x.T - x*u.T + tau*u*u.T*x*u.T * [beta = tau*u.T*x (scalar)] (DOT) * = A22 - u*x.T - x*u.T + beta*u*u.T * = A22 - u*(x - 0.5*beta*u).T - (x - 0.5*beta*u)*u.T * [w = x - 0.5*beta*u] (AXPY) * = A22 - u*w.T - w*u.T (SYR2) * * Result of reduction for N = 5: * ( d . . . . ) * ( e d . . . ) * ( v1 e d . . ) * ( v1 v2 e d . ) * ( v1 v2 v3 e d ) */ func unblkReduceTridiagLower(A, tauq, W *cmat.FloatMatrix) { var ATL, ABR cmat.FloatMatrix var A00, a11, a21, A22 cmat.FloatMatrix var tqT, tqB, tq0, tauq1, tq2 cmat.FloatMatrix var y21 cmat.FloatMatrix var v0 float64 util.Partition2x2( &ATL, nil, nil, &ABR, A, 0, 0, util.PTOPLEFT) util.Partition2x1( &tqT, &tqB, tauq, 0, util.PTOP) for m(&ABR) > 0 && n(&ABR) > 0 { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, nil, &a11, nil, nil, &a21, &A22, A, 1, util.PBOTTOMRIGHT) util.Repartition2x1to3x1(&tqT, &tq0, &tauq1, &tq2, tauq, 1, util.PBOTTOM) // set temp vectors for this round y21.SetBuf(n(&A22), 1, n(&A22), W.Data()) // ------------------------------------------------------ // Compute householder to zero subdiagonal entries computeHouseholderVec(&a21, &tauq1) tauqv := tauq1.Get(0, 0) // set subdiagonal to unit v0 = a21.Get(0, 0) a21.Set(0, 0, 1.0) // y21 := tauq*A22*a21 blasd.MVMultSym(&y21, &A22, &a21, tauqv, 0.0, gomas.LOWER) // beta := tauq*a21.T*y21 beta := tauqv * blasd.Dot(&a21, &y21) // y21 := y21 - 0.5*beta*a21 blasd.Axpy(&y21, &a21, -0.5*beta) // A22 := A22 - a21*y21.T - y21*a21.T blasd.MVUpdate2Sym(&A22, &a21, &y21, -1.0, gomas.LOWER) // restore subdiagonal a21.Set(0, 0, v0) // ------------------------------------------------------ util.Continue3x3to2x2( &ATL, nil, nil, &ABR, &A00, &a11, &A22, A, util.PBOTTOMRIGHT) util.Continue3x1to2x1( &tqT, &tqB, &tq0, &tauq1, tauq, util.PBOTTOM) } }
/* * Unblocked code for generating M by N matrix Q with orthogonal columns which * are defined as the last N columns of the product of K first elementary * reflectors. * * Parameter nk is last nk elementary reflectors that are not used in computing * the matrix Q. Parameter mk length of the first unused elementary reflectors * First nk columns are zeroed and subdiagonal mk-nk is set to unit. * * Compatible with lapack.DORG2L subroutine. */ func unblkBuildQL(A, Tvec, W *cmat.FloatMatrix, mk, nk int, mayClear bool) { var ATL, ATR, ABL, ABR cmat.FloatMatrix var A00, a01, a10, a11, a21, A22 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2, w12, D cmat.FloatMatrix // (mk, nk) = (rows, columns) of upper left partition util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, mk, nk, util.PTOPLEFT) util.Partition2x1( &tT, &tB, Tvec, nk, util.PTOP) // zero the left side if nk > 0 && mayClear { blasd.Scale(&ABL, 0.0) blasd.Scale(&ATL, 0.0) D.Diag(&ATL, nk-mk) blasd.Add(&D, 1.0) } for m(&ABR) > 0 && n(&ABR) > 0 { util.Repartition2x2to3x3(&ATL, &A00, &a01, nil, &a10, &a11, nil, nil, &a21, &A22, A, 1, util.PBOTTOMRIGHT) util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2, Tvec, 1, util.PBOTTOM) // ------------------------------------------------------ w12.SubMatrix(W, 0, 0, a10.Len(), 1) applyHouseholder2x1(&tau1, &a01, &a10, &A00, &w12, gomas.LEFT) blasd.Scale(&a01, -tau1.Get(0, 0)) a11.Set(0, 0, 1.0-tau1.Get(0, 0)) // zero bottom elements blasd.Scale(&a21, 0.0) // ------------------------------------------------------ util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &a11, &A22, A, util.PBOTTOMRIGHT) util.Continue3x1to2x1( &tT, &tB, &t0, &tau1, Tvec, util.PBOTTOM) } }
/* * Unblocked code for generating M by N matrix Q with orthogonal columns which * are defined as the first N columns of the product of K first elementary * reflectors. * * Parameters nk = n(A)-K, mk = m(A)-K define the initial partitioning of * matrix A. * * Q = H(k)H(k-1)...H(1) , 0 < k <= M, where H(i) = I - tau*v*v.T * * Computation is ordered as H(k)*H(k-1)...*H(1)*I ie. from bottom to top. * * If k < M rows k+1:M are cleared and diagonal entries [k+1:M,k+1:M] are * set to unit. Then the matrix Q is generated by right multiplying elements below * of i'th elementary reflector H(i). * * Compatible to lapack.xORG2L subroutine. */ func unblkBuildLQ(A, Tvec, W *cmat.FloatMatrix, mk, nk int, mayClear bool) { var ATL, ATR, ABL, ABR cmat.FloatMatrix var A00, a10, a11, a12, a21, A22 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2, w12, D cmat.FloatMatrix util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, mk, nk, util.PBOTTOMRIGHT) util.Partition2x1( &tT, &tB, Tvec, mk, util.PBOTTOM) // zero the bottom part if mk > 0 && mayClear { blasd.Scale(&ABL, 0.0) blasd.Scale(&ABR, 0.0) D.Diag(&ABR) blasd.Add(&D, 1.0) } for m(&ATL) > 0 && n(&ATL) > 0 { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, &a10, &a11, &a12, nil, &a21, &A22, A, 1, util.PTOPLEFT) util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2, Tvec, 1, util.PTOP) // ------------------------------------------------------ w12.SubMatrix(W, 0, 0, a21.Len(), 1) applyHouseholder2x1(&tau1, &a12, &a21, &A22, &w12, gomas.RIGHT) blasd.Scale(&a12, -tau1.Get(0, 0)) a11.Set(0, 0, 1.0-tau1.Get(0, 0)) // zero blasd.Scale(&a10, 0.0) // ------------------------------------------------------ util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &a11, &A22, A, util.PTOPLEFT) util.Continue3x1to2x1( &tT, &tB, &t0, &tau1, Tvec, util.PTOP) } }
/* * Unblocked RQ decomposition. As implemented * in lapack.DGERQ2 subroutine. */ func unblockedRQ(A, Tvec, W *cmat.FloatMatrix) { var ATL, ABR cmat.FloatMatrix var A00, a11, a01, a10, A22 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2, w12 cmat.FloatMatrix util.Partition2x2( &ATL, nil, nil, &ABR, A, 0, 0, util.PBOTTOMRIGHT) util.Partition2x1( &tT, &tB, Tvec, 0, util.PBOTTOM) for m(&ATL) > 0 && n(&ATL) > 0 { util.Repartition2x2to3x3(&ATL, &A00, &a01, nil, &a10, &a11, nil, nil, nil, &A22, A, 1, util.PTOPLEFT) util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2, Tvec, 1, util.PTOP) // ------------------------------------------------------ computeHouseholder(&a11, &a10, &tau1) w12.SubMatrix(W, 0, 0, a01.Len(), 1) applyHouseholder2x1(&tau1, &a10, &a01, &A00, &w12, gomas.RIGHT) // ------------------------------------------------------ util.Continue3x3to2x2( &ATL, nil, nil, &ABR, &A00, &a11, &A22, A, util.PTOPLEFT) util.Continue3x1to2x1( &tT, &tB, &t0, &tau1, Tvec, util.PTOP) } }
/* * Blocked version of Hessenberg reduction algorithm as presented in (1). This * version uses compact-WY transformation. * * Some notes: * * Elementary reflectors stored in [A11; A21].T are not on diagonal of A11. Update of * a block aligned with A11; A21 is as follow * * 1. Update from left Q(k)*C: * c0 0 c0 * (I - Y*T*Y.T).T*C = C - Y*(C.T*Y)*T.T = C1 - Y1 * (C1.T.Y1+C2.T*Y2)*T.T = C1-Y1*W * C2 Y2 C2-Y2*W * * where W = (C1.T*Y1+C2.T*Y2)*T.T and first row of C is not affected by update * * 2. Update from right C*Q(k): * 0 * C - C*Y*T*Y.T = c0;C1;C2 - c0;C1;C2 * Y1 *T*(0;Y1;Y2) = c0; C1-W*Y1; C2-W*Y2 * Y2 * where W = (C1*Y1 + C2*Y2)*T and first column of C is not affected * */ func blkHessGQvdG(A, Tvec, W *cmat.FloatMatrix, nb int, conf *gomas.Config) *gomas.Error { var ATL, ATR, ABL, ABR cmat.FloatMatrix var A00, A11, A12, A21, A22, A2 cmat.FloatMatrix var tT, tB, td cmat.FloatMatrix var t0, t1, t2, T cmat.FloatMatrix var V, VT, VB /*V0, V1, V2,*/, Y1, Y2, W0 cmat.FloatMatrix //fmt.Printf("blkHessGQvdG...\n") T.SubMatrix(W, 0, 0, conf.LB, conf.LB) V.SubMatrix(W, conf.LB, 0, m(A), conf.LB) td.Diag(&T) util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, 0, 0, util.PTOPLEFT) util.Partition2x1( &tT, &tB, Tvec, 0, util.PTOP) for m(&ABR) > nb+1 && n(&ABR) > nb { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, nil, &A11, &A12, nil, &A21, &A22, A, nb, util.PBOTTOMRIGHT) util.Repartition2x1to3x1(&tT, &t0, &t1, &t2, Tvec, nb, util.PBOTTOM) util.Partition2x1( &VT, &VB, &V, m(&ATL), util.PTOP) // ------------------------------------------------------ unblkBuildHessGQvdG(&ABR, &T, &VB, nil) blasd.Copy(&t1, &td) // m(Y) == m(ABR)-1, n(Y) == n(A11) Y1.SubMatrix(&ABR, 1, 0, n(&A11), n(&A11)) Y2.SubMatrix(&ABR, 1+n(&A11), 0, m(&A21)-1, n(&A11)) // [A01; A02] == ATR := ATR*(I - Y*T*Y.T) updateHessRightWY(&ATR, &Y1, &Y2, &T, &VT, conf) // A2 = [A12; A22].T util.Merge2x1(&A2, &A12, &A22) // A2 := A2 - VB*T*A21.T be := A21.Get(0, -1) A21.Set(0, -1, 1.0) blasd.MultTrm(&VB, &T, 1.0, gomas.UPPER|gomas.RIGHT) blasd.Mult(&A2, &VB, &A21, -1.0, 1.0, gomas.TRANSB, conf) A21.Set(0, -1, be) // A2 := (I - Y*T*Y.T).T * A2 W0.SubMatrix(&V, 0, 0, n(&A2), n(&Y2)) updateHessLeftWY(&A2, &Y1, &Y2, &T, &W0, conf) // ------------------------------------------------------ util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &A11, &A22, A, util.PBOTTOMRIGHT) util.Continue3x1to2x1( &tT, &tB, &t0, &t1, Tvec, util.PBOTTOM) } if m(&ABR) > 1 { // do the rest with unblocked util.Merge2x1(&A2, &ATR, &ABR) W0.SetBuf(m(A), 1, m(A), W.Data()) unblkHessGQvdG(&A2, &tB, &W0, m(&ATR)) } return nil }
func blkBuildLQ(A, Tvec, Twork, W *cmat.FloatMatrix, K, lb int, conf *gomas.Config) { var ATL, ATR, ABL, ABR, AL cmat.FloatMatrix var A00, A10, A11, A12, A21, A22 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau, t2, Wrk, D, T cmat.FloatMatrix nk := n(A) - K mk := m(A) - K uk := K % lb util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, mk+uk, nk+uk, util.PBOTTOMRIGHT) util.Partition2x1( &tT, &tB, Tvec, mk+uk, util.PBOTTOM) // zero the bottom part __CHECK HERE: nk? or mk? if nk+uk > 0 { blasd.Scale(&ABL, 0.0) if uk > 0 { // number of reflectors is not multiple of blocking factor // do the first part with unblocked code. unblkBuildLQ(&ABR, &tB, W, m(&ABR)-uk, n(&ABR)-uk, true) } else { // blocking factor is multiple of K blasd.Scale(&ABR, 0.0) D.Diag(&ABR) blasd.Add(&D, 1.0) } } for m(&ATL) > 0 && n(&ATL) > 0 { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, &A10, &A11, &A12, nil, &A21, &A22, A, lb, util.PTOPLEFT) util.Repartition2x1to3x1(&tT, &t0, &tau, &t2, Tvec, lb, util.PTOP) // ------------------------------------------------------ util.Merge1x2(&AL, &A11, &A12) // build block reflector T.SubMatrix(Twork, 0, 0, n(&A11), n(&A11)) unblkBlockReflectorLQ(&T, &AL, &tau) // update A21 and A22 with (I - Y*T*Y.T) from right ar, ac := A21.Size() Wrk.SubMatrix(W, 0, 0, ar, ac) updateRightLQ(&A21, &A22, &A11, &A12, &T, &Wrk, false, conf) // update current block unblkBuildLQ(&AL, &tau, W, 0, n(&A12), false) // zero top rows blasd.Scale(&A10, 0.0) // ------------------------------------------------------ util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &A11, &A22, A, util.PTOPLEFT) util.Continue3x1to2x1( &tT, &tB, &t0, &tau, Tvec, util.PTOP) } }
/* * Blocked version for computing C = C*Q and C = C*Q.T from elementary reflectors * and scalar coefficients. * * Elementary reflectors and scalar coefficients are used to build block reflector T. * Matrix C is updated by applying block reflector T using compact WY algorithm. */ func blockedMultQRight(C, A, tau, W *cmat.FloatMatrix, flags, nb int, conf *gomas.Config) { var ATL, ATR, ABL, ABR, AL cmat.FloatMatrix var A00, A10, A11, A20, A21, A22 cmat.FloatMatrix var CL, CR, C0, C1, C2 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2 cmat.FloatMatrix var W0, Wrk, Tw, Twork cmat.FloatMatrix var Aref *cmat.FloatMatrix var pAdir, pAstart, pDir, pStart, pCstart, pCdir util.Direction var bsz, cb, mb int // partitioning start and direction if flags&gomas.TRANS != 0 { // from bottom-right to top-left to produce transpose sequence (C*Q.T) pAstart = util.PBOTTOMRIGHT pAdir = util.PTOPLEFT pStart = util.PBOTTOM pDir = util.PTOP pCstart = util.PRIGHT pCdir = util.PLEFT mb = imax(0, m(A)-n(A)) cb = n(C) - n(A) Aref = &ATL } else { // from top-left to bottom-right to produce normal sequence (C*Q) pAstart = util.PTOPLEFT pAdir = util.PBOTTOMRIGHT pStart = util.PTOP pDir = util.PBOTTOM pCstart = util.PLEFT pCdir = util.PRIGHT mb = 0 cb = 0 Aref = &ABR } // intermediate reflector at start of workspace Twork.SetBuf(nb, nb, nb, W.Data()) W0.SetBuf(m(C), nb, m(C), W.Data()[Twork.Len():]) util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, mb, 0, pAstart) util.Partition1x2( &CL, &CR, C, cb, pCstart) util.Partition2x1( &tT, &tB, tau, 0, pStart) transpose := flags&gomas.TRANS != 0 for m(Aref) > 0 && n(Aref) > 0 { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, &A10, &A11, nil, &A20, &A21, &A22, A, nb, pAdir) util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2, tau, nb, pDir) bsz = n(&A11) // C1 block size must match A11 util.Repartition1x2to1x3(&CL, &C0, &C1, &C2, C, bsz, pCdir) // -------------------------------------------------------- // clear & build block reflector from current block util.Merge2x1(&AL, &A11, &A21) Tw.SubMatrix(&Twork, 0, 0, bsz, bsz) blasd.Scale(&Tw, 0.0) unblkQRBlockReflector(&Tw, &AL, &tau1) // compute: C*Q.T == C - C*(Y*T*Y.T).T = C - C*Y*T.T*Y.T // C*Q == C - C*Y*T*Y.T Wrk.SubMatrix(&W0, 0, 0, m(&C1), bsz) updateWithQTRight(&C1, &C2, &A11, &A21, &Tw, &Wrk, transpose, conf) // -------------------------------------------------------- util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &A11, &A22, A, pAdir) util.Continue1x3to1x2( &CL, &CR, &C0, &C1, C, pCdir) util.Continue3x1to2x1( &tT, &tB, &t0, &tau1, tau, pDir) } }
/* * Unblocked algorith for computing C = Q.T*C and C = Q*C. * * Q = H(1)H(2)...H(k) where elementary reflectors H(i) are stored on i'th column * below diagonal in A. * * Progressing A from top-left to bottom-right i.e from smaller column numbers * to larger, produces H(k)...H(2)H(1) == Q.T. and C = Q.T*C * * Progressing from bottom-right to top-left produces H(1)H(2)...H(k) == Q and C = Q*C */ func unblockedMultQLeft(C, A, tau, w *cmat.FloatMatrix, flags int) { var ATL, ATR, ABL, ABR cmat.FloatMatrix var A00, a10, a11, A20, a21, A22 cmat.FloatMatrix var CT, CB, C0, c1t, C2 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2, w1 cmat.FloatMatrix var Aref *cmat.FloatMatrix var pAdir, pAstart, pDir, pStart util.Direction var mb, tb, nb int // partitioning start and direction if flags&gomas.TRANS != 0 { // from top-left to bottom-right to produce transposed sequence (Q.T*C) pAstart = util.PTOPLEFT pAdir = util.PBOTTOMRIGHT pStart = util.PTOP pDir = util.PBOTTOM mb = 0 tb = 0 nb = 0 Aref = &ABR } else { // from bottom-right to top-left to produce normal sequence (Q*C) pAstart = util.PBOTTOMRIGHT pAdir = util.PTOPLEFT pStart = util.PBOTTOM pDir = util.PTOP mb = imax(0, m(A)-n(A)) nb = imax(0, n(A)-m(A)) tb = imax(0, tau.Len()-n(A)) Aref = &ATL } util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, mb, nb, pAstart) util.Partition2x1( &CT, &CB, C, mb, pStart) util.Partition2x1( &tT, &tB, tau, tb, pStart) for m(Aref) > 0 && n(Aref) > 0 { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, &a10, &a11, nil, &A20, &a21, &A22, A, 1, pAdir) util.Repartition2x1to3x1(&CT, &C0, &c1t, &C2, C, 1, pDir) util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2, tau, 1, pDir) // -------------------------------------------------------- w1.SubMatrix(w, 0, 0, c1t.Len(), 1) applyHouseholder2x1(&tau1, &a21, &c1t, &C2, &w1, gomas.LEFT) // -------------------------------------------------------- util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &a11, &A22, A, pAdir) util.Continue3x1to2x1( &CT, &CB, &C0, &c1t, C, pDir) util.Continue3x1to2x1( &tT, &tB, &t0, &tau1, tau, pDir) } }
/* * Unblocked algorith for computing C = C*Q.T and C = C*Q. * * Q = H(0)H(1)...H(K-1) where elementary reflectors H(i) are stored on i'th row * right of diagonal in A. * * Progressing A from top-left to bottom-right i.e from smaller column numbers * to larger, produces C*H(0)H(1)...H(K-1) == C*Q. * * Progressing from bottom-right to top-left produces C*H(K-1)...H(1)H(0) == C*Q.T. */ func unblockedMultRQRight(C, A, tau, w *cmat.FloatMatrix, flags int) { var ATL, ABR cmat.FloatMatrix var A00, a10, a11, A22 cmat.FloatMatrix var CL, CR, C0, c1, C2 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2, w1 cmat.FloatMatrix var Aref *cmat.FloatMatrix var pAdir, pAstart, pDir, pStart, pCstart, pCdir util.Direction var cb, mb, tb, nb int // partitioning start and direction if flags&gomas.TRANS != 0 { // from bottom-right to top-left to produce transpose sequence (C*Q.T) pAstart = util.PBOTTOMRIGHT pAdir = util.PTOPLEFT pStart = util.PBOTTOM pDir = util.PTOP pCstart = util.PRIGHT pCdir = util.PLEFT mb = 0 nb = 0 cb = 0 tb = 0 Aref = &ATL } else { // from top-left to bottom-right to produce normal sequence (C*Q) pAstart = util.PTOPLEFT pAdir = util.PBOTTOMRIGHT pStart = util.PTOP pDir = util.PBOTTOM pCstart = util.PLEFT pCdir = util.PRIGHT mb = imax(0, m(A)-n(A)) nb = imax(0, n(A)-m(A)) cb = imax(0, n(C)-m(A)) tb = imax(0, tau.Len()-n(A)) Aref = &ABR } util.Partition2x2( &ATL, nil, nil, &ABR /**/, A, mb, nb, pAstart) util.Partition1x2( &CL, &CR /**/, C, cb, pCstart) util.Partition2x1( &tT, &tB /**/, tau, tb, pStart) w1.SubMatrix(w, 0, 0, m(C), 1) for m(Aref) > 0 && n(Aref) > 0 { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, &a10, &a11, nil, nil, nil, &A22 /**/, A, 1, pAdir) util.Repartition1x2to1x3(&CL, &C0, &c1, &C2 /**/, C, 1, pCdir) util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2 /**/, tau, 1, pDir) // -------------------------------------------------------- applyHouseholder2x1(&tau1, &a10, &c1, &C0, &w1, gomas.RIGHT) // -------------------------------------------------------- util.Continue3x3to2x2( &ATL, nil, nil, &ABR /**/, &A00, &a11, &A22, A, pAdir) util.Continue1x3to1x2( &CL, &CR /**/, &C0, &c1, C, pCdir) util.Continue3x1to2x1( &tT, &tB /**/, &t0, &tau1, tau, pDir) } }
/* * Blocked version for computing C = Q*C and C = Q.T*C with block reflector. * * Block reflector T is [T(0), T(1), ... T(k-1)], conf.LB*n(A) matrix where * where each T(n), expect T(k-1), is conf.LB*conf.LB. T(k-1) is IB*IB where * IB = imin(LB, K%LB) */ func blockedMultQTLeft(C, A, T, W *cmat.FloatMatrix, flags int, conf *gomas.Config) *gomas.Error { var ATL, ATR, ABL, ABR cmat.FloatMatrix var A00, A10, A11, A20, A21, A22 cmat.FloatMatrix var CT, CB, C0, C1, C2 cmat.FloatMatrix var TL, TR, T00, T01, T02 cmat.FloatMatrix var Wrk cmat.FloatMatrix var Aref *cmat.FloatMatrix var pAdir, pAstart, pCdir, pCstart, pTstart, pTdir util.Direction var bsz, mb, tb int lb := conf.LB if conf.LB == 0 { lb = m(T) } transpose := flags&gomas.TRANS != 0 nb := lb //W0 := cmat.MakeMatrix(n(C), conf.LB, W.Data()) // partitioning start and direction if flags&gomas.TRANS != 0 { // from top-left to bottom-right to produce transposed sequence (Q.T*C) pAstart = util.PTOPLEFT pAdir = util.PBOTTOMRIGHT pCstart = util.PTOP pCdir = util.PBOTTOM pTstart = util.PLEFT pTdir = util.PRIGHT mb = 0 tb = nb Aref = &ABR } else { // from bottom-right to top-left to produce normal sequence (Q*C) pAstart = util.PBOTTOMRIGHT pAdir = util.PTOPLEFT pCstart = util.PBOTTOM pCdir = util.PTOP pTstart = util.PRIGHT pTdir = util.PLEFT mb = m(A) - n(A) Aref = &ATL // if N%LB != 0 then the last T is not of size LB and we need // adjust first repartitioning accordingly. tb = n(A) % lb } util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, mb, 0, pAstart) util.Partition1x2( &TL, &TR, T, 0, pTstart) util.Partition2x1( &CT, &CB, C, mb, pCstart) nb = tb for m(Aref) > 0 && n(Aref) > 0 { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, &A10, &A11, nil, &A20, &A21, &A22, A, nb, pAdir) util.Repartition1x2to1x3(&TL, &T00, &T01, &T02, T, nb, pTdir) bsz = n(&A11) // must match A11 block size util.Repartition2x1to3x1(&CT, &C0, &C1, &C2, C, bsz, pCdir) // -------------------------------------------------------- tr, tc := T01.Size() // compute: Q.T*C == C - Y*(C.T*Y*T).T transpose == true // Q*C == C - C*Y*T*Y.T transpose == false Wrk.SubMatrix(W, 0, 0, n(&C1), bsz) if tr != tc { // this happens when n(A) not multiple of LB var Tmp cmat.FloatMatrix Tmp.SubMatrix(&T01, 0, 0, tc, tc) updateWithQTLeft(&C1, &C2, &A11, &A21, &Tmp, &Wrk, transpose, conf) } else { updateWithQTLeft(&C1, &C2, &A11, &A21, &T01, &Wrk, transpose, conf) } // -------------------------------------------------------- util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &A11, &A22, A, pAdir) util.Continue1x3to1x2( &TL, &TR, &T00, &T01, T, pTdir) util.Continue3x1to2x1( &CT, &CB, &C0, &C1, C, pCdir) nb = lb } return nil }
func blkMultRightQL(C, A, tau, W *cmat.FloatMatrix, flags, lb int, conf *gomas.Config) { var ATL, ABR, AL cmat.FloatMatrix var A00, A01, A11, A22 cmat.FloatMatrix var CL, CR, C0, C1, C2 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2 cmat.FloatMatrix var T0, T, W0, Wrk cmat.FloatMatrix var Aref *cmat.FloatMatrix var pAdir, pAstart, pDir, pStart, pCdir, pCstart util.Direction var mb, tb, nb, cb int // partitioning start and direction if flags&gomas.TRANS != 0 { // from top-left to bottom-right to produce transpose sequence (C*Q.T) pAstart = util.PTOPLEFT pAdir = util.PBOTTOMRIGHT pStart = util.PTOP pDir = util.PBOTTOM pCstart = util.PLEFT pCdir = util.PRIGHT mb = imax(0, m(A)-n(A)) nb = imax(0, n(A)-m(A)) cb = imax(0, n(C)-n(A)) tb = imax(0, tau.Len()-n(A)) Aref = &ABR } else { // A from bottom-right to top-left to produce normal sequence (C*Q) pAstart = util.PBOTTOMRIGHT pAdir = util.PTOPLEFT pStart = util.PBOTTOM pDir = util.PTOP pCstart = util.PRIGHT pCdir = util.PLEFT mb = 0 tb = 0 nb = 0 cb = 0 Aref = &ATL } util.Partition2x2( &ATL, nil, nil, &ABR /**/, A, mb, nb, pAstart) util.Partition1x2( &CL, &CR /**/, C, cb, pCstart) util.Partition2x1( &tT, &tB /**/, tau, tb, pStart) transpose := flags&gomas.TRANS != 0 // divide workspace for block reflector and temporary work matrix T0.SetBuf(lb, lb, lb, W.Data()) W0.SetBuf(m(C), lb, m(C), W.Data()[T0.Len():]) for n(Aref) > 0 { util.Repartition2x2to3x3(&ATL, &A00, &A01, nil, nil, &A11, nil, nil, nil, &A22 /**/, A, lb, pAdir) bsz := n(&A11) util.Repartition1x2to1x3(&CL, &C0, &C1, &C2 /**/, C, bsz, pCdir) util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2 /**/, tau, bsz, pDir) // -------------------------------------------------------- util.Merge2x1(&AL, &A01, &A11) T.SubMatrix(&T0, 0, 0, bsz, bsz) blasd.Scale(&T, 0.0) unblkQLBlockReflector(&T, &AL, &tau1) Wrk.SubMatrix(&W0, 0, 0, m(C), bsz) updateQLRight(&C1, &C0, &A11, &A01, &T, &Wrk, transpose, conf) // -------------------------------------------------------- util.Continue3x3to2x2( &ATL, nil, nil, &ABR /**/, &A00, &A11, &A22, A, pAdir) util.Continue1x3to1x2( &CL, &CR /**/, &C0, &C1, C, pCdir) util.Continue3x1to2x1( &tT, &tB /**/, &t0, &tau1, tau, pDir) } }
/* * This is adaptation of BIRED_LAZY_UNB algorithm from (1). * * Z matrix accumulates updates of row transformations i.e. first * Householder that zeros off diagonal entries on row. Vector z21 * is updates for current round, Z20 are already accumulated updates. * Vector z21 updates a12 before next transformation. * * Y matrix accumulates updates on column tranformations ie Householder * that zeros elements below sub-diagonal. Vector y21 is updates for current * round, Y20 are already accumulated updates. Vector y21 updates * a21 befor next transformation. * * Z, Y matrices upper trigonal part is not needed, temporary vector * w00 that has maximum length of n(Y) is placed on the last column of * Z matrix on each iteration. */ func unblkBuildBidiagRight(A, tauq, taup, Y, Z *cmat.FloatMatrix) { var ATL, ABL, ABR cmat.FloatMatrix var A00, a01, A02, a10, a11, a12t, A20, a21, A22 cmat.FloatMatrix var YTL, YBR, ZTL, ZBR cmat.FloatMatrix var Y00, y10, Y20, y11, y21, Y22 cmat.FloatMatrix var Z00, z10, Z20, z11, z21, Z22 cmat.FloatMatrix var tqT, tqB, tq0, tauq1, tq2 cmat.FloatMatrix var tpT, tpB, tp0, taup1, tp2 cmat.FloatMatrix var w00 cmat.FloatMatrix var v0 float64 // Y is workspace for building updates for first Householder. // And Z is space for build updates for second Householder // Y is n(A)-2,nb and Z is m(A)-1,nb util.Partition2x2( &ATL, nil, &ABL, &ABR, A, 0, 0, util.PTOPLEFT) util.Partition2x2( &YTL, nil, nil, &YBR, Y, 0, 0, util.PTOPLEFT) util.Partition2x2( &ZTL, nil, nil, &ZBR, Z, 0, 0, util.PTOPLEFT) util.Partition2x1( &tqT, &tqB, tauq, 0, util.PTOP) util.Partition2x1( &tpT, &tpB, taup, 0, util.PTOP) k := 0 for k < n(Y) { util.Repartition2x2to3x3(&ATL, &A00, &a01, &A02, &a10, &a11, &a12t, &A20, &a21, &A22, A, 1, util.PBOTTOMRIGHT) util.Repartition2x2to3x3(&YTL, &Y00, nil, nil, &y10, &y11, nil, &Y20, &y21, &Y22, Y, 1, util.PBOTTOMRIGHT) util.Repartition2x2to3x3(&ZTL, &Z00, nil, nil, &z10, &z11, nil, &Z20, &z21, &Z22, Z, 1, util.PBOTTOMRIGHT) util.Repartition2x1to3x1(&tqT, &tq0, &tauq1, &tq2, tauq, 1, util.PBOTTOM) util.Repartition2x1to3x1(&tpT, &tp0, &taup1, &tp2, taup, 1, util.PBOTTOM) // set temp vectors for this round, w00.SubMatrix(Z, 0, n(Z)-1, m(&A02), 1) // ------------------------------------------------------ // u10 == a10, U20 == A20, u21 == a21, // v10 == a01, V20 == A02, v21 == a12t if n(&Y20) > 0 { // a11 := a11 - u10t*z10 - y10*v10 aa := blasd.Dot(&a10, &z10) aa += blasd.Dot(&y10, &a01) a11.Set(0, 0, a11.Get(0, 0)-aa) // a12t := a12t - V20*z10 - Z20*u10 blasd.MVMult(&a12t, &A02, &y10, -1.0, 1.0, gomas.TRANS) blasd.MVMult(&a12t, &Z20, &a10, -1.0, 1.0, gomas.NONE) // a21 := a21 - Y20*v10 - U20*z10 blasd.MVMult(&a21, &Y20, &a01, -1.0, 1.0, gomas.NONE) blasd.MVMult(&a21, &A20, &z10, -1.0, 1.0, gomas.NONE) // here restore bidiagonal entry a10.Set(0, -1, v0) } // Compute householder to zero superdiagonal entries computeHouseholder(&a11, &a12t, &taup1) taupv := taup1.Get(0, 0) // y21 := a21 + A22*v21 - Y20*U20.T*v21 - V20*Z20.T*v21 blasd.Axpby(&y21, &a21, 1.0, 0.0) blasd.MVMult(&y21, &A22, &a12t, 1.0, 1.0, gomas.NONE) // w00 := U20.T*v21 [= A02*a12t] blasd.MVMult(&w00, &A02, &a12t, 1.0, 0.0, gomas.NONE) // y21 := y21 - U20*w00 [U20 == A20] blasd.MVMult(&y21, &Y20, &w00, -1.0, 1.0, gomas.NONE) // w00 := Z20.T*v21 blasd.MVMult(&w00, &Z20, &a12t, 1.0, 0.0, gomas.TRANS) // y21 := y21 - V20*w00 [V20 == A02.T] blasd.MVMult(&y21, &A20, &w00, -1.0, 1.0, gomas.NONE) // a21 := a21 - taup*y21 blasd.Scale(&y21, taupv) blasd.Axpy(&a21, &y21, -1.0) // Compute householder to zero elements below 1st subdiagonal computeHouseholderVec(&a21, &tauq1) v0 = a21.Get(0, 0) a21.Set(0, 0, 1.0) tauqv := tauq1.Get(0, 0) // z21 := tauq*(A22*y - V20*Y20.T*u - Z20*U20.T*u - beta*v) // [v == a12t, u == a21] beta := blasd.Dot(&y21, &a21) // z21 := beta*v blasd.Axpby(&z21, &a12t, beta, 0.0) // w00 = Y20.T*u blasd.MVMult(&w00, &Y20, &a21, 1.0, 0.0, gomas.TRANS) // z21 = z21 + V20*w00 == A02.T*w00 blasd.MVMult(&z21, &A02, &w00, 1.0, 1.0, gomas.TRANS) // w00 := U20.T*u (U20.T == A20.T) blasd.MVMult(&w00, &A20, &a21, 1.0, 0.0, gomas.TRANS) // z21 := z21 + Z20*w00 blasd.MVMult(&z21, &Z20, &w00, 1.0, 1.0, gomas.NONE) // z21 := -tauq*z21 + tauq*A22*v blasd.MVMult(&z21, &A22, &a21, tauqv, -tauqv, gomas.TRANS) // ------------------------------------------------------ k += 1 util.Continue3x3to2x2( &ATL, nil, &ABL, &ABR, &A00, &a11, &A22, A, util.PBOTTOMRIGHT) util.Continue3x3to2x2( &YTL, nil, nil, &YBR, &Y00, &y11, &Y22, Y, util.PBOTTOMRIGHT) util.Continue3x3to2x2( &ZTL, nil, nil, &ZBR, &Z00, &z11, &Z22, Z, util.PBOTTOMRIGHT) util.Continue3x1to2x1( &tqT, &tqB, &tq0, &tauq1, tauq, util.PBOTTOM) util.Continue3x1to2x1( &tpT, &tpB, &tp0, &taup1, taup, util.PBOTTOM) } // restore ABL.Set(0, -1, v0) }
func blkBidiagRight(A, tauq, taup, W *cmat.FloatMatrix, lb int, conf *gomas.Config) { var ATL, ABR cmat.FloatMatrix var A00, A11, A12, A21, A22 cmat.FloatMatrix var tqT, tqB, tq0, tauq1, tq2 cmat.FloatMatrix var tpT, tpB, tp0, taup1, tp2 cmat.FloatMatrix var ZT, ZB, YT, YB cmat.FloatMatrix var Z0, Z1, Z2, Y0, Y1, Y2 cmat.FloatMatrix var Y, Z cmat.FloatMatrix // setup work buffers Z.SetBuf(n(A), lb, n(A), W.Data()) Y.SetBuf(m(A), lb, m(A), W.Data()[Z.Len():]) util.Partition2x2( &ATL, nil, nil, &ABR, A, 0, 0, util.PTOPLEFT) util.Partition2x1( &tqT, &tqB, tauq, 0, util.PTOP) util.Partition2x1( &tpT, &tpB, taup, 0, util.PTOP) util.Partition2x1( &YT, &YB, &Y, 0, util.PTOP) util.Partition2x1( &ZT, &ZB, &Z, 0, util.PTOP) for m(&ABR) > lb && n(&ABR) > lb { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, nil, &A11, &A12, nil, &A21, &A22, A, lb, util.PBOTTOMRIGHT) util.Repartition2x1to3x1(&tqT, &tq0, &tauq1, &tq2, tauq, lb, util.PBOTTOM) util.Repartition2x1to3x1(&tpT, &tp0, &taup1, &tp2, taup, lb, util.PBOTTOM) util.Repartition2x1to3x1(&ZT, &Z0, &Z1, &Z2, &Z, lb, util.PBOTTOM) util.Repartition2x1to3x1(&YT, &Y0, &Y1, &Y2, &Y, lb, util.PBOTTOM) // ------------------------------------------------------ unblkBuildBidiagRight(&ABR, &tauq1, &taup1, &YB, &ZB) // set sub-diagonal entry to one v0 := A21.Get(0, n(&A21)-1) A21.Set(0, n(&A21)-1, 1.0) // A22 := A22 - U2*Z2.T blasd.Mult(&A22, &A21, &Z2, -1.0, 1.0, gomas.TRANSB, conf) // A22 := A22 - Y2*V2.T blasd.Mult(&A22, &Y2, &A12, -1.0, 1.0, gomas.NONE, conf) // restore sub-diagonal entry A21.Set(0, n(&A21)-1, v0) // ------------------------------------------------------ util.Continue3x3to2x2( &ATL, nil, nil, &ABR, &A00, &A11, &A22, A, util.PBOTTOMRIGHT) util.Continue3x1to2x1( &tqT, &tqB, &tq0, &tauq1, tauq, util.PBOTTOM) util.Continue3x1to2x1( &tpT, &tpB, &tp0, &taup1, taup, util.PBOTTOM) util.Continue3x1to2x1( &ZT, &ZB, &Z0, &Z1, &Z, util.PBOTTOM) util.Continue3x1to2x1( &YT, &YB, &Y0, &Y1, &Y, util.PBOTTOM) } if n(&ABR) > 0 { // do rest with unblocked unblkReduceBidiagRight(&ABR, &tqB, &tpB, W) } }
/* * Blocked code for generating M by N matrix Q with orthogonal columns which * are defined as the last N columns of the product of K first elementary * reflectors. * * If the number K of elementary reflectors is not multiple of the blocking * factor lb, then unblocked code is used first to generate the upper left corner * of the matrix Q. * * Compatible with lapack.DORGQL subroutine. */ func blkBuildQL(A, Tvec, Twork, W *cmat.FloatMatrix, K, lb int, conf *gomas.Config) { var ATL, ATR, ABL, ABR, AL cmat.FloatMatrix var A00, A01, A10, A11, A21, A22 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau, t2, Wrk, D, T cmat.FloatMatrix nk := n(A) - K mk := m(A) - K uk := K % lb util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, mk+uk, nk+uk, util.PTOPLEFT) util.Partition2x1( &tT, &tB, Tvec, nk+uk, util.PTOP) // zero the left side if nk+uk > 0 { blasd.Scale(&ABL, 0.0) if uk > 0 { // number of reflectors is not multiple of blocking factor // do the first part with unblocked code. unblkBuildQL(&ATL, &tT, W, m(&ATL)-uk, n(&ATL)-uk, true) } else { // blocking factor is multiple of K blasd.Scale(&ATL, 0.0) D.Diag(&ATL) blasd.Add(&D, 1.0) } } for m(&ABR) > 0 && n(&ABR) > 0 { util.Repartition2x2to3x3(&ATL, &A00, &A01, nil, &A10, &A11, nil, nil, &A21, &A22, A, lb, util.PBOTTOMRIGHT) util.Repartition2x1to3x1(&tT, &t0, &tau, &t2, Tvec, lb, util.PBOTTOM) // ------------------------------------------------------ util.Merge2x1(&AL, &A01, &A11) // build block reflector T.SubMatrix(Twork, 0, 0, n(&A11), n(&A11)) unblkQLBlockReflector(&T, &AL, &tau) // update left side i.e. A10 and A00 with (I - Y*T*Y.T) ar, ac := A10.Size() Wrk.SubMatrix(W, 0, 0, ac, ar) updateQLLeft(&A10, &A00, &A11, &A01, &T, &Wrk, false, conf) // update current block unblkBuildQL(&AL, &tau, W, m(&A01), 0, false) // zero bottom rows blasd.Scale(&A21, 0.0) // ------------------------------------------------------ util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &A11, &A22, A, util.PBOTTOMRIGHT) util.Continue3x1to2x1( &tT, &tB, &t0, &tau, Tvec, util.PBOTTOM) } }
/* * Compute unblocked bidiagonal reduction for A when M >= N * * Diagonal and first super/sub diagonal are overwritten with the * upper/lower bidiagonal matrix B. * * This computing (1-tauq*v*v.T)*A*(1-taup*u.u.T) from left to right. */ func unblkReduceBidiagLeft(A, tauq, taup, W *cmat.FloatMatrix) { var ATL, ABR cmat.FloatMatrix var A00, a11, a12t, a21, A22 cmat.FloatMatrix var tqT, tqB, tq0, tauq1, tq2 cmat.FloatMatrix var tpT, tpB, tp0, taup1, tp2 cmat.FloatMatrix var y21, z21 cmat.FloatMatrix var v0 float64 util.Partition2x2( &ATL, nil, nil, &ABR, A, 0, 0, util.PTOPLEFT) util.Partition2x1( &tqT, &tqB, tauq, 0, util.PTOP) util.Partition2x1( &tpT, &tpB, taup, 0, util.PTOP) for m(&ABR) > 0 && n(&ABR) > 0 { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, nil, &a11, &a12t, nil, &a21, &A22, A, 1, util.PBOTTOMRIGHT) util.Repartition2x1to3x1(&tqT, &tq0, &tauq1, &tq2, tauq, 1, util.PBOTTOM) util.Repartition2x1to3x1(&tpT, &tp0, &taup1, &tp2, taup, 1, util.PBOTTOM) // set temp vectors for this round y21.SetBuf(n(&a12t), 1, n(&a12t), W.Data()) z21.SetBuf(m(&a21), 1, m(&a21), W.Data()[y21.Len():]) // ------------------------------------------------------ // Compute householder to zero subdiagonal entries computeHouseholder(&a11, &a21, &tauq1) // y21 := a12 + A22.T*a21 blasd.Axpby(&y21, &a12t, 1.0, 0.0) blasd.MVMult(&y21, &A22, &a21, 1.0, 1.0, gomas.TRANSA) // a12t := a12t - tauq*y21 tauqv := tauq1.Get(0, 0) blasd.Axpy(&a12t, &y21, -tauqv) // Compute householder to zero elements above 1st superdiagonal computeHouseholderVec(&a12t, &taup1) v0 = a12t.Get(0, 0) a12t.Set(0, 0, 1.0) taupv := taup1.Get(0, 0) // [v == a12t, u == a21] beta := blasd.Dot(&y21, &a12t) // z21 := tauq*beta*u blasd.Axpby(&z21, &a21, tauqv*beta, 0.0) // z21 := A22*v - z21 blasd.MVMult(&z21, &A22, &a12t, 1.0, -1.0, gomas.NONE) // A22 := A22 - tauq*u*y21 blasd.MVUpdate(&A22, &a21, &y21, -tauqv) // A22 := A22 - taup*z21*v blasd.MVUpdate(&A22, &z21, &a12t, -taupv) a12t.Set(0, 0, v0) // ------------------------------------------------------ util.Continue3x3to2x2( &ATL, nil, nil, &ABR, &A00, &a11, &A22, A, util.PBOTTOMRIGHT) util.Continue3x1to2x1( &tqT, &tqB, &tq0, &tauq1, tauq, util.PBOTTOM) util.Continue3x1to2x1( &tpT, &tpB, &tp0, &taup1, taup, util.PBOTTOM) } }
/* * This is adaptation of TRIRED_LAZY_UNB algorithm from (1). */ func unblkBuildTridiagLower(A, tauq, Y, W *cmat.FloatMatrix) { var ATL, ABR cmat.FloatMatrix var A00, a10, a11, A20, a21, A22 cmat.FloatMatrix var YTL, YBR cmat.FloatMatrix var Y00, y10, y11, Y20, y21, Y22 cmat.FloatMatrix var tqT, tqB, tq0, tauq1, tq2 cmat.FloatMatrix var w12 cmat.FloatMatrix var v0 float64 util.Partition2x2( &ATL, nil, nil, &ABR, A, 0, 0, util.PTOPLEFT) util.Partition2x2( &YTL, nil, nil, &YBR, Y, 0, 0, util.PTOPLEFT) util.Partition2x1( &tqT, &tqB, tauq, 0, util.PTOP) k := 0 for k < n(Y) { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, &a10, &a11, nil, &A20, &a21, &A22, A, 1, util.PBOTTOMRIGHT) util.Repartition2x2to3x3(&YTL, &Y00, nil, nil, &y10, &y11, nil, &Y20, &y21, &Y22, Y, 1, util.PBOTTOMRIGHT) util.Repartition2x1to3x1(&tqT, &tq0, &tauq1, &tq2, tauq, 1, util.PBOTTOM) // set temp vectors for this round //w12.SetBuf(y10.Len(), 1, y10.Len(), W.Data()) w12.SubMatrix(Y, 0, 0, 1, n(&Y00)) // ------------------------------------------------------ if n(&Y00) > 0 { aa := blasd.Dot(&a10, &y10) aa += blasd.Dot(&y10, &a10) a11.Set(0, 0, a11.Get(0, 0)-aa) // a21 := a21 - A20*y10 blasd.MVMult(&a21, &A20, &y10, -1.0, 1.0, gomas.NONE) // a21 := a21 - Y20*a10 blasd.MVMult(&a21, &Y20, &a10, -1.0, 1.0, gomas.NONE) // restore subdiagonal value a10.Set(0, -1, v0) } // Compute householder to zero subdiagonal entries computeHouseholderVec(&a21, &tauq1) tauqv := tauq1.Get(0, 0) // set subdiagonal to unit v0 = a21.Get(0, 0) a21.Set(0, 0, 1.0) // y21 := tauq*A22*a21 blasd.MVMultSym(&y21, &A22, &a21, tauqv, 0.0, gomas.LOWER) // w12 := A20.T*a21 blasd.MVMult(&w12, &A20, &a21, 1.0, 0.0, gomas.TRANS) // y21 := y21 - Y20*(A20.T*a21) blasd.MVMult(&y21, &Y20, &w12, -tauqv, 1.0, gomas.NONE) // w12 := Y20.T*a21 blasd.MVMult(&w12, &Y20, &a21, 1.0, 0.0, gomas.TRANS) // y21 := y21 - A20*(Y20.T*a21) blasd.MVMult(&y21, &A20, &w12, -tauqv, 1.0, gomas.NONE) // beta := tauq*a21.T*y21 beta := tauqv * blasd.Dot(&a21, &y21) // y21 := y21 - 0.5*beta*a21 blasd.Axpy(&y21, &a21, -0.5*beta) // ------------------------------------------------------ k += 1 util.Continue3x3to2x2( &ATL, nil, nil, &ABR, &A00, &a11, &A22, A, util.PBOTTOMRIGHT) util.Continue3x3to2x2( &YTL, nil, nil, &YBR, &Y00, &y11, &Y22, A, util.PBOTTOMRIGHT) util.Continue3x1to2x1( &tqT, &tqB, &tq0, &tauq1, tauq, util.PBOTTOM) } // restore subdiagonal value A.Set(m(&ATL), n(&ATL)-1, v0) }
/* * Unblocked solve A*X = B for Bunch-Kauffman factorized symmetric real matrix. */ func unblkSolveBKUpper(B, A *cmat.FloatMatrix, p Pivots, phase int, conf *gomas.Config) *gomas.Error { var err *gomas.Error = nil var ATL, ATR, ABL, ABR cmat.FloatMatrix var A00, a01, A02, a11, a12t, A22 cmat.FloatMatrix var Aref *cmat.FloatMatrix var BT, BB, B0, b1, B2, Bx cmat.FloatMatrix var pT, pB, p0, p1, p2 Pivots var aStart, aDir, bStart, bDir util.Direction var nc int np := 0 if phase == 2 { aStart = util.PTOPLEFT aDir = util.PBOTTOMRIGHT bStart = util.PTOP bDir = util.PBOTTOM nc = 1 Aref = &ABR } else { aStart = util.PBOTTOMRIGHT aDir = util.PTOPLEFT bStart = util.PBOTTOM bDir = util.PTOP nc = m(A) Aref = &ATL } util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, 0, 0, aStart) util.Partition2x1( &BT, &BB, B, 0, bStart) partitionPivot2x1( &pT, &pB, p, 0, bStart) // phase 1: // - solve U*D*X = B, overwriting B with X // - looping from BOTTOM to TOP // phase 1: // - solve U*X = B, overwriting B with X // - looping from TOP to BOTTOM for n(Aref) > 0 { // see if next diagonal block is 1x1 or 2x2 np = 1 if p[nc-1] < 0 { np = 2 } // repartition according the pivot size util.Repartition2x2to3x3(&ATL, &A00, &a01, &A02, nil, &a11, &a12t, nil, nil, &A22 /**/, A, np, aDir) util.Repartition2x1to3x1(&BT, &B0, &b1, &B2 /**/, B, np, bDir) repartPivot2x1to3x1(&pT, &p0, &p1, &p2 /**/, p, np, bDir) // ------------------------------------------------------------ switch phase { case 1: // computes D.-1*(U.-1*B); // b1 is current row, last row of BT if np == 1 { if p1[0] != nc { // swap rows on top part of B swapRows(&BT, m(&BT)-1, p1[0]-1) } // B0 = B0 - a01*b1 blasd.MVUpdate(&B0, &a01, &b1, -1.0) // b1 = b1/d1 blasd.InvScale(&b1, a11.Get(0, 0)) nc -= 1 } else if np == 2 { if p1[0] != -nc { // swap rows on top part of B swapRows(&BT, m(&BT)-2, -p1[0]-1) } b := a11.Get(0, 1) apb := a11.Get(0, 0) / b dpb := a11.Get(1, 1) / b // (a/b)*(d/b)-1.0 == (a*d - b^2)/b^2 scale := apb*dpb - 1.0 scale *= b // B0 = B0 - a01*b1 blasd.Mult(&B0, &a01, &b1, -1.0, 1.0, gomas.NONE, conf) // b1 = a11.-1*b1.T //(2x2 block, no subroutine for doing this in-place) for k := 0; k < n(&b1); k++ { s0 := b1.Get(0, k) s1 := b1.Get(1, k) b1.Set(0, k, (dpb*s0-s1)/scale) b1.Set(1, k, (apb*s1-s0)/scale) } nc -= 2 } case 2: // compute X = U.-T*B if np == 1 { blasd.MVMult(&b1, &B0, &a01, -1.0, 1.0, gomas.TRANS) if p1[0] != nc { // swap rows on bottom part of B util.Merge2x1(&Bx, &B0, &b1) swapRows(&Bx, m(&Bx)-1, p1[0]-1) } nc += 1 } else if np == 2 { blasd.Mult(&b1, &a01, &B0, -1.0, 1.0, gomas.TRANSA, conf) if p1[0] != -nc { // swap rows on bottom part of B util.Merge2x1(&Bx, &B0, &b1) swapRows(&Bx, m(&Bx)-2, -p1[0]-1) } nc += 2 } } // ------------------------------------------------------------ util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &a11, &A22, A, aDir) util.Continue3x1to2x1( &BT, &BB, &B0, &b1, B, bDir) contPivot3x1to2x1( &pT, &pB, p0, p1, p, bDir) } return err }
/* * Computes upper Hessenberg reduction of N-by-N matrix A using unblocked * algorithm as described in (1). * * Hessengerg reduction: A = Q.T*B*Q, Q unitary, B upper Hessenberg * Q = H(0)*H(1)*...*H(k) where H(k) is k'th Householder reflector. * * Compatible with lapack.DGEHD2. */ func unblkHessGQvdG(A, Tvec, W *cmat.FloatMatrix, row int) { var ATL, ATR, ABL, ABR cmat.FloatMatrix var A00, a11, a21, A22 cmat.FloatMatrix var AL, AR, A0, a1, A2 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2, w12, v1 cmat.FloatMatrix util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, row, 0, util.PTOPLEFT) util.Partition1x2( &AL, &AR, A, 0, util.PLEFT) util.Partition2x1( &tT, &tB, Tvec, 0, util.PTOP) v1.SubMatrix(W, 0, 0, m(A), 1) for m(&ABR) > 1 && n(&ABR) > 0 { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, nil, &a11, nil, nil, &a21, &A22, A, 1, util.PBOTTOMRIGHT) util.Repartition1x2to1x3(&AL, &A0, &a1, &A2, A, 1, util.PRIGHT) util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2, Tvec, 1, util.PBOTTOM) // ------------------------------------------------------ // a21 = [beta; H(k)].T computeHouseholderVec(&a21, &tau1) tauval := tau1.Get(0, 0) beta := a21.Get(0, 0) a21.Set(0, 0, 1.0) // v1 := A2*a21 blasd.MVMult(&v1, &A2, &a21, 1.0, 0.0, gomas.NONE) // A2 := A2 - tau*v1*a21 (A2 := A2*H(k)) blasd.MVUpdate(&A2, &v1, &a21, -tauval) w12.SubMatrix(W, 0, 0, n(&A22), 1) // w12 := a21.T*A22 = A22.T*a21 blasd.MVMult(&w12, &A22, &a21, 1.0, 0.0, gomas.TRANS) // A22 := A22 - tau*a21*w12 (A22 := H(k)*A22) blasd.MVUpdate(&A22, &a21, &w12, -tauval) a21.Set(0, 0, beta) // ------------------------------------------------------ util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &a11, &A22, A, util.PBOTTOMRIGHT) util.Continue1x3to1x2( &AL, &AR, &A0, &a1, A, util.PRIGHT) util.Continue3x1to2x1( &tT, &tB, &t0, &tau1, Tvec, util.PBOTTOM) } }
func blkMultLeftQL(C, A, tau, W *cmat.FloatMatrix, flags, lb int, conf *gomas.Config) { var ATL /*ATR, ABL,*/, ABR, AL cmat.FloatMatrix var A00, A01, A11, A22 cmat.FloatMatrix var CT, CB, C0, C1, C2 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2 cmat.FloatMatrix var T0, T, W0, Wrk cmat.FloatMatrix var Aref *cmat.FloatMatrix var pAdir, pAstart, pDir, pStart util.Direction var mb, tb, nb int // partitioning start and direction if flags&gomas.TRANS != 0 { // A from bottom-right to top-left to produce transposed sequence (Q.T*C) pAstart = util.PBOTTOMRIGHT pAdir = util.PTOPLEFT pStart = util.PBOTTOM pDir = util.PTOP mb = 0 tb = 0 nb = 0 Aref = &ATL } else { // from top-left to bottom-right to produce normal sequence (Q*C) pAstart = util.PTOPLEFT pAdir = util.PBOTTOMRIGHT pStart = util.PTOP pDir = util.PBOTTOM mb = imax(0, m(A)-n(A)) nb = imax(0, n(A)-m(A)) tb = imax(0, tau.Len()-n(A)) Aref = &ABR } util.Partition2x2( &ATL, nil, nil, &ABR, A, mb, nb, pAstart) util.Partition2x1( &CT, &CB, C, mb, pStart) util.Partition2x1( &tT, &tB, tau, tb, pStart) transpose := flags&gomas.TRANS != 0 // divide workspace for block reflector and temporart space T0.SetBuf(lb, lb, lb, W.Data()) W0.SetBuf(n(C), lb, n(C), W.Data()[T0.Len():]) for n(Aref) > 0 { util.Repartition2x2to3x3(&ATL, &A00, &A01, nil, nil, &A11, nil, nil, nil, &A22, A, lb, pAdir) util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2, tau, lb, pDir) bsz := n(&A11) util.Repartition2x1to3x1(&CT, &C0, &C1, &C2, C, bsz, pDir) // -------------------------------------------------------- // build block reflector for current block util.Merge2x1(&AL, &A01, &A11) T.SubMatrix(&T0, 0, 0, bsz, bsz) blasd.Scale(&T, 0.0) unblkQLBlockReflector(&T, &AL, &tau1) // update with (I - Y*T*Y.T) or (I - Y*T*Y.T).T Wrk.SubMatrix(&W0, 0, 0, n(&C1), bsz) updateQLLeft(&C1, &C0, &A11, &A01, &T, &Wrk, transpose, conf) // -------------------------------------------------------- util.Continue3x3to2x2( &ATL, nil, nil, &ABR, &A00, &A11, &A22, A, pAdir) util.Continue3x1to2x1( &CT, &CB, &C0, &C1, C, pDir) util.Continue3x1to2x1( &tT, &tB, &t0, &tau1, tau, pDir) } }
/* * Blocked version for computing C = Q*C and C = Q.T*C from elementary reflectors * and scalar coefficients. * * Elementary reflectors and scalar coefficients are used to build block reflector T. * Matrix C is updated by applying block reflector T using compact WY algorithm. */ func blockedMultQLeft(C, A, tau, W *cmat.FloatMatrix, flags, nb int, conf *gomas.Config) { var ATL, ATR, ABL, ABR, AL cmat.FloatMatrix var A00, A10, A11, A20, A21, A22 cmat.FloatMatrix var CT, CB, C0, C1, C2 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2 cmat.FloatMatrix var Wrk, W0, Tw, Twork cmat.FloatMatrix var Aref *cmat.FloatMatrix var pAdir, pAstart, pDir, pStart util.Direction var bsz, mb int // partitioning start and direction if flags&gomas.TRANS != 0 || nb == n(A) { // from top-left to bottom-right to produce transposed sequence (Q.T*C) pAstart = util.PTOPLEFT pAdir = util.PBOTTOMRIGHT pStart = util.PTOP pDir = util.PBOTTOM mb = 0 Aref = &ABR } else { // from bottom-right to top-left to produce normal sequence (Q*C) pAstart = util.PBOTTOMRIGHT pAdir = util.PTOPLEFT pStart = util.PBOTTOM pDir = util.PTOP mb = imax(0, m(A)-n(A)) Aref = &ATL } util.Partition2x2( &ATL, &ATR, &ABL, &ABR, A, mb, 0, pAstart) util.Partition2x1( &CT, &CB, C, mb, pStart) util.Partition2x1( &tT, &tB, tau, 0, pStart) transpose := flags&gomas.TRANS != 0 // intermediate reflector at start of workspace Twork.SetBuf(nb, nb, nb, W.Data()) W0.SetBuf(n(C), nb, n(C), W.Data()[Twork.Len():]) for m(Aref) > 0 && n(Aref) > 0 { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, &A10, &A11, nil, &A20, &A21, &A22, A, nb, pAdir) util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2, tau, nb, pDir) bsz = n(&A11) util.Repartition2x1to3x1(&CT, &C0, &C1, &C2, C, bsz, pDir) // -------------------------------------------------------- // clear & build block reflector from current block util.Merge2x1(&AL, &A11, &A21) Tw.SubMatrix(&Twork, 0, 0, bsz, bsz) blasd.Scale(&Tw, 0.0) unblkQRBlockReflector(&Tw, &AL, &tau1) // compute: Q*T.C == C - Y*(C.T*Y*T).T transpose == true // Q*C == C - C*Y*T*Y.T transpose == false Wrk.SubMatrix(&W0, 0, 0, n(&C1), bsz) updateWithQTLeft(&C1, &C2, &A11, &A21, &Tw, &Wrk, transpose, conf) // -------------------------------------------------------- util.Continue3x3to2x2( &ATL, &ATR, &ABL, &ABR, &A00, &A11, &A22, A, pAdir) util.Continue3x1to2x1( &CT, &CB, &C0, &C1, C, pDir) util.Continue3x1to2x1( &tT, &tB, &t0, &tau1, tau, pDir) } }
/* * This is adaptation of TRIRED_LAZY_UNB algorithm from (1). */ func unblkBuildTridiagUpper(A, tauq, Y, W *cmat.FloatMatrix) { var ATL, ABR cmat.FloatMatrix var A00, a01, A02, a11, a12, A22 cmat.FloatMatrix var YTL, YBR cmat.FloatMatrix var Y00, y01, Y02, y11, y12, Y22 cmat.FloatMatrix var tqT, tqB, tq0, tauq1, tq2 cmat.FloatMatrix var w12 cmat.FloatMatrix var v0 float64 util.Partition2x2( &ATL, nil, nil, &ABR, A, 0, 0, util.PBOTTOMRIGHT) util.Partition2x2( &YTL, nil, nil, &YBR, Y, 0, 0, util.PBOTTOMRIGHT) util.Partition2x1( &tqT, &tqB, tauq, 0, util.PBOTTOM) k := 0 for k < n(Y) { util.Repartition2x2to3x3(&ATL, &A00, &a01, &A02, nil, &a11, &a12, nil, nil, &A22, A, 1, util.PTOPLEFT) util.Repartition2x2to3x3(&YTL, &Y00, &y01, &Y02, nil, &y11, &y12, nil, nil, &Y22, Y, 1, util.PTOPLEFT) util.Repartition2x1to3x1(&tqT, &tq0, &tauq1, &tq2, tauq, 1, util.PTOP) // set temp vectors for this round w12.SubMatrix(Y, -1, 0, 1, n(&Y02)) // ------------------------------------------------------ if n(&Y02) > 0 { aa := blasd.Dot(&a12, &y12) aa += blasd.Dot(&y12, &a12) a11.Set(0, 0, a11.Get(0, 0)-aa) // a01 := a01 - A02*y12 blasd.MVMult(&a01, &A02, &y12, -1.0, 1.0, gomas.NONE) // a01 := a01 - Y02*a12 blasd.MVMult(&a01, &Y02, &a12, -1.0, 1.0, gomas.NONE) // restore superdiagonal value a12.Set(0, 0, v0) } // Compute householder to zero subdiagonal entries computeHouseholderRev(&a01, &tauq1) tauqv := tauq1.Get(0, 0) // set sub&iagonal to unit v0 = a01.Get(-1, 0) a01.Set(-1, 0, 1.0) // y01 := tauq*A00*a01 blasd.MVMultSym(&y01, &A00, &a01, tauqv, 0.0, gomas.UPPER) // w12 := A02.T*a01 blasd.MVMult(&w12, &A02, &a01, 1.0, 0.0, gomas.TRANS) // y01 := y01 - Y02*(A02.T*a01) blasd.MVMult(&y01, &Y02, &w12, -tauqv, 1.0, gomas.NONE) // w12 := Y02.T*a01 blasd.MVMult(&w12, &Y02, &a01, 1.0, 0.0, gomas.TRANS) // y01 := y01 - A02*(Y02.T*a01) blasd.MVMult(&y01, &A02, &w12, -tauqv, 1.0, gomas.NONE) // beta := tauq*a01.T*y01 beta := tauqv * blasd.Dot(&a01, &y01) // y01 := y01 - 0.5*beta*a01 blasd.Axpy(&y01, &a01, -0.5*beta) // ------------------------------------------------------ k += 1 util.Continue3x3to2x2( &ATL, nil, nil, &ABR, &A00, &a11, &A22, A, util.PTOPLEFT) util.Continue3x3to2x2( &YTL, nil, nil, &YBR, &Y00, &y11, &Y22, A, util.PTOPLEFT) util.Continue3x1to2x1( &tqT, &tqB, &tq0, &tauq1, tauq, util.PTOP) } // restore superdiagonal value A.Set(m(&ATL)-1, n(&ATL), v0) }
/* * Blocked version for computing C = C*Q and C = C*Q.T from elementary * reflectors and scalar coefficients. * * Elementary reflectors and scalar coefficients are used to build block * reflector T. Matrix C is updated by applying block reflector T using * compact WY algorithm. */ func blockedMultRQRight(C, A, tau, W *cmat.FloatMatrix, flags, lb int, conf *gomas.Config) { var ATL, ABR, AL cmat.FloatMatrix var A00, A10, A11, A22 cmat.FloatMatrix var CL, CR, C0, C1, C2 cmat.FloatMatrix var tT, tB cmat.FloatMatrix var t0, tau1, t2 cmat.FloatMatrix var W0, Wrk, Tw, Twork cmat.FloatMatrix var Aref *cmat.FloatMatrix var pAdir, pAstart, pDir, pStart, pCstart, pCdir util.Direction var bsz, cb, mb, nb, tb int var transpose bool // partitioning start and direction if flags&gomas.TRANS != 0 { // from bottom-right to top-left to produce transpose sequence (C*Q.T) pAstart = util.PBOTTOMRIGHT pAdir = util.PTOPLEFT pStart = util.PBOTTOM pDir = util.PTOP pCstart = util.PRIGHT pCdir = util.PLEFT mb = 0 nb = 0 cb = 0 tb = 0 Aref = &ATL transpose = false } else { // from top-left to bottom-right to produce normal sequence (C*Q) pAstart = util.PTOPLEFT pAdir = util.PBOTTOMRIGHT pStart = util.PTOP pDir = util.PBOTTOM pCstart = util.PLEFT pCdir = util.PRIGHT mb = imax(0, m(A)-n(A)) nb = imax(0, n(A)-m(A)) cb = imax(0, n(C)-m(A)) tb = imax(0, tau.Len()-m(A)) Aref = &ABR transpose = true } // intermediate reflector at start of workspace Twork.SetBuf(lb, lb, lb, W.Data()) W0.SetBuf(m(C), lb, m(C), W.Data()[Twork.Len():]) util.Partition2x2( &ATL, nil, nil, &ABR /**/, A, mb, nb, pAstart) util.Partition1x2( &CL, &CR /**/, C, cb, pCstart) util.Partition2x1( &tT, &tB /**/, tau, tb, pStart) for m(Aref) > 0 && n(Aref) > 0 { util.Repartition2x2to3x3(&ATL, &A00, nil, nil, &A10, &A11, nil, nil, nil, &A22 /**/, A, lb, pAdir) bsz = m(&A11) // C1 block size must match A11 util.Repartition2x1to3x1(&tT, &t0, &tau1, &t2 /**/, tau, bsz, pDir) util.Repartition1x2to1x3(&CL, &C0, &C1, &C2 /**/, C, bsz, pCdir) // -------------------------------------------------------- // clear & build block reflector from current block util.Merge1x2(&AL, &A10, &A11) Tw.SubMatrix(&Twork, 0, 0, bsz, bsz) blasd.Scale(&Tw, 0.0) unblkBlockReflectorRQ(&Tw, &AL, &tau1) Wrk.SubMatrix(&W0, 0, 0, m(&C1), bsz) updateRightRQ(&C1, &C0, &A11, &A10, &Tw, &Wrk, transpose, conf) // -------------------------------------------------------- util.Continue3x3to2x2( &ATL, nil, nil, &ABR /**/, &A00, &A11, &A22, A, pAdir) util.Continue1x3to1x2( &CL, &CR /**/, &C0, &C1, C, pCdir) util.Continue3x1to2x1( &tT, &tB /**/, &t0, &tau1, tau, pDir) } }