rounding.h

// -*-c++-*-
#ifndef STORMM_ROUNDING_H
#define STORMM_ROUNDING_H
 
#include <cmath>
#include <vector>
#include "copyright.h"
#include "Constants/behavior.h"
#include "Constants/symbol_values.h"
#include "DataTypes/common_types.h"
#include "math_enumerators.h"
 
namespace stormm {
namespace stmath {
 
using constants::CartesianDimension;
using constants::UnitCellAxis;
using symbols::pi;
using symbols::pi_f;
using symbols::near_to_one_f;
using symbols::near_to_one_lf;
  
template <typename T> T roundUp(T jagged, T increment);
 
  
template <typename T> T roundDown(T jagged, T increment);

std::vector<uint> primeFactors(ullint number, const std::vector<uint> &primes, int n_primes = 0);

std::vector<uint> primeFactorCounts(ullint number, const std::vector<uint> &primes,
                                    int n_primes = 0);

ulint getSmallestLot(int element_size, int increment, int n_primes = 8);

ullint nearestFactor(ullint number, ullint target, const std::vector<uint> &primes,
                     LimitApproach approach, int n_primes = 0);
  
size_t getPaddedMemorySize(size_t length, size_t growth_increment, size_t element_size = 1);

template <typename Tcalc>
Tcalc angleVerification(const Tcalc costheta, const Tcalc* crabbc, const Tcalc* crbccd,
                        const Tcalc* bc, const Tcalc* scr);

void partition(int n, int pmax, const std::vector<int> &pref, const std::vector<int> &dscr,
               std::vector<int> *result);
 
std::vector<int> partition(int n, int pmax, const std::vector<int> &pref,
                           const std::vector<int> &dscr);

int sanctionedDensityGridDimension(ullint big_product, const double* invu, UnitCellAxis edge,
                                   const std::vector<uint> &primes, double max_spacing = 1.0);
 
int sanctionedDensityGridDimension(ullint big_product, const double* inv, CartesianDimension edge,
                                   const std::vector<uint> &primes, double max_spacing = 1.0);
  
} // namespace stmath
} // namespace stormm
 
#include "rounding.tpp"
 
#endif