UavController::UavController(){
uav1_cmd_topic_="/uav1/cmd_vel";
uav2_cmd_topic_="/uav2/cmd_vel";
uav3_cmd_topic_="/uav3/cmd_vel";
nh_st_="UavController";
subAll();
}
Int_t main(Int_t argc, Char_t *argv[])
{
ROOT::Mpi::TEnvironment env(argc, argv);
ROOT::Mpi::TIntraCommunicator world;
// MpiInitTest(world, 2, ROOT::Mpi::GreaterIqual);
TMatrixT<Double_t> mResult;
TMatrixT<Double_t> m1(rowm1, colm1);
TMatrixT<Double_t> m2(rowm2, colm2);
TMatrixT<Double_t> m1square(side, side);
TMatrixT<Double_t> m2square(side, side);
for (Int_t i = 0; i < rowm1; i++)
for (Int_t j = 0; j < colm1; j++)
m1[i][j] = i + j;
for (Int_t i = 0; i < rowm2; i++)
for (Int_t j = 0; j < colm2; j++)
m2[i][j] = j;
for (Int_t i = 0; i < side; i++)
for (Int_t j = 0; j < side; j++) {
m1square[i][j] = j;
m2square[i][j] = i;
}
///////////////////////////////////////////////
//Testing methdos with results in single Rank//
///////////////////////////////////////////////
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mul(m1);
mul.Mult(m2, root);
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> add(m1square);
add.Addition(m2square, root);
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> sub(m1square);
sub.Subtraction(m2square, root);
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> trans(m2);
trans.Transpose(root);
if (world.Rank() == root) {
mul.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1 * m2, world.Rank(), "Matrix Multiplication Single");
add.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1square + m2square, world.Rank(), "Matrix Addition Single");
sub.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1square - m2square, world.Rank(), "Matrix Subtraction Single");
trans.GetResult(mResult);
MpiCompareTMatrixTest(mResult, TMatrixT<Double_t>(m2.GetNcols(), m2.GetNrows()).Transpose(m2), world.Rank(), "Matrix Transpose Single");
}
///////////////////////////////////////////////
//Testing methdos with results in all ranks //
///////////////////////////////////////////////
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulAll(m1);//return the results in all ranks
mulAll.Mult(m2);
mulAll.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1 * m2, world.Rank(), "Matrix Multiplication All");
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> addAll(m1square);
addAll.Addition(m2square);
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> subAll(m1square);
subAll.Subtraction(m2square);
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> transAll(m2);
transAll.Transpose();
addAll.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1square + m2square, world.Rank(), "Matrix Addition All");
subAll.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1square - m2square, world.Rank(), "Matrix Subtraction All");
transAll.GetResult(mResult);
MpiCompareTMatrixTest(mResult, TMatrixT<Double_t>(m2.GetNcols(), m2.GetNrows()).Transpose(m2), world.Rank(), "Matrix Transpose All");
//////////////////////////////////////////////////
//Testing methdos with multiple matrices types //
//////////////////////////////////////////////////
THilbertMatrixT<Double_t> him(side, side);
TMatrixTSparse<Double_t> sm1(rowm1, colm1);
TMatrixTSparse<Double_t> sm2(rowm2, colm2);
TMatrixTFlat<Double_t> fm1(m1);
TMatrixTFlat<Double_t> fm2(m2);
TMatrixTSparse<Double_t> smResult;
for (Int_t i = 0; i < rowm1; i++)
for (Int_t j = 0; j < colm1; j++) {
sm1[i][j] = i * j;
}
for (Int_t i = 0; i < rowm2; i++)
for (Int_t j = 0; j < colm2; j++) {
sm2[i][j] = i * j;
}
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulHim(m1square);//return the results in all ranks
mulHim.Mult(him);
mulHim.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1square * TMatrixT<Double_t>(him), world.Rank(), "Matrix Multiplication HilbertMatrix");
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulHim2(him);//return the results in all ranks
mulHim2.Mult(m1square);
mulHim2.GetResult(mResult);
MpiCompareTMatrixTest(mResult, TMatrixT<Double_t>(him)*m1square, world.Rank(), "Matrix Multiplication HilbertMatrix In Constructor");
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulSm(m1);//return the results in all ranks
mulSm.Mult(sm2);
mulSm.GetResult(smResult);
MpiCompareTMatrixTest(smResult, m1 * sm2, world.Rank(), "Matrix Multiplication SparseMatrix");
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulSm2(sm1);//return the results in all ranks
mulSm2.Mult(m2);
mulSm2.GetResult(smResult);
MpiCompareTMatrixTest(smResult, sm1 * m2, world.Rank(), "Matrix Multiplication SparseMatrix In Constructor");
//
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulFm(m1);//return the results in all ranks
mulFm.Mult(fm2);
mulFm.GetResult(mResult);
MpiCompareTMatrixTest(mResult, m1 * TMatrixT<Double_t>(fm2.GetMatrix()->GetNrows(), fm2.GetMatrix()->GetNcols(), fm2.GetMatrix()->GetMatrixArray()), world.Rank(), "Matrix Multiplication FlatMatrix");
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulFm2(fm1);//return the results in all ranks
mulFm2.Mult(m2);
mulFm2.GetResult(mResult);
//NOTE fm matrix have data from m2, is the same tell m1*m2, just change the representation in memory
MpiCompareTMatrixTest(mResult, m1 * m2, world.Rank(), "Matrix Multiplication FlatMatrix In Constructor");
TVectorT<Double_t> vec(rowv);
for (Int_t i = 0; i < rowv; i++) vec[i] = i;
ROOT::Mpi::Math::TMatrixTWrapper<Double_t> mulVec(m1);//return the results in all ranks
mulVec.Mult(vec);
mulVec.GetResult(mResult);
TMatrixT<Double_t> mr((m1 * vec).GetNrows(), 1, (m1 * vec).GetMatrixArray());
// mResult.Print();
// mr.Print();
MpiCompareTMatrixTest(mResult, mr, world.Rank(), "Matrix Multiplication with Vector");
return 0;
}
Int_t main(Int_t argc, Char_t *argv[])
{
ROOT::Mpi::TEnvironment env(argc, argv);
ROOT::Mpi::TIntraCommunicator world;
TVectorT<Double_t> mResult;
Double_t fScalarResult;
TVectorT<Double_t> v1(elements);
TVectorT<Double_t> v2(elements);
for (Int_t i = 0; i < elements; i++) {
v1[i] = i + (i + world.Size());
v2[i] = i * (i + world.Size());
}
///////////////////////////////////////////////
//Testing methdos with results in single Rank//
///////////////////////////////////////////////
ROOT::Mpi::Math::TVectorTWrapper<Double_t> add(v1);
add.Addition(v2, root);
ROOT::Mpi::Math::TVectorTWrapper<Double_t> sub(v1);
sub.Subtraction(v2, root);
ROOT::Mpi::Math::TVectorTWrapper<Double_t> dot(v1);
dot.Dot(v2, root);
ROOT::Mpi::Math::TVectorTWrapper<Double_t> norm2Sqr(v1);
norm2Sqr.Norm2Sqr(root);
ROOT::Mpi::Math::TVectorTWrapper<Double_t> norm1(v1);
norm1.Norm1(root);
ROOT::Mpi::Math::TVectorTWrapper<Double_t> min(v1);
min.Min(root);
ROOT::Mpi::Math::TVectorTWrapper<Double_t> max(v1);
max.Max(root);
ROOT::Mpi::Math::TVectorTWrapper<Double_t> normalize(v1);
normalize.Normalize(root);
ROOT::Mpi::Math::TVectorTWrapper<Double_t> sum(v1);
sum.Sum(root);
if (world.Rank() == root) {
add.GetResult(mResult);
MpiCompareTVectorTest(mResult, v1 + v2, world.Rank(), "Vector Addition Single");
sub.GetResult(mResult);
MpiCompareTVectorTest(mResult, v1 - v2, world.Rank(), "Vector Subtraction Single");
dot.GetResult(fScalarResult);
MpiCompareTest(fScalarResult, Dot(v1, v2) , world.Rank(), "Vector Dot Product Single");
norm2Sqr.GetResult(fScalarResult);
MpiCompareTest(fScalarResult, v1.Norm2Sqr() , world.Rank(), "Vector Norm2Sqr Single");
norm1.GetResult(fScalarResult);
MpiCompareTest(fScalarResult, v1.Norm1() , world.Rank(), "Vector Norm1 Single");
min.GetResult(fScalarResult);
MpiCompareTest(fScalarResult, v1.Min() , world.Rank(), "Vector Min Single");
max.GetResult(fScalarResult);
MpiCompareTest(fScalarResult, v1.Max() , world.Rank(), "Vector Max Single");
normalize.GetResult(mResult);
MpiCompareTest(mResult.Norm2Sqr(), ((1 / TMath::Sqrt(v1.Norm2Sqr()))*v1).Norm2Sqr() , world.Rank(), "Vector Normalize Single");
sum.GetResult(fScalarResult);
MpiCompareTest(fScalarResult, v1.Sum(), world.Rank(), "Vector Sum Single");
}
///////////////////////////////////////////////
//Testing methdos with results in all ranks //
///////////////////////////////////////////////
ROOT::Mpi::Math::TVectorTWrapper<Double_t> addAll(v1);
add.Addition(v2);
ROOT::Mpi::Math::TVectorTWrapper<Double_t> subAll(v1);
sub.Subtraction(v2);
add.GetResult(mResult);
MpiCompareTVectorTest(mResult, v1 + v2, world.Rank(), "Vector Addition All");
sub.GetResult(mResult);
MpiCompareTVectorTest(mResult, v1 - v2, world.Rank(), "Vector Subtraction All");
ROOT::Mpi::Math::TVectorTWrapper<Double_t> dotAll(v1);
dotAll.Dot(v2);
dotAll.GetResult(fScalarResult);
MpiCompareTest(fScalarResult, Dot(v1, v2) , world.Rank(), "Vector Dot Product All");
ROOT::Mpi::Math::TVectorTWrapper<Double_t> norm2SqrAll(v2);
norm2SqrAll.Norm2Sqr();
norm2SqrAll.GetResult(fScalarResult);
MpiCompareTest(fScalarResult, v2.Norm2Sqr() , world.Rank(), "Vector Norm2Sqr All");
ROOT::Mpi::Math::TVectorTWrapper<Double_t> norm1All(v2);
norm1All.Norm1();
norm1All.GetResult(fScalarResult);
MpiCompareTest(fScalarResult, v2.Norm1() , world.Rank(), "Vector Norm1 All");
ROOT::Mpi::Math::TVectorTWrapper<Double_t> minAll(v2);
minAll.Min();
minAll.GetResult(fScalarResult);
MpiCompareTest(fScalarResult, v2.Min() , world.Rank(), "Vector Min All");
ROOT::Mpi::Math::TVectorTWrapper<Double_t> maxAll(v2);
maxAll.Max();
maxAll.GetResult(fScalarResult);
MpiCompareTest(fScalarResult, v2.Max() , world.Rank(), "Vector Max All");
ROOT::Mpi::Math::TVectorTWrapper<Double_t> normalizeAll(v2);
normalizeAll.Normalize();
normalizeAll.GetResult(mResult);
//show if the vector is normalize, then Norm2Sqr of result is near to 1
MpiCompareTest(mResult.Norm2Sqr(), ((1 / TMath::Sqrt(v2.Norm2Sqr()))*v2).Norm2Sqr() , world.Rank(), "Vector Normalize All");
ROOT::Mpi::Math::TVectorTWrapper<Double_t> sumAll(v2);
sumAll.Sum();
sumAll.GetResult(fScalarResult);
MpiCompareTest(fScalarResult, v2.Sum() , world.Rank(), "Vector Sum All");
return 0;
}
