olb::opti Namespace Reference

All optimization code is contained in this namespace. More...

Namespaces
namespace	projection

Classes
class	AdjointLbSolverBase
	Base class for solvers that solve both primal and dual problems. More...
class	BlockDdifferenceObjectiveDf3D
	functor to compute 0.5*(f-f_wanted)^2 on a lattice More...
class	BlockDrelativeDifferenceObjectiveComponentDf3D
	functor to compute 0.5*(f[extractDim]-f_wanted[0])^2/f_wanted^2 on a lattice More...
class	BlockDrelativeDifferenceObjectiveDf3D
	functor to compute 0.5(f-f_wanted)^2/f_wanted^2 on a lattice More...
class	BlockLatticeDphysDissipationDf3D
	functor to get the pointwise dual dissipation density on local lattices, if globIC is not on the local processor, the returned vector is empty More...
class	BlockLatticeDphysVelocityDf3D
	functor to get pointwise dual velocity density on local lattices, if globIC is not on the local processor, the returned vector is empty More...
class	BlockLatticeSerialDataF
class	Controller
class	DdifferenceObjectiveDf3D
	functor to compute 0.5*(f-f_wanted)^2 on a lattice More...
class	DifferenceObjective3D
	functor to compute 0.5*L2Norm(f-f_wanted)^2 on a lattice More...
class	DrelativeDifferenceObjectiveComponentDf3D
	functor to compute 0.5*(f[extractDim]-f_wanted[0])^2/f_wanted^2 on a lattice More...
class	DrelativeDifferenceObjectiveDf3D
	functor to compute 0.5(f-f_wanted)^2/f_wanted^2 on a lattice More...
class	DrelativeDifferenceObjectiveDf3D_Lattice
	functor to compute 0.5(f-f_wanted)^2/f_wanted^2 on a lattice More...
struct	DualBoundaryHelpers
	All boundary helper functions are inside this structure. More...
class	DualController
class	DualForcedBGKdynamics
	Implementation of the dual BGK collision step with external force. More...
class	DualForcedMRTdynamics
	Implementation of the dual MRT collision step with external force. More...
struct	dualLbDynamicsHelpers
	All helper functions are inside this structure. More...
struct	dualLbExternalHelpers
	Helper functions for dynamics that access external field. More...
struct	dualLbHelpers
	This structure forwards the calls to the appropriate helper class. More...
struct	dualLbLatticeHelpers
	Helper functions with full-lattice access. More...
class	DualPorousBGKdynamics
	Implementation of the dual BGK collision step with external force. More...
class	GeometrySerializer
	This class serializes the cells inside the geometry. More...
class	OptiCase
	Abstract base class for optimization tasks. More...
class	OptiCaseAD
	Derivatives are computed with automatic differentiation. More...
class	OptiCaseAdForSolver
	Interface for OptiCaseAD that performs Lattice-Boltzmann-Solver construction itself (from xml file) More...
class	OptiCaseAnalytical
	Gradient is just passed as a function (and not computed by an own routine) More...
class	OptiCaseCDQ
	Gradient computation with central difference quotients. More...
class	OptiCaseDQ
class	OptiCaseDual
	This class implements the evaluation of the goal functional and its derivatives by using adjoint LBM. More...
class	OptiCaseFDQ
	Gradient computation with forward difference quotients. More...
class	Optimizer
	Interface for the use of various optimization algorithms. More...
class	OptimizerBarzilaiBorwein
	Optimization algorithm: BarzilaiBorwein. More...
class	OptimizerLBFGS
	Optimization algorithm: LBFGS. More...
class	OptimizerLineSearch
	Optimization algorithm: LineSearch. More...
class	OptimizerSteepestDescent
	Optimization algorithm: SteepestDescent. More...
class	RelativeDifferenceObjective3D
	functor to compute 0.5*L2Norm(f-f_wanted)^2/L2Norm(f_wanted)^2 on a lattice More...
class	SimpleGeometrySerializer
	This class serializes the cells inside the geometry. More...
class	SparseGeometrySerializer
	This class serializes the cells which are marked by indicator. More...
class	SuperLatticeDphysDissipationDf3D
	functor to get pointwise dual dissipation density on local lattices, if globIC is not on the local processor, the returned vector is empty More...
class	SuperLatticeDphysVelocityDf3D
	functor to get pointwise dual velocity density on local lattices, if globIC is not on the local processor, the returned vector is empty More...
class	SuperLatticeSerialDataF
	A data field whose values are managed by a controller. More...

Enumerations
enum class	SolverMode : int { Reference , Primal , Dual }
	Tags different simulation modes: compute either reference simulation or perform primal or dual (adjoint) simulation. More...
enum	ControlType { ForceControl , PorosityControl }
enum	OptimizerLogType {   control , derivative , value , error ,   norm_derivative }
enum	StartValueType { Control , ProjectedControl , Porosity , Permeability }

Functions
template<typename S , typename C >
	OptiCaseAnalytical (std::function< S(const C &)>, std::function< void(const C &, C &)>) -> OptiCaseAnalytical< S, C >
template<typename S , typename C >
	OptiCaseAnalytical (std::function< S(const C &)>, std::function< void(const C &, C &)>, std::function< void(void)>) -> OptiCaseAnalytical< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &)>, std::function< void(void)>) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &)>, S, std::function< void(void)>) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &, unsigned)>, std::function< void(void)>) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &, unsigned)>, S, std::function< void(void)>) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &)>) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &)>, S) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &, unsigned)>) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseFDQ (std::function< S(const C &, unsigned)>, S) -> OptiCaseFDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &)>, std::function< void(void)>) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &)>, S, std::function< void(void)>) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &, unsigned)>, std::function< void(void)>) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &, unsigned)>, S, std::function< void(void)>) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &)>) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &)>, S) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &, unsigned)>) -> OptiCaseCDQ< S, C >
template<typename S , typename C >
	OptiCaseCDQ (std::function< S(const C &, unsigned)>, S) -> OptiCaseCDQ< S, C >
template<typename S , typename T , template< typename > typename SOLVER>
	OptiCaseAdForSolver (std::shared_ptr< SOLVER< S > >, std::shared_ptr< SOLVER< T > >) -> OptiCaseAdForSolver< S, T::dim, SOLVER, util::StdVector >
void	getGnuplotTagsFromString (std::string gplotAnalysisString, std::vector< OptimizerLogType > &gplotAnalysis)
	the gplotAnalysisString is gained from the xml file and the function than separates and prepares it to be used in the constructor
template<typename S , typename C = std::vector<S>>
OptimizerBarzilaiBorwein< S, C > *	createOptimizerBarzilaiBorwein (XMLreader const &params, std::size_t dimCtrl)
	Creator Function for Barzilai-Borwein.
template<typename S , typename C = std::vector<S>>
OptimizerLBFGS< S, C > *	createOptimizerLBFGS (XMLreader const &params, std::size_t dimCtrl)
	Creator Function for LBFGS.
template<typename S , typename C = std::vector<S>>
OptimizerSteepestDescent< S, C > *	createOptimizerSteepestDescent (XMLreader const &params, std::size_t dimCtrl)
	Creator Function for Steepest Decent.
template<typename S , unsigned dim>
int	getMaterialGlobally (SuperGeometry< S, dim > &sGeometry, LatticeR< dim+1 > latticeR)
	Helper that gives global access to material numbers.

Detailed Description

All optimization code is contained in this namespace.

Enumeration Type Documentation

ControlType

enum olb::opti::ControlType

Enumerator
ForceControl
PorosityControl

Definition at line 44 of file optiCaseDual.h.

{ForceControl, PorosityControl};

OptimizerLogType

enum olb::opti::OptimizerLogType

Enumerator
control
derivative
value
error
norm_derivative

Definition at line 46 of file optimizer.h.

{control, derivative, value, error, norm_derivative};

SolverMode

enum class olb::opti::SolverMode : int

strong

Tags different simulation modes: compute either reference simulation or perform primal or dual (adjoint) simulation.

Enumerator
Reference
Primal
Dual

Definition at line 39 of file adjointLbSolver.h.

: int {Reference, Primal, Dual};

StartValueType

enum olb::opti::StartValueType

Enumerator
Control
ProjectedControl
Porosity
Permeability

Definition at line 42 of file projection.h.

{Control, ProjectedControl, Porosity, Permeability};

Function Documentation

createOptimizerBarzilaiBorwein()

template<typename S , typename C = std::vector<S>>

OptimizerBarzilaiBorwein< S, C > * olb::opti::createOptimizerBarzilaiBorwein	(	XMLreader const &	params,
		std::size_t	dimCtrl )

Creator Function for Barzilai-Borwein.

Definition at line 181 of file optimizerBarzilaiBorwein.h.

{
  OstreamManager clout(std::cout,"createOptimizerBarzilaiBorwein");
 
  // create variables with default values
  int maxIt = 100;
 
  S controlEps = S(0);
  S eps = S(1.e-10);
 
  S lambda = 1.; //starting lambda for steepest descent step (it==0)
  int maxStepAttempts  = 100;
  std::string stepCondition = "None";
 
  bool verboseOn=true;
  std::string fname = "control.dat";
  std::string logFileName = "log.txt";
 
  bool vectorBounds = false;
  bool withUpperBound = false;
  S upperBound = S();
  bool withLowerBound = false;
  S lowerBound = S();
 
  std::vector<OptimizerLogType> gplotAnalysis  = {};
  std::string gplotAnalysisString = "";
 
  // Read Values from XML File
  params.readOrWarn<int>("Optimization", "MaxIter", "", maxIt);
 
  params.readOrWarn<S>("Optimization", "Tolerance", "", eps);
  params.readOrWarn<S>("Optimization", "ControlTolerance", "", controlEps);
  params.readOrWarn<S>("Optimization", "Lambda", "", lambda);
  params.readOrWarn<int>("Optimization", "MaxStepAttempts", "", maxStepAttempts);
  params.readOrWarn<std::string>("Optimization", "StepCondition", "", stepCondition);
 
  params.readOrWarn<bool>("Optimization", "Verbose", "", verboseOn);
  params.readOrWarn<std::string>("Optimization", "InputFileName", "", fname);
  params.readOrWarn<std::string>("Optimization", "LogFileName", "", logFileName);
 
  params.readOrWarn<bool>("Optimization", "VectorBounds", "", vectorBounds);
  if ( params.readOrWarn<S>("Optimization", "UpperBound", "", upperBound, false, false) ) {
    withUpperBound = true;
  }
  if ( params.readOrWarn<S>("Optimization", "LowerBound", "", lowerBound, false, false) ) {
    withLowerBound = true;
  }
 
  // get the parameters for the gnuplot Analysis from the xml file from the VisualizationGnuplot area
  params.readOrWarn<std::string>("Optimization", "VisualizationGnuplot", "VisualizedParameters", "", gplotAnalysisString, false, false);
  // transform the data from the xml file to the enums needed for continueing
  getGnuplotTagsFromString(gplotAnalysisString, gplotAnalysis);
 
  // Create Optimizer Object
  return new OptimizerBarzilaiBorwein<S,C>(dimCtrl, eps, maxIt, lambda, maxStepAttempts, stepCondition,
                                         verboseOn, fname, logFileName, withUpperBound, upperBound, withLowerBound, lowerBound,
                                         vectorBounds, controlEps, gplotAnalysis);
}

References getGnuplotTagsFromString(), and olb::XMLreader::readOrWarn().

Here is the call graph for this function:

createOptimizerLBFGS()

template<typename S , typename C = std::vector<S>>

OptimizerLBFGS< S, C > * olb::opti::createOptimizerLBFGS	(	XMLreader const &	params,
		std::size_t	dimCtrl )

Creator Function for LBFGS.

Definition at line 263 of file optimizerLBFGS.h.

{
  OstreamManager clout(std::cout, "createOptimizerLBFGS");
 
  // create variables with default values
  int maxIt = 100;
  int l = 20;
  S lambda = 1.; //starting lambda for steepest descent step (it==0)
  int maxStepAttempts = 100;
  std::string stepCondition = "StrongWolfe";
 
  //S controlEps = S(std::numeric_limits<double>::epsilon() );
  S controlEps = S(0);
  S eps = S(1.e-10);
  S startCoefH = S(1e-4);
 
  bool verboseOn=true;
  std::string fname = "control.dat";
  std::string logFileName = "log.txt";
  bool vectorBounds = false;
  bool withUpperBound = false;
  S upperBound = S();
  bool withLowerBound = false;
  S lowerBound = S();
  bool failOnMaxIter = true;
 
  std::vector<OptimizerLogType> gplotAnalysis  = {};
  std::string gplotAnalysisString = "";
 
  // Read Values from XML File from area "Optimization"
  params.readOrWarn<int>("Optimization", "MaxIter", "", maxIt);
  params.readOrWarn<int>("Optimization", "L", "", l);
  params.readOrWarn<S>("Optimization", "Lambda", "", lambda);
  params.readOrWarn<int>("Optimization", "MaxStepAttempts", "", maxStepAttempts);
  params.readOrWarn<std::string>("Optimization", "StepCondition", "", stepCondition);
 
  params.readOrWarn<S>("Optimization", "Tolerance", "", eps);
  params.readOrWarn<S>("Optimization", "ControlTolerance", "", controlEps);
  params.readOrWarn<S>("Optimization", "StartCoefH", "", startCoefH);
  params.readOrWarn<bool>("Optimization", "FailOnMaxIter", "", failOnMaxIter);
  params.readOrWarn<bool>("Optimization", "Verbose", "", verboseOn);
  params.readOrWarn<std::string>("Optimization", "InputFileName", "", fname);
  params.readOrWarn<std::string>("Optimization", "LogFileName", "", logFileName);
 
  params.readOrWarn<bool>("Optimization", "VectorBounds", "", vectorBounds);
  if ( params.readOrWarn<S>("Optimization", "UpperBound", "", upperBound, false, false) ) {
    withUpperBound = true;
  }
 
  if ( params.readOrWarn<S>("Optimization", "LowerBound", "", lowerBound, false, false) ) {
    withLowerBound = true;
  }
 
  // get the parameters for the gnuplot Analysis from the xml file from the VisualizationGnuplot area
  params.readOrWarn<std::string>("Optimization",
                                        "VisualizationGnuplot",
                                        "VisualizedParameters", gplotAnalysisString, false, false);
  // transform the data from the xml file to the enums needed for continueing
  getGnuplotTagsFromString(gplotAnalysisString, gplotAnalysis);
 
  clout << "Creating optimizer ..." << std::endl;
  // Create Optimizer Object
  return new OptimizerLBFGS<S,C>(dimCtrl, eps, maxIt, lambda, maxStepAttempts, stepCondition, l, startCoefH,
                               verboseOn, fname, logFileName, withUpperBound, upperBound, withLowerBound, lowerBound, vectorBounds,
                               controlEps, failOnMaxIter, gplotAnalysis);
}

References getGnuplotTagsFromString(), and olb::XMLreader::readOrWarn().

Here is the call graph for this function:

createOptimizerSteepestDescent()

template<typename S , typename C = std::vector<S>>

OptimizerSteepestDescent< S, C > * olb::opti::createOptimizerSteepestDescent	(	XMLreader const &	params,
		std::size_t	dimCtrl )

Creator Function for Steepest Decent.

Definition at line 93 of file optimizerSteepestDecent.h.

{
  OstreamManager clout(std::cout,"createOptimizerSteepestDescent");
 
  // create variables with default values
  int maxIt = 100;
 
  //S controlEps = S(std::numeric_limits<double>::epsilon() );
  S controlEps = S(0);
  S eps = S(1.e-10);
 
  S lambda = 1.;
  int maxStepAttempts = 100;
  std::string stepCondition = "Armijo";
 
  bool vectorBounds = false;
  bool verboseOn=true;
  std::string fname = "control.dat";
  std::string logFileName = "log.txt";
 
  bool withUpperBound = false;
  S upperBound = S();
  bool withLowerBound = false;
  S lowerBound = S();
 
  std::vector<OptimizerLogType> gplotAnalysis  = {};
  std::string gplotAnalysisString = "";
 
  // Read Values from XML File from area "Optimization"
  params.readOrWarn<int>("Optimization", "MaxIter", "", maxIt);
 
  params.readOrWarn<S>("Optimization", "Tolerance", "", eps);
  params.readOrWarn<S>("Optimization", "ControlTolerance", "", controlEps);
  params.readOrWarn<S>("Optimization", "Lambda", "", lambda);
  params.readOrWarn<int>("Optimization", "MaxStepAttempts", "", maxStepAttempts);
  params.readOrWarn<std::string>("Optimization", "StepCondition", "", stepCondition);
 
  params.readOrWarn<bool>("Optimization", "Verbose", "", verboseOn);
  params.readOrWarn<std::string>("Optimization", "InputFileName", "", fname);
  params.readOrWarn<std::string>("Optimization", "LogFileName", "", logFileName);
 
  params.readOrWarn<bool>("Optimization", "VectorBounds", "", vectorBounds);
  if ( params.readOrWarn<S>("Optimization", "UpperBound", "", upperBound, false, false) ) {
    withUpperBound = true;
  }
 
  if ( params.readOrWarn<S>("Optimization", "LowerBound", "", lowerBound, false, false) ) {
    withLowerBound = true;
  }
 
  // get the parameters for the gnuplot Analysis from the xml file from the VisualizationGnuplot area
  params.readOrWarn<std::string>("Optimization", "VisualizationGnuplot", "VisualizedParameters", "", gplotAnalysisString, false, false);
  // transform the data from the xml file to the enums needed for continueing
  getGnuplotTagsFromString(gplotAnalysisString, gplotAnalysis);
 
  // Create Optimizer Object
  return new OptimizerSteepestDescent<S,C>(dimCtrl, eps, maxIt, lambda, maxStepAttempts, stepCondition,
                                         verboseOn, fname, logFileName, withUpperBound, upperBound, withLowerBound, lowerBound,
                                         vectorBounds, controlEps, gplotAnalysis);
}

References getGnuplotTagsFromString(), and olb::XMLreader::readOrWarn().

Here is the call graph for this function:

getGnuplotTagsFromString()

void olb::opti::getGnuplotTagsFromString	(	std::string	gplotAnalysisString,
		std::vector< OptimizerLogType > &	gplotAnalysis )

the gplotAnalysisString is gained from the xml file and the function than separates and prepares it to be used in the constructor

Definition at line 236 of file optimizer.hh.

                                                                          {
  // part the string to get the enum vector
  std::vector<std::string> gplotAnalysisStringVector;
  std::istringstream iss(gplotAnalysisString);
  std::copy(std::istream_iterator<std::string>(iss),
        std::istream_iterator<std::string>(),
       std::back_inserter(gplotAnalysisStringVector));
 
  for(unsigned i = 0; i < gplotAnalysisStringVector.size(); i++){
    if(gplotAnalysisStringVector[i] == "VALUE"){
      gplotAnalysis.push_back(OptimizerLogType::value);
    } else if(gplotAnalysisStringVector[i] == "CONTROL"){
      gplotAnalysis.push_back(OptimizerLogType::control);
    } else if(gplotAnalysisStringVector[i] == "DERIVATIVE"){
      gplotAnalysis.push_back(OptimizerLogType::derivative);
    } else if(gplotAnalysisStringVector[i] == "ERROR"){
      gplotAnalysis.push_back(OptimizerLogType::error);
    } else if(gplotAnalysisStringVector[i] == "NORM_DERIVATIVE"){
      gplotAnalysis.push_back(OptimizerLogType::norm_derivative);
    }
  }
}

References control, derivative, error, norm_derivative, and value.

Here is the caller graph for this function:

getMaterialGlobally()

template<typename S , unsigned dim>

int olb::opti::getMaterialGlobally	(	SuperGeometry< S, dim > &	sGeometry,
		LatticeR< dim+1 >	latticeR )

Helper that gives global access to material numbers.

Definition at line 298 of file serialization.h.

{
  int material = 0;
  if ( sGeometry.getLoadBalancer().rank(latticeR[0]) == singleton::mpi().getRank() ) {
    material = sGeometry.get(latticeR);
  }
#ifdef PARALLEL_MODE_MPI
  singleton::mpi().bCast(&material, 1, sGeometry.getLoadBalancer().rank(latticeR[0]));
#endif
  return material;
}

References olb::singleton::MpiManager::bCast(), olb::SuperGeometry< T, D >::get(), olb::SuperStructure< T, D >::getLoadBalancer(), olb::singleton::MpiManager::getRank(), and olb::singleton::mpi().

Here is the call graph for this function:

Here is the caller graph for this function:

OptiCaseAdForSolver()

template<typename S , typename T , template< typename > typename SOLVER>

olb::opti::OptiCaseAdForSolver	(	std::shared_ptr< SOLVER< S > >	,
		std::shared_ptr< SOLVER< T > >	) -> OptiCaseAdForSolver< S, T::dim, SOLVER, util::StdVector >

OptiCaseAnalytical() [1/2]

template<typename S , typename C >

olb::opti::OptiCaseAnalytical	(	std::function< S(const C &)>	,
		std::function< void(const C &, C &)>	) -> OptiCaseAnalytical< S, C >

OptiCaseAnalytical() [2/2]

template<typename S , typename C >

olb::opti::OptiCaseAnalytical	(	std::function< S(const C &)>	,
		std::function< void(const C &, C &)>	,
		std::function< void(void)>	) -> OptiCaseAnalytical< S, C >

OptiCaseCDQ() [1/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ

(

std::function< S(const C &)>

)

-> OptiCaseCDQ< S, C >

OptiCaseCDQ() [2/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ	(	std::function< S(const C &)>	,
		S	) -> OptiCaseCDQ< S, C >

OptiCaseCDQ() [3/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ	(	std::function< S(const C &)>	,
		S	,
		std::function< void(void)>	) -> OptiCaseCDQ< S, C >

OptiCaseCDQ() [4/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ	(	std::function< S(const C &)>	,
		std::function< void(void)>	) -> OptiCaseCDQ< S, C >

OptiCaseCDQ() [5/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ

(

std::function< S(const C &, unsigned)>

)

-> OptiCaseCDQ< S, C >

OptiCaseCDQ() [6/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ	(	std::function< S(const C &, unsigned)>	,
		S	) -> OptiCaseCDQ< S, C >

OptiCaseCDQ() [7/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ	(	std::function< S(const C &, unsigned)>	,
		S	,
		std::function< void(void)>	) -> OptiCaseCDQ< S, C >

OptiCaseCDQ() [8/8]

template<typename S , typename C >

olb::opti::OptiCaseCDQ	(	std::function< S(const C &, unsigned)>	,
		std::function< void(void)>	) -> OptiCaseCDQ< S, C >

OptiCaseFDQ() [1/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ

(

std::function< S(const C &)>

)

-> OptiCaseFDQ< S, C >

OptiCaseFDQ() [2/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ	(	std::function< S(const C &)>	,
		S	) -> OptiCaseFDQ< S, C >

OptiCaseFDQ() [3/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ	(	std::function< S(const C &)>	,
		S	,
		std::function< void(void)>	) -> OptiCaseFDQ< S, C >

OptiCaseFDQ() [4/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ	(	std::function< S(const C &)>	,
		std::function< void(void)>	) -> OptiCaseFDQ< S, C >

OptiCaseFDQ() [5/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ

(

std::function< S(const C &, unsigned)>

)

-> OptiCaseFDQ< S, C >

OptiCaseFDQ() [6/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ	(	std::function< S(const C &, unsigned)>	,
		S	) -> OptiCaseFDQ< S, C >

OptiCaseFDQ() [7/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ	(	std::function< S(const C &, unsigned)>	,
		S	,
		std::function< void(void)>	) -> OptiCaseFDQ< S, C >

OptiCaseFDQ() [8/8]

template<typename S , typename C >

olb::opti::OptiCaseFDQ	(	std::function< S(const C &, unsigned)>	,
		std::function< void(void)>	) -> OptiCaseFDQ< S, C >