Zadeh's fuzzy extension principle by the transformation method, where the optimization problems are solved by sampling the optimization domains and taking the best points. More...

#include <FuzzyExtensionPrincipleViaTransformation.hpp>

Inheritance diagram for sgpp::optimization::FuzzyExtensionPrincipleViaTransformation:

Public Member Functions
void	clone (std::unique_ptr< FuzzyExtensionPrinciple > &clone) const override

	FuzzyExtensionPrincipleViaTransformation (const base::ScalarFunction &f, size_t numberOfAlphaSegments=DEFAULT_NUMBER_OF_ALPHA_SEGMENTS)
	Constructor.

	FuzzyExtensionPrincipleViaTransformation (const FuzzyExtensionPrincipleViaTransformation &other)
	Copy constructor.

	~FuzzyExtensionPrincipleViaTransformation () override
	Destructor.

Public Member Functions inherited from sgpp::optimization::FuzzyExtensionPrincipleViaOptimization
	FuzzyExtensionPrincipleViaOptimization (const base::ScalarFunction &f, size_t numberOfAlphaSegments=DEFAULT_NUMBER_OF_ALPHA_SEGMENTS)
	Constructor.

	FuzzyExtensionPrincipleViaOptimization (const FuzzyExtensionPrincipleViaOptimization &other)
	Copy constructor.

	FuzzyExtensionPrincipleViaOptimization (const optimizer::UnconstrainedOptimizer &optimizer, size_t numberOfAlphaSegments=DEFAULT_NUMBER_OF_ALPHA_SEGMENTS)
	Constructor with custom optimization algorithm.

	~FuzzyExtensionPrincipleViaOptimization () override
	Destructor.

Public Member Functions inherited from sgpp::optimization::FuzzyExtensionPrinciple
FuzzyInterval *	apply (const std::vector< FuzzyInterval * > &xFuzzy)
	Apply the fuzzy extension principle to fuzzy input intervals.

	FuzzyExtensionPrinciple (const base::ScalarFunction &f, size_t numberOfAlphaSegments=DEFAULT_NUMBER_OF_ALPHA_SEGMENTS)
	Constructor.

	FuzzyExtensionPrinciple (const FuzzyExtensionPrinciple &other)
	Copy constructor.

const base::DataVector &	getAlphaLevels () const

const std::vector< base::DataVector > &	getMaximumPoints () const

const base::DataVector &	getMaximumValues () const

const std::vector< base::DataVector > &	getMinimumPoints () const

const base::DataVector &	getMinimumValues () const

size_t	getNumberOfAlphaSegments () const

const std::vector< base::DataVector > &	getOptimizationDomainsLowerBounds () const

const std::vector< base::DataVector > &	getOptimizationDomainsUpperBounds () const

void	setNumberOfAlphaSegments (size_t numberOfAlphaSegments)

virtual	~FuzzyExtensionPrinciple ()
	Destructor.

Protected Member Functions
void	optimizeForSingleAlphaLevel (size_t j, base::DataVector &minimumPoint, double &minimumValue, base::DataVector &maximumPoint, double &maximumValue) override
	Solve the minimization/maximization problem for a single \(\alpha\) level.

void	prepareApply () override
	Custom preparation method that is called before the parallelized optimizeForSingleAlphaLevel calls.

Protected Attributes
std::vector< std::vector< base::DataVector > >	C
	sampling points

std::vector< size_t >	gammaSize
	index scaling vector

base::DataVector	xTmp
	temporary vector used in optimizeForSingleAlphaLevel

Protected Attributes inherited from sgpp::optimization::FuzzyExtensionPrincipleViaOptimization
optimizer::MultiStart	defaultOptimizer
	default optimization algorithm

std::unique_ptr< base::ScalarFunctionGradient >	fGradient
	objective function gradient

std::unique_ptr< base::ScalarFunctionGradient >	fGradientScaled
	scaled objective gradient (confidence interval to unit hyper-cube)

std::unique_ptr< base::ScalarFunctionHessian >	fHessian
	objective function Hessian

std::unique_ptr< base::ScalarFunctionHessian >	fHessianScaled
	scaled objective Hessian (confidence interval to unit hyper-cube)

std::unique_ptr< base::ScalarFunction >	fScaled
	scaled objective function (confidence interval to unit hyper-cube)

std::unique_ptr< optimizer::UnconstrainedOptimizer >	optimizer
	optimization algorithm

Protected Attributes inherited from sgpp::optimization::FuzzyExtensionPrinciple
base::DataVector	alphaLevels
	number of \(\alpha\) segments

std::unique_ptr< base::ScalarFunction >	f
	function through which to propagate the uncertainties

size_t	m
	number of \(\alpha\) segments

std::vector< base::DataVector >	maximumPoints
	vector of maximum points (after `apply` call)

base::DataVector	maximumValues
	vector of maximum function values (after `apply` call)

std::vector< base::DataVector >	minimumPoints
	vector of minimum points (after `apply` call)

base::DataVector	minimumValues
	vector of minimum function values (after `apply` call)

std::vector< base::DataVector >	optimizationDomainsLowerBounds
	vector of lower bounds of input confidence intervals (after `apply` call)

std::vector< base::DataVector >	optimizationDomainsUpperBounds
	vector of upper bounds of input confidence intervals (after `apply` call)

Additional Inherited Members
Static Public Attributes inherited from sgpp::optimization::FuzzyExtensionPrinciple
static const size_t	DEFAULT_NUMBER_OF_ALPHA_SEGMENTS = 10
	default number of \(\alpha\) segments

Detailed Description

Zadeh's fuzzy extension principle by the transformation method, where the optimization problems are solved by sampling the optimization domains and taking the best points.

The transformation method produces inaccurate results if the fuzzy input intervals are not fuzzy numbers, i.e., if the confidence intervals for \(\alpha = 1\) contain more than one point.

Constructor & Destructor Documentation

◆ FuzzyExtensionPrincipleViaTransformation() [1/2]

sgpp::optimization::FuzzyExtensionPrincipleViaTransformation::FuzzyExtensionPrincipleViaTransformation	(	const base::ScalarFunction &	f,
		size_t	numberOfAlphaSegments = `DEFAULT_NUMBER_OF_ALPHA_SEGMENTS`
	)

explicit

Constructor.

Parameters

f	function through which to propagate the uncertainties
numberOfAlphaSegments	number of \(\alpha\) segments

◆ FuzzyExtensionPrincipleViaTransformation() [2/2]

sgpp::optimization::FuzzyExtensionPrincipleViaTransformation::FuzzyExtensionPrincipleViaTransformation ( const FuzzyExtensionPrincipleViaTransformation & other )

Copy constructor.

Parameters

other other fuzzy extension principle

◆ ~FuzzyExtensionPrincipleViaTransformation()

sgpp::optimization::FuzzyExtensionPrincipleViaTransformation::~FuzzyExtensionPrincipleViaTransformation ( )

override

Destructor.

Member Function Documentation

◆ clone()

void sgpp::optimization::FuzzyExtensionPrincipleViaTransformation::clone ( std::unique_ptr< FuzzyExtensionPrinciple > & clone ) const

overridevirtual

Parameters

[out] clone pointer to cloned object

Reimplemented from sgpp::optimization::FuzzyExtensionPrincipleViaOptimization.

References clone().

Referenced by clone().

◆ optimizeForSingleAlphaLevel()

void sgpp::optimization::FuzzyExtensionPrincipleViaTransformation::optimizeForSingleAlphaLevel	(	size_t	j,
		base::DataVector &	minimumPoint,
		double &	minimumValue,
		base::DataVector &	maximumPoint,
		double &	maximumValue
	)

overrideprotectedvirtual

Solve the minimization/maximization problem for a single \(\alpha\) level.

Parameters

[in]	j	index of \(\alpha\) level
[out]	minimumPoint	minimum point
[out]	minimumValue	minimum function value
[out]	maximumPoint	maximum point
[out]	maximumValue	maximum function value