testSimpleMatrix.cpp File Reference

#include <iostream>
#include "DGtal/base/Common.h"
#include "DGtal/math/linalg/SimpleMatrix.h"
#include "DGtal/math/linalg/CStaticMatrix.h"
#include "DGtal/math/linalg/CDenseMatrix.h"
#include "DGtal/math/linalg/CStaticVector.h"
#include "DGtal/math/linalg/CDenseVector.h"
#include "DGtal/math/linalg/CLinearAlgebra.h"
#include "DGtal/math/linalg/IntegerMatrixFunctions.h"
#include "DGtal/helpers/StdDefs.h"

Include dependency graph for testSimpleMatrix.cpp:

Go to the source code of this file.

Functions
bool	testSimpleMatrix ()
bool	testArithm ()
bool	testColRow ()
bool	testDetCofactor ()
bool	testM1Matrix ()
bool	testInverse ()
bool	testConstructor ()
bool	testConcepts ()
bool	testBareissDeterminant ()
template<typename Number>
std::ostream &	operator<< (std::ostream &out, const std::vector< Number > &v)
bool	testLLL ()
bool	testOrthogonalLattice ()
int	main (int argc, char **argv)

Detailed Description

This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Author

David Coeurjolly (david.nosp@m..coe.nosp@m.urjol.nosp@m.ly@l.nosp@m.iris..nosp@m.cnrs.nosp@m..fr ) Laboratoire d'InfoRmatique en Image et Systèmes d'information - LIRIS (CNRS, UMR 5205), CNRS, France

Date

2012/07/10

Functions for testing class SimpleMatrix.

This file is part of the DGtal library.

Definition in file testSimpleMatrix.cpp.

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 712 of file testSimpleMatrix.cpp.

{
  trace.beginBlock ( "Testing class SimpleMatrix" );
  trace.info() << "Args:";
  for ( int i = 0; i < argc; ++i )
    trace.info() << " " << argv[ i ];
  trace.info() << endl;
 
  bool res = testSimpleMatrix() && testArithm() && testColRow()
    && testDetCofactor() && testM1Matrix() && testInverse()
    && testConcepts() && testConstructor()
    && testBareissDeterminant()
    && testLLL()
    && testOrthogonalLattice();
  trace.emphase() << ( res ? "Passed." : "Error." ) << endl;
  trace.endBlock();
  return res ? 0 : 1;
}

References DGtal::Trace::beginBlock(), DGtal::Trace::emphase(), DGtal::Trace::endBlock(), DGtal::Trace::info(), main(), testArithm(), testBareissDeterminant(), testColRow(), testConcepts(), testConstructor(), testDetCofactor(), testInverse(), testLLL(), testM1Matrix(), testOrthogonalLattice(), testSimpleMatrix(), and DGtal::trace.

operator<<()

template<typename Number>

std::ostream & operator<<	(	std::ostream &	out,
		const std::vector< Number > &	v )

Definition at line 488 of file testSimpleMatrix.cpp.

{
  for ( auto i = 0; i < v.size(); i++ )
    out << v[ i ] << " ";
  out << "\n";
  return out;
}

References DGtal::operator<<().

testArithm()

bool testArithm

(

)

Definition at line 92 of file testSimpleMatrix.cpp.

{
  unsigned int nbok = 0;
  unsigned int nb = 0;
 
 
  typedef SimpleMatrix<double,3,4> M34d;
  typedef SimpleMatrix<double,4,3> M43d;
  typedef SimpleMatrix<double,3,3> M33d;
 
  M34d m34d, two,four;
  M34d m34dbis, resadd, ressub;
 
  two.constant(2);
  four.constant(4);
 
  for(DGtal::Dimension i = 0; i< 3; ++i)
    for(DGtal::Dimension j = 0; j< 4; ++j)
      {
        m34d.setComponent(i,j,i*j);
        m34dbis.setComponent(i,j,i+j);
        resadd.setComponent(i,j,i*j+i+j);
        ressub.setComponent(i,j,i*j-(double)i-(double)j);
      }
 
 
  trace.info() << m34d <<std::endl;
  trace.info() << m34dbis<<std::endl;
 
  trace.beginBlock ( "Testing add ..." );
  nbok += ((m34d + m34dbis) == resadd) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
         << "ok" << std::endl;
  nbok += ((m34dbis + m34d) == resadd) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
         << "ok commutative" << std::endl;
 
  M34d other;
  other += m34d;
  nbok += (other == m34d) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
         << "ok +=" << std::endl;
 
  trace.endBlock();
 
  trace.beginBlock ( "Testing subtraction ..." );
  nbok += ((m34d - m34dbis) == ressub) ? 1 : 0;
  nb++;
  trace.info()<<ressub<<std::endl;
  trace.info()<<m34d - m34dbis<<std::endl;
 
  trace.info() << "(" << nbok << "/" << nb << ") "
         << "ok simple" << std::endl;
  trace.endBlock();
 
  trace.beginBlock ( "Testing scalar product/divide ..." );
  nbok += ( (two*2.0) == four) ? 1 : 0;
  nb++;
  trace.info()<<ressub<<std::endl;
  trace.info() << "(" << nbok << "/" << nb << ") "
         << " [2]*2 == [4]" << std::endl;
 
  nbok += ( two == four/2.0) ? 1 : 0;
  nb++;
  trace.info()<<ressub<<std::endl;
  trace.info() << "(" << nbok << "/" << nb << ") "
         << " [2]= [4]/2" << std::endl;
  trace.endBlock();
 
 
  trace.beginBlock ( "Testing transpose ..." );
  M43d transp = m34d.transpose();
  nbok += (transp.transpose() == m34d) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
           << "ok idem potent" << std::endl;
  trace.endBlock();
 
  trace.beginBlock ( "Testing product ..." );
 
  M43d one;
  M33d eight33;
 
  one.constant(1);
  eight33.constant(8);
  trace.info() << two * one<<std::endl;
  nbok += (two * one  == eight33) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
           << " [2]*[1] = [8]" << std::endl;
  trace.endBlock();
 
 
 
  return nbok == nb;
 
}

References DGtal::Trace::beginBlock(), DGtal::SimpleMatrix< TComponent, TM, TN >::constant(), DGtal::Trace::endBlock(), DGtal::Trace::info(), testArithm(), and DGtal::trace.

Referenced by main(), and testArithm().

testBareissDeterminant()

bool testBareissDeterminant

(

)

Definition at line 401 of file testSimpleMatrix.cpp.

{
  unsigned int nbok = 0;
  unsigned int nb   = 0;
 
  trace.beginBlock( "Bareiss determinant test" );
  {
    typedef DGtal::SimpleMatrix<int,3,3> Matrix;
 
    Matrix M = { 1, 2, 3, 4, 5, 7, 6, 8, 9 };
    auto   d = M.determinant();
    int    db;
    DGtal::functions::getDeterminantBareiss( db, M );
    trace.info() << "d=" << d << " db=" << db << "\n";
    nbok += ( d == 7 ) ? 1 : 0;
    nb++;
    nbok += ( db == 7 ) ? 1 : 0;
    nb++;
  }
 
  {
    typedef DGtal::SimpleMatrix<int,4,4> Matrix;
    Matrix  M = { 1, 2, 3, -4, 13, 4, 5, 7, 6, 8, 17, 9, 21, 12, -5, 11 };
    auto    d = M.determinant();
    int64_t db, dbv;
    DGtal::functions::getDeterminantBareiss( db, M );
    auto  MV = DGtal::functions::matrixAsVectorVector( M );
    DGtal::functions::getDeterminantBareiss( dbv, MV );
    trace.info() << "d=" << d << " db=" << db << " dbv=" << dbv << "\n";
    nbok += ( d == -12260 ) ? 1 : 0;
    nb++;
    nbok += ( db == -12260 ) ? 1 : 0;
    nb++;
    nbok += ( dbv == -12260 ) ? 1 : 0;
    nb++;
  }
  {
    std::vector<int> V = { 1, 2, 3, -4, 13, 4, 5, 7, 6, 8, 17, 9, 21, 12, -5, 11 };
    auto MV = DGtal::functions::matrixAsVectorVector( 4, 4, V );
    int64_t db;
    DGtal::functions::getDeterminantBareiss( db, MV );
    trace.info() << "db=" << db << "\n";
    nbok += ( db == -12260 ) ? 1 : 0;
    nb++;
  }
  {
    typedef DGtal::SimpleMatrix<int,5,5> Matrix;
    Matrix  M = { 1311, 1, 2, 3, -4,
                  13, 457, 4, 5, 7,
                  6, 8, -535, 17, 9,
                  21, 12, -5, 243, 11,
                  123,-39,411,630,23 };
    auto    d = M.determinant();
    int64_t db;
    BigInteger big_db;
    DGtal::functions::getDeterminantBareiss( db, M );
    DGtal::functions::getDeterminantBareiss( big_db, M );
    int64_t   cdb = NumberTraits<BigInteger>::castToInt64_t( big_db );
    trace.info() << "d=" << d << " (i64)db=" << db << " (big)db=" << cdb << "\n";
    // The line below raises a warning in the macos compiler.
    // nbok += ( int64_t(d) != -171492636038LL ) ? 1 : 0; // int overflow
    nbok += ( int(d) != (-171492636038LL % 2147483648LL ) ) ? 1 : 0; // int overflow
    nb++;
    nbok += ( db != -171492636038LL ) ? 1 : 0; // int64 overflow (intermediate computation)
    nb++;
    nbok += ( cdb == -171492636038LL ) ? 1 : 0;
    nb++;
  }
 
  {
    typedef DGtal::SimpleMatrix<double,4,4> Matrix;
    Matrix  M = { 1.5, 2.2, 3.1, -4.6, 13.3, 4.2, 5.7, 7.3, 6.4, 8.0, 17.9, 9.3, 21.2, 12.2, -5.1, 11.8 };
    auto    d = M.determinant();
    double  db;
    DGtal::functions::getDeterminantBareiss( db, M );
    trace.info() << "d=" << d << " db=" << db << "\n";
    nbok += ( std::fabs( d - db ) < 1e-10 ) ? 1 : 0;
    nb++;
  }
 
  std::cout << "(" << nbok << "/" << nb << ")\n";
  trace.endBlock();
 
  return nbok == nb;
}

References DGtal::Trace::beginBlock(), DGtal::SimpleMatrix< TComponent, TM, TN >::determinant(), DGtal::Trace::endBlock(), DGtal::functions::getDeterminantBareiss(), DGtal::Trace::info(), DGtal::functions::matrixAsVectorVector(), testBareissDeterminant(), and DGtal::trace.

Referenced by main(), and testBareissDeterminant().

testColRow()

bool testColRow

(

)

Definition at line 193 of file testSimpleMatrix.cpp.

{
  unsigned int nbok = 0;
  unsigned int nb = 0;
 
  DGtal::SimpleMatrix<double,3,4> mat;
  for(DGtal::Dimension i = 0; i< 3; ++i)
    for(DGtal::Dimension j = 0; j< 4; ++j)
      mat.setComponent(i,j,i+j);
 
  trace.beginBlock("Get Row");
  trace.info() << mat <<std::endl;
  DGtal::SimpleMatrix<double,3,4>::RowVector row;
  row = mat.row(1);
  trace.info() << row << std::endl;
  nbok += (row[1] == 2 ) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
           << " row value" << std::endl;
  trace.endBlock();
 
  trace.beginBlock("Get Col");
  DGtal::SimpleMatrix<double,3,4>::ColumnVector col;
  col = mat.column(1);
  trace.info() << row << std::endl;
  nbok += (col[1] == 2 ) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
           << " col value" << std::endl;
  trace.endBlock();
 
 
 
  trace.beginBlock("Prod Matrix x Row^t");
  //Row vector is a dim 4 vector
  DGtal::SimpleMatrix<double,3,4>::RowVector r(1,2,3,4);
  DGtal::SimpleMatrix<double,3,4>::ColumnVector c;
  c = mat*r;
  DGtal::SimpleMatrix<double,3,4>::ColumnVector expected(20,30,40);
 
  trace.info() << c << std::endl;
  nbok += (c == expected) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
           << " mat*row^t" << std::endl;
  trace.endBlock();
 
  return nbok == nb;
}

References DGtal::Trace::beginBlock(), DGtal::SimpleMatrix< TComponent, TM, TN >::column(), DGtal::Trace::endBlock(), DGtal::Trace::info(), DGtal::SimpleMatrix< TComponent, TM, TN >::row(), DGtal::SimpleMatrix< TComponent, TM, TN >::setComponent(), testColRow(), and DGtal::trace.

Referenced by main(), and testColRow().

testConcepts()

bool testConcepts

(

)

Definition at line 385 of file testSimpleMatrix.cpp.

{
  typedef DGtal::SimpleMatrix<double,3,3> Matrix;
  typedef Matrix::ColumnVector Vector;
 
  BOOST_CONCEPT_ASSERT(( concepts::CStaticVector<Vector> ));
  BOOST_CONCEPT_ASSERT(( concepts::CDenseVector<Vector> ));
  BOOST_CONCEPT_ASSERT(( concepts::CStaticMatrix<Matrix> ));
  BOOST_CONCEPT_ASSERT(( concepts::CDenseMatrix<Matrix> ));
  BOOST_CONCEPT_ASSERT(( concepts::CLinearAlgebra<Vector, Matrix> ));
  BOOST_CONCEPT_ASSERT(( concepts::CStaticVector<DGtal::Z3i::Space::Vector> ));
  BOOST_CONCEPT_ASSERT(( concepts::CDenseVector<DGtal::Z3i::Space::Vector> ));
 
  return true;
}

References testConcepts().

testConstructor()

bool testConstructor

(

)

Definition at line 355 of file testSimpleMatrix.cpp.

{
  unsigned int nbok = 0;
  unsigned int nb   = 0;
 
  trace.beginBlock( "Initilizer-list constructor test" );
  SimpleMatrix<double, 3, 3> mat = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  trace.info() << mat << std::endl;
 
  trace.info() << "Testing values: ";
  trace.info() << mat( 0, 0 );
  nbok += ( mat( 0, 0 ) == 1 ) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") ";
 
  trace.info() << mat( 0, 1 );
  nbok += ( mat( 0, 1 ) == 2 ) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") ";
 
  trace.info() << mat( 2, 2 );
  nbok += ( mat( 2, 2 ) == 9 ) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") ";
 
  trace.info() << std::endl;
  trace.endBlock();
  return nbok == nb;
}

References DGtal::Trace::beginBlock(), DGtal::Trace::endBlock(), DGtal::Trace::info(), testConstructor(), and DGtal::trace.

Referenced by main(), and testConstructor().

testDetCofactor()

bool testDetCofactor

(

)

Definition at line 243 of file testSimpleMatrix.cpp.

{
  unsigned int nbok = 0;
  unsigned int nb = 0;
 
  typedef DGtal::SimpleMatrix<double,2,2> MAT2;
  MAT2 mat2;
  mat2.setComponent(0,0,1);
  mat2.setComponent(1,1,2);
 
  trace.beginBlock("det2x2 tests...");
  trace.info() << mat2<<std::endl;
  trace.info() << mat2.determinant() << std::endl;
  nbok += (mat2.determinant() == 2) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
           << " 2" << std::endl;
  trace.endBlock();
 
  typedef DGtal::SimpleMatrix<double,3,3> MAT;
  MAT mat;
  mat.setComponent(0,0,1);
  mat.setComponent(1,1,2);
  mat.setComponent(2,2,4);
 
  trace.beginBlock("det3x3 tests...");
  trace.info() << mat<<std::endl;
  nbok += (mat.determinant() == 8) ? 1 : 0;
   nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
           << " 8" << std::endl;
  trace.endBlock();
 
 
  typedef DGtal::SimpleMatrix<double,4,4> MAT44;
  MAT44 mat44;
  mat44.setComponent(0,0,1);
  mat44.setComponent(1,1,2);
  mat44.setComponent(2,2,4);
  mat44.setComponent(3,3,4);
 
  trace.beginBlock("det4x4 tests...");
  trace.info() << mat44 <<std::endl;
  trace.info() << mat44.determinant() << std::endl;
  nbok += (mat44.determinant() == 32) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
           << " 32" << std::endl;
  trace.endBlock();
 
 
  return nbok == nb;
}

References DGtal::Trace::beginBlock(), DGtal::Trace::endBlock(), DGtal::Trace::info(), DGtal::SimpleMatrix< TComponent, TM, TN >::setComponent(), testDetCofactor(), and DGtal::trace.

Referenced by main(), and testDetCofactor().

testInverse()

bool testInverse

(

)

Definition at line 306 of file testSimpleMatrix.cpp.

{
  unsigned int nbok = 0;
  unsigned int nb = 0;
 
  trace.beginBlock("Inverse tests 2X2...");
 
  typedef DGtal::SimpleMatrix<double,2,2> MAT2;
  MAT2 mat2;
  mat2.setComponent(0,0,1);
  mat2.setComponent(1,1,2);
 
  MAT2 Id2;
  Id2.identity();
 
  trace.info() << mat2<<std::endl;
  trace.info() << mat2.inverse() << std::endl;
  nbok += (( mat2 * mat2.inverse() )== Id2 ) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
           << " M*M^-1=Id" << std::endl;
 
  trace.endBlock();
 
  trace.beginBlock("Inverse tests 6x6 random...");
 
  typedef DGtal::SimpleMatrix<double,6,6> MAT6;
  MAT6 mat;
 
  for(unsigned int i=0; i< 6; i++)
    for(unsigned int j=0; j< 6; j++)
      mat.setComponent(i,j, rand() % 10);
 
  MAT6 Id6;
  Id6.identity();
 
  trace.info() << "M= "<<mat<<std::endl;
  trace.info() << "M^-1=" <<mat.inverse() << std::endl;
  trace.info() << "det(M)= "<<mat.determinant() <<std::endl;
  trace.info() << "M*M^-1= "<<mat.inverse()*mat << std::endl;
 
 
 
  trace.endBlock();
 
 
  return nbok == nb;
}

References DGtal::Trace::beginBlock(), DGtal::Trace::endBlock(), DGtal::Trace::info(), DGtal::SimpleMatrix< TComponent, TM, TN >::setComponent(), testInverse(), and DGtal::trace.

Referenced by main(), and testInverse().

testLLL()

bool testLLL

(

)

Definition at line 497 of file testSimpleMatrix.cpp.

{
  unsigned int nbok = 0;
  unsigned int nb   = 0;
 
  typedef int64_t     Integer;
  trace.beginBlock( "Test LLL-reduction on matrices." );
  {
    std::vector< std::vector< Integer > > B = {
      {73,-127,63},
      {99,-12,-14},
      {17,-26,14}
    };
    auto L1 = DGtal::functions::computeLLLBasis( B, 0.75 );
    auto L2 = DGtal::functions::computeLLLBasis( B, 0.99 );
    std::cout << "Init base: \n" << B
              << "\nLLL base: delta=0.75\n" << L1 << "\n"
              << "\nLLL base: delta=0.99\n" << L2 << "\n";
 
    std::vector< std::vector< Integer > > R = { {-12,3,-7}, {32,-17,-49}, {-7,-20,0} };
    nbok += L1 == R ? 1 : 0;
    nb++;
    nbok += L2 == R ? 1 : 0;
    nb++;
    std::cout << "(" << nbok << "/" << nb << ") " << (nbok == nb ? "PASSED\n" : "ERROR\n");
  }
  {
    std::vector< std::vector< Integer > > B = {
      {118, 113,  90,  78},
      {187, 229,  12, 109},
      { 26, 163, 223,  21}
    };
    auto L1 = DGtal::functions::computeLLLBasis( B, 0.75 );
    auto L2 = DGtal::functions::computeLLLBasis( B, 0.99 );
    std::cout << "Init base: \n" << B
              << "\nLLL base: delta=0.75\n" << L1 << "\n"
              << "\nLLL base: delta=0.99\n" << L2 << "\n";
 
    std::vector< std::vector< Integer > > R1 = {
      { 69, 116, -78,  31},
      {-23, 166,  55, -26},
      { 49,  -3, 168,  47}
    };
    std::vector< std::vector< Integer > > R2 = {
      { 69, 116, -78,  31},
      {-23, 166,  55, -26},
      { 49,  -3, 168,  47}
    };
    nbok += L1 == R1 ? 1 : 0;
    nb++;
    nbok += L2 == R2 ? 1 : 0;
    nb++;
    std::cout << "(" << nbok << "/" << nb << ") " << (nbok == nb ? "PASSED\n" : "ERROR\n");
  }
  {
    std::vector< std::vector< Integer > > B = {
      {16,16,11,13,31,25,21, 9},
      {31, 3, 2,18,11,31,30, 2},
      { 4,25,11,18, 8,20,13,10},
      {16,21, 9, 2,10,23, 7,27},
      {28,12,26, 1, 2,18, 4,19}
    };
    auto L1 = DGtal::functions::computeLLLBasis( B, 0.75 );
    auto L2 = DGtal::functions::computeLLLBasis( B, 0.99 );
    std::cout << "Init base: \n" << B
              << "\nLLL base: delta=0.75\n" << L1 << "\n"
              << "\nLLL base: delta=0.99\n" << L2 << "\n";
 
    std::vector< std::vector< Integer > > R1 = {
      { 15,-13, -9,  5,-20,  6,  9, -7},
      {-12,  9,  0,  5,-23, -5, -8,  1},
      { 12, -4, -2,-16,  2,  3, -6, 17},
      { 12, -9, 17, -1, -8, -5, -3, -8},
      {  4, 25, 11, 18,  8, 20, 13, 10}
    };
    std::vector< std::vector< Integer > > R2 = {
      { 12, -9, 17, -1, -8, -5, -3, -8},
      { 12, -4, -2,-16,  2,  3, -6, 17},
      {-12,  9,  0,  5,-23, -5, -8,  1},
      { 15,-13, -9,  5,-20,  6,  9, -7},
      {  4, 25, 11, 18,  8, 20, 13, 10}
    };
    nbok += L1 == R1 ? 1 : 0;
    nb++;
    nbok += L2 == R2 ? 1 : 0;
    nb++;
    std::cout << "(" << nbok << "/" << nb << ") " << (nbok == nb ? "PASSED\n" : "ERROR\n");
  }
  {
    // when the matrix is unimodular, outputs canonic vectors.
    std::vector< std::vector< Integer > > B = {
      {   -3,   10,   47,   61,  -53, -126,  713,  601,-1476, 1569},
      {    2,   -7,  -33,  -43,   37,   89, -502, -425, 1047,-1103},
      {   -3,   11,   53,   69,  -59, -142,  800,  677,-1663, 1764},
      {    1,   -9,  -48,  -63,   52,  130, -727, -623, 1543,-1604},
      {   -2,    9,   48,   63,  -49, -124,  680,  583,-1409, 1533},
      {    5,  -25, -118, -163,  113,  334,-1761,-1595, 4030,-3838},
      {   -3,   17,   85,  118,  -84, -245, 1297, 1173,-2974, 2824},
      {    5,  -24, -119, -156,  126,  321,-1782,-1534, 3799,-3921},
      {    2,  -10,  -44,  -65,   42,  137, -699, -659, 1713,-1489},
      {    1,   -5,  -23,  -27,   33,   64, -405, -315,  784, -868}
    };
    auto L2 = DGtal::functions::computeLLLBasis( B, 0.99 );
    Integer d, d2;
    DGtal::functions::getDeterminantBareiss( d,  B );
    DGtal::functions::getDeterminantBareiss( d2, L2 );
    std::cout << "Init base: \n" << B
              << "\nLLL base: delta=0.99\n" << L2 << "\n"
              << "det(B)=" << d << " det(L)=" << d2 << "\n";
    nbok += d  == 1 ? 1 : 0;
    nb++;
    nbok += d2 == 1 ? 1 : 0;
    nb++;
    std::cout << "(" << nbok << "/" << nb << ") "
              << "When input matrix is unimodular, output matrix L is unimodular: "
              << (nbok == nb ? "PASSED\n" : "ERROR\n");
    for ( auto i = 0; i < B.size(); i++ )
      {
        nbok += DGtal::functions::normL1( L2[ i ] ) == 1 ? 1 : 0;
        nb++;
      }
    std::cout << "(" << nbok << "/" << nb << ") "
              << "The output matrix is then canonic: "
              << (nbok == nb ? "PASSED\n" : "ERROR\n");
    trace.beginBlock( "Shorten B" );
    auto nbs = functions::shortenBasis( B );
    std::cout << "Shorten base: \n" << B << "#nb shortening=" << nbs << "\n";
    trace.endBlock();
  }
  trace.endBlock();
  return nbok == nb;
}

References DGtal::Trace::beginBlock(), DGtal::functions::computeLLLBasis(), DGtal::Trace::endBlock(), DGtal::functions::getDeterminantBareiss(), DGtal::functions::normL1(), DGtal::R1, DGtal::functions::shortenBasis(), testLLL(), and DGtal::trace.

Referenced by main(), and testLLL().

testM1Matrix()

bool testM1Matrix

(

)

Definition at line 297 of file testSimpleMatrix.cpp.

{
  trace.beginBlock("Mx1 matrix test");
  SimpleMatrix<double, 3,1> mat;
  trace.info() << mat<<std::endl;
  trace.endBlock();
  return true;
}

References DGtal::Trace::beginBlock(), DGtal::Trace::endBlock(), DGtal::Trace::info(), testM1Matrix(), and DGtal::trace.

Referenced by main(), and testM1Matrix().

testOrthogonalLattice()

bool testOrthogonalLattice

(

)

Definition at line 630 of file testSimpleMatrix.cpp.

{
  unsigned int nbok = 0;
  unsigned int nb   = 0;
 
  typedef int64_t     Integer;
  trace.beginBlock( "Test orthogonal lattice computation." );
  for ( auto i = 0; i < 10000; i++ )
    {
      vector<int64_t> n = { rand() % 30 - 15, rand() % 30 - 15, rand() % 30 - 15 };
 
      auto g = functions::makePrimitive( n );
      if ( g==0 ) continue;
      vector<int64_t> no = n;
      functions::negate( no );
      auto L = DGtal::functions::computeOrthogonalLattice( n );
      functions::shortenBasis( L );
      Integer l0 = functions::dotProduct( L[ 0 ], n ); // vectors are orthogonal
      Integer l1 = functions::dotProduct( L[ 1 ], n );
      auto     c = functions::crossProduct( L[ 0 ], L[ 1 ] ); // u x v = n
      nbok += l0 == 0 ? 1 : 0;
      nbok += l1 == 0 ? 1 : 0;
      nbok += ( functions::equals( c, n )  || functions::equals( c, no ) ) ? 1 : 0;
      nb   += 3;
      if ( nbok != nb )
        {
          std::cout << "----------- " << nbok << "/" << nb << " ----------------\n";
          std::cout << "Error for vector n=" << n;
          std::cout << "u.n=" << l0 << " v.n=" << l1 << " uxv=" << c << "\n";
          std::cout << "u=" << L[0] << "v=" << L[1];
          std::cout << "u.n=" << l0 << " v.n=" << l1 << " uxv=" << c << "\n";
          std::cout << "------------------------------------\n";
          break;
        }
    }
  trace.info() << "(" << nbok << "/" << nb << ") "
               << "Orthogonal lattice in 3D: "
               << (nbok == nb ? "PASSED\n" : "ERROR\n");
  for ( auto i = 0; i < 10000; i++ )
    {
      vector<int64_t> n = { rand() % 30 - 15, rand() % 30 - 15,
                            rand() % 30 - 15, rand() % 30 - 15 };
      auto g = functions::makePrimitive( n );
      if ( g==0 ) continue;
      vector<int64_t> no = n;
      functions::negate( no );
      auto L = DGtal::functions::computeOrthogonalLattice( n );
      functions::shortenBasis( L );
      Integer l0 = functions::dotProduct( L[ 0 ], n );
      Integer l1 = functions::dotProduct( L[ 1 ], n );
      Integer l2 = functions::dotProduct( L[ 2 ], n );
      Integer n0 = functions::dotProduct( L[ 0 ], L[ 0 ] );
      Integer n1 = functions::dotProduct( L[ 1 ], L[ 1 ] );
      Integer n2 = functions::dotProduct( L[ 2 ], L[ 2 ] );
      nbok += l0 == 0 ? 1 : 0; // vectors are orthogonal
      nbok += l1 == 0 ? 1 : 0;
      nbok += l2 == 0 ? 1 : 0;
      nbok += n0 > 0 ? 1 : 0;  // vectors are non null
      nbok += n1 > 0 ? 1 : 0;
      nbok += n2 > 0 ? 1 : 0;
      nb   += 6;
      if ( nbok != nb )
        {
          std::cout << "----------- " << nbok << "/" << nb << " ----------------\n";
          std::cout << "Error for vector n=" << n;
          std::cout << "u=" << L[0] << "v=" << L[1] << "w=" << L[2];
          std::cout << "u.n=" << l0 << " v.n=" << l1 << " w.n=" << l2 << "\n";
          std::cout << "u.u=" << n0 << " v.v=" << n1 << " w.w=" << n2 << "\n";
          std::cout << "------------------------------------\n";
          break;
        }
    }
  trace.info() << "(" << nbok << "/" << nb << ") "
               << "Orthogonal lattice in 4D: "
               << (nbok == nb ? "PASSED\n" : "ERROR\n");
  trace.endBlock();
  return nbok == nb;
}

References DGtal::Trace::beginBlock(), DGtal::functions::computeOrthogonalLattice(), DGtal::functions::crossProduct(), DGtal::functions::dotProduct(), DGtal::Trace::endBlock(), DGtal::functions::equals(), g(), DGtal::Trace::info(), DGtal::L, DGtal::functions::makePrimitive(), DGtal::functions::negate(), DGtal::functions::shortenBasis(), testOrthogonalLattice(), and DGtal::trace.

Referenced by main(), and testOrthogonalLattice().

testSimpleMatrix()

bool testSimpleMatrix

(

)

Example of a test. To be completed.

Definition at line 53 of file testSimpleMatrix.cpp.

{
  unsigned int nbok = 0;
  unsigned int nb = 0;
 
  trace.beginBlock ( "Testing create ..." );
 
  typedef SimpleMatrix<double,3,4> M34d;
 
  M34d m34d;
  trace.info() << m34d<<std::endl;
 
  m34d.setComponent(1,2, 0.5);
  trace.info() << m34d<<std::endl;
 
  nbok += (m34d(1,2) == 0.5) ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
         << "true == true" << std::endl;
 
  M34d matrix;
  bool res=true;
 
  matrix.constant(12.3);
  trace.info() << matrix;
  for(DGtal::Dimension i = 0; i< 3; ++i)
    for(DGtal::Dimension j = 0; j< 4; ++j)
        res = res && (matrix(i,j) == 12.3);
  nbok += res ? 1 : 0;
  nb++;
  trace.info() << "(" << nbok << "/" << nb << ") "
         << "all equals to 12.3" << std::endl;
 
 
  trace.endBlock();
 
  return nbok == nb;
}

References DGtal::Trace::beginBlock(), DGtal::Trace::endBlock(), DGtal::Trace::info(), testSimpleMatrix(), and DGtal::trace.

Referenced by main(), and testSimpleMatrix().