/usr/include/openturns/NumericalMathFunction.hxx is in libopenturns-dev 0.15-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 | // -*- C++ -*-
/**
* @file NumericalMathFunction.hxx
* @brief The class that implements numerical math functions
*
* (C) Copyright 2005-2011 EDF-EADS-Phimeca
*
* This library 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 2.1 of the License.
*
* This library 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 this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* @author: $LastChangedBy: schueller $
* @date: $LastChangedDate: 2011-05-24 19:30:41 +0200 (Tue, 24 May 2011) $
* Id: $Id: NumericalMathFunction.hxx 1910 2011-05-24 17:30:41Z schueller $
*/
#ifndef OPENTURNS_NUMERICALMATHFUNCTION_HXX
#define OPENTURNS_NUMERICALMATHFUNCTION_HXX
#include "TypedInterfaceObject.hxx"
#include "NumericalMathFunctionImplementation.hxx"
#include "ComparisonOperator.hxx"
#include "Collection.hxx"
namespace OpenTURNS {
namespace Base {
namespace Func {
/**
* @class NumericalMathFunction
* @brief Simulates a numerical math function
* @ingroup Function
*
* The class that simulates a numerical math function,
* its gradient and its hessian. This class is just an interface
* to actual implementation objects that can be hot-replaced
* during computation. Each implementation object refers to
* the function, the gradient or the hessian.
* @see NumericalMathFunctionImplementation
*/
class NumericalMathFunction
: public Common::TypedInterfaceObject<NumericalMathFunctionImplementation>
{
CLASSNAME;
public:
/* Some typedefs for easy reading */
typedef NumericalMathFunctionImplementation::Implementation Implementation;
typedef NumericalMathFunctionImplementation::EvaluationImplementation EvaluationImplementation;
typedef NumericalMathFunctionImplementation::GradientImplementation GradientImplementation;
typedef NumericalMathFunctionImplementation::HessianImplementation HessianImplementation;
typedef NumericalMathFunctionImplementation::NumericalPoint NumericalPoint;
typedef NumericalMathFunctionImplementation::NumericalPointWithDescription NumericalPointWithDescription;
typedef NumericalMathFunctionImplementation::NumericalSample NumericalSample;
typedef NumericalMathFunctionImplementation::Matrix Matrix;
typedef NumericalMathFunctionImplementation::SymmetricTensor SymmetricTensor;
typedef NumericalMathFunctionImplementation::Indices Indices;
typedef NumericalMathFunctionImplementation::Description Description;
typedef NumericalMathFunctionImplementation::InvalidArgumentException InvalidArgumentException;
typedef NumericalMathFunctionImplementation::InternalException InternalException;
typedef Common::ComparisonOperator ComparisonOperator;
typedef Type::Collection<NumericalMathFunction> NumericalMathFunctionCollection;
/** Default constructor */
NumericalMathFunction();
/** Constructor from a wrapper name
* @param name The name of the wrapper expurged of its extension
* @see WrapperFile
*/
NumericalMathFunction(const String & name);
/** Constructor from NumericalMathFunctionImplementation */
NumericalMathFunction(const NumericalMathFunctionImplementation & implementation);
#ifndef SWIG
/** Constructor from implementation */
NumericalMathFunction(const Implementation & p_implementation);
/** Constructor from implementation pointer */
NumericalMathFunction(NumericalMathFunctionImplementation * p_implementation);
#endif
/** @brief Composition constructor
*
* Builds a new %NumericalMathFunction from two others as if they were mathematicaly composed,
*
* Example: h = f o g
* - f is the left %NumericalMathFunction
* - g is the right %NumericalMathFunction
* - h is the composed %NumericalMathFunction
* .
* The condition for successful composition is that the dimension of the output of g is the dimension
* of the input of f. The composed %NumericalMathFunction has the input dimension of g and the output dimension
* of f.
* @param left The left %NumericalMathFunction (aka f)
* @param right The right %NumericalMathFunction (aka g)
*/
NumericalMathFunction(const NumericalMathFunction & left,
const NumericalMathFunction & right);
/** @brief Analytical formula constructor
*
* Builds a new %NumericalMathFunction by analytical expression parsing. The expression involving the input
* variables (stored in \e inputVariablesNames) to produce the output variables (stored in \e outputVariablesNames)
* are described in \e formulas.
*
* The input dimension of the new %NumericalMathFunction is the size of \e inputVariablesNames and
* the output dimension of the new %NumericalMathFunction is the size of \e outputVariablesName.
* @param inputVariablesNames The ordered collection of input variables names
* @param outputVariablesNames The ordered collection of output variables names
* @param formulas The ordered collection of analytical expressions to compute the output variables
*/
NumericalMathFunction(const Description & inputVariablesNames,
const Description & outputVariablesNames,
const Description & formulas);
/** Same as the previous one, but with default names for the output variables */
NumericalMathFunction(const Description & inputVariablesNames,
const Description & formulas);
/** Indicator function constructor */
NumericalMathFunction(const NumericalMathFunction & function,
const ComparisonOperator & comparisonOperator,
const NumericalScalar threshold);
/** Aggregated function constructor: the output is the aggregation of the several functions */
NumericalMathFunction(const NumericalMathFunctionCollection & functionCollection);
/** Linear combination function constructor */
NumericalMathFunction(const NumericalMathFunctionCollection & functionCollection,
const NumericalPoint & coefficients);
/** Dual linear combination function constructor */
NumericalMathFunction(const NumericalMathFunctionCollection & functionCollection,
const NumericalSample & coefficients);
/** Simplified analytical formula constructor */
NumericalMathFunction(const String & inputVariableName,
const String & formula,
const String & outputVariableName = "outputVariable");
#ifndef SWIG
/** Constructor from implementations */
NumericalMathFunction(const EvaluationImplementation & evaluationImplementation,
const GradientImplementation & gradientImplenmentation,
const HessianImplementation & hessianImplementation);
#endif
/** Constructor from a wrapper file */
NumericalMathFunction(const WrapperFile & wrapperFile);
/** Constructor from samples */
NumericalMathFunction(const NumericalSample & inputSample,
const NumericalSample & outputSample);
/** Comparison operator */
Bool operator ==(const NumericalMathFunction & other) const;
/** String converter */
virtual String __repr__() const;
/** String converter */
virtual String __str__(const String & offset = "") const;
/** @brief Enable the internal cache
*
* The cache stores previously computed output values, so calling the cache before processing the %NumericalMathFunction
* can save much time and avoid useless computations. However, calling the cache can eat time if the computation is
* very short. So cache is disabled by default, except when the underlying implementation uses a wrapper.
*
* The reason is that building and linking to a wrapper is an extra burden that is valuable only if the computation
* code is long enough to justify it. Calling the cache in this case will save time for sure.
*/
void enableCache() const;
/** @brief Disable the internal cache
* @see enableCache()
*/
void disableCache() const;
/** @brief Test the internal cache activity
* @see enableCache()
*/
Bool isCacheEnabled() const;
/** Function implementation accessors */
void setEvaluationImplementation(const EvaluationImplementation & functionImplementation);
const EvaluationImplementation & getEvaluationImplementation() const;
/** Gradient implementation accessors */
void setGradientImplementation(const NumericalMathGradientImplementation & gradientImplementation);
#ifndef SWIG
/** Gradient implementation accessors */
void setGradientImplementation(const GradientImplementation & gradientImplementation);
#endif
const GradientImplementation & getGradientImplementation() const;
/** Hessian implementation accessors */
void setHessianImplementation(const NumericalMathHessianImplementation & hessianImplementation);
#ifndef SWIG
/** Hessian implementation accessors */
void setHessianImplementation(const HessianImplementation & hessianImplementation);
#endif
const HessianImplementation & getHessianImplementation() const;
/** Initial function implementation accessors */
const EvaluationImplementation & getInitialEvaluationImplementation() const;
/** Initial gradient implementation accessors */
const GradientImplementation & getInitialGradientImplementation() const;
/** Initial hessian implementation accessors */
const HessianImplementation & getInitialHessianImplementation() const;
/** Flag for default gradient accessors */
Bool getUseDefaultGradientImplementation() const;
void setUseDefaultGradientImplementation(const Bool gradientFlag);
/** Flag for default hessian accessors */
Bool getUseDefaultHessianImplementation() const;
void setUseDefaultHessianImplementation(const Bool hessianFlag);
/** Multiplication of two 1D output functions with the same input dimension */
virtual NumericalMathFunction operator * (const NumericalMathFunction & right) const;
/** Operator () */
NumericalPoint operator() (const NumericalPoint & inP) const
/* throw(InvalidArgumentException,InternalException) */;
NumericalSample operator() (const NumericalSample & inS) const
/* throw(InvalidArgumentException,InternalException) */;
/** Method gradient() returns the Jacobian transposed matrix of the function at point */
Matrix gradient(const NumericalPoint & inP) const
/* throw(InvalidArgumentException,InternalException) */;
/** Method hessian() returns the symmetric tensor of the function at point */
SymmetricTensor hessian(const NumericalPoint & inP) const
/* throw(InvalidArgumentException,InternalException) */;
/** Gradient according to the marginal parameters */
virtual Matrix parametersGradient(const NumericalPoint & inP) const;
/** Parameters value and description accessor */
virtual NumericalPointWithDescription getParameters() const;
virtual void setParameters(const NumericalPointWithDescription & parameters);
/** Accessor for input point dimension
* @deprecated
* This method is deprecated. Use getInputDimension() instead.
*/
UnsignedLong getInputNumericalPointDimension() const DEPRECATED
/* throw(InternalException) */;
/** Accessor for output point dimension
* @deprecated
* This method is deprecated. Use getOutputDimension() instead.
*/
UnsignedLong getOutputNumericalPointDimension() const DEPRECATED
/* throw(InternalException) */;
/** Accessor for input point dimension */
UnsignedLong getInputDimension() const
/* throw(InternalException) */;
/** Accessor for output point dimension */
UnsignedLong getOutputDimension() const
/* throw(InternalException) */;
/** Description Accessor, i.e. the names of the input and output parameters */
void setDescription(const Description & description);
Description getDescription() const;
/** Input description Accessor, i.e. the names of the input parameters */
Description getInputDescription() const;
/** Output description Accessor, i.e. the names of the Output parameters */
Description getOutputDescription() const;
/** Get the i-th marginal function */
NumericalMathFunction getMarginal(const UnsignedLong i) const /* throw(InvalidArgumentException) */;
/** Get the function corresponding to indices components */
NumericalMathFunction getMarginal(const Indices & indices) const /* throw(InvalidArgumentException) */;
/** Number of calls to the evaluation */
UnsignedLong getEvaluationCallsNumber() const;
/** Number of calls to the gradient */
UnsignedLong getGradientCallsNumber() const;
/** Number of calls to the hessian */
UnsignedLong getHessianCallsNumber() const;
/** Static methods for documentation of analytical fnctions */
static Description GetValidConstants();
static Description GetValidFunctions();
static Description GetValidOperators();
}; /* class NumericalMathFunction */
} /* namespace Func */
} /* namespace Base */
} /* namespace OpenTURNS */
#endif /* OPENTURNS_NUMERICALMATHFUNCTION_HXX */
|