lob.hpp

Go to the documentation of this file.

// Copyright (c) 2025  Joel Benway
// SPDX-License-Identifier: GPL-3.0-or-later
// Please see end of file for extended copyright information
 
#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <type_traits>
 
#include "lob/lob_export.hpp"
 
namespace lob {

LOB_EXPORT const char* Version();

enum class LOB_EXPORT DragFunctionT : uint8_t {
  kG1 = 1U,  
  kG2 = 2U,  
  kG5 = 5U,  
  kG6 = 6U,  
  kG7 = 7U,  
  kG8 = 8U   
};

enum class LOB_EXPORT AtmosphereReferenceT : uint8_t {
  kArmyStandardMetro,  
  kIcao  
};

enum class LOB_EXPORT ClockAngleT : uint8_t {
  kI = 1U,  
  kII,      
  kIII,     
  kIV,      
  kV,       
  kVI,      
  kVII,     
  kVIII,    
  kIX,      
  kX,       
  kXI,      
  kXII      
};  // enum class ClockAngleT
 
enum class LOB_EXPORT ErrorT : uint8_t {
  kNone,
  kAirPressureOOR,
  kAltitudeOfBarometerOOR,
  kAltitudeOfFiringSiteOOR,
  kAltitudeOfThermometerOOR,
  kAzimuthOOR,
  kBallisticCoefficientOOR,
  kBallisticCoefficientRequired,
  kBaseDiameterOOR,
  kDiameterOOR,
  kHumidityOOR,
  kInitialVelocityRequired,
  kInternalError,
  kLatitudeOOR,
  kLengthOOR,
  kMassOOR,
  kMaximumTimeOOR,
  kMeplatDiameterOOR,
  kNoseLengthOOR,
  kOgiveRtROOR,
  kRangeAngleOOR,
  kTailLengthOOR,
  kWindHeadingOOR,
  kZeroAngleOOR,
  kZeroDataRequired,
  kZeroDistanceOOR,
  kNotFormed
};  // enum class ErrorT

template <typename T = double>
constexpr T NaN() {
  static_assert(std::is_floating_point<T>::value,
                "NaN() only supports floating-point types");
  return std::numeric_limits<T>::quiet_NaN();
}

struct LOB_EXPORT Input {
  static constexpr uint8_t kTableSize{85};   
  std::array<uint16_t, kTableSize> drags{};  
  double table_coefficient{NaN()};  
  double speed_of_sound{NaN()};     
  uint16_t velocity{0};        
  double mass{NaN()};          
  double optic_height{NaN()};  
  struct Gravity {             
    double x{NaN()};  
    double y{NaN()};  
  } gravity;
  struct Wind {       
    double x{NaN()};  
    double z{NaN()};  
  } wind;
  struct Coriolis {             
    double cos_l_sin_a{NaN()};  
    double sin_l{NaN()};        
    double cos_l_cos_a{NaN()};  
  } corilolis;
  double zero_angle{NaN()};  
  double stability_factor{NaN()};    
  double aerodynamic_jump{NaN()};    
  double spindrift_factor{NaN()};    
  uint16_t minimum_speed{0};         
  double max_time{NaN()};            
  uint16_t step_size{0};             
  ErrorT error{ErrorT::kNotFormed};  
};  // struct Input
 
class Impl;

class LOB_EXPORT Builder {
 public:
  Builder();                          
  ~Builder();                         
  Builder(const Builder& other);      
  Builder(Builder&& other) noexcept;  
  Builder& operator=(
      const Builder& rhs);  
  Builder& operator=(
      Builder&& rhs) noexcept;  

  Builder& BallisticCoefficientPsi(double value);

  Builder& BCAtmosphere(AtmosphereReferenceT type);

  Builder& BCDragFunction(DragFunctionT type);

  Builder& DiameterInch(double value);

  Builder& MeplatDiameterInch(double value);

  Builder& BaseDiameterInch(double value);

  Builder& LengthInch(double value);

  Builder& NoseLengthInch(double value);

  Builder& TailLengthInch(double value);

  Builder& OgiveRtR(double value);

  Builder& MachVsDragTable(const float* pmachs, const float* pdrags,
                           size_t size);
  template <size_t N>
  Builder& MachVsDragTable(const std::array<float, N>& machs,
                           const std::array<float, N>& drags) {
    return MachVsDragTable(machs.data(), drags.data(), N);
  }

  Builder& MassGrains(double value);

  Builder& InitialVelocityFps(uint16_t value);
  Builder& OpticHeightInches(double value);

  Builder& TwistInchesPerTurn(double value);

  Builder& ZeroAngleMOA(double value);

  Builder& ZeroDistanceYds(double value);

  Builder& ZeroImpactHeightInches(double value);

  Builder& AltitudeOfFiringSiteFt(double value);

  Builder& AirPressureInHg(double value);

  Builder& AltitudeOfBarometerFt(double value);

  Builder& TemperatureDegF(double value);

  Builder& AltitudeOfThermometerFt(double value);

  Builder& RelativeHumidityPercent(double value);

  Builder& WindHeading(ClockAngleT value);

  Builder& WindHeadingDeg(double value);

  Builder& WindSpeedFps(double value);

  Builder& WindSpeedMph(double value);

  Builder& AzimuthDeg(double value);

  Builder& LatitudeDeg(double value);

  Builder& RangeAngleDeg(double value);

  Builder& MinimumSpeed(uint16_t value);

  Builder& MinimumEnergy(uint16_t value);

  Builder& MaximumTime(double value);

  Builder& StepSize(uint16_t value);

  Builder& Reset() noexcept;

  Input Build();
 
 private:
  static constexpr size_t kBufferSize{536};
  union AlignmentT {
    double foo;
    size_t bar;
  };
  alignas(AlignmentT) std::array<uint8_t, kBufferSize> buffer_{};
  Impl* pimpl_{nullptr};
};  // class Builder

struct LOB_EXPORT Output {
  uint32_t range{0};       
  uint16_t velocity{0};    
  uint32_t energy{0};      
  double elevation{0.0};   
  double deflection{0.0};  
  double time_of_flight{0.0};  
};  // struct Output

LOB_EXPORT size_t Solve(const Input& in, const uint32_t* pranges, Output* pouts,
                        size_t size);

template <size_t N>
size_t Solve(const Input& in, const std::array<uint32_t, N>& pranges,
             std::array<Output, N>& pouts) {
  return Solve(in, pranges.data(), pouts.data(), N);
}

LOB_EXPORT double MoaToMil(double value);

LOB_EXPORT double MoaToDeg(double value);

LOB_EXPORT double MoaToIphy(double value);

LOB_EXPORT double MoaToInch(double value, double range_ft);

LOB_EXPORT double MilToMoa(double value);

LOB_EXPORT double MilToDeg(double value);

LOB_EXPORT double MilToIphy(double value);

LOB_EXPORT double MilToInch(double value, double range_ft);

LOB_EXPORT double DegToMoa(double value);

LOB_EXPORT double DegToMil(double value);

LOB_EXPORT double InchToMoa(double value, double range_ft);

LOB_EXPORT double InchToMil(double value, double range_ft);

LOB_EXPORT double InchToDeg(double value, double range_ft);

LOB_EXPORT double JToFtLbs(double value);

LOB_EXPORT double FtLbsToJ(double value);

LOB_EXPORT double MtoYd(double value);

LOB_EXPORT double YdToFt(double value);

LOB_EXPORT double MToFt(double value);

LOB_EXPORT double FtToIn(double value);

LOB_EXPORT double MmToIn(double value);

LOB_EXPORT double CmToIn(double value);

LOB_EXPORT double YdToM(double value);

LOB_EXPORT double FtToM(double value);

LOB_EXPORT double FtToYd(double value);

LOB_EXPORT double InToMm(double value);

LOB_EXPORT double InToCm(double value);

LOB_EXPORT double InToFt(double value);

LOB_EXPORT double PaToInHg(double value);

LOB_EXPORT double MbarToInHg(double value);

LOB_EXPORT double PsiToInHg(double value);

LOB_EXPORT double LbsToGrain(double value);

LOB_EXPORT double GToGrain(double value);

LOB_EXPORT double KgToGrain(double value);

LOB_EXPORT double KgSqMToPmsi(double value);

LOB_EXPORT double FpsToMps(double value);

LOB_EXPORT double MpsToFps(double value);

LOB_EXPORT double KphToMph(double value);

LOB_EXPORT double KnToMph(double value);

LOB_EXPORT double MsToS(double value);

LOB_EXPORT double UsToS(double value);

LOB_EXPORT double SToMs(double value);

LOB_EXPORT double SToUs(double value);

LOB_EXPORT double DegCToDegF(double value);
 
}  // namespace lob
 
// This file is part of lob.
//
// lob 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.
//
// lob 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
// lob. If not, see <https://www.gnu.org/licenses/>.