本文整理汇总了C++中A11函数的典型用法代码示例。如果您正苦于以下问题：C++ A11函数的具体用法？C++ A11怎么用？C++ A11使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了A11函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: MakeExplicitlyHermitian
void MakeExplicitlyHermitian( UpperOrLower uplo, DistMatrix<F,MC,MR>& A )
{
const Grid& g = A.Grid();
DistMatrix<F,MC,MR> ATL(g), ATR(g), A00(g), A01(g), A02(g),
ABL(g), ABR(g), A10(g), A11(g), A12(g),
A20(g), A21(g), A22(g);
DistMatrix<F,MC,MR> A11Adj(g);
DistMatrix<F,MR,MC> A11_MR_MC(g);
DistMatrix<F,MR,MC> A21_MR_MC(g);
DistMatrix<F,MR,MC> A12_MR_MC(g);
PartitionDownDiagonal
( A, ATL, ATR,
ABL, ABR, 0 );
while( ATL.Height() < A.Height() )
{
RepartitionDownDiagonal
( ATL, /**/ ATR, A00, /**/ A01, A02,
/*************/ /******************/
/**/ A10, /**/ A11, A12,
ABL, /**/ ABR, A20, /**/ A21, A22 );
A11Adj.AlignWith( A11 );
A11_MR_MC.AlignWith( A11 );
A12_MR_MC.AlignWith( A21 );
A21_MR_MC.AlignWith( A12 );
//--------------------------------------------------------------------//
A11_MR_MC = A11;
A11Adj.ResizeTo( A11.Height(), A11.Width() );
Adjoint( A11_MR_MC.LocalMatrix(), A11Adj.LocalMatrix() );
if( uplo == LOWER )
{
MakeTrapezoidal( LEFT, UPPER, 1, A11Adj );
Axpy( (F)1, A11Adj, A11 );
A21_MR_MC = A21;
Adjoint( A21_MR_MC.LocalMatrix(), A12.LocalMatrix() );
}
else
{
MakeTrapezoidal( LEFT, LOWER, -1, A11Adj );
Axpy( (F)1, A11Adj, A11 );
A12_MR_MC = A12;
Adjoint( A12_MR_MC.LocalMatrix(), A21.LocalMatrix() );
}
//--------------------------------------------------------------------//
A21_MR_MC.FreeAlignments();
A12_MR_MC.FreeAlignments();
A11_MR_MC.FreeAlignments();
A11Adj.FreeAlignments();
SlidePartitionDownDiagonal
( ATL, /**/ ATR, A00, A01, /**/ A02,
/**/ A10, A11, /**/ A12,
/*************/ /******************/
ABL, /**/ ABR, A20, A21, /**/ A22 );
}
}示例2: main
int main()
{
DoubleMatrix A(3,3);
DoubleInterval A00(2,3);
DoubleInterval A10(5,9);
DoubleInterval A11(3,4);
DoubleInterval A20(-2,5);
DoubleInterval A21(3,8);
A(0,0) = A00;
A(0,1) = 0;
A(0,2) = 0;
A(1,0) = A10;
A(1,1) = A11;
A(1,2) = 0;
A(2,0) = A20;
A(2,1) = A21;
A(2,2) = 5;
DoubleInterval X(0,0);
mtl::dense_vector<DoubleInterval> b(3,X);
b[0] = 5;
b[1] = 3;
b[2] = -6;
mtl::dense_vector<DoubleInterval> x(3,X);
x = mtl::mat::upper_trisolve(A,b);
std::cout << x << std::endl;
return 0;
}示例3: makeFormattedString
std::string makeFormattedString(
const char* aFormat,
const A1& a1 = A1(),
const A2& a2 = A2(),
const A3& a3 = A3(),
const A4& a4 = A4(),
const A5& a5 = A5(),
const A6& a6 = A6(),
const A7& a7 = A7(),
const A8& a8 = A8(),
const A9& a9 = A9(),
const A10& a10 = A10(),
const A11& a11 = A11(),
const A12& a12 = A12(),
const A13& a13 = A13(),
const A14& a14 = A14(),
const A15& a15 = A15(),
const A16& a16 = A16(),
const A17& a17 = A17(),
const A18& a18 = A18(),
const A19& a19 = A19(),
const A20& a20 = A20()
)
{
return makeStringByPrintf(aFormat,
a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
a11, a12, a13, a14, a15, a16, a17, a18, a19, a20
);
}示例4: A
void graphics::NgoiLang(QPainter& painter,int x,int y,int c,int r)
{
QPoint A(x-r/2,y+c);
QPoint B(x+r/2,y+c);
QPoint C(x+r/2,y+c/3);
QPoint D(x,y);
QPoint E(x-r/2,y+c/3);
QPolygon poly1;
poly1 << D << E << A << B << C;
painter.drawPolygon(poly1);
// ve cai cua
QPoint A1(x,y+c);
QPoint B1(x,y+2*c/3);
QPoint C1(x-r/4,y+2*c/3);
QPoint D1(x-r/4,y+c);
QPolygon poly2;
poly2 << A1 << B1 << C1 << D1;
painter.drawPolyline(poly2);
// ve cua so
QPoint A11(x-r/4,y+c/6);
QPoint B11(x-r/4,y);
QPoint C11(x-r/8,y);
QPoint D11(x-r/8,y+c/12);
QPolygon poly21;
poly21 << A11 << B11 << C11 << D11;
painter.drawPolygon(poly21);
painter.drawRect(x+r/4,y+c/2.5,c/10,r/10);
}示例5: main
int main()
{
Rat a1(-1,2);
Rat a2(2,9);
Rat b2(3,2);
Rat c1(-1,9);
DoubleInterval A11(a2,b2);
DoubleInterval A12(a1,0);
DoubleInterval A21(-1,c1);
DoubleInterval A22(a2,b2);
DoubleMatrix A(2,2);
A(0,0) = A11;
A(0,1) = A12;
A(1,0) = A21;
A(1,1) = A22;
DoubleInterval B1(1,3);
DoubleInterval B2(3,4);
DoubleVector b(2, (DoubleInterval)0);
b[0] = B1;
b[1] = B2;
std::cout << A << std::endl;
std::cout << b << std::endl;
DoubleVector x(2, (DoubleInterval)0);
x = A * b;
std::cout << x << std::endl;
//Need to sort this out
DoubleInterval test(-1,2);
DoubleInterval testb(5,100);
DoubleInterval ans;
ans = testb/test;
std::cout << ans << std::endl;
DoubleInterval k00(0,2);
DoubleInterval k01(1,3);
DoubleInterval k10(3,5);
DoubleInterval k11(5,7);
std::cout << "INVERSE IS " << std::endl;
std::cout << boost::numeric::Doubleinterval_lib::multiplicative_inverse(k11) << std::endl;
std::cout << boost::numeric::norm(k11) << std::endl;
std::cout << k00 * k11 << std::endl;
std::cout << k01 * k10 << std::endl;
std::cout << (k00 * k11) - (k01 * k10) << std::endl;
return 0;
}示例6: main
int main()
{
const int sz=7;
CArray A(sz);
A(0) = complex<float>(1,2);
A(1) = complex<float>(3,4);
Array<float,1> Ar = real(A);
BZTEST(int(Ar(0)) == 1 && int(Ar(1)) == 3);
Array<float,1> Ai = imag(A);
BZTEST(int(Ai(0)) == 2 && int(Ai(1)) == 4);
CArray Ac(sz);
Ac = conj(A);
BZTEST(Ac(0) == complex<float>(1,-2));
BZTEST(Ac(1) == complex<float>(3,-4));
Array<float,1> Ab(sz);
Ab = abs(A);
BZTEST(fabs(Ab(0) - 2.236068) < eps);
BZTEST(fabs(Ab(1) - 5.0) < eps);
Ab = arg(A);
BZTEST(fabs(Ab(0) - atan(2.0)) < eps);
BZTEST(fabs(Ab(1) - atan(4.0/3.0)) < eps);
Array<float,1> r(sz), theta(sz);
r(0) = 4.0f;
r(1) = 15.0f;
theta(0) = float(3.141592/3.0);
theta(1) = float(3.0*3.141592/2.0);
Ac = blitz::polar(r,theta);
BZTEST(fabs(real(Ac(0)) - 2) < eps);
BZTEST(fabs(imag(Ac(0)) - 3.4641012) < eps);
BZTEST(fabs(real(Ac(1)) - 0.0) < eps);
BZTEST(fabs(imag(Ac(1)) + 15.0) < eps);
Array<complex<long double>,1> A11(5),B11(5),C11(5);
A11=1,2,3,4,5;
B11=1,2,3,4,5;
C11=A11+B11;
BZTEST(fabs(real(C11(0)) - 2.) < eps);
C11=A11/B11;
BZTEST(fabs(real(C11(1)) - 1.) < eps);
C11=1.0l/A11;
BZTEST(fabs(real(C11(2)) - 1/3.) < eps);
C11=A11/1.0l;
BZTEST(fabs(real(C11(3)) - 4.) < eps);
C11=complex<long double>(0,1)/A11;
BZTEST(fabs(imag(C11(4)) - 1/5.) < eps);
C11=A11/complex<long double>(0,1);
BZTEST(fabs(imag(C11(0)) - -1.) < eps);
return 0;
}示例7: LQ
inline void
LQ( DistMatrix<R,MC,MR>& A )
{
#ifndef RELEASE
PushCallStack("LQ");
#endif
if( IsComplex<R>::val )
throw std::logic_error("Called real routine with complex datatype");
const Grid& g = A.Grid();
// Matrix views
DistMatrix<R,MC,MR>
ATL(g), ATR(g), A00(g), A01(g), A02(g), ATopPan(g), ABottomPan(g),
ABL(g), ABR(g), A10(g), A11(g), A12(g),
A20(g), A21(g), A22(g);
PartitionDownLeftDiagonal
( A, ATL, ATR,
ABL, ABR, 0 );
while( ATL.Height() < A.Height() && ATL.Width() < A.Width() )
{
RepartitionDownDiagonal
( ATL, /**/ ATR, A00, /**/ A01, A02,
/*************/ /******************/
/**/ A10, /**/ A11, A12,
ABL, /**/ ABR, A20, /**/ A21, A22 );
ATopPan.View1x2( A11, A12 );
ABottomPan.View1x2( A21, A22 );
//--------------------------------------------------------------------//
internal::PanelLQ( ATopPan );
ApplyPackedReflectors
( RIGHT, UPPER, HORIZONTAL, FORWARD, 0, ATopPan, ABottomPan );
//--------------------------------------------------------------------//
SlidePartitionDownDiagonal
( ATL, /**/ ATR, A00, A01, /**/ A02,
/**/ A10, A11, /**/ A12,
/*************/ /******************/
ABL, /**/ ABR, A20, A21, /**/ A22 );
}
#ifndef RELEASE
PopCallStack();
#endif
}示例8: PushCallStack
inline void
SymmLLC
( T alpha, const DistMatrix<T>& A, const DistMatrix<T>& B,
T beta, DistMatrix<T>& C )
{
#ifndef RELEASE
PushCallStack("internal::SymmLLC");
if( A.Grid() != B.Grid() || B.Grid() != C.Grid() )
throw std::logic_error
("{A,B,C} must be distributed over the same grid");
#endif
const Grid& g = A.Grid();
// Matrix views
DistMatrix<T>
ATL(g), ATR(g), A00(g), A01(g), A02(g), AColPan(g),
ABL(g), ABR(g), A10(g), A11(g), A12(g), ARowPan(g),
A20(g), A21(g), A22(g);
DistMatrix<T>
BT(g), B0(g),
BB(g), B1(g),
B2(g);
DistMatrix<T>
CT(g), C0(g), CAbove(g),
CB(g), C1(g), CBelow(g),
C2(g);
// Temporary distributions
DistMatrix<T,MC, STAR> AColPan_MC_STAR(g);
DistMatrix<T,STAR,MC > ARowPan_STAR_MC(g);
DistMatrix<T,MR, STAR> B1Trans_MR_STAR(g);
B1Trans_MR_STAR.AlignWith( C );
// Start the algorithm
Scale( beta, C );
LockedPartitionDownDiagonal
( A, ATL, ATR,
ABL, ABR, 0 );
LockedPartitionDown
( B, BT,
BB, 0 );
PartitionDown
( C, CT,
CB, 0 );
while( CB.Height() > 0 )
{
LockedRepartitionDownDiagonal
( ATL, /**/ ATR, A00, /**/ A01, A02,
/*************/ /******************/
/**/ A10, /**/ A11, A12,
ABL, /**/ ABR, A20, /**/ A21, A22 );
LockedRepartitionDown
( BT, B0,
/**/ /**/
B1,
BB, B2 );
RepartitionDown
( CT, C0,
/**/ /**/
C1,
CB, C2 );
LockedView1x2( ARowPan, A10, A11 );
LockedView2x1
( AColPan, A11,
A21 );
View2x1
( CAbove, C0,
C1 );
View2x1
( CBelow, C1,
C2 );
AColPan_MC_STAR.AlignWith( CBelow );
ARowPan_STAR_MC.AlignWith( CAbove );
//--------------------------------------------------------------------//
AColPan_MC_STAR = AColPan;
ARowPan_STAR_MC = ARowPan;
MakeTrapezoidal( LEFT, LOWER, 0, AColPan_MC_STAR );
MakeTrapezoidal( RIGHT, LOWER, -1, ARowPan_STAR_MC );
B1Trans_MR_STAR.TransposeFrom( B1 );
LocalGemm
( NORMAL, TRANSPOSE,
alpha, AColPan_MC_STAR, B1Trans_MR_STAR, T(1), CBelow );
LocalGemm
( TRANSPOSE, TRANSPOSE,
alpha, ARowPan_STAR_MC, B1Trans_MR_STAR, T(1), CAbove );
//--------------------------------------------------------------------//
AColPan_MC_STAR.FreeAlignments();
ARowPan_STAR_MC.FreeAlignments();
SlideLockedPartitionDownDiagonal
( ATL, /**/ ATR, A00, A01, /**/ A02,
//.........这里部分代码省略.........
示例9: entry
inline void
TwoSidedTrsmUVar1
( UnitOrNonUnit diag, DistMatrix<F>& A, const DistMatrix<F>& U )
{
#ifndef RELEASE
CallStackEntry entry("internal::TwoSidedTrsmUVar1");
if( A.Height() != A.Width() )
LogicError("A must be square");
if( U.Height() != U.Width() )
LogicError("Triangular matrices must be square");
if( A.Height() != U.Height() )
LogicError("A and U must be the same size");
#endif
const Grid& g = A.Grid();
// Matrix views
DistMatrix<F>
ATL(g), ATR(g), A00(g), A01(g), A02(g),
ABL(g), ABR(g), A10(g), A11(g), A12(g),
A20(g), A21(g), A22(g);
DistMatrix<F>
UTL(g), UTR(g), U00(g), U01(g), U02(g),
UBL(g), UBR(g), U10(g), U11(g), U12(g),
U20(g), U21(g), U22(g);
// Temporary distributions
DistMatrix<F,STAR,STAR> A11_STAR_STAR(g);
DistMatrix<F,VC, STAR> A01_VC_STAR(g);
DistMatrix<F,STAR,STAR> U11_STAR_STAR(g);
DistMatrix<F,MC, STAR> U01_MC_STAR(g);
DistMatrix<F,VC, STAR> U01_VC_STAR(g);
DistMatrix<F,VR, STAR> U01_VR_STAR(g);
DistMatrix<F,STAR,MR > U01Adj_STAR_MR(g);
DistMatrix<F,STAR,STAR> X11_STAR_STAR(g);
DistMatrix<F,MR, MC > Z01_MR_MC(g);
DistMatrix<F,MC, STAR> Z01_MC_STAR(g);
DistMatrix<F,MR, STAR> Z01_MR_STAR(g);
DistMatrix<F> Y01(g);
PartitionDownDiagonal
( A, ATL, ATR,
ABL, ABR, 0 );
LockedPartitionDownDiagonal
( U, UTL, UTR,
UBL, UBR, 0 );
while( ATL.Height() < A.Height() )
{
RepartitionDownDiagonal
( ATL, /**/ ATR, A00, /**/ A01, A02,
/*************/ /******************/
/**/ A10, /**/ A11, A12,
ABL, /**/ ABR, A20, /**/ A21, A22 );
LockedRepartitionDownDiagonal
( UTL, /**/ UTR, U00, /**/ U01, U02,
/*************/ /******************/
/**/ U10, /**/ U11, U12,
UBL, /**/ UBR, U20, /**/ U21, U22 );
A01_VC_STAR.AlignWith( A01 );
U01_MC_STAR.AlignWith( A00 );
U01_VR_STAR.AlignWith( A00 );
U01_VC_STAR.AlignWith( A00 );
U01Adj_STAR_MR.AlignWith( A00 );
Y01.AlignWith( A01 );
Z01_MR_MC.AlignWith( A01 );
Z01_MC_STAR.AlignWith( A00 );
Z01_MR_STAR.AlignWith( A00 );
//--------------------------------------------------------------------//
// Y01 := A00 U01
U01_MC_STAR = U01;
U01_VR_STAR = U01_MC_STAR;
U01Adj_STAR_MR.AdjointFrom( U01_VR_STAR );
Zeros( Z01_MC_STAR, A01.Height(), A01.Width() );
Zeros( Z01_MR_STAR, A01.Height(), A01.Width() );
LocalSymmetricAccumulateLU
( ADJOINT,
F(1), A00, U01_MC_STAR, U01Adj_STAR_MR, Z01_MC_STAR, Z01_MR_STAR );
Z01_MR_MC.SumScatterFrom( Z01_MR_STAR );
Y01 = Z01_MR_MC;
Y01.SumScatterUpdate( F(1), Z01_MC_STAR );
// A01 := inv(U00)' A01
//
// This is the bottleneck because A01 only has blocksize columns
Trsm( LEFT, UPPER, ADJOINT, diag, F(1), U00, A01 );
// A01 := A01 - 1/2 Y01
Axpy( F(-1)/F(2), Y01, A01 );
// A11 := A11 - (U01' A01 + A01' U01)
A01_VC_STAR = A01;
U01_VC_STAR = U01_MC_STAR;
Zeros( X11_STAR_STAR, A11.Height(), A11.Width() );
Her2k
( UPPER, ADJOINT,
F(-1), A01_VC_STAR.Matrix(), U01_VC_STAR.Matrix(),
F(0), X11_STAR_STAR.Matrix() );
A11.SumScatterUpdate( F(1), X11_STAR_STAR );
//.........这里部分代码省略.........
示例10: Householder
inline void
Householder( DistMatrix<F>& A, DistMatrix<F,MD,STAR>& t )
{
#ifndef RELEASE
CallStackEntry entry("qr::Householder");
if( A.Grid() != t.Grid() )
LogicError("{A,s} must be distributed over the same grid");
#endif
const Grid& g = A.Grid();
if( t.Viewing() )
{
if( !t.AlignedWithDiagonal( A ) )
LogicError("t was not aligned with A");
}
else
{
t.AlignWithDiagonal( A );
}
t.ResizeTo( Min(A.Height(),A.Width()), 1 );
// Matrix views
DistMatrix<F>
ATL(g), ATR(g), A00(g), A01(g), A02(g), ALeftPan(g), ARightPan(g),
ABL(g), ABR(g), A10(g), A11(g), A12(g),
A20(g), A21(g), A22(g);
DistMatrix<F,MD,STAR>
tT(g), t0(g),
tB(g), t1(g),
t2(g);
PartitionDownDiagonal
( A, ATL, ATR,
ABL, ABR, 0 );
PartitionDown
( t, tT,
tB, 0 );
while( ATL.Height() < A.Height() && ATL.Width() < A.Width() )
{
RepartitionDownDiagonal
( ATL, /**/ ATR, A00, /**/ A01, A02,
/*************/ /******************/
/**/ A10, /**/ A11, A12,
ABL, /**/ ABR, A20, /**/ A21, A22 );
RepartitionDown
( tT, t0,
/**/ /**/
t1,
tB, t2 );
View2x1
( ALeftPan, A11,
A21 );
View2x1
( ARightPan, A12,
A22 );
//--------------------------------------------------------------------//
PanelHouseholder( ALeftPan, t1 );
ApplyQ( LEFT, ADJOINT, ALeftPan, t1, ARightPan );
//--------------------------------------------------------------------//
SlidePartitionDown
( tT, t0,
t1,
/**/ /**/
tB, t2 );
SlidePartitionDownDiagonal
( ATL, /**/ ATR, A00, A01, /**/ A02,
/**/ A10, A11, /**/ A12,
/*************/ /******************/
ABL, /**/ ABR, A20, A21, /**/ A22 );
}
}示例11: PushCallStack
inline void
internal::HermitianTridiagU( DistMatrix<R,MC,MR>& A )
{
#ifndef RELEASE
PushCallStack("internal::HermitianTridiagU");
if( A.Height() != A.Width() )
throw std::logic_error( "A must be square." );
#endif
const Grid& g = A.Grid();
if( g.InGrid() )
{
// Matrix views
DistMatrix<R,MC,MR>
ATL(g), ATR(g), A00(g), A01(g), A02(g),
ABL(g), ABR(g), A10(g), A11(g), A12(g),
A20(g), A21(g), A22(g);
// Temporary distributions
DistMatrix<R,MC, MR > WPan(g);
DistMatrix<R,STAR,STAR> A11_STAR_STAR(g);
DistMatrix<R,MC, STAR> APan_MC_STAR(g), A01_MC_STAR(g),
A11_MC_STAR(g);
DistMatrix<R,MR, STAR> APan_MR_STAR(g), A01_MR_STAR(g),
A11_MR_STAR(g);
DistMatrix<R,MC, STAR> WPan_MC_STAR(g), W01_MC_STAR(g),
W11_MC_STAR(g);
DistMatrix<R,MR, STAR> WPan_MR_STAR(g), W01_MR_STAR(g),
W11_MR_STAR(g);
PartitionUpDiagonal
( A, ATL, ATR,
ABL, ABR, 0 );
while( ABR.Height() < A.Height() )
{
RepartitionUpDiagonal
( ATL, /**/ ATR, A00, A01, /**/ A02,
/**/ A10, A11, /**/ A12,
/*************/ /******************/
ABL, /**/ ABR, A20, A21, /**/ A22 );
if( A00.Height() > 0 )
{
WPan.AlignWith( A01 );
APan_MC_STAR.AlignWith( A00 );
WPan_MC_STAR.AlignWith( A00 );
APan_MR_STAR.AlignWith( A00 );
WPan_MR_STAR.AlignWith( A00 );
//------------------------------------------------------------//
WPan.ResizeTo( ATL.Height(), A11.Width() );
APan_MC_STAR.ResizeTo( ATL.Height(), A11.Width() );
WPan_MC_STAR.ResizeTo( ATL.Height(), A11.Width() );
APan_MR_STAR.ResizeTo( ATL.Height(), A11.Width() );
WPan_MR_STAR.ResizeTo( ATL.Height(), A11.Width() );
internal::HermitianPanelTridiagU
( ATL, WPan,
APan_MC_STAR, APan_MR_STAR, WPan_MC_STAR, WPan_MR_STAR );
PartitionUp
( APan_MC_STAR, A01_MC_STAR,
A11_MC_STAR, A11.Height() );
PartitionUp
( APan_MR_STAR, A01_MR_STAR,
A11_MR_STAR, A11.Height() );
PartitionUp
( WPan_MC_STAR, W01_MC_STAR,
W11_MC_STAR, A11.Height() );
PartitionUp
( WPan_MR_STAR, W01_MR_STAR,
W11_MR_STAR, A11.Height() );
internal::LocalTrr2k
( UPPER, TRANSPOSE, TRANSPOSE,
(R)-1, A01_MC_STAR, W01_MR_STAR,
W01_MC_STAR, A01_MR_STAR,
(R)1, A00 );
//------------------------------------------------------------//
WPan_MR_STAR.FreeAlignments();
APan_MR_STAR.FreeAlignments();
WPan_MC_STAR.FreeAlignments();
APan_MC_STAR.FreeAlignments();
WPan.FreeAlignments();
}
else
{
A11_STAR_STAR = A11;
HermitianTridiag( UPPER, A11_STAR_STAR.LocalMatrix() );
A11 = A11_STAR_STAR;
}
SlidePartitionUpDiagonal
( ATL, /**/ ATR, A00, /**/ A01, A02,
/*************/ /******************/
/**/ A10, /**/ A11, A12,
ABL, /**/ ABR, A20, /**/ A21, A22 );
}
}
#ifndef RELEASE
PopCallStack();
//.........这里部分代码省略.........
示例12: main
int main()
{
std::cout << "============== Test 1 ==============" << std::endl << std::endl;
DoubleInterval A00(2,3);
DoubleInterval A01(0,1);
DoubleInterval A10(1,2);
DoubleInterval A11(2,3);
DoubleInterval B0(0,120);
DoubleInterval B1(60,240);
DoubleMatrix *A = new DoubleMatrix(2,2);
(*A)(0,0) = A00;
(*A)(0,1) = A01;
(*A)(1,0) = A10;
(*A)(1,1) = A11;
std::cout << "A: " << std::endl;
std::cout << *A << std::endl;
DoubleVector *b = new DoubleVector(2, (DoubleInterval)0);
(*b)[0] = B0;
(*b)[1] = B1;
std::cout << "b: " << std::endl;
std::cout << *b << std::endl << std::endl;
DoubleVector *x = new DoubleVector(2, (DoubleInterval)0);
try
{
x = hansen_gaussian_elimination_v1(*A,*b);
if(x != NULL)
{
std::cout << "x = " << std::endl;
std::cout << *x << std::endl << std::endl;
}
}
catch(const std::exception& e)
{
std::cout << e.what() << std::endl << std::endl;
}
catch(std::string& error)
{
std::cout << error << std::endl << std::endl;
}
//Solution should be [[-120,90], [-60,240]]^T
delete A;
delete b;
delete x;
/*std::cout << "============== Test 2 ==============" << std::endl << std::endl;
A = new DoubleMatrix(3,3);
(*A)(0,0) = 2;
(*A)(0,1) = 1;
(*A)(0,2) = -1;
(*A)(1,0) = -3;
(*A)(1,1) = -1;
(*A)(1,2) = 2;
(*A)(2,0) = -2;
(*A)(2,1) = 1;
(*A)(2,2) = 2;
std::cout << "A = " << std::endl;
std::cout << *A << std::endl;
b = new DoubleVector(3, (DoubleInterval)0);
(*b)[0] = 8;
(*b)[1] = -11;
(*b)[2] = -3;
std::cout << "b = " << std::endl;
std::cout << *b << std::endl << std::endl;
x = new DoubleVector(3, (DoubleInterval)0);
try
{
x = hansen_gaussian_elimination_v1(*A,*b);
if(x != NULL)
{
std::cout << "x = " << std::endl;
std::cout << *x << std::endl << std::endl;
}
}
catch(const std::exception& e)
{
std::cout << e.what() << std::endl << std::endl;
}
catch(std::string& error)
{
std::cout << error << std::endl << std::endl;
}
delete A;
delete b;
delete x;
//Solution should be [2, 3, -1]^T
std::cout << "============== Test 3 ==============" << std::endl << std::endl;
//.........这里部分代码省略.........
示例13: PushCallStack
inline void
TwoSidedTrsmLVar2
( UnitOrNonUnit diag, DistMatrix<F>& A, const DistMatrix<F>& L )
{
#ifndef RELEASE
PushCallStack("internal::TwoSidedTrsmLVar2");
if( A.Height() != A.Width() )
throw std::logic_error("A must be square");
if( L.Height() != L.Width() )
throw std::logic_error("Triangular matrices must be square");
if( A.Height() != L.Height() )
throw std::logic_error("A and L must be the same size");
#endif
const Grid& g = A.Grid();
// Matrix views
DistMatrix<F>
ATL(g), ATR(g), A00(g), A01(g), A02(g),
ABL(g), ABR(g), A10(g), A11(g), A12(g),
A20(g), A21(g), A22(g);
DistMatrix<F>
LTL(g), LTR(g), L00(g), L01(g), L02(g),
LBL(g), LBR(g), L10(g), L11(g), L12(g),
L20(g), L21(g), L22(g);
// Temporary distributions
DistMatrix<F,MR, STAR> A10Adj_MR_STAR(g);
DistMatrix<F,STAR,VR > A10_STAR_VR(g);
DistMatrix<F,STAR,STAR> A11_STAR_STAR(g);
DistMatrix<F,VC, STAR> A21_VC_STAR(g);
DistMatrix<F,MR, STAR> F10Adj_MR_STAR(g);
DistMatrix<F,MR, STAR> L10Adj_MR_STAR(g);
DistMatrix<F,VC, STAR> L10Adj_VC_STAR(g);
DistMatrix<F,STAR,MC > L10_STAR_MC(g);
DistMatrix<F,STAR,STAR> L11_STAR_STAR(g);
DistMatrix<F,MC, STAR> X11_MC_STAR(g);
DistMatrix<F,MC, STAR> X21_MC_STAR(g);
DistMatrix<F,MC, STAR> Y10Adj_MC_STAR(g);
DistMatrix<F,MR, MC > Y10Adj_MR_MC(g);
DistMatrix<F> X11(g);
DistMatrix<F> Y10Adj(g);
Matrix<F> Y10Local;
PartitionDownDiagonal
( A, ATL, ATR,
ABL, ABR, 0 );
LockedPartitionDownDiagonal
( L, LTL, LTR,
LBL, LBR, 0 );
while( ATL.Height() < A.Height() )
{
RepartitionDownDiagonal
( ATL, /**/ ATR, A00, /**/ A01, A02,
/*************/ /******************/
/**/ A10, /**/ A11, A12,
ABL, /**/ ABR, A20, /**/ A21, A22 );
LockedRepartitionDownDiagonal
( LTL, /**/ LTR, L00, /**/ L01, L02,
/*************/ /******************/
/**/ L10, /**/ L11, L12,
LBL, /**/ LBR, L20, /**/ L21, L22 );
A10Adj_MR_STAR.AlignWith( L10 );
F10Adj_MR_STAR.AlignWith( A00 );
L10Adj_MR_STAR.AlignWith( A00 );
L10Adj_VC_STAR.AlignWith( A00 );
L10_STAR_MC.AlignWith( A00 );
X11.AlignWith( A11 );
X11_MC_STAR.AlignWith( L10 );
X21_MC_STAR.AlignWith( A20 );
Y10Adj_MC_STAR.AlignWith( A00 );
Y10Adj_MR_MC.AlignWith( A10 );
//--------------------------------------------------------------------//
// Y10 := L10 A00
L10Adj_MR_STAR.AdjointFrom( L10 );
L10Adj_VC_STAR = L10Adj_MR_STAR;
L10_STAR_MC.AdjointFrom( L10Adj_VC_STAR );
Y10Adj_MC_STAR.ResizeTo( A10.Width(), A10.Height() );
F10Adj_MR_STAR.ResizeTo( A10.Width(), A10.Height() );
Zero( Y10Adj_MC_STAR );
Zero( F10Adj_MR_STAR );
LocalSymmetricAccumulateRL
( ADJOINT,
F(1), A00, L10_STAR_MC, L10Adj_MR_STAR,
Y10Adj_MC_STAR, F10Adj_MR_STAR );
Y10Adj.SumScatterFrom( Y10Adj_MC_STAR );
Y10Adj_MR_MC = Y10Adj;
Y10Adj_MR_MC.SumScatterUpdate( F(1), F10Adj_MR_STAR );
Adjoint( Y10Adj_MR_MC.LockedLocalMatrix(), Y10Local );
// X11 := A10 L10'
X11_MC_STAR.ResizeTo( A11.Height(), A11.Width() );
LocalGemm
( NORMAL, NORMAL, F(1), A10, L10Adj_MR_STAR, F(0), X11_MC_STAR );
// A10 := A10 - Y10
Axpy( F(-1), Y10Local, A10.LocalMatrix() );
//.........这里部分代码省略.........
示例14: main
int main()
{
DoubleMatrix X(3,3);
DoubleInterval A(2,5);
X = A;
DoubleMatrix Y(3,3);
DoubleInterval B(5,9);
Y = B;
std::cout << X << std::endl;
std::cout << Y << std::endl;
DoubleMatrix Z(3,3);
Z = mtl::mat::trans(X);
std::cout << Z << std::endl;
mtl::mat::swap_row(Z,1,2);
std::cout << Z << std::endl;
DoubleInterval C;
C = boost::numeric::max(A,B);
std::cout << C << std::endl;
std::cout << "============== Test 1 ==============" << std::endl << std::endl;
DoubleInterval A00(2,3);
DoubleInterval A01(0,1);
DoubleInterval A10(1,2);
DoubleInterval A11(2,3);
DoubleMatrix *Test = new DoubleMatrix(2,2);
(*Test)(0,0) = A00;
(*Test)(0,1) = A01;
(*Test)(1,0) = A10;
(*Test)(1,1) = A11;
std::cout << "Test: " << std::endl;
std::cout << *Test << std::endl;
bool diag = diagonally_dominant(*Test);
if(diag == true)
std::cout << "Test is diagonally dominant" << std::endl << std::endl;
else
std::cout << "Test is NOT diagonally dominant" << std::endl << std::endl;
std::cout << "Max on row 2 is " << row_max_element(*Test,1,0) << std::endl;
std::cout << "The max is located on element " << row_max_term(*Test,1,0) << std::endl;
std::cout << std::endl;
std::cout << "determinant = " << det(*Test) << std::endl;
delete Test;
std::cout << "============== Test 2 ==============" << std::endl << std::endl;
Test = new DoubleMatrix(3,3);
(*Test)(0,0) = 1;
(*Test)(0,1) = 2;
(*Test)(0,2) = 3;
(*Test)(1,0) = 4;
(*Test)(1,1) = 5;
(*Test)(1,2) = 6;
(*Test)(2,0) = 7;
(*Test)(2,1) = 8;
(*Test)(2,2) = 9;
std::cout << "Test: " << std::endl;
std::cout << *Test << std::endl;
diag = diagonally_dominant(*Test);
if(diag == true)
std::cout << "Test is diagonally dominant" << std::endl << std::endl;
else
std::cout << "Test is NOT diagonally dominant" << std::endl << std::endl;
for(unsigned int i = 0; i < mtl::mat::num_rows(*Test); i++)
{
std::cout << "Max on row " << i << " is " << row_max_element(*Test,i,0) << std::endl;
std::cout << "The max is located on element " << row_max_term(*Test,i,0) << std::endl;
}
std::cout << std::endl;
std::cout << "determinant = " << det(*Test) << std::endl;
delete Test;
std::cout << "============== Test 3 ==============" << std::endl << std::endl;
Test = new DoubleMatrix(3,3);
(*Test)(0,0) = 1;
(*Test)(0,1) = 2;
(*Test)(0,2) = 3;
(*Test)(1,0) = 10;
(*Test)(1,1) = 5;
(*Test)(1,2) = 6;
(*Test)(2,0) = 10;
(*Test)(2,1) = 8;
(*Test)(2,2) = 9;
std::cout << "Test: " << std::endl;
std::cout << *Test << std::endl;
diag = diagonally_dominant(*Test);
//.........这里部分代码省略.........
示例15: entry
void LSquare
( DistMatrix<Complex<R> >& A,
DistMatrix<Complex<R>,STAR,STAR>& t )
{
#ifndef RELEASE
CallStackEntry entry("hermitian_tridiag::LSquare");
if( A.Grid() != t.Grid() )
throw std::logic_error("{A,t} must be distributed over the same grid");
#endif
const Grid& g = A.Grid();
#ifndef RELEASE
if( g.Height() != g.Width() )
throw std::logic_error("The process grid must be square");
if( A.Height() != A.Width() )
throw std::logic_error("A must be square");
if( t.Viewing() )
throw std::logic_error("t must not be a view");
#endif
typedef Complex<R> C;
DistMatrix<C,MD,STAR> tDiag(g);
tDiag.AlignWithDiagonal( A, -1 );
tDiag.ResizeTo( A.Height()-1, 1 );
// Matrix views
DistMatrix<C>
ATL(g), ATR(g), A00(g), A01(g), A02(g),
ABL(g), ABR(g), A10(g), A11(g), A12(g),
A20(g), A21(g), A22(g);
DistMatrix<C,MD,STAR> tT(g), t0(g),
tB(g), t1(g),
t2(g);
// Temporary distributions
DistMatrix<C> WPan(g);
DistMatrix<C,STAR,STAR> t1_STAR_STAR(g);
DistMatrix<C,STAR,STAR> A11_STAR_STAR(g);
DistMatrix<C,MC, STAR> APan_MC_STAR(g), A11_MC_STAR(g),
A21_MC_STAR(g);
DistMatrix<C,MR, STAR> APan_MR_STAR(g), A11_MR_STAR(g),
A21_MR_STAR(g);
DistMatrix<C,MC, STAR> WPan_MC_STAR(g), W11_MC_STAR(g),
W21_MC_STAR(g);
DistMatrix<C,MR, STAR> WPan_MR_STAR(g), W11_MR_STAR(g),
W21_MR_STAR(g);
PartitionDownDiagonal
( A, ATL, ATR,
ABL, ABR, 0 );
PartitionDown
( tDiag, tT,
tB, 0 );
while( ATL.Height() < A.Height() )
{
RepartitionDownDiagonal
( ATL, /**/ ATR, A00, /**/ A01, A02,
/*************/ /******************/
/**/ A10, /**/ A11, A12,
ABL, /**/ ABR, A20, /**/ A21, A22 );
RepartitionDown
( tT, t0,
/**/ /**/
t1,
tB, t2 );
if( A22.Height() > 0 )
{
WPan.AlignWith( A11 );
APan_MC_STAR.AlignWith( A11 );
WPan_MC_STAR.AlignWith( A11 );
APan_MR_STAR.AlignWith( A11 );
WPan_MR_STAR.AlignWith( A11 );
//----------------------------------------------------------------//
WPan.ResizeTo( ABR.Height(), A11.Width() );
APan_MC_STAR.ResizeTo( ABR.Height(), A11.Width() );
WPan_MC_STAR.ResizeTo( ABR.Height(), A11.Width() );
APan_MR_STAR.ResizeTo( ABR.Height(), A11.Width() );
WPan_MR_STAR.ResizeTo( ABR.Height(), A11.Width() );
hermitian_tridiag::PanelLSquare
( ABR, WPan, t1,
APan_MC_STAR, APan_MR_STAR, WPan_MC_STAR, WPan_MR_STAR );
PartitionDown
( APan_MC_STAR, A11_MC_STAR,
A21_MC_STAR, A11.Height() );
PartitionDown
( APan_MR_STAR, A11_MR_STAR,
A21_MR_STAR, A11.Height() );
PartitionDown
( WPan_MC_STAR, W11_MC_STAR,
W21_MC_STAR, A11.Height() );
PartitionDown
( WPan_MR_STAR, W11_MR_STAR,
W21_MR_STAR, A11.Height() );
LocalTrr2k
( LOWER, ADJOINT, ADJOINT,
C(-1), A21_MC_STAR, W21_MR_STAR,
//.........这里部分代码省略.........