SimdOperation.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
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* SimdOperation.h                                             (C) 2000-2022 */
/*                                                                           */
/* Operations on Simd types.                                                 */
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_UTILS_SIMDOPERATION_H
#define ARCANE_UTILS_SIMDOPERATION_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/Simd.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#if defined(ARCANE_HAS_AVX512)
#include "arcane/utils/SimdAVX512Generated.h"
#endif
#if defined(ARCANE_HAS_AVX)
#include "arcane/utils/SimdAVXGenerated.h"
#endif
#if defined(ARCANE_HAS_SSE)
#include "arcane/utils/SimdSSEGenerated.h"
#endif
 
#include "arcane/utils/SimdEMULGenerated.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline SimdReal3
operator+(const SimdReal3& a, const SimdReal3& b)
{
  return SimdReal3(a.x + b.x, a.y + b.y, a.z + b.z);
}
 
inline SimdReal3
operator-(const SimdReal3& a)
{
  return SimdReal3(-a.x, -a.y, -a.z);
}
 
inline SimdReal3
operator-(const SimdReal3& a, const SimdReal3& b)
{
  return SimdReal3(a.x - b.x, a.y - b.y, a.z - b.z);
}
 
inline SimdReal3
operator*(const SimdReal3& a, Real b)
{
  return SimdReal3(a.x * b, a.y * b, a.z * b);
}
 
inline SimdReal3
operator*(const SimdReal3& a, const SimdReal& b)
{
  return SimdReal3(a.x * b, a.y * b, a.z * b);
}
 
inline SimdReal3
operator*(Real b, const SimdReal3& a)
{
  return SimdReal3(b * a.x, b * a.y, b * a.z);
}
 
inline SimdReal3
operator*(const SimdReal& b, const SimdReal3& a)
{
  return SimdReal3(b * a.x, b * a.y, b * a.z);
}
 
inline SimdReal3
operator*(const SimdReal3& a, const SimdReal3& b)
{
  return SimdReal3(a.x * b.x, a.y * b.y, a.z * b.z);
}
 
inline SimdReal3
operator/(const SimdReal3& a, const SimdReal& b)
{
  return SimdReal3(a.x / b, a.y / b, a.z / b);
}
 
inline SimdReal3
operator/(const SimdReal3& a, Real b)
{
  return SimdReal3(a.x / b, a.y / b, a.z / b);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline SimdReal2
operator+(const SimdReal2& a, const SimdReal2& b)
{
  return SimdReal2(a.x + b.x, a.y + b.y);
}
 
inline SimdReal2
operator-(const SimdReal2& a, const SimdReal2& b)
{
  return SimdReal2(a.x - b.x, a.y - b.y);
}
 
inline SimdReal2
operator*(const SimdReal2& a, Real b)
{
  return SimdReal2(a.x * b, a.y * b);
}
 
inline SimdReal2
operator*(Real b, const SimdReal2& a)
{
  return SimdReal2(b * a.x, b * a.y);
}
 
inline SimdReal2
operator*(const SimdReal2& a, const SimdReal2& b)
{
  return SimdReal2(a.x * b.x, a.y * b.y);
}
 
inline SimdReal2
operator/(const SimdReal2& a, const SimdReal& b)
{
  return SimdReal2(a.x / b, a.y / b);
}
 
inline SimdReal2
operator/(const SimdReal2& a, Real b)
{
  return SimdReal2(a.x / b, a.y / b);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline SimdReal3x3
operator+(const SimdReal3x3& a, const SimdReal3x3& b)
{
  return SimdReal3x3(a.x + b.x, a.y + b.y, a.z + b.z);
}
 
inline SimdReal3x3
operator-(const SimdReal3x3& a)
{
  return SimdReal3x3(-a.x, -a.y, -a.z);
}
 
inline SimdReal3x3
operator-(const SimdReal3x3& a, const SimdReal3x3& b)
{
  return SimdReal3x3(a.x - b.x, a.y - b.y, a.z - b.z);
}
 
inline SimdReal3x3
operator*(const SimdReal3x3& a, Real b)
{
  return SimdReal3x3(a.x * b, a.y * b, a.z * b);
}
 
inline SimdReal3x3
operator*(const SimdReal3x3& a, const SimdReal& b)
{
  return SimdReal3x3(a.x * b, a.y * b, a.z * b);
}
 
inline SimdReal3x3
operator*(Real b, const SimdReal3x3& a)
{
  return SimdReal3x3(b * a.x, b * a.y, b * a.z);
}
 
inline SimdReal3x3
operator*(const SimdReal& b, const SimdReal3x3& a)
{
  return SimdReal3x3(b * a.x, b * a.y, b * a.z);
}
 
inline SimdReal3x3
operator*(const SimdReal3x3& a, const SimdReal3x3& b)
{
  return SimdReal3x3(a.x * b.x, a.y * b.y, a.z * b.z);
}
 
inline SimdReal3x3
operator/(const SimdReal3x3& a, const SimdReal& b)
{
  return SimdReal3x3(a.x / b, a.y / b, a.z / b);
}
 
inline SimdReal3x3
operator/(const SimdReal3x3& a, Real b)
{
  return SimdReal3x3(a.x / b, a.y / b, a.z / b);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
inline SimdReal2x2
operator+(const SimdReal2x2& a, const SimdReal2x2& b)
{
  return SimdReal2x2(a.x + b.x, a.y + b.y);
}
 
inline SimdReal2x2
operator-(const SimdReal2x2& a, const SimdReal2x2& b)
{
  return SimdReal2x2(a.x - b.x, a.y - b.y);
}
 
inline SimdReal2x2
operator*(const SimdReal2x2& a, Real b)
{
  return SimdReal2x2(a.x * b, a.y * b);
}
 
inline SimdReal2x2
operator*(Real b, const SimdReal2x2& a)
{
  return SimdReal2x2(b * a.x, b * a.y);
}
 
inline SimdReal2x2
operator*(const SimdReal2x2& a, const SimdReal2x2& b)
{
  return SimdReal2x2(a.x * b.x, a.y * b.y);
}
 
inline SimdReal2x2
operator/(const SimdReal2x2& a, const SimdReal& b)
{
  return SimdReal2x2(a.x / b, a.y / b);
}
 
inline SimdReal2x2
operator/(const SimdReal2x2& a, Real b)
{
  return SimdReal2x2(a.x / b, a.y / b);
}
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif