{

public:

#if !defined(GPUCA_GPUCODE)

/// constructor for runtime evaluation of polynomial formula

/// \param nDim number of dimensions

/// \param degree degree of the polynomial

template <bool IsEnabled = true, typename std::enable_if<(IsEnabled && (Dim == 0 && Degree == 0)), int32_t>::type = 0>

MultivariatePolynomial(const uint32_t nDim, const uint32_t degree, const bool interactionOnly = false) : MultivariatePolynomialHelper<Dim, Degree, false>{nDim, degree, interactionOnly}, mNParams{this->getNParameters(degree, nDim, interactionOnly)}

{

construct();

}

/// constructor for compile time evaluation of polynomial formula

template <bool IsEnabled = true, typename std::enable_if<(IsEnabled && (Dim != 0 && Degree != 0)), int32_t>::type = 0>

MultivariatePolynomial() : mNParams{this->template getNParameters<Degree, Dim, InteractionOnly>()}

{

construct();

}

#else

/// default constructor

MultivariatePolynomial() = default;

#endif

/// default destructor

~MultivariatePolynomial() = default;

/// Copy constructor

MultivariatePolynomial(const MultivariatePolynomial& obj) { this->cloneFromObject(obj, nullptr); }

/// ========== FlatObject functionality, see FlatObject class for description =================

#if !defined(GPUCA_GPUCODE)

/// cloning a container object (use newFlatBufferPtr=nullptr for simple copy)

void cloneFromObject(const MultivariatePolynomial& obj, char* newFlatBufferPtr);

/// move flat buffer to new location

/// \param newBufferPtr new buffer location

void moveBufferTo(char* newBufferPtr);

#endif

/// destroy the object (release internal flat buffer)

void destroy();

/// set location of external flat buffer

void setActualBufferAddress(char* actualFlatBufferPtr);

/// set future location of the flat buffer

void setFutureBufferAddress(char* futureFlatBufferPtr);

/// ================================================================================================

/// evaluates the polynomial for given coordinates

/// \param x query coordinates

GPUd() float eval(const float x[/*Dim*/]) const { return this->evalPol(mParams, x); }

#if !defined(GPUCA_GPUCODE)

/// \return returns number of parameters of the polynomials

uint32_t getNParams() const { return mNParams; }

/// set the parameters for the coefficients of the polynomial

/// \param params parameter for the coefficients

void setParams(const float params[/*mNParams*/]) { std::copy(params, params + mNParams, mParams); }

/// \param parameter which will be set

/// \val value of the parameter

void setParam(const uint32_t param, const float val) { mParams[param] = val; };

/// \return returns the paramaters of the coefficients

const float* getParams() const { return mParams; }

#ifndef GPUCA_STANDALONE

/// load parameters from input file (which were written using the writeToFile method)

/// \param inpf input file

/// \parma name name of the object in the file

void loadFromFile(TFile& inpf, const char* name);

/// write parameters to file

/// \param outf output file

/// \param name name of the output object

void writeToFile(TFile& outf, const char* name) const;

/// performs fit of input point

/// \param x position of the points of length 'Dim * nPoints' (structured as in https://root.cern.ch/doc/master/classTLinearFitter.html)

/// \param y values which will be fitted of length 'nPoints'

/// \param error error of weigths of the points (if empty no weights are applied)

/// \param clearPoints perform the fit on new data points

template <bool IsEnabled = true, typename std::enable_if<(IsEnabled && (Dim == 0 && Degree == 0)), int32_t>::type = 0>

void fit(std::vector<double>& x, std::vector<double>& y, std::vector<double>& error, const bool clearPoints)

{

const auto vec = MultivariatePolynomialHelper<Dim, Degree, InteractionOnly>::fit(x, y, error, clearPoints);

if (vec.empty()) {

return;

}

setParams(vec.data());

}

#endif

/// converts the parameters to a container which can be written to a root file

MultivariatePolynomialContainer getContainer() const { return MultivariatePolynomialContainer{this->getDim(), this->getDegree(), mNParams, mParams, this->isInteractionOnly()}; }

/// set the parameters from MultivariatePolynomialContainer

/// \param container container for the parameters

void setFromContainer(const MultivariatePolynomialContainer& container);

#endif

private:

using DataTParams = float; ///< data type of the parameters of the polynomials

uint32_t mNParams{}; ///< number of parameters of the polynomial

DataTParams* mParams{nullptr}; ///< parameters of the coefficients of the polynomial

#if !defined(GPUCA_GPUCODE)

/// \return returns the size of the parameters

std::size_t sizeOfParameters() const { return mNParams * sizeof(DataTParams); }

// construct the object (flatbuffer)

void construct();

#endif

ClassDefNV(MultivariatePolynomial, 1);