/usr/include/openturns/NumericalMathEvaluationImplementation.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 | // -*- C++ -*-
/**
* @file NumericalMathEvaluationImplementation.hxx
* @brief Abstract top-level class for all numerical math function implementations
*
* (C) Copyright 2005-2011 EDF
*
* Permission to copy, use, modify, sell and distribute this software
* is granted provided this copyright notice appears in all copies.
* This software is provided "as is" without express or implied
* warranty, and with no claim as to its suitability for any purpose.
*
*
* \author $LastChangedBy: souchaud $
* \date $LastChangedDate: 2011-07-01 10:34:36 +0200 (Fri, 01 Jul 2011) $
*/
#ifndef OPENTURNS_NUMERICALMATHEVALUATIONIMPLEMENTATION_HXX
#define OPENTURNS_NUMERICALMATHEVALUATIONIMPLEMENTATION_HXX
#include "PersistentObject.hxx"
#include "NumericalPoint.hxx"
#include "NumericalPointWithDescription.hxx"
#include "NumericalSample.hxx"
#include "Exception.hxx"
#include "Description.hxx"
#include "Indices.hxx"
#include "FunctionCache.hxx"
#include "Matrix.hxx"
#include "Collection.hxx"
#include "Pointer.hxx"
#include "StorageManager.hxx"
namespace OpenTURNS {
namespace Base {
namespace Func {
/**
* @class NumericalMathEvaluationImplementation
*
* This class offers an abstract interface for the implementation
* of an real numerical mathematical function into the platform.
*/
class NumericalMathEvaluationImplementation
: public Common::PersistentObject
{
CLASSNAME;
public:
typedef Pointer<NumericalMathEvaluationImplementation> Implementation;
typedef Type::Description Description;
typedef Type::NumericalPoint NumericalPoint;
typedef Type::Indices Indices;
typedef Type::Matrix Matrix;
typedef Common::InvalidArgumentException InvalidArgumentException;
typedef Common::InternalException InternalException;
typedef Stat::NumericalSample NumericalSample;
typedef Common::StorageManager StorageManager;
typedef Base::Func::FunctionCache CacheType;
typedef Pointer<CacheType> CacheImplementation;
typedef Type::NumericalPointWithDescription NumericalPointWithDescription;
/** Default constructor */
NumericalMathEvaluationImplementation();
/** Virtual constructor */
virtual NumericalMathEvaluationImplementation * clone() const;
/** Comparison operator */
Bool operator ==(const NumericalMathEvaluationImplementation & other) const;
/** String converter */
virtual String __repr__() const;
virtual String __str__(const String & offset = "") const;
/** 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;
/** Enable or disable the internal cache */
void enableCache() const;
void disableCache() const;
Bool isCacheEnabled() const;
void setCache(const CacheType & cache);
const FunctionCache getCache() const;
/* Here is the interface that all derived class must implement */
/** Test for actual implementation */
virtual Bool isActualImplementation() const;
/** Operator () */
virtual NumericalPoint operator() (const NumericalPoint & inP) const
/* throw(InvalidArgumentException, InternalException) */;
/** Operator () on a sample, not pure virtual because a generic implementation is given */
virtual NumericalSample operator() (const NumericalSample & inSample) const
/* throw(InvalidArgumentException, InternalException) */;
/** Accessor for input point dimension */
virtual UnsignedLong getInputDimension() const
/* throw(InternalException) */;
/** Accessor for output point dimension */
virtual UnsignedLong getOutputDimension() const
/* throw(InternalException) */;
/** Get the i-th marginal evaluation */
virtual NumericalMathEvaluationImplementation * getMarginal(const UnsignedLong i) const;
/** Get the evaluation corresponding to indices components */
virtual NumericalMathEvaluationImplementation * getMarginal(const Indices & indices) const;
/** 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);
/** Get the number of calls to operator() */
UnsignedLong getCallsNumber() const;
/** Method save() stores the object through the StorageManager */
void save(StorageManager::Advocate & adv) const;
/** Method load() reloads the object from the StorageManager */
void load(StorageManager::Advocate & adv);
protected:
/** Number of calls since the construction */
mutable UnsignedLong callsNumber_;
/* A cache to store already computed points */
mutable CacheImplementation p_cache_;
private:
/** The description of all the components */
Description description_;
/** The value and description of all the parameters */
NumericalPointWithDescription parameters_;
}; /* class NumericalMathEvaluationImplementation */
} /* namespace Func */
} /* namespace Base */
} /* namespace OpenTURNS */
#endif /* OPENTURNS_NUMERICALMATHEVALUATIONIMPLEMENTATION_HXX */
|