Esempio n. 1
0
void test_kronecker_product()
{
  // DM = dense matrix; SM = sparse matrix
  Matrix<double, 2, 3> DM_a;
  MatrixXd             DM_b(3,2);
  SparseMatrix<double> SM_a(2,3);
  SparseMatrix<double> SM_b(3,2);
  SM_a.insert(0,0) = DM_a(0,0) = -0.4461540300782201;
  SM_a.insert(0,1) = DM_a(0,1) = -0.8057364375283049;
  SM_a.insert(0,2) = DM_a(0,2) =  0.3896572459516341;
  SM_a.insert(1,0) = DM_a(1,0) = -0.9076572187376921;
  SM_a.insert(1,1) = DM_a(1,1) =  0.6469156566545853;
  SM_a.insert(1,2) = DM_a(1,2) = -0.3658010398782789;
  SM_b.insert(0,0) = DM_b(0,0) =  0.9004440976767099;
  SM_b.insert(0,1) = DM_b(0,1) = -0.2368830858139832;
  SM_b.insert(1,0) = DM_b(1,0) = -0.9311078389941825;
  SM_b.insert(1,1) = DM_b(1,1) =  0.5310335762980047;
  SM_b.insert(2,0) = DM_b(2,0) = -0.1225112806872035;
  SM_b.insert(2,1) = DM_b(2,1) =  0.5903998022741264;
  SparseMatrix<double,RowMajor> SM_row_a(SM_a), SM_row_b(SM_b);

  // test kroneckerProduct(DM_block,DM,DM_fixedSize)
  Matrix<double, 6, 6> DM_fix_ab;
  DM_fix_ab(0,0)=37.0;
  kroneckerProduct(DM_a.block(0,0,2,3),DM_b,DM_fix_ab);
  CALL_SUBTEST(check_kronecker_product(DM_fix_ab));

  // test kroneckerProduct(DM,DM,DM_block)
  MatrixXd DM_block_ab(10,15);
  DM_block_ab(0,0)=37.0;
  kroneckerProduct(DM_a,DM_b,DM_block_ab.block(2,5,6,6));
  CALL_SUBTEST(check_kronecker_product(DM_block_ab.block(2,5,6,6)));

  // test kroneckerProduct(DM,DM,DM)
  MatrixXd DM_ab(1,5);
  DM_ab(0,0)=37.0;
  kroneckerProduct(DM_a,DM_b,DM_ab);
  CALL_SUBTEST(check_kronecker_product(DM_ab));

  // test kroneckerProduct(SM,DM,SM)
  SparseMatrix<double> SM_ab(1,20);
  SM_ab.insert(0,0)=37.0;
  kroneckerProduct(SM_a,DM_b,SM_ab);
  CALL_SUBTEST(check_kronecker_product(SM_ab));
  SparseMatrix<double,RowMajor> SM_ab2(10,3);
  SM_ab2.insert(0,0)=37.0;
  kroneckerProduct(SM_a,DM_b,SM_ab2);
  CALL_SUBTEST(check_kronecker_product(SM_ab2));

  // test kroneckerProduct(DM,SM,SM)
  SM_ab.insert(0,0)=37.0;
  kroneckerProduct(DM_a,SM_b,SM_ab);
  CALL_SUBTEST(check_kronecker_product(SM_ab));
  SM_ab2.insert(0,0)=37.0;
  kroneckerProduct(DM_a,SM_b,SM_ab2);
  CALL_SUBTEST(check_kronecker_product(SM_ab2));

  // test kroneckerProduct(SM,SM,SM)
  SM_ab.resize(2,33);
  SM_ab.insert(0,0)=37.0;
  kroneckerProduct(SM_a,SM_b,SM_ab);
  CALL_SUBTEST(check_kronecker_product(SM_ab));
  SM_ab2.resize(5,11);
  SM_ab2.insert(0,0)=37.0;
  kroneckerProduct(SM_a,SM_b,SM_ab2);
  CALL_SUBTEST(check_kronecker_product(SM_ab2));

  // test kroneckerProduct(SM,SM,SM) with sparse pattern
  SM_a.resize(4,5);
  SM_b.resize(3,2);
  SM_a.resizeNonZeros(0);
  SM_b.resizeNonZeros(0);
  SM_a.insert(1,0) = -0.1;
  SM_a.insert(0,3) = -0.2;
  SM_a.insert(2,4) =  0.3;
  SM_a.finalize();
  SM_b.insert(0,0) =  0.4;
  SM_b.insert(2,1) = -0.5;
  SM_b.finalize();
  SM_ab.resize(1,1);
  SM_ab.insert(0,0)=37.0;
  kroneckerProduct(SM_a,SM_b,SM_ab);
  CALL_SUBTEST(check_sparse_kronecker_product(SM_ab));

  // test dimension of result of kroneckerProduct(DM,DM,DM)
  MatrixXd DM_a2(2,1);
  MatrixXd DM_b2(5,4);
  MatrixXd DM_ab2;
  kroneckerProduct(DM_a2,DM_b2,DM_ab2);
  CALL_SUBTEST(check_dimension(DM_ab2,2*5,1*4));
  DM_a2.resize(10,9);
  DM_b2.resize(4,8);
  kroneckerProduct(DM_a2,DM_b2,DM_ab2);
  CALL_SUBTEST(check_dimension(DM_ab2,10*4,9*8));
}
Esempio n. 2
0
void test_kronecker_product()
{
  // DM = dense matrix; SM = sparse matrix

  Matrix<double, 2, 3> DM_a;
  SparseMatrix<double> SM_a(2,3);
  SM_a.insert(0,0) = DM_a.coeffRef(0,0) = -0.4461540300782201;
  SM_a.insert(0,1) = DM_a.coeffRef(0,1) = -0.8057364375283049;
  SM_a.insert(0,2) = DM_a.coeffRef(0,2) =  0.3896572459516341;
  SM_a.insert(1,0) = DM_a.coeffRef(1,0) = -0.9076572187376921;
  SM_a.insert(1,1) = DM_a.coeffRef(1,1) =  0.6469156566545853;
  SM_a.insert(1,2) = DM_a.coeffRef(1,2) = -0.3658010398782789;
 
  MatrixXd             DM_b(3,2);
  SparseMatrix<double> SM_b(3,2);
  SM_b.insert(0,0) = DM_b.coeffRef(0,0) =  0.9004440976767099;
  SM_b.insert(0,1) = DM_b.coeffRef(0,1) = -0.2368830858139832;
  SM_b.insert(1,0) = DM_b.coeffRef(1,0) = -0.9311078389941825;
  SM_b.insert(1,1) = DM_b.coeffRef(1,1) =  0.5310335762980047;
  SM_b.insert(2,0) = DM_b.coeffRef(2,0) = -0.1225112806872035;
  SM_b.insert(2,1) = DM_b.coeffRef(2,1) =  0.5903998022741264;

  SparseMatrix<double,RowMajor> SM_row_a(SM_a), SM_row_b(SM_b);

  // test DM_fixedSize = kroneckerProduct(DM_block,DM)
  Matrix<double, 6, 6> DM_fix_ab = kroneckerProduct(DM_a.topLeftCorner<2,3>(),DM_b);

  CALL_SUBTEST(check_kronecker_product(DM_fix_ab));
  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(DM_a.topLeftCorner<2,3>(),DM_b)));

  for(int i=0;i<DM_fix_ab.rows();++i)
    for(int j=0;j<DM_fix_ab.cols();++j)
       VERIFY_IS_APPROX(kroneckerProduct(DM_a,DM_b).coeff(i,j), DM_fix_ab(i,j));

  // test DM_block = kroneckerProduct(DM,DM)
  MatrixXd DM_block_ab(10,15);
  DM_block_ab.block<6,6>(2,5) = kroneckerProduct(DM_a,DM_b);
  CALL_SUBTEST(check_kronecker_product(DM_block_ab.block<6,6>(2,5)));

  // test DM = kroneckerProduct(DM,DM)
  MatrixXd DM_ab = kroneckerProduct(DM_a,DM_b);
  CALL_SUBTEST(check_kronecker_product(DM_ab));
  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(DM_a,DM_b)));

  // test SM = kroneckerProduct(SM,DM)
  SparseMatrix<double> SM_ab = kroneckerProduct(SM_a,DM_b);
  CALL_SUBTEST(check_kronecker_product(SM_ab));
  SparseMatrix<double,RowMajor> SM_ab2 = kroneckerProduct(SM_a,DM_b);
  CALL_SUBTEST(check_kronecker_product(SM_ab2));
  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(SM_a,DM_b)));

  // test SM = kroneckerProduct(DM,SM)
  SM_ab.setZero();
  SM_ab.insert(0,0)=37.0;
  SM_ab = kroneckerProduct(DM_a,SM_b);
  CALL_SUBTEST(check_kronecker_product(SM_ab));
  SM_ab2.setZero();
  SM_ab2.insert(0,0)=37.0;
  SM_ab2 = kroneckerProduct(DM_a,SM_b);
  CALL_SUBTEST(check_kronecker_product(SM_ab2));
  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(DM_a,SM_b)));

  // test SM = kroneckerProduct(SM,SM)
  SM_ab.resize(2,33);
  SM_ab.insert(0,0)=37.0;
  SM_ab = kroneckerProduct(SM_a,SM_b);
  CALL_SUBTEST(check_kronecker_product(SM_ab));
  SM_ab2.resize(5,11);
  SM_ab2.insert(0,0)=37.0;
  SM_ab2 = kroneckerProduct(SM_a,SM_b);
  CALL_SUBTEST(check_kronecker_product(SM_ab2));
  CALL_SUBTEST(check_kronecker_product(kroneckerProduct(SM_a,SM_b)));

  // test SM = kroneckerProduct(SM,SM) with sparse pattern
  SM_a.resize(4,5);
  SM_b.resize(3,2);
  SM_a.resizeNonZeros(0);
  SM_b.resizeNonZeros(0);
  SM_a.insert(1,0) = -0.1;
  SM_a.insert(0,3) = -0.2;
  SM_a.insert(2,4) =  0.3;
  SM_a.finalize();
  
  SM_b.insert(0,0) =  0.4;
  SM_b.insert(2,1) = -0.5;
  SM_b.finalize();
  SM_ab.resize(1,1);
  SM_ab.insert(0,0)=37.0;
  SM_ab = kroneckerProduct(SM_a,SM_b);
  CALL_SUBTEST(check_sparse_kronecker_product(SM_ab));

  // test dimension of result of DM = kroneckerProduct(DM,DM)
  MatrixXd DM_a2(2,1);
  MatrixXd DM_b2(5,4);
  MatrixXd DM_ab2 = kroneckerProduct(DM_a2,DM_b2);
  CALL_SUBTEST(check_dimension(DM_ab2,2*5,1*4));
  DM_a2.resize(10,9);
  DM_b2.resize(4,8);
  DM_ab2 = kroneckerProduct(DM_a2,DM_b2);
  CALL_SUBTEST(check_dimension(DM_ab2,10*4,9*8));
  
  for(int i = 0; i < g_repeat; i++)
  {
    double density = Eigen::internal::random<double>(0.01,0.5);
    int ra = Eigen::internal::random<int>(1,50);
    int ca = Eigen::internal::random<int>(1,50);
    int rb = Eigen::internal::random<int>(1,50);
    int cb = Eigen::internal::random<int>(1,50);
    SparseMatrix<float,ColMajor> sA(ra,ca), sB(rb,cb), sC;
    SparseMatrix<float,RowMajor> sC2;
    MatrixXf dA(ra,ca), dB(rb,cb), dC;
    initSparse(density, dA, sA);
    initSparse(density, dB, sB);
    
    sC = kroneckerProduct(sA,sB);
    dC = kroneckerProduct(dA,dB);
    VERIFY_IS_APPROX(MatrixXf(sC),dC);
    
    sC = kroneckerProduct(sA.transpose(),sB);
    dC = kroneckerProduct(dA.transpose(),dB);
    VERIFY_IS_APPROX(MatrixXf(sC),dC);
    
    sC = kroneckerProduct(sA.transpose(),sB.transpose());
    dC = kroneckerProduct(dA.transpose(),dB.transpose());
    VERIFY_IS_APPROX(MatrixXf(sC),dC);
    
    sC = kroneckerProduct(sA,sB.transpose());
    dC = kroneckerProduct(dA,dB.transpose());
    VERIFY_IS_APPROX(MatrixXf(sC),dC);
    
    sC2 = kroneckerProduct(sA,sB);
    dC = kroneckerProduct(dA,dB);
    VERIFY_IS_APPROX(MatrixXf(sC2),dC);
  }
}