PhysicsOperation.hpp

Go to the documentation of this file.

// ----------------- BEGIN LICENSE BLOCK ---------------------------------
//
// Copyright (C) 2018-2021 Intel Corporation
//
// SPDX-License-Identifier: MIT
//
// ----------------- END LICENSE BLOCK -----------------------------------
 
#pragma once
 
#include "ad/physics/Types.hpp"
 
inline ad::physics::Speed operator*(ad::physics::Acceleration const &a, ad::physics::Duration const &t)
{
  a.ensureValid();
  t.ensureValid();
  ad::physics::Speed const v(static_cast<double>(a) * static_cast<double>(t));
  v.ensureValid();
  return v;
}
 
inline ad::physics::Distance operator*(ad::physics::Acceleration const &a, ad::physics::DurationSquared const &t2)
{
  a.ensureValid();
  t2.ensureValid();
  ad::physics::Distance const s(static_cast<double>(a) * static_cast<double>(t2));
  s.ensureValid();
  return s;
}
 
inline ad::physics::SpeedSquared operator*(ad::physics::Acceleration const &a, ad::physics::Distance const &s)
{
  a.ensureValid();
  s.ensureValid();
  ad::physics::SpeedSquared const v2(static_cast<double>(a) * static_cast<double>(s));
  v2.ensureValid();
  return v2;
}
 
inline ad::physics::Speed operator*(ad::physics::Duration const &t, ad::physics::Acceleration const &a)
{
  return operator*(a, t);
}
 
inline ad::physics::Distance operator*(ad::physics::Speed const &v, ad::physics::Duration const &t)
{
  v.ensureValid();
  t.ensureValid();
  ad::physics::Distance const s(static_cast<double>(v) * static_cast<double>(t));
  s.ensureValid();
  return s;
}
 
inline ad::physics::Distance operator*(ad::physics::Duration const &t, ad::physics::Speed const &v)
{
  return operator*(v, t);
}
 
inline ad::physics::Duration operator/(ad::physics::Distance const &s, ad::physics::Speed const &v)
{
  s.ensureValid();
  v.ensureValidNonZero();
  ad::physics::Duration const t(static_cast<double>(s) / static_cast<double>(v));
  t.ensureValid();
  return t;
}
 
inline ad::physics::Duration operator/(ad::physics::Speed const &v, ad::physics::Acceleration const &a)
{
  v.ensureValid();
  a.ensureValidNonZero();
  ad::physics::Duration const t(static_cast<double>(v) / static_cast<double>(a));
  t.ensureValid();
  return t;
}
 
inline ad::physics::Acceleration operator/(ad::physics::Speed const &v, ad::physics::Duration const &t)
{
  v.ensureValid();
  t.ensureValidNonZero();
  ad::physics::Acceleration const a(static_cast<double>(v) / static_cast<double>(t));
  a.ensureValid();
  return a;
}
 
inline ad::physics::Distance operator/(ad::physics::SpeedSquared const &v2, ad::physics::Acceleration const &a)
{
  v2.ensureValid();
  a.ensureValidNonZero();
  ad::physics::Distance const t(static_cast<double>(v2) / static_cast<double>(a));
  t.ensureValid();
  return t;
}
 
inline ad::physics::DurationSquared operator/(ad::physics::Distance const &s, ad::physics::Acceleration const &a)
{
  s.ensureValid();
  a.ensureValidNonZero();
  ad::physics::DurationSquared const t2(static_cast<double>(s) / static_cast<double>(a));
  t2.ensureValid();
  return t2;
}