benchGeometry.cpp File Reference

#include <iostream>
#include <iomanip>
#include <Eigen/Core>
#include <Eigen/Geometry>
#include <bench/BenchTimer.h>

Classes
struct	func< res, arg1, arg2, TV >
struct	func< res, arg1, arg2, TMATV >
struct	func< res, arg1, arg2, TMATVMAT >
struct	test_transform< func, arg1, arg2 >

Macros
#define	REPEAT   1000000
#define	run_vec(op, scalar, mode, option, vsize)
#define	run_trans(op, scalar, mode, option)

Enumerations
enum	func_opt { TV , TMATV , TMATVMAT }

Functions
int	main (int argc, char *argv[])

Macro Definition Documentation

REPEAT

#define REPEAT   1000000

run_trans

#define run_trans	(		op,
			scalar,
			mode,
			option
	)

Value:

  std::cout << #scalar << "\t " << #mode << "\t " << #option << "   "; \
  {                                                                    \
    typedef Transform<scalar, 3, mode, option> Trans;                  \
    typedef func<Trans, Trans, Trans, op> Func;                        \
    test_transform<Func, Trans, Trans>::run();                         \
  }

run_vec

#define run_vec	(		op,
			scalar,
			mode,
			option,
			vsize
	)

Value:

  std::cout << #scalar << "\t " << #mode << "\t " << #option << " " << #vsize " "; \
  {                                                                                \
    typedef Transform<scalar, 3, mode, option> Trans;                              \
    typedef Matrix<scalar, vsize, 1, option> Vec;                                  \
    typedef func<Vec, Trans, Vec, op> Func;                                        \
    test_transform<Func, Trans, Vec>::run();                                       \
  }

Enumeration Type Documentation

func_opt

enum func_opt

Enumerator
TV
TMATV
TMATVMAT

              {
  TV,
  TMATV,
  TMATVMAT,
};

Function Documentation

main()

int main	(	int argc	,
		char *	argv[]
	)

                                 {
  cout << "vec = trans * vec" << endl;
  run_vec(TV, float, Isometry, AutoAlign, 3);
  run_vec(TV, float, Isometry, DontAlign, 3);
  run_vec(TV, float, Isometry, AutoAlign, 4);
  run_vec(TV, float, Isometry, DontAlign, 4);
  run_vec(TV, float, Projective, AutoAlign, 4);
  run_vec(TV, float, Projective, DontAlign, 4);
  run_vec(TV, double, Isometry, AutoAlign, 3);
  run_vec(TV, double, Isometry, DontAlign, 3);
  run_vec(TV, double, Isometry, AutoAlign, 4);
  run_vec(TV, double, Isometry, DontAlign, 4);
  run_vec(TV, double, Projective, AutoAlign, 4);
  run_vec(TV, double, Projective, DontAlign, 4);
 
  cout << "vec = trans.matrix() * vec" << endl;
  run_vec(TMATV, float, Isometry, AutoAlign, 4);
  run_vec(TMATV, float, Isometry, DontAlign, 4);
  run_vec(TMATV, double, Isometry, AutoAlign, 4);
  run_vec(TMATV, double, Isometry, DontAlign, 4);
 
  cout << "trans = trans1 * trans" << endl;
  run_trans(TV, float, Isometry, AutoAlign);
  run_trans(TV, float, Isometry, DontAlign);
  run_trans(TV, double, Isometry, AutoAlign);
  run_trans(TV, double, Isometry, DontAlign);
  run_trans(TV, float, Projective, AutoAlign);
  run_trans(TV, float, Projective, DontAlign);
  run_trans(TV, double, Projective, AutoAlign);
  run_trans(TV, double, Projective, DontAlign);
 
  cout << "trans = trans1.matrix() * trans.matrix()" << endl;
  run_trans(TMATVMAT, float, Isometry, AutoAlign);
  run_trans(TMATVMAT, float, Isometry, DontAlign);
  run_trans(TMATVMAT, double, Isometry, AutoAlign);
  run_trans(TMATVMAT, double, Isometry, DontAlign);
}

References Eigen::AutoAlign, Eigen::DontAlign, Eigen::Isometry, Eigen::Projective, run_trans, run_vec, TMATV, TMATVMAT, and TV.