CepsVertex.cpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   CEPS 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 CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#include "common/math/CepsVertex.hpp"
#include "common/core/CepsIoMacros.hpp"
#include "common/core/Precision.hpp"
 
CepsVertex::
CepsVertex (const CepsReal &x, const CepsReal &y, const CepsReal &z) :
    m_coor ({x, y, z})
{}
 
CepsVertex::
CepsVertex (const CepsReal3D &coor) :
    m_coor (coor)
{}
 
CepsVertex::
operator CepsMathVertex () const
{
  return CepsMathVertex (x (), y (), z ());
}
 
// Coordinates
void CepsVertex::
setX (const CepsReal &x)
{
  m_coor[0] = x;
  return;
}
 
void CepsVertex::
setY (const CepsReal &y)
{
  m_coor[1] = y;
  return;
}
 
void CepsVertex::
setZ (const CepsReal &z)
{
  m_coor[2] = z;
  return;
}
 
void CepsVertex::
setCoordinate (const CepsUInt& dim, const CepsReal &coor)
{
  #ifdef CEPS_DEBUG_ENABLED
    CEPS_ABORT_IF(dim>2, "Cannot set vertex coordinate in dimension " << dim);
  #endif
  m_coor[dim] = coor;
  return;
}
 
void CepsVertex::
setCoordinates (const CepsReal &x, const CepsReal &y, const CepsReal &z)
{
  m_coor = {x, y, z};
  return;
}
 
void CepsVertex::
setCoordinates (const CepsReal3D &coors)
{
  m_coor = coors;
  return;
}
 
void CepsVertex::
setCoordinates (const CepsReal *coors, const CepsUInt &n)
{
  for (CepsUInt dim = 0; dim < 3U; ++dim)
    if (n > dim)
      m_coor[dim] = coors[dim];
 
  return;
}
 
void CepsVertex::
scale (const CepsReal &scaleFactor)
{
  #ifdef CEPS_DEBUG_ENABLED
    CEPS_WARNS_IF (
      std::fabs (scaleFactor) < FLOATING_POINT_EPSILON,
      "Scaling vertex coordinates by very small factor : " << scaleFactor
    );
  #endif
  m_coor[0] *= scaleFactor;
  m_coor[1] *= scaleFactor;
  m_coor[2] *= scaleFactor;
  return;
}
 
const CepsReal & CepsVertex::
x () const
{
  return m_coor[0];
}
 
const CepsReal & CepsVertex::
y () const
{
  return m_coor[1];
}
 
const CepsReal & CepsVertex::
z () const
{
  return m_coor[2];
}
 
CepsReal& CepsVertex::
getCoordinate (const CepsSize &dim)
{
  #ifdef CEPS_DEBUG_ENABLED
    CEPS_ABORT_IF (dim>2, "Invalid coordinate index: " << dim);
  #endif
  return m_coor[dim];
}
 
const CepsReal& CepsVertex::
getCoordinate (const CepsSize &dim) const
{
  #ifdef CEPS_DEBUG_ENABLED
    CEPS_ABORT_IF (dim>2, "Invalid coordinate index: " << dim);
  #endif
  return m_coor[dim];
}
 
CepsReal& CepsVertex::
operator[] (const CepsUInt& dim)
{
  return getCoordinate(dim);
}
 
const CepsReal& CepsVertex::
operator[] (const CepsUInt& dim) const
{
  return getCoordinate(dim);
}
 
CepsReal3D & CepsVertex::
getCoordinates ()
{
  return m_coor;
}
 
const CepsReal3D & CepsVertex::
getCoordinates () const
{
  return m_coor;
}
 
CepsMathVertex CepsVertex::
getCoordinatesForEigen () const
{
  return static_cast<const CepsMathVertex &> (*this);  // call operator CepsMathVertices
}
 
CepsBool CepsVertex::
equals (const CepsVertex &vertex, const CepsReal &errorFactor)
{
  return (
    ceps::approxEquals (m_coor[0], vertex.x (), errorFactor) and
    ceps::approxEquals (m_coor[1], vertex.y (), errorFactor) and
    ceps::approxEquals (m_coor[2], vertex.z (), errorFactor)
  );
}
 
CepsReal CepsVertex::
norm2 (const CepsSize &dim) const
{
  const CepsReal &_x = x ();
  const CepsReal &_y = y ();
  const CepsReal &_z = z ();
 
  switch (dim)
  {
    case 1U: return abs (_x);
    case 2U: return std::sqrt (_x * _x + _y * _y);
    case 3U: return sqrt (_x * _x + _y * _y + _z * _z);
  }
  return 0.0;
}
 
CepsReal CepsVertex::
normp (const CepsInt &p, const CepsSize &dim) const
{
  if (dim == 0)
    return 0.;
 
  if (p < 0)
  {
    CepsReal val = std::abs (m_coor[0]);
    for (CepsUInt i = 1; i < dim; ++i)
      val = (std::abs (m_coor[i]) > val ? std::abs (m_coor[i]) : val);
 
    return val;
  }
 
  CepsReal val = 0.0;
  for (CepsUInt i = 0; i < dim; ++i) {
    val += std::pow (std::abs(m_coor[i]), p);
  }
  return std::pow (val, 1.0 / p);
}
 
CepsReal CepsVertex::
dot (const CepsVertex &other, const CepsSize &dim) const
{
  switch (dim)
  {
    case 1U: return x () * other.x ();
    case 2U: return x () * other.x () + y () * other.y ();
    case 3U: return x () * other.x () + y () * other.y () + z () * other.z ();
  }
  return 0.0;
}
 
// Display vertex
 
std::ostream & 
operator<< (std::ostream &os, const CepsVertex &vertex)
{
  os << "(" << std::setprecision (CEPS_IO_DECIMAL_PRECISION) << vertex.x () << ", " << vertex.y () << ", "
     << vertex.z () << ")";
  return os;
}
 
CepsReal
dotProduct (const CepsVertex &a, const CepsVertex &b, const CepsSize &dim)
{
  switch (dim)
  {
    case 1U: return a.x () * b.x ();
    case 2U: return a.x () * b.x () + a.y () * b.y ();
    case 3U: return a.x () * b.x () + a.y () * b.y () + a.z () * b.z ();
  }
  return 0.0;
}