Astro.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
 * Copyright (c) 2025, Davide Stocco and Enrico Bertolazzi.                                      *
 *                                                                                               *
 * The Astro project is distributed under the GNU GPLv3.                                         *
 *                                                                                               *
 * Davide Stocco                                                               Enrico Bertolazzi *
 * University of Trento                                                     University of Trento *
 * e-mail: davide.stocco@unitn.it                             e-mail: enrico.bertolazzi@unitn.it *
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#pragma once
 
#ifndef INCLUDE_ASTRO_HH
#define INCLUDE_ASTRO_HH
 
// C++ standard libraries
#include <iostream>
#include <tuple>
#include <string>
#include <cmath>
 
// Eigen library
#include <Eigen/Dense>
 
// Sandals library
#ifdef ASTRO_ENABLE_SANDALS
  #include <Sandals/Sandals.hh>
#endif
 
// Print Astro errors
#ifndef ASTRO_ERROR
#define ASTRO_ERROR(MSG)                \
  {                                     \
    std::ostringstream os;              \
    os << MSG;                          \
    throw std::runtime_error(os.str()); \
  }
#endif
 
 
// Assert for Astro
#ifndef ASTRO_ASSERT
#define ASTRO_ASSERT(COND, MSG) \
  if (!(COND))                  \
  {                             \
    SANDALS_ERROR(MSG);         \
  }
#endif
 
// Warning for Astro
#ifndef ASTRO_WARNING
#define ASTRO_WARNING(MSG)         \
  {                                \
    std::cout << MSG << std::endl; \
  }
#endif
 
// Warning assert for Astro
#ifndef ASTRO_ASSERT_WARNING
#define ASTRO_ASSERT_WARNING(COND, MSG) \
  if (!(COND))                          \
  {                                     \
    ASTRO_WARNING(MSG);                 \
  }
#endif

namespace Astro
{
 
  /*\
   |      _    _ _
   |     / \  | (_) __ _ ___  ___  ___
   |    / _ \ | | |/ _` / __|/ _ \/ __|
   |   / ___ \| | | (_| \__ \  __/\__ \
   |  /_/   \_\_|_|\__,_|___/\___||___/
   |
  \*/
 
  using Real = double; 
  using Size = int;    
 
  using Vector0 = Eigen::Vector<Real, 0>;    
  using Matrix0 = Eigen::Matrix<Real, 0, 0>; 
  using Vector1 = Eigen::Vector<Real, 1>;    
  using Matrix1 = Eigen::Matrix<Real, 1, 1>; 
  using Vector2 = Eigen::Vector<Real, 2>;    
  using Matrix2 = Eigen::Matrix<Real, 2, 2>; 
  using Vector3 = Eigen::Vector<Real, 3>;    
  using Matrix3 = Eigen::Matrix<Real, 3, 3>; 
  using Vector4 = Eigen::Vector<Real, 4>;    
  using Matrix4 = Eigen::Matrix<Real, 4, 4>; 
  using Vector5 = Eigen::Vector<Real, 5>;    
  using Matrix5 = Eigen::Matrix<Real, 5, 5>; 
  using Vector6 = Eigen::Vector<Real, 6>;    
  using Matrix6 = Eigen::Matrix<Real, 6, 6>; 
  using Vector7 = Eigen::Vector<Real, 7>;    
  using Matrix7 = Eigen::Matrix<Real, 7, 7>; 
  using Vector8 = Eigen::Vector<Real, 8>;    
  using Matrix8 = Eigen::Matrix<Real, 8, 8>; 
  using Vector9 = Eigen::Vector<Real, 9>;    
  using Matrix9 = Eigen::Matrix<Real, 9, 9>; 
 
  using VectorX = Eigen::Vector<Real, Eigen::Dynamic>;                 
  using MatrixX = Eigen::Matrix<Real, Eigen::Dynamic, Eigen::Dynamic>; 
 
  using Scale     = Eigen::DiagonalMatrix<Real, 3>;           
  using Translate = Eigen::Translation<Real, 3>;              
  using AngleAxis = Eigen::AngleAxis<Real>;                   
  using Affine    = Eigen::Transform<Real, 3, Eigen::Affine>; 
 
  /*\
   |    ____                _              _
   |   / ___|___  _ __  ___| |_ __ _ _ __ | |_ ___
   |  | |   / _ \| '_ \/ __| __/ _` | '_ \| __/ __|
   |  | |__| (_) | | | \__ \ || (_| | | | | |_\__ \
   |   \____\___/|_| |_|___/\__\__,_|_| |_|\__|___/
   |
  \*/
 
  static Real const EPSILON        = std::numeric_limits<Real>::epsilon();            
  static Real const SQRT_EPSILON   = std::sqrt(EPSILON);                              
  static Real const CBRT_EPSILON   = std::cbrt(EPSILON);                              
  static Real const EPSILON_HIGH   = Real(1.0e-12);                                   
  static Real const EPSILON_MEDIUM = Real(1.0e-10);                                   
  static Real const EPSILON_LOW    = Real(1.0e-08);                                   
  static Real const INFTY          = std::numeric_limits<Real>::infinity();           
  static Real const QUIET_NAN      = std::numeric_limits<Real>::quiet_NaN();          
  static Real const PI             = Real(3.141592653589793238462643383279502884197); 
  static Real const PIMUL2         = Real(6.283185307179586476925286766559005768394); 
  static Real const PIDIV2         = Real(1.570796326794896619231321691639751442098); 
  static Real const DEG2RAD        = Real(0.017453292519943295769236907684886127134); 
  static Real const RAD2DEG        = Real(57.29577951308232087679815481410517033240); 
 
  static Vector1 const NAN_VEC1      = Vector1::Constant(QUIET_NAN); 
  static Matrix1 const NAN_MAT1      = Matrix1::Constant(QUIET_NAN); 
  static Vector1 const ZEROS_VEC1    = Vector1::Zero();              
  static Matrix1 const ZEROS_MAT1    = Matrix1::Zero();              
  static Vector1 const ONES_VEC1     = Vector1::Ones();              
  static Matrix1 const ONES_MAT1     = Matrix1::Ones();              
  static Matrix1 const IDENTITY_MAT1 = Matrix1::Identity();          
 
  static Vector2 const NAN_VEC2      = Vector2::Constant(QUIET_NAN); 
  static Matrix2 const NAN_MAT2      = Matrix2::Constant(QUIET_NAN); 
  static Vector2 const ZEROS_VEC2    = Vector2::Zero();              
  static Matrix2 const ZEROS_MAT2    = Matrix2::Zero();              
  static Vector2 const ONES_VEC2     = Vector2::Ones();              
  static Matrix2 const ONES_MAT2     = Matrix2::Ones();              
  static Matrix2 const IDENTITY_MAT2 = Matrix2::Identity();          
 
  static Vector3 const NAN_VEC3      = Vector3::Constant(QUIET_NAN); 
  static Matrix3 const NAN_MAT3      = Matrix3::Constant(QUIET_NAN); 
  static Vector3 const ZEROS_VEC3    = Vector3::Zero();              
  static Matrix3 const ZEROS_MAT3    = Matrix3::Zero();              
  static Vector3 const ONES_VEC3     = Vector3::Ones();              
  static Matrix3 const ONES_MAT3     = Matrix3::Ones();              
  static Matrix3 const IDENTITY_MAT3 = Matrix3::Identity();          
 
  static Vector4 const NAN_VEC4      = Vector4::Constant(QUIET_NAN); 
  static Matrix4 const NAN_MAT4      = Matrix4::Constant(QUIET_NAN); 
  static Vector4 const ZEROS_VEC4    = Vector4::Zero();              
  static Matrix4 const ZEROS_MAT4    = Matrix4::Zero();              
  static Vector4 const ONES_VEC4     = Vector4::Ones();              
  static Matrix4 const ONES_MAT4     = Matrix4::Ones();              
  static Matrix4 const IDENTITY_MAT4 = Matrix4::Identity();          
 
  static Vector5 const NAN_VEC5      = Vector5::Constant(QUIET_NAN); 
  static Matrix5 const NAN_MAT5      = Matrix5::Constant(QUIET_NAN); 
  static Vector5 const ZEROS_VEC5    = Vector5::Zero();              
  static Matrix5 const ZEROS_MAT5    = Matrix5::Zero();              
  static Vector5 const ONES_VEC5     = Vector5::Ones();              
  static Matrix5 const ONES_MAT5     = Matrix5::Ones();              
  static Matrix5 const IDENTITY_MAT5 = Matrix5::Identity();          
 
  static Vector6 const NAN_VEC6      = Vector6::Constant(QUIET_NAN); 
  static Matrix6 const NAN_MAT6      = Matrix6::Constant(QUIET_NAN); 
  static Vector6 const ZEROS_VEC6    = Vector6::Zero();              
  static Matrix6 const ZEROS_MAT6    = Matrix6::Zero();              
  static Vector6 const ONES_VEC6     = Vector6::Ones();              
  static Matrix6 const ONES_MAT6     = Matrix6::Ones();              
  static Matrix6 const IDENTITY_MAT6 = Matrix6::Identity();          
 
  static Vector7 const NAN_VEC7      = Vector7::Constant(QUIET_NAN); 
  static Matrix7 const NAN_MAT7      = Matrix7::Constant(QUIET_NAN); 
  static Vector7 const ZEROS_VEC7    = Vector7::Zero();              
  static Matrix7 const ZEROS_MAT7    = Matrix7::Zero();              
  static Vector7 const ONES_VEC7     = Vector7::Ones();              
  static Matrix7 const ONES_MAT7     = Matrix7::Ones();              
  static Matrix7 const IDENTITY_MAT7 = Matrix7::Identity();          
 
  static Vector8 const NAN_VEC8      = Vector8::Constant(QUIET_NAN); 
  static Matrix8 const NAN_MAT8      = Matrix8::Constant(QUIET_NAN); 
  static Vector8 const ZEROS_VEC8    = Vector8::Zero();              
  static Matrix8 const ZEROS_MAT8    = Matrix8::Zero();              
  static Vector8 const ONES_VEC8     = Vector8::Ones();              
  static Matrix8 const ONES_MAT8     = Matrix8::Ones();              
  static Matrix8 const IDENTITY_MAT8 = Matrix8::Identity();          
 
  static Vector9 const NAN_VEC9      = Vector9::Constant(QUIET_NAN); 
  static Matrix9 const NAN_MAT9      = Matrix9::Constant(QUIET_NAN); 
  static Vector9 const ZEROS_VEC9    = Vector9::Zero();              
  static Matrix9 const ZEROS_MAT9    = Matrix9::Zero();              
  static Vector9 const ONES_VEC9     = Vector9::Ones();              
  static Matrix9 const ONES_MAT9     = Matrix9::Ones();              
  static Matrix9 const IDENTITY_MAT9 = Matrix9::Identity();          
 
} // namespace Astro
 
// Utility functions
#include "Astro/Utilities.hxx"
 
#endif // INCLUDE_ASTRO_HH