Vector3.h

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2026 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Vector3.h                                                   (C) 2000-2026 */
/*                                                                           */
/* Vector in 3 dimensions.                                                   */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_VECTOR3_H
#define ARCANE_UTILS_VECTOR3_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/UtilsTypes.h"
 
#include <iostream>
#include <array>
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/

template <typename T>
class Vector3
{
 public:
 
  using ThatClass = Vector3<T>;
  using value_type = T;
 
 public:
 
  T x = {};
  T y = {};
  T z = {};
 
 public:

  constexpr ARCCORE_HOST_DEVICE
  Vector3() = default;

  constexpr ARCCORE_HOST_DEVICE Vector3(const T& ax, const T& ay, const T& az)
  : x(ax)
  , y(ay)
  , z(az)
  {
  }

  constexpr ARCCORE_HOST_DEVICE explicit Vector3(const T& v)
  : x(v)
  , y(v)
  , z(v)
  {
  }

  constexpr explicit Vector3(const std::array<T, 3>& v)
  : x(v[0])
  , y(v[1])
  , z(v[2])
  {
  }

  constexpr Vector3(std::initializer_list<T> v)
  {
    _setFromList(v);
  }

  constexpr Vector3& operator=(std::initializer_list<T> v)
  {
    _setFromList(v);
    return (*this);
  }
 
 public:
 
  friend constexpr ARCCORE_HOST_DEVICE bool
  operator<(const Vector3<T>& v1, const Vector3<T>& v2)
  {
    if (v1.x == v2.x) {
      if (v1.y == v2.y)
        return v1.z < v2.z;
      else
        return v1.y < v2.y;
    }
    return (v1.x < v2.x);
  }

  friend std::ostream& operator<<(std::ostream& o, const Vector3<T>& t)
  {
    t._print(o);
    return o;
  }
 
  friend constexpr ARCCORE_HOST_DEVICE bool
  operator==(const Vector3<T>& v1, const Vector3<T>& v2)
  {
    return v1.x == v2.x && v1.y == v2.y && v1.z == v2.z;
  }
 
  friend constexpr ARCCORE_HOST_DEVICE bool
  operator!=(const Vector3<T>& v1, const Vector3<T>& v2)
  {
    return !(v1 == v2);
  }
 
 public:

  constexpr ARCCORE_HOST_DEVICE void operator+=(const T& b)
  {
    x += b;
    y += b;
    z += b;
  }

  constexpr ARCCORE_HOST_DEVICE void operator+=(const ThatClass& b)
  {
    x += b.x;
    y += b.y;
    z += b.z;
  }

  constexpr ARCCORE_HOST_DEVICE void operator-=(const T& b)
  {
    x -= b;
    y -= b;
    z -= b;
  }

  constexpr ARCCORE_HOST_DEVICE void operator-=(const ThatClass& b)
  {
    x -= b.x;
    y -= b.y;
    z -= b.z;
  }

  constexpr ARCCORE_HOST_DEVICE void operator*=(const T& b)
  {
    x *= b;
    y *= b;
    z *= b;
  }

  constexpr ARCCORE_HOST_DEVICE void operator/=(const T& b)
  {
    x /= b;
    y /= b;
    z /= b;
  }

  friend constexpr ARCCORE_HOST_DEVICE ThatClass operator+(const ThatClass& a, const ThatClass& b)
  {
    return ThatClass(a.x + b.x, a.y + b.y, a.z + b.z);
  }

  friend constexpr ARCCORE_HOST_DEVICE ThatClass operator+(const ThatClass& a, const T& b)
  {
    return ThatClass(a.x + b, a.y + b, a.z + b);
  }

  friend constexpr ARCCORE_HOST_DEVICE ThatClass operator+(const T& a, const ThatClass& b)
  {
    return ThatClass(a + b.x, a + b.y, a + b.z);
  }

  friend constexpr ARCCORE_HOST_DEVICE ThatClass operator-(const ThatClass& a, const ThatClass& b)
  {
    return ThatClass(a.x - b.x, a.y - b.y, a.z - b.z);
  }

  friend constexpr ARCCORE_HOST_DEVICE ThatClass operator-(const ThatClass& a, const T& b)
  {
    return ThatClass(a.x - b, a.y - b, a.z - b);
  }

  constexpr ARCCORE_HOST_DEVICE ThatClass operator-() const { return ThatClass(-x, -y, -z); }
 

  friend constexpr ARCCORE_HOST_DEVICE ThatClass operator*(const T& a, const ThatClass& b)
  {
    return ThatClass(b.x * a, b.y * a, b.z * a);
  }

  friend constexpr ARCCORE_HOST_DEVICE ThatClass operator*(const ThatClass& a, const T& b)
  {
    return ThatClass(a.x * b, a.y * b, a.z * b);
  }

  friend constexpr ARCCORE_HOST_DEVICE ThatClass operator/(const ThatClass& a, const T& b)
  {
    return ThatClass(a.x / b, a.y / b, a.z / b);
  }
 
 private:
 
  void _print(std::ostream& o) const
  {
    o << '{' << x << ',' << y << ',' << z << '}';
  }
  constexpr void _setFromList(std::initializer_list<T> v)
  {
    auto s = v.size();
    auto ptr = v.begin();
    if (s > 0)
      x = *ptr;
    ++ptr;
    if (s > 1)
      y = *ptr;
    ++ptr;
    if (s > 2)
      z = *ptr;
  }
};
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif