radial_basis_interpolator.py
6c4eee04e0dfmaster

radial_basis_interpolator.py
View Options

			# Copyright (C) 2018 by the RROMPy authors
			#
			# This file is part of RROMPy.
			#
			# RROMPy is free software: you can redistribute it and/or modify
			# it under the terms of the GNU Lesser General Public License as published by
			# the Free Software Foundation, either version 3 of the License, or
			# (at your option) any later version.
			#
			# RROMPy 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 Lesser General Public License for more details.
			#
			# You should have received a copy of the GNU Lesser General Public License
			# along with RROMPy. If not, see <http://www.gnu.org/licenses/>.
			#

			import numpy as np
			from copy import deepcopy as copy
			from rrompy.utilities.base.types import (List, ListAny, DictAny, Np1D, Np2D,
			paramList)
			from rrompy.utilities.poly_fitting.interpolator import GenericInterpolator
			from rrompy.utilities.poly_fitting.custom_fit import customFit
			from .base import polyfitname
			from .val import polyval
			from .vander import polyvander as pv
			from rrompy.utilities.numerical import dot
			from rrompy.utilities.numerical.degree import degreeTotalToFull
			from rrompy.utilities.exception_manager import RROMPyException, RROMPyAssert
			from rrompy.parameter import checkParameterList

			__all__ = ['RadialBasisInterpolator']

			class RadialBasisInterpolator(GenericInterpolator):
			def __init__(self, other = None):
			if other is None: return
			self.support = other.support
			self.coeffsGlobal = other.coeffsGlobal
			self.coeffsLocal = other.coeffsLocal
			self.directionalWeights = other.directionalWeights
			self.npar = other.npar
			self.polybasis = other.polybasis

			@property
			def shape(self):
			sh = self.coeffsLocal.shape[1 :] if self.coeffsLocal.ndim > 1 else 1
			return sh

			@property
			def deg(self):
			return [x - 1 for x in self.coeffsGlobal.shape[: self.npar]]

			def __call__(self, mu:paramList, der : List[int] = None,
			scl : Np1D = None):
			if der is not None and np.sum(der) > 0:
			raise RROMPyException(("Cannot take derivatives of radial basis "
			"function."))
			return polyval(mu, self.coeffsGlobal, self.coeffsLocal, self.support,
			self.directionalWeights, self.polybasis)

			def __copy__(self):
			return RadialBasisInterpolator(self)

			def __deepcopy__(self, memo):
			other = RadialBasisInterpolator()
			(other.support, other.coeffsGlobal, other.coeffsLocal,
			other.directionalWeights, other.npar, other.polybasis) = copy(
			(self.support, self.coeffsGlobal,
			self.coeffsLocal, self.directionalWeights,
			self.npar, self.polybasis), memo)
			return other

			def postmultiplyTensorize(self, A:Np2D):
			RROMPyAssert(A.shape[0], self.shape[-1], "Shape of output")
			self.coeffsLocal = dot(self.coeffsLocal, A)
			self.coeffsGlobal = dot(self.coeffsGlobal, A)

			def pad(self, nleft : List[int] = None, nright : List[int] = None):
			if nleft is None: nleft = [0] * len(self.shape)
			if nright is None: nright = [0] * len(self.shape)
			if not hasattr(nleft, "__len__"): nleft = [nleft]
			if not hasattr(nright, "__len__"): nright = [nright]
			RROMPyAssert(len(self.shape), len(nleft), "Shape of output")
			RROMPyAssert(len(self.shape), len(nright), "Shape of output")
			padwidth = [(0, 0)] + [(l, r) for l, r in zip(nleft, nright)]
			self.coeffsLocal = np.pad(self.coeffsLocal, padwidth, "constant",
			constant_values = (0., 0.))
			padwidth = [(0, 0)] * (self.npar - 1) + padwidth
			self.coeffsGlobal = np.pad(self.coeffsGlobal, padwidth, "constant",
			constant_values = (0., 0.))

			def setupByInterpolation(self, support:paramList, values:ListAny,
			deg:int, polybasis : str = "MONOMIAL_GAUSSIAN",
			directionalWeights : Np1D = None,
			verbose : bool = True, totalDegree : bool = True,
			vanderCoeffs : DictAny = {},
			fitCoeffs : DictAny = {}):
			support = checkParameterList(support)
			RROMPyAssert(len(support), len(values), "Number of support values")
			self.support = copy(support)
			if "reorder" in vanderCoeffs.keys():
			self.support = self.support[vanderCoeffs["reorder"]]
			self.npar = support.shape[1]
			if directionalWeights is None: directionalWeights = [1.] * self.npar
			directionalWeights = np.array(directionalWeights)
			self.polybasis = polybasis
			if not totalDegree and not hasattr(deg, "__len__"):
			deg = [deg] * self.npar
			vander, self.directionalWeights = pv(support, deg, basis = polybasis,
			directionalWeights = directionalWeights,
			**vanderCoeffs)
			outDim = values.shape[1:]
			values = values.reshape(values.shape[0], -1)
			values = np.pad(values, ((0, len(vander) - len(values)), (0, 0)),
			"constant")
			fitOut = customFit(vander, values, full = True, **fitCoeffs)
			P = fitOut[0][len(support) :]
			if verbose:
			msg = ("Fitting {}+{} samples with degree {} through {}... "
			"Conditioning of LS system: {:.4e}.").format(
			len(support), len(vander) - len(support),
			deg, polyfitname(self.polybasis),
			fitOut[1][2][0] / fitOut[1][2][-1])
			else: msg = None
			self.coeffsLocal = fitOut[0][: len(support)].reshape((len(support),)
			+ outDim)
			if totalDegree:
			self.coeffsGlobal = degreeTotalToFull(tuple([deg + 1] * self.npar)
			+ outDim, self.npar, P)
			else:
			self.coeffsGlobal = P.reshape(tuple([d + 1 for d in deg]) + outDim)
			return fitOut[1][1] == vander.shape[1], msg

RROMPy/rrompy/utilities/poly_fitting/radial_basis/radial_basis_interpolator.py6c4eee04e0dfmaster

radial_basis_interpolator.pyView Options

RROMPy/rrompy/utilities/poly_fitting/radial_basis/radial_basis_interpolator.py
6c4eee04e0dfmaster

radial_basis_interpolator.py
View Options