split_fixed_precision.h

// -*-c++-*-
#ifndef STORMM_SPLIT_FIXED_PRECISION_H
#define STORMM_SPLIT_FIXED_PRECISION_H
 
#include <string>
#include <climits>
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "Constants/behavior.h"
#include "Constants/scaling.h"
#include "DataTypes/stormm_vector_types.h"
#include "numeric_enumerators.h"
 
namespace stormm {
namespace numerics {
 
using card::Hybrid;
using constants::ExceptionResponse;
using constants::PrecisionModel;
  
constexpr llint max_int_accumulation_ll = (1LL << (int_bit_count_int - 1));
constexpr double max_int_accumulation   = max_int_accumulation_ll;
constexpr float max_int_accumulation_f  = max_int_accumulation;
constexpr double max_llint_accumulation = max_int_accumulation * max_int_accumulation * 2.0;
constexpr float max_llint_accumulation_f  = max_llint_accumulation;
constexpr int max_short_accumulation = (1 << 15);

AccumulationMethod translateAccumulationMethod(const std::string &choice,
                                               ExceptionResponse policy);

std::string getAccumulationMethodName(AccumulationMethod method);

AccumulationMethod chooseAccumulationMethod(int frc_bits);

std::string fixedPrecisionRangeErrorMessage(int choice, int min_val, int max_val);

void checkGlobalPositionBits(int choice);

void checkLocalPositionBits(int choice);

void checkVelocityBits(int choice);

void checkForceBits(int choice);

void checkEnergyBits(int choice);

void checkChargeMeshBits(int choice, PrecisionModel pmodel);

void checkFPVectorLength(size_t primary_length, size_t overflow_length, const char* caller,
                         const std::string &message = std::string(""));

int2 hostFloatToInt63(const float fval);
 
void hostFloatToInt63(const float fval, int *primary, int *overflow);
 
void hostFloatToInt63(const float* fval, int* primary, int* overflow, size_t n_values,
                      float scale = 1.0f);
 
void hostFloatToInt63(const float* fval_x, const float* fval_y, const float* fval_z,
                      int* primary_x, int* overflow_x, int* primary_y, int* overflow_y,
                      int* primary_z, int* overflow_z, size_t n_values, float scale = 1.0f);
 
void hostFloatToInt63(const std::vector<float> &fval, std::vector<int> *primary,
                      std::vector<int> *overflow, float scale = 1.0f);
 
void hostFloatToInt63(const Hybrid<float> &fval, Hybrid<int> *primary, Hybrid<int> *overflow,
                      float scale = 1.0f);
 
void hostFloatToInt63(const std::vector<float> &fval_x, const std::vector<float> &fval_y,
                      const std::vector<float> &fval_z, std::vector<int> *primary_x,
                      std::vector<int> *overflow_x, std::vector<int> *primary_y,
                      std::vector<int> *overflow_y, std::vector<int> *primary_z,
                      std::vector<int> *overflow_z, float scale = 1.0f);
 
void hostFloatToInt63(const Hybrid<float> &fval_x, const Hybrid<float> &fval_y,
                      const Hybrid<float> &fval_z, Hybrid<int> *primary_x, Hybrid<int> *overflow_x,
                      Hybrid<int> *primary_y, Hybrid<int> *overflow_y, Hybrid<int> *primary_z,
                      Hybrid<int> *overflow_z, float scale = 1.0f);
 
int2 hostLongLongToInt63(const llint val);
 
void hostLongLongToInt63(const llint val, int *primary, int *overflow);
 
void hostLongLongToInt63(const llint* val, int* primary, int* overflow, size_t n_values);
 
void hostLongLongToInt63(const llint* val_x, const llint* val_y, const llint* val_z,
                         int* primary_x, int* overflow_x, int* primary_y, int* overflow_y,
                         int* primary_z, int* overflow_z, size_t n_values);
 
void hostLongLongToInt63(const std::vector<llint> &val, std::vector<int> *primary,
                         std::vector<int> *overflow);
 
void hostLongLongToInt63(const std::vector<llint> &val_x, const std::vector<llint> &val_y,
                         const std::vector<llint> &val_z, std::vector<int> *primary_x,
                         std::vector<int> *overflow_x, std::vector<int> *primary_y,
                         std::vector<int> *overflow_y, std::vector<int> *primary_z,
                         std::vector<int> *overflow_z);
 
void hostLongLongToInt63(const Hybrid<llint> &val, Hybrid<int> *primary, Hybrid<int> *overflow);
 
void hostLongLongToInt63(const Hybrid<llint> &val_x, const Hybrid<llint> &val_y,
                         const Hybrid<llint> &val_z, Hybrid<int> *primary_x,
                         Hybrid<int> *overflow_x, Hybrid<int> *primary_y, Hybrid<int> *overflow_y,
                         Hybrid<int> *primary_z, Hybrid<int> *overflow_z);
 
int2 hostDoubleToInt63(const double fval);
 
void hostDoubleToInt63(const double fval, int *primary, int *overflow);
 
int95_t hostDoubleToInt95(const double fval);
 
void hostDoubleToInt95(const double fval, llint *primary, int *overflow);
 
void hostDoubleToInt95(const double* dval, llint* primary, int* overflow, size_t n_values,
                       double scale = 1.0);
 
void hostDoubleToInt95(const std::vector<double> &dval, std::vector<llint> *primary,
                       std::vector<int> *overflow, double scale = 1.0);
 
void hostDoubleToInt95(const Hybrid<double> &dval, Hybrid<llint> *primary, Hybrid<int> *overflow,
                       double scale = 1.0);
  
void hostDoubleToInt95(const double* dval_x, const double* dval_y, const double* dval_z,
                       llint* primary_x, int* overflow_x, llint* primary_y, int* overflow_y,
                       llint* primary_z, int* overflow_z, size_t n_values, double scale = 1.0);
 
void hostDoubleToInt95(const std::vector<double> &dval_x, const std::vector<double> &dval_y,
                       const std::vector<double> &dval_z, std::vector<llint> *primary_x,
                       std::vector<int> *overflow_x, std::vector<llint> *primary_y,
                       std::vector<int> *overflow_y, std::vector<llint> *primary_z,
                       std::vector<int> *overflow_z, double scale = 1.0);
 
void hostDoubleToInt95(const Hybrid<double> &dval_x, const Hybrid<double> &dval_y,
                       const Hybrid<double> &dval_z, Hybrid<llint> *primary_x,
                       Hybrid<int> *overflow_x, Hybrid<llint> *primary_y, Hybrid<int> *overflow_y,
                       Hybrid<llint> *primary_z, Hybrid<int> *overflow_z, double scale = 1.0);

llint hostInt63ToLongLong(int primary, int overflow);
 
void hostInt63ToLongLong(llint* result, const int* primary, const int* overflow, size_t n_values);
 
void hostInt63ToLongLong(std::vector<llint> *result, const std::vector<int> &primary,
                         const std::vector<int> &overflow, size_t n_values);
 
void hostInt63ToLongLong(Hybrid<llint> *result, const Hybrid<int> &primary,
                         const Hybrid<int> &overflow, size_t n_values);
 
void hostInt63ToLongLong(llint* result_x, llint* result_y, llint* result_z, const int* primary_x,
                         const int* overflow_x, const int* primary_y, const int* overflow_y,
                         const int* primary_z, const int* overflow_z, size_t n_values);
 
void hostInt63ToLongLong(std::vector<llint> *result_x, std::vector<llint> *result_y,
                         std::vector<llint> *result_z, const std::vector<int> &primary_x,
                         const std::vector<int> &overflow_x, const std::vector<int> &primary_y,
                         const std::vector<int> &overflow_y, const std::vector<int> &primary_z,
                         const std::vector<int> &overflow_z, size_t n_values);
 
void hostInt63ToLongLong(Hybrid<llint> *result_x, Hybrid<llint> *result_y, Hybrid<llint> *result_z,
                         const Hybrid<int> &primary_x, const Hybrid<int> &overflow_x,
                         const Hybrid<int> &primary_y, const Hybrid<int> &overflow_y,
                         const Hybrid<int> &primary_z, const Hybrid<int> &overflow_z,
                         size_t n_values);
 
double hostInt63ToDouble(int primary, int overflow);
 
void hostInt63ToDouble(double* result, const int* primary, const int* overflow, size_t n_values,
                       double descale = 1.0);
 
void hostInt63ToDouble(std::vector<double> *result, const std::vector<int> &primary,
                       const std::vector<int> &overflow, double descale = 1.0);
 
void hostInt63ToDouble(Hybrid<double> *result, const Hybrid<int> &primary,
                       const Hybrid<int> &overflow, double descale = 1.0);
 
float hostInt63ToFloat(int primary, int overflow);
 
void hostInt63ToFloat(float* result, const int* primary, const int* overflow, size_t n_values,
                      float descale = 1.0f);
 
void hostInt63ToFloat(std::vector<float> *result, const std::vector<int> &primary,
                      const std::vector<int> &overflow, float descale = 1.0f);
 
void hostInt63ToFloat(Hybrid<float> *result, const Hybrid<int> &primary,
                      const Hybrid<int> &overflow, float descale = 1.0f);
 
void hostInt63ToDouble(double* result_x, double* result_y, double* result_z, const int* primary_x,
                       const int* overflow_x, const int* primary_y, const int* overflow_y,
                       const int* primary_z, const int* overflow_z, size_t n_values,
                       double descale = 1.0);
 
void hostInt63ToDouble(std::vector<double> *result_x, std::vector<double> *result_y,
                       std::vector<double> *result_z, const std::vector<int> &primary_x,
                       const std::vector<int> &overflow_x, const std::vector<int> &primary_y,
                       const std::vector<int> &overflow_y, const std::vector<int> &primary_z,
                       const std::vector<int> &overflow_z, size_t n_values, double descale = 1.0);
 
void hostInt63ToDouble(Hybrid<double> *result_x, Hybrid<double> *result_y,
                       Hybrid<double> *result_z, const Hybrid<int> &primary_x,
                       const Hybrid<int> &overflow_x, const Hybrid<int> &primary_y,
                       const Hybrid<int> &overflow_y, const Hybrid<int> &primary_z,
                       const Hybrid<int> &overflow_z, size_t n_values, double descale = 1.0);
 
void hostInt63ToFloat(float* result_x, float* result_y, float* result_z, const int* primary_x,
                      const int* overflow_x, const int* primary_y, const int* overflow_y,
                      const int* primary_z, const int* overflow_z, size_t n_values,
                      float descale = 1.0f);
 
void hostInt63ToFloat(std::vector<float> *result_x, std::vector<float> *result_y,
                      std::vector<float> *result_z, const std::vector<int> &primary_x,
                      const std::vector<int> &overflow_x, const std::vector<int> &primary_y,
                      const std::vector<int> &overflow_y, const std::vector<int> &primary_z,
                      const std::vector<int> &overflow_z, float descale = 1.0f);
 
void hostInt63ToFloat(Hybrid<float> *result_x, Hybrid<float> *result_y, Hybrid<float> *result_z,
                      const Hybrid<int> &primary_x, const Hybrid<int> &overflow_x,
                      const Hybrid<int> &primary_y, const Hybrid<int> &overflow_y,
                      const Hybrid<int> &primary_z, const Hybrid<int> &overflow_z,
                      float descale = 1.0f);
 
double hostInt63ToDouble(int2 ival);
 
float hostInt63ToFloat(int2 ival);
 
double hostInt95ToDouble(const int95_t ival);
  
double hostInt95ToDouble(llint primary, int overflow);
 
void hostInt95ToDouble(double* result, const llint* primary, const int* overflow, size_t n_values,
                       double descale = 1.0);
 
void hostInt95ToDouble(std::vector<double> *result, const std::vector<llint> &primary,
                       const std::vector<int> &overflow, double descale = 1.0);
 
void hostInt95ToDouble(Hybrid<double> *result, const Hybrid<llint> &primary,
                       const Hybrid<int> &overflow, double descale = 1.0);
 
void hostInt95ToDouble(double* result_x, double* result_y, double* result_z,
                       const llint* primary_x, const int* overflow_x, const llint* primary_y,
                       const int* overflow_y, const llint* primary_z, const int* overflow_z,
                       size_t n_values, double descale = 1.0);
 
void hostInt95ToDouble(std::vector<double> *result_x, std::vector<double> *result_y,
                       std::vector<double> *result_z, const std::vector<llint> &primary_x,
                       const std::vector<int> &overflow_x, const std::vector<llint> &primary_y,
                       const std::vector<int> &overflow_y, const std::vector<llint> &primary_z,
                       const std::vector<int> &overflow_z, double descale = 1.0);
 
void hostInt95ToDouble(Hybrid<double> *result_x, Hybrid<double> *result_y,
                       Hybrid<double> *result_z, const Hybrid<llint> &primary_x,
                       const Hybrid<int> &overflow_x, const Hybrid<llint> &primary_y,
                       const Hybrid<int> &overflow_y, const Hybrid<llint> &primary_z,
                       const Hybrid<int> &overflow_z, double descale = 1.0);
 
double hostSplitFPToReal(const int95_t isfp);
 
float hostSplitFPToReal(const int2 isfp);
 
double hostSplitFPToReal(const int95_t isfp);
 
float hostSplitFPToReal(const int2 isfp);

void hostSplitAccumulation(const float fval, int *primary, int *overflow);
 
void hostSplitAccumulation(const double fval, llint *primary, int *overflow);

int95_t hostSplitFPSum(const int95_t a, const int95_t b);
 
int2 hostSplitFPSum(const int2 a, const int2 b);
 
int95_t hostSplitFPSum(const int95_t a, double breal);
 
int2 hostSplitFPSum(const int2 a, float breal);
 
int95_t hostSplitFPSum(const int95_t a, llint b_x, int b_y);
 
int2 hostSplitFPSum(const int2 a, int b_x, int b_y);
 
template <typename T> void hostSplitFPSum(T *a_x, int *a_y, const int95_t b);
 
template <typename T> void hostSplitFPSum(T *a_x, int *a_y, const int2 b);
 
int95_t hostInt95Sum(llint a_x, int a_y, llint b_x, int b_y);
 
int2 hostInt63Sum(int a_x, int a_y, int b_x, int b_y);
 
int95_t hostInt95Sum(llint a_x, int a_y, double breal);
 
int2 hostInt63Sum(int a_x, int a_y, float breal);

int95_t hostSplitFPSubtract(const int95_t a, const int95_t b);
 
int2 hostSplitFPSubtract(const int2 a, const int2 b);
 
int95_t hostSplitFPSubtract(const int95_t a, double breal);
 
int2 hostSplitFPSubtract(const int2 a, float breal);
 
int95_t hostSplitFPSubtract(const int95_t a, llint b_x, int b_y);
 
int2 hostSplitFPSubtract(const int2 a, int b_x, int b_y);
 
template <typename T> void hostSplitFPSubtract(T *a_x, int *a_y, const int95_t b);
 
template <typename T> void hostSplitFPSubtract(T *a_x, int *a_y, const int2 b);
 
int95_t hostInt95Subtract(llint a_x, int a_y, llint b_x, int b_y);
 
int2 hostInt63Subtract(int a_x, int a_y, int b_x, int b_y);
 
int95_t hostInt95Subtract(llint a_x, int a_y, double breal);
 
int2 hostInt63Subtract(int a_x, int a_y, float breal);

int95_t hostSplitFPMult(const int95_t a, int b);
 
int95_t hostInt95Mult(llint a_x, int a_y, int b);
 
int2 hostSplitFPMult(const int2 a, int b);
 
int2 hostInt63Mult(int a_x, int a_y, int b);
  
int2 hostChangeFPBits(const int2 fp, int native_bits, int output_bits);
 
int95_t hostChangeFPBits(const int95_t fp, int native_bits, int output_bits);
 
void hostChangeFPBits(std::vector<int95_t> *fp, int native_bits, int output_bits);
 
void hostChangeFPBits(int* fp, int* fp_ovrf, size_t length, int native_bits, int output_bits);
 
void hostChangeFPBits(llint* fp, int* fp_ovrf, size_t length, int native_bits, int output_bits);
 
void hostChangeFPBits(std::vector<int> *fp, std::vector<int> *fp_ovrf, int native_bits,
                      int output_bits);
 
void hostChangeFPBits(std::vector<llint> *fp, std::vector<int> *fp_ovrf, int native_bits,
                      int output_bits);
 
void hostChangeFPBits(Hybrid<int> *fp, Hybrid<int> *fp_ovrf, int native_bits, int output_bits);
 
void hostChangeFPBits(Hybrid<llint> *fp, Hybrid<int> *fp_ovrf, int native_bits, int output_bits);

void fixedPrecisionGrid(std::vector<int95_t> *coordinates, const int95_t origin,
                        const int95_t increment);
 
void fixedPrecisionGrid(std::vector<llint> *primary, std::vector<int> *overflow,
                        const int95_t origin, const int95_t increment);
 
void fixedPrecisionGrid(Hybrid<llint> *primary, Hybrid<int> *overflow, const int95_t origin,
                        const int95_t increment);
 
void fixedPrecisionGrid(llint *primary, int *overflow, const int95_t origin,
                        const int95_t increment, const size_t grid_size);

int95_t operator+=(const int95_t lhs, const int95_t rhs);
int95_t operator-=(const int95_t lhs, const int95_t rhs);
int95_t operator+(const int95_t lhs, const int95_t rhs);
int95_t operator-(const int95_t lhs, const int95_t rhs);
 
} // namespace numerics
} // namespace stormm
 
#include "split_fixed_precision.tpp"
 
// Make basic arithmetic functions native to the stormm namespace
namespace stormm {
  using numerics::hostFloatToInt63;
  using numerics::hostDoubleToInt95;
  using numerics::hostInt63ToDouble;
  using numerics::hostInt63ToFloat;
  using numerics::hostInt95ToDouble;
  using numerics::hostSplitAccumulation;
  using numerics::hostSplitFPSubtract;
  using numerics::hostSplitFPSum;
  using numerics::hostSplitFPToReal;
  using numerics::hostInt95Subtract;
  using numerics::hostInt95Sum;
  using numerics::hostInt63Subtract;
  using numerics::hostInt63Sum;
  using numerics::operator+=;
  using numerics::operator-=;
  using numerics::operator+;
  using numerics::operator-;
  using numerics::max_int_accumulation;
  using numerics::max_int_accumulation_f;
  using numerics::max_int_accumulation_ll;
  using numerics::max_llint_accumulation;
  using numerics::max_llint_accumulation_f;
  using numerics::max_short_accumulation;
} // namespace stormm
 
#endif