AbstractBasis

Super type for all bases. A basis must implement the following methods: nVariates, length, getType, isDifferentiable, value. If the basis contains only differentiable functions, in which case isDifferentiable returns true, it must also implement derivative.

AbstractTransformation

Super type for all transformations.

A transformation is a function $\varphi: \mathbb{R}^d \to \mathbb{R}^d$, which is applied on the fly to the data before proceeding with the least squares problem. A transformation must implement apply! and jacobian.

To define a new transformation, define a new concrete subtype of AbstractTransformation and implement the corresponding apply! and jacobian methods. For instance the scaled log-transformation $\varphi(x) = \alpha \log(x)$ where $\alpha \in \mathbb{R}$ is defined as follows

struct LogTransformation <: AbstractTransformation
    scale::Vector{<:Real}
end

function apply!(t::LogTransformation, tx::AbstractVector{Td}, x::AbstractVector{Td}) where Td<:Real
    tx .= t.scale .* log.(x)
end

function jacobian(t::LogTransformation, x::AbstractVector{<:Real}, i::Integer, j::Integer)
    if i != j
        return 0.
    end
    t.scale[i] / x[i]
end

GaussianTransformation(x::AbstractVector{<:AbstractVector{T}}) where T<:Real

Create a Gaussian transformation by setting α as the empirical mean and σ as the empirical standard deviation. Each entry of x is supposed to be one sample of the data.

GaussianTransformation{Td} <: AbstractTransformation where Td<:Real

Implement an Gaussian transformation of the data defined by $\varphi(x) = N((x - \alpha) / \sigma)$ where $N$ is the cdf of the standard Gaussian distribution

LinearTransformation(x::AbstractVector{<:AbstractVector{T}}) where T<:Real

Create a linear transformation by setting α as the empirical mean and σ as the inverse of the empirical standard deviation. Each entry of x is supposed to be one sample of the data.

LinearTransformation{Td} <: AbstractTransformation where Td<:Real

Implement a linear transformation of the data defined by $\varphi(x) = (x - \alpha) * \sigma$

LogNormalTransformation(x::AbstractVector{<:AbstractVector{T}}) where T<:Real

Create a Log-normal transformation by setting α and σ as the empirical mean and variance of log(x) . Each entry of x is supposed to be one sample of the data.

LogNormalTransformation{Td} <: AbstractTransformation where Td<:Real

Implement a Log-normal transformation of the data defined by $\varphi(x) = N((\log(x) - \alpha) / \sigma)$ where $N$ is the cdf of the standard Gaussian distribution.

PiecewiseConstantBasis(nVariates::Integer, nIntervals::Integer)

Create a PiecewiseConstantBasis with nIntervals along each direction.

PiecewiseConstantBasis(nVariates::Integer, nIntervals::Vector{<:Integer})

Create a PiecewiseConstantBasis by specifying the number of intervals per direction (possibly different to allow non squared grids).

PiecewiseConstantBasis

Represent a basis of local functions defined on $[0,1]^d$

• nVariates is the dimension d of the space.
• nIntervals is a vector of size d defining the number of sub-intervals to use along each dimension

PolynomialBasis(type::PolynomialType, nVariates::Integer, degree::Integer)

Create a polynomial basis with type, nVariates variables and total maximum degree

PolynomialBasis

Represent a multivariate polynomial

• degree::Int64: maximum total degree
• nVariates::Int6: number of variates
• dim::Int6: dimension of the generated vector space
• type::PolynomialType: a value from PolynomialType
• tensor::SparseMatrixCSC{Int64, Int64}: the sparse tensor representation of the polynomial. Polynomials are stored by column.

PolynomialType

List the families of polynomials available through the PolynomialBasis type

• Canonic
• Hermite
• Tchebychev

VSLeastSquares(basis::Tb, transform::Tt=VoidTransformation(), Td::Type=Float64) where {Tb<:AbstractBasis, Tt<:AbstractTransformation}

Create a VSLeastSquares object from basis and transform and capable of handling Td typed data.

VSLeastSquares{Tb<:AbstractBasis, Tt<:AbstractTransformation, Td<:Real}

The main object to solve a least squares problem.

VoidTransformation <: AbstractTransformation

This transformation does nothing.

length(b::AbstractBasis)

Return the number of elements in the basis.

length(vslsq::VSLeastSquares{Tb, Tt, Td}) where {Tb<:AbstractBasis, Tt<:AbstractTransformation, Td<:Real}

Return the number of functions of the basis used to solve the least squares problem

size(b::AbstractBasis)

Return the tuple (nVariates, length).

size(vslsq::VSLeastSquares{Tb, Tt, Td}) where {Tb<:AbstractBasis, Tt<:AbstractTransformation, Td<:Real}

Return the tuple (nVariates, length)

apply!(t::AbstractTransformation, tx::AbstractVector{Td}, x::AbstractVector{Td}) where Td<:Real

Apply the transformation t to x and store the result in tx.

derivative(b::AbstractBasis, x::AbstractVector{<:Real}, index::Integer, derivativeIndex::Integer)

Compute the value of the first derivative of the index-th basis function w.r.t to the derivativeIndex variate at point x.

derivative(polType::PolynomialType, degree::Integer, x::Real)

Evaluate the first derivative of a 1d polynomial of type polType and degree degree at x

derivative(vslsq::VSLeastSquares{Tb, Tt, Td}, x::AbstractVector{Td}, index::Integer) where {Tb<:AbstractBasis, Tt<:AbstractTransformation, Td<:Real}

Compute the partial derivative of the prediction w.r.t to the index variable.

The method fit must have been called before.

derivative(p::PolynomialBasis, x::AbstractVector{Td}, polIndex::Ti, derivativeIndex::Ti) where {Td<:Real, Ti<:Integer}

Evaluate the first partial derivative w.r.t variable derivativeIndex of the polIndex-th member of the polynomial basis p

fit(vslsq::VSLeastSquares{Tb, Tt, Td}, x::AbstractVector{<:AbstractVector{Td}}, y::AbstractVector{Td}) where {Tb<:AbstractBasis, Tt<:AbstractTransformation, Td<:Real}

Solve the least squares problem.

fit(vslsq::VSLeastSquares{PiecewiseConstantBasis, Tt, Td}, x::AbstractVector{<:AbstractVector{Td}}, y::AbstractVector{Td}) where {Tt<:AbstractTransformation, Td<:Real}

Solve the least squares problem using the specific structure of the PiecewiseConstantBasis.

getBasis(vslsq::VSLeastSquares{Tb, Tt, Td}) where {Tb<:AbstractBasis, Tt<:AbstractTransformation, Td<:Real}

Return the basis used to solve the least squares problem.

getCenter(t::LinearTransformation{<:Real})

Return the center α of the linear transformation

getCoefficients(vslsq::VSLeastSquares{Tb, Tt, Td}) where {Tb<:AbstractBasis, Tt<:AbstractTransformation, Td<:Real}

Return the coefficients solution to the least squares problem.

getMean(t::LinearTransformation{<:Real})

Return the mean α of the Gaussian distribution

getMean(t::LinearTransformation{<:Real})

Return the mean α of the underlying Gaussian distribution

getScale(t::LinearTransformation{<:Real}) = t.scale

Return the scale σ of the linear transformation

getScale(t::LinearTransformation{<:Real}) = t.scale

Return the standard deviation σ of the Gaussian distribution

getScale(t::LinearTransformation{<:Real}) = t.scale

Return the standard deviation σ of the underlying Gaussian distribution

getType(b::AbstractBasis)

Return the internal basis type.

gradient(vslsq::VSLeastSquares{Tb, Tt, Td}, x::AbstractVector{Td}) where {Tb<:AbstractBasis, Tt<:AbstractTransformation, Td<:Real}

Compute the gradient of the prediction at x.

The method fit must have been called before.

isDifferentiable(b::AbstractBasis)

Return true if the functions in the basis are differentiable. In this case, a specific method derivative must be implemented.

jacobian(t::AbstractTransformation, x::AbstractVector{<:Real}, i::Integer, j::Integer)

Compute $\partial_{x_j} \varphi_i(x)$.

nVariates(b::AbstractBasis)

Return the number of variates of the functions inside the basis.

nVariates(vslsq::VSLeastSquares{Tb, Tt, Td}) where {Tb<:AbstractBasis, Tt<:AbstractTransformation, Td<:Real}

Return the number of variates in the least squares problem

predict(vslsq::VSLeastSquares{Tb, Tt, Td}, x::AbstractVector{Td}) where {Tb<:AbstractBasis, Tt<:AbstractTransformation, Td<:Real}

Compute the value predicted by the least squares problem.

The method fit must have been called before.

predict(vslsq::VSLeastSquares{PiecewiseConstantBasis, Tt, Td}, x::AbstractVector{Td}) where {Tt<:AbstractTransformation, Td<:Real}

Compute the value predicted by the least squares problem using the specific structure of the PiecewiseConstantBasis.

The method fit must have been called before.

value(b::AbstractBasis, x::AbstractVector{<:Real}, index::Integer)

Compute the value of the index-th basis function at point x.

value(p::PolynomialBasis, x::AbstractVector{<:Real}, i::Integer)

Evaluate the i-th function of a Polynomial basis p at point x

value(polType::PolynomialType, degree::Integer, x::Real)

Evaluate a 1d polynomial of type polType and degree degree at x