bpp-core-2.2.0/genIncludes.sh000775 001750 001750 00000001231 12370705300 017477 0ustar00jdutheiljdutheil000000 000000 #! /bin/bash createGeneric() { echo "-- Creating generic include file: $1.all" #Make sure we run into subdirectories first: dirs=() for file in "$1"/* do if [ -d "$file" ] then # Recursion: dirs+=( "$file" ) fi done for dir in ${dirs[@]} do createGeneric $dir done #Now list all files, including newly created .all files: if [ -f $1.all ] then rm $1.all fi dir=`basename $1` for file in "$1"/* do if [ -f "$file" ] && ( [ "${file##*.}" == "h" ] || [ "${file##*.}" == "all" ] ) then file=`basename $file` echo "#include \"$dir/$file\"" >> $1.all fi done; } createGeneric $1 bpp-core-2.2.0/src/CMakeLists.txt000664 001750 001750 00000022553 12370705300 020241 0ustar00jdutheiljdutheil000000 000000 # CMake script for Bio++ Core # Author: Sylvain Gaillard and Julien Dutheil # Created: 17/08/2009 # File list SET(CPP_FILES Bpp/Exceptions.cpp Bpp/BppString.cpp Bpp/App/ApplicationTools.cpp Bpp/App/BppApplication.cpp Bpp/App/NumCalcApplicationTools.cpp Bpp/Io/FileTools.cpp Bpp/Io/BppOParametrizableFormat.cpp Bpp/Io/BppODiscreteDistributionFormat.cpp Bpp/Io/IoDiscreteDistributionFactory.cpp Bpp/Utils/AttributesTools.cpp Bpp/Text/KeyvalTools.cpp Bpp/Text/NestedStringTokenizer.cpp Bpp/Text/StringTokenizer.cpp Bpp/Text/TextTools.cpp Bpp/Graph/BasicONode.cpp Bpp/Graph/BasicTNode.cpp Bpp/Graphics/ColorTools.cpp Bpp/Graphics/GraphicDevice.cpp Bpp/Graphics/Fig/XFigGraphicDevice.cpp Bpp/Graphics/Fig/XFigLaTeXFontManager.cpp Bpp/Graphics/Fig/XFigPostscriptFontManager.cpp Bpp/Graphics/Font/Font.cpp Bpp/Graphics/Latex/DvipsColorSet.cpp Bpp/Graphics/Latex/PgfGraphicDevice.cpp Bpp/Graphics/Molscript/MolscriptColorSet.cpp Bpp/Graphics/Svg/SvgGraphicDevice.cpp Bpp/Graphics/R/RColorSet.cpp Bpp/Numeric/NumTools.cpp Bpp/Numeric/Parameter.cpp Bpp/Numeric/ParameterExceptions.cpp Bpp/Numeric/ParameterList.cpp Bpp/Numeric/Random/RandomTools.cpp Bpp/Numeric/Random/ContingencyTableGenerator.cpp Bpp/Numeric/Random/Uniform01K.cpp Bpp/Numeric/Random/Uniform01QD.cpp Bpp/Numeric/Random/Uniform01WH.cpp Bpp/Numeric/AbstractParameterAliasable.cpp Bpp/Numeric/AbstractParametrizable.cpp Bpp/Numeric/AdaptiveKernelDensityEstimation.cpp Bpp/Numeric/VectorTools.cpp Bpp/Numeric/AutoParameter.cpp Bpp/Numeric/DataTable.cpp Bpp/Numeric/Function/AbstractOptimizer.cpp Bpp/Numeric/Function/BrentOneDimension.cpp Bpp/Numeric/Function/ConjugateGradientMultiDimensions.cpp Bpp/Numeric/Function/DirectionFunction.cpp Bpp/Numeric/Function/DownhillSimplexMethod.cpp Bpp/Numeric/Function/FivePointsNumericalDerivative.cpp Bpp/Numeric/Function/FunctionTools.cpp Bpp/Numeric/Function/GoldenSectionSearch.cpp Bpp/Numeric/Function/MetaOptimizer.cpp Bpp/Numeric/Function/NewtonOneDimension.cpp Bpp/Numeric/Function/NewtonBacktrackOneDimension.cpp Bpp/Numeric/Function/BfgsMultiDimensions.cpp Bpp/Numeric/Function/OneDimensionOptimizationTools.cpp Bpp/Numeric/Function/OptimizationStopCondition.cpp Bpp/Numeric/Function/PowellMultiDimensions.cpp Bpp/Numeric/Function/ReparametrizationFunctionWrapper.cpp Bpp/Numeric/Function/SimpleMultiDimensions.cpp Bpp/Numeric/Function/SimpleNewtonMultiDimensions.cpp Bpp/Numeric/Function/ThreePointsNumericalDerivative.cpp Bpp/Numeric/Function/TwoPointsNumericalDerivative.cpp Bpp/Numeric/Hmm/HmmLikelihood.cpp Bpp/Numeric/Hmm/AbstractHmmTransitionMatrix.cpp Bpp/Numeric/Hmm/FullHmmTransitionMatrix.cpp Bpp/Numeric/Hmm/AutoCorrelationTransitionMatrix.cpp Bpp/Numeric/Hmm/LogsumHmmLikelihood.cpp Bpp/Numeric/Hmm/LowMemoryRescaledHmmLikelihood.cpp Bpp/Numeric/Hmm/RescaledHmmLikelihood.cpp Bpp/Numeric/Prob/Simplex.cpp Bpp/Numeric/Prob/AbstractDiscreteDistribution.cpp Bpp/Numeric/Prob/BetaDiscreteDistribution.cpp Bpp/Numeric/Prob/ConstantDistribution.cpp Bpp/Numeric/Prob/DirichletDiscreteDistribution.cpp Bpp/Numeric/Prob/ExponentialDiscreteDistribution.cpp Bpp/Numeric/Prob/GammaDiscreteDistribution.cpp Bpp/Numeric/Prob/GaussianDiscreteDistribution.cpp Bpp/Numeric/Prob/InvariantMixedDiscreteDistribution.cpp Bpp/Numeric/Prob/MixtureOfDiscreteDistributions.cpp Bpp/Numeric/Prob/SimpleDiscreteDistribution.cpp Bpp/Numeric/Prob/TruncatedExponentialDiscreteDistribution.cpp Bpp/Numeric/Prob/UniformDiscreteDistribution.cpp Bpp/Numeric/Stat/ContingencyTableTest.cpp Bpp/Numeric/Stat/StatTools.cpp Bpp/Numeric/Stat/Mva/DualityDiagram.cpp Bpp/Numeric/Stat/Mva/PrincipalComponentAnalysis.cpp Bpp/Numeric/Stat/Mva/CorrespondenceAnalysis.cpp ) SET(H_FILES Bpp/BppString.h Bpp/BppBoolean.h Bpp/BppVector.h Bpp/Clonable.h Bpp/Exceptions.h Bpp/App/ApplicationTools.h Bpp/App/BppApplication.h Bpp/App/NumCalcApplicationTools.h Bpp/Graph/UNode.h Bpp/Graph/ONode.h Bpp/Graph/TNode.h Bpp/Graph/BasicONode.h Bpp/Graph/BasicTNode.h Bpp/Graphics/AbstractGraphicDevice.h Bpp/Graphics/ColorManager.h Bpp/Graphics/ColorSet.h Bpp/Graphics/ColorTools.h Bpp/Graphics/DefaultColorSet.h Bpp/Graphics/GraphicDevice.h Bpp/Graphics/Point2D.h Bpp/Graphics/Point2DTools.h Bpp/Graphics/RgbColor.h Bpp/Io/FileTools.h Bpp/Io/IoFormat.h Bpp/Io/IoParametrizable.h Bpp/Io/IoDiscreteDistribution.h Bpp/Io/IoDiscreteDistributionFactory.h Bpp/Io/OutputStream.h Bpp/Io/BppOParametrizableFormat.h Bpp/Io/BppODiscreteDistributionFormat.h Bpp/Numeric/AbstractParameterAliasable.h Bpp/Numeric/AbstractParametrizable.h Bpp/Numeric/AdaptiveKernelDensityEstimation.h Bpp/Numeric/AutoParameter.h Bpp/Numeric/Constraints.h Bpp/Numeric/DataTableExceptions.h Bpp/Numeric/DataTable.h Bpp/Numeric/Number.h Bpp/Numeric/NumConstants.h Bpp/Numeric/NumTools.h Bpp/Numeric/ParameterAliasable.h Bpp/Numeric/ParameterExceptions.h Bpp/Numeric/Parameter.h Bpp/Numeric/ParameterList.h Bpp/Numeric/Parametrizable.h Bpp/Numeric/ParametrizableCollection.cpp Bpp/Numeric/TransformedParameter.h Bpp/Numeric/Random/RandomFactory.h Bpp/Numeric/Random/RandomTools.h Bpp/Numeric/Random/ContingencyTableGenerator.h Bpp/Numeric/Random/Uniform01K.h Bpp/Numeric/Random/Uniform01QD.h Bpp/Numeric/Random/Uniform01WH.h Bpp/Numeric/VectorExceptions.h Bpp/Numeric/VectorTools.h Bpp/Numeric/Range.h Bpp/Text/KeyvalTools.h Bpp/Text/NestedStringTokenizer.h Bpp/Text/StringTokenizer.h Bpp/Text/TextTools.h Bpp/Utils/AttributesTools.h Bpp/Utils/MapTools.h Bpp/Graphics/Fig/XFigGraphicDevice.h Bpp/Graphics/Fig/XFigLaTeXFontManager.h Bpp/Graphics/Fig/XFigPostscriptFontManager.h Bpp/Graphics/Font/Font.h Bpp/Graphics/Font/FontManager.h Bpp/Graphics/Latex/DvipsColorSet.h Bpp/Graphics/Latex/PgfGraphicDevice.h Bpp/Graphics/Molscript/MolscriptColorSet.h Bpp/Graphics/R/RColorSet.h Bpp/Graphics/Svg/SvgGraphicDevice.h Bpp/Numeric/Function/AbstractNumericalDerivative.h Bpp/Numeric/Function/AbstractOptimizer.h Bpp/Numeric/Function/BrentOneDimension.h Bpp/Numeric/Function/ConjugateGradientMultiDimensions.h Bpp/Numeric/Function/DirectionFunction.h Bpp/Numeric/Function/DownhillSimplexMethod.h Bpp/Numeric/Function/FivePointsNumericalDerivative.h Bpp/Numeric/Function/Functions.h Bpp/Numeric/Function/FunctionTools.h Bpp/Numeric/Function/GoldenSectionSearch.h Bpp/Numeric/Function/MetaOptimizer.h Bpp/Numeric/Function/NewtonOneDimension.h Bpp/Numeric/Function/NewtonBacktrackOneDimension.h Bpp/Numeric/Function/BfgsMultiDimensions.h Bpp/Numeric/Function/OneDimensionOptimizationTools.h Bpp/Numeric/Function/OptimizationStopCondition.h Bpp/Numeric/Function/Optimizer.h Bpp/Numeric/Function/PowellMultiDimensions.h Bpp/Numeric/Function/ReparametrizationFunctionWrapper.h Bpp/Numeric/Function/SimpleMultiDimensions.h Bpp/Numeric/Function/SimpleNewtonMultiDimensions.h Bpp/Numeric/Function/ThreePointsNumericalDerivative.h Bpp/Numeric/Function/TwoPointsNumericalDerivative.h Bpp/Numeric/Hmm/HmmEmissionProbabilities.h Bpp/Numeric/Hmm/HmmExceptions.h Bpp/Numeric/Hmm/HmmLikelihood.h Bpp/Numeric/Hmm/HmmStateAlphabet.h Bpp/Numeric/Hmm/HmmTransitionMatrix.h Bpp/Numeric/Hmm/AbstractHmmTransitionMatrix.h Bpp/Numeric/Hmm/FullHmmTransitionMatrix.h Bpp/Numeric/Hmm/AutoCorrelationTransitionMatrix.h Bpp/Numeric/Hmm/LogsumHmmLikelihood.h Bpp/Numeric/Hmm/LowMemoryRescaledHmmLikelihood.h Bpp/Numeric/Hmm/RescaledHmmLikelihood.h Bpp/Numeric/Matrix/EigenValue.h Bpp/Numeric/Matrix/LUDecomposition.h Bpp/Numeric/Matrix/Matrix.h Bpp/Numeric/Matrix/MatrixTools.h Bpp/Numeric/Prob/Simplex.h Bpp/Numeric/Prob/AbstractDiscreteDistribution.h Bpp/Numeric/Prob/BetaDiscreteDistribution.h Bpp/Numeric/Prob/ConstantDistribution.h Bpp/Numeric/Prob/DirichletDiscreteDistribution.h Bpp/Numeric/Prob/DiscreteDistribution.h Bpp/Numeric/Prob/ExponentialDiscreteDistribution.h Bpp/Numeric/Prob/GammaDiscreteDistribution.h Bpp/Numeric/Prob/GaussianDiscreteDistribution.h Bpp/Numeric/Prob/InvariantMixedDiscreteDistribution.h Bpp/Numeric/Prob/MixtureOfDiscreteDistributions.h Bpp/Numeric/Prob/MultipleDiscreteDistribution.h Bpp/Numeric/Prob/SimpleDiscreteDistribution.h Bpp/Numeric/Prob/TruncatedExponentialDiscreteDistribution.h Bpp/Numeric/Prob/UniformDiscreteDistribution.h Bpp/Numeric/Stat/StatTest.h Bpp/Numeric/Stat/ContingencyTableTest.h Bpp/Numeric/Stat/StatTools.h Bpp/Numeric/Stat/Mva/DualityDiagram.h Bpp/Numeric/Stat/Mva/PrincipalComponentAnalysis.h Bpp/Numeric/Stat/Mva/CorrespondenceAnalysis.h ) # Build the static lib ADD_LIBRARY(bppcore-static STATIC ${CPP_FILES}) SET_TARGET_PROPERTIES(bppcore-static PROPERTIES OUTPUT_NAME bpp-core CLEAN_DIRECT_OUTPUT 1 ) TARGET_LINK_LIBRARIES(bppcore-static ${LIBS}) # Build the shared lib ADD_LIBRARY(bppcore-shared SHARED ${CPP_FILES}) SET_TARGET_PROPERTIES(bppcore-shared PROPERTIES OUTPUT_NAME bpp-core CLEAN_DIRECT_OUTPUT 1 VERSION ${BPPCORE_VERSION} SOVERSION ${BPPCORE_VERSION_MAJOR} ) TARGET_LINK_LIBRARIES(bppcore-shared ${LIBS}) # Install libs INSTALL(TARGETS bppcore-static bppcore-shared DESTINATION lib${LIB_SUFFIX}) # Install headers INSTALL(DIRECTORY Bpp/ DESTINATION include/Bpp FILES_MATCHING PATTERN "*.h") # Generate generic include files (.all) INSTALL(CODE "EXECUTE_PROCESS(COMMAND ${CMAKE_SOURCE_DIR}/genIncludes.sh ${CMAKE_PREFIX_PATH}/include/Bpp)") bpp-core-2.2.0/src/Bpp/Graph/UNode.h000664 001750 001750 00000006706 12370705300 020450 0ustar00jdutheiljdutheil000000 000000 // // File: UNode.h // Author: Sylvain Gaillard // Created: 12/01/2011 08:33:55 // /* Copyright or © or Copr. CNRS, (January 12, 2011) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BPP_GRAPH_UNODE_H_ #define _BPP_GRAPH_UNODE_H_ #include "../Clonable.h" // From the STL #include namespace bpp { /** * @brief Unoriented node interface * * UNode is an interface for unoriented nodes aimed to build unoriented * graphs. * * In these classes we choose to use int for positions rathed than size_t * because negative positions are used in some implementations to distinguish * between two types of neighbors in operator[]. @see bpp::ONode * * @author Sylvain Gaillard */ class UNode: public virtual Clonable { public: /** * @name Neighbors * * @{ */ /** * @brief Get a neighbor of this node in const context. * * @param pos the position of the neighbor to get. * @return A pointer toward the neighbor node. */ virtual const UNode * getNeighbor(int pos) const = 0; /** * @brief Get a neighbor of this node. * * @param pos the position of the neighbor to get. * @return A pointer toward the neighbor node. */ virtual UNode * getNeighbor(int pos) = 0; /** * @brief Get the degree i.e. the number of neighbors of this node. */ virtual int degree() const = 0; /** @} */ /** * @name The Clonable interface. * * @{ */ #ifndef NO_VIRTUAL_COV UNode * clone() const = 0; #endif /** @} */ /** * @name Operators * * @{ */ /** * @brief Direct access to a neighbor in const context. */ virtual const UNode * operator[] (int i) const = 0; /** * @brief Direct access to a neighbor. */ virtual UNode * operator[] (int i) = 0; /** @} */ }; } #endif //_BPP_GRAPH_UNODE_H_ bpp-core-2.2.0/src/Bpp/Graph/ONode.h000664 001750 001750 00000010716 12370705300 020436 0ustar00jdutheiljdutheil000000 000000 // // File: ONode.h // Author: Sylvain Gaillard // Created: 12/01/2011 08:36:47 // /* Copyright or © or Copr. CNRS, (January 12, 2011) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BPP_GRAPH_ONODE_H_ #define _BPP_GRAPH_ONODE_H_ #include "UNode.h" namespace bpp { /** * @brief Oriented Node interface * * ONode is an interface for oriented nodes aimed to build oriented graphs. * * @author Sylvain Gaillard */ class ONode: public virtual UNode { public: /** * @name Neighbors * * @{ */ virtual const ONode * getNeighbor(int pos) const = 0; virtual ONode * getNeighbor(int pos) = 0; /** @} */ /** * @name The Clonable interface. * * @{ */ #ifndef NO_VIRTUAL_COV ONode * clone() const = 0; #endif /** @} */ /** * @name Fathers * * @{ */ /** * @brief Get a particular father in const environment. */ virtual const ONode * getFather(int pos) const = 0; /** * @brief Get a particular father. */ virtual ONode * getFather(int pos) = 0; /** * @brief Tell if this node has one or more father nodes. */ virtual bool hasFathers() const = 0; /** * @brief Give the number of father nodes for this node. */ virtual int getNumberOfFathers() const = 0; /** @} */ /** * @name Sons * * @{ */ /** * @brief Get a particular son in const environment. */ virtual const ONode * getSon(int pos) const = 0; /** * @brief Get a particular son. */ virtual ONode * getSon(int pos) = 0; /** * @brief Tell if this node has one or more son nodes. */ virtual bool hasSons() const = 0; /** * @brief Give the number of son nodes for this node. */ virtual int getNumberOfSons() const = 0; /** @} */ /** * @name Operators * * @{ */ /** * @brief Direct access to a neighbor in const context. * * - a positive i gives access to sons (from 0 to n - 1) * - a negative i gives access to fathers (from 1 to m) * * No check is done, you have to ensure that you query an existing * neighbor. * * @param i the position of the neighbor * @return A pointer toward the neighbor */ virtual const ONode * operator[] (int i) const = 0; /** * @brief Direct access to a neighbor. * * - a positive i gives access to sons (from 0 to n - 1) * - a negative i gives access to fathers (from 1 to m) * * No check is done, you have to ensure that you query an existing * neighbor. * * @param i the position of the neighbor * @return A pointer toward the neighbor */ virtual ONode * operator[] (int i) = 0; /** @} */ }; } #endif //_BPP_GRAPH_ONODE_H_ bpp-core-2.2.0/src/Bpp/Graph/BasicTNode.h000664 001750 001750 00000011055 12370705300 021402 0ustar00jdutheiljdutheil000000 000000 // // File: BasicTNode.h // Author: Sylvain Gaillard // Created: 13/01/2011 16:39:23 // /* Copyright or © or Copr. CNRS, (January 12, 2011) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BPP_GRAPH_BASICTNODE_H_ #define _BPP_GRAPH_BASICTNODE_H_ #include "TNode.h" #include "../Exceptions.h" namespace bpp { /** * @brief Simple implementation of TNode * * Contains only methods for node manipulation. * * @author Sylvain Gaillard */ class BasicTNode: public TNode { private: std::vector< BasicTNode * > sons_; BasicTNode * father_; public: /** * @brief Simple constructor. */ BasicTNode(): sons_(), father_(0) {}; /** * @brief Destructor. * * When destroyed, the node remove himself as son of its father and as * father of its sons. */ virtual ~BasicTNode(); /** * @brief Copy constructor. */ BasicTNode(const BasicTNode& node); /** * @brief Assignation operator. */ BasicTNode& operator=(const BasicTNode& node); BasicTNode* clone() const { return new BasicTNode(* this); } // Neighbors const BasicTNode* getNeighbor(int pos) const; BasicTNode* getNeighbor(int pos); int degree() const { return sons_.size() - 1 + father_ ? 1 : 0; } const BasicTNode* operator[](int i) const; BasicTNode* operator[](int i); // Fathers /** * @brief Tell if the node has a father. */ bool hasFather() const { return father_ ? true : false; } bool hasFathers() const { return father_ ? true : false; } int getNumberOfFathers() const { return father_ ? 1 : 0; } const BasicTNode* getFather(int pos) const; BasicTNode* getFather(int pos); const BasicTNode* getFather() const; BasicTNode* getFather(); /** * @brief Tell if the node is a father of this node. */ virtual bool isFather(const BasicTNode* node) const; /** * @brief Add a father to this node. */ virtual void addFather(BasicTNode* node); /** * @brief Remove the father of this node. * * @return A pointer to the removed father node. */ virtual BasicTNode* removeFather(); // Sons bool hasSons() const { return !sons_.empty(); } int getNumberOfSons() const { return static_cast(sons_.size()); } const BasicTNode* getSon(int pos) const; BasicTNode* getSon(int pos); /** * @brief Tell if a node is son of this node. */ virtual bool isSon(const BasicTNode* node) const; /** * @brief Add a son to this node. */ virtual void addSon(BasicTNode* node); /** * @brief Remove a son of this node. */ virtual void removeSon(BasicTNode* son); /** * @brief Remove a son of this node. * * @return A pointer to the removed son node or a Null pointer if son is * not found. */ virtual BasicTNode* removeSon(int pos); }; } #endif //_BPP_GRAPH_BASICTNODE_H_ bpp-core-2.2.0/src/Bpp/Graph/BasicTNode.cpp000664 001750 001750 00000013652 12370705300 021742 0ustar00jdutheiljdutheil000000 000000 // // File: BasicTNode.cpp // Author: Sylvain Gaillard // Created: 14/01/2011 14:59:07 // /* Copyright or © or Copr. Bio++ Development Team, (January 12, 2011) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "BasicTNode.h" using namespace bpp; #include using namespace std; BasicTNode::~BasicTNode() { if (father_) { father_->removeSon(this); } for (size_t i = 0 ; i < sons_.size() ; i++) { sons_[i]->removeFather(); } } BasicTNode::BasicTNode(const BasicTNode& node): sons_(node.sons_), father_(node.father_) {}; BasicTNode& BasicTNode::operator=(const BasicTNode& node) { sons_ = node.sons_; father_ = node.father_; return * this; } // Neighbors const BasicTNode* BasicTNode::getNeighbor(int pos) const { if (pos < 0 || pos > static_cast(sons_.size())) { throw IndexOutOfBoundsException("BasicTNode::getNeighbor() pos is out of bounds", static_cast(pos), 0, sons_.size()); } if (pos == 0) return father_; else return sons_[static_cast(pos - 1)]; } BasicTNode* BasicTNode::getNeighbor(int pos) { if (pos < 0 || pos > static_cast(sons_.size())) { throw IndexOutOfBoundsException("BasicTNode::getNeighbor() pos is out of bounds", static_cast(pos), 0, sons_.size()); } if (pos == 0) return father_; else return sons_[static_cast(pos - 1)]; } const BasicTNode* BasicTNode::operator[](int i) const { if (i < 0) { return father_; } else { return sons_[static_cast(i)]; } } BasicTNode* BasicTNode::operator[](int i) { if (i < 0) { return father_; } else { return sons_[static_cast(i)]; } } // Fathers const BasicTNode* BasicTNode::getFather(int pos) const { if (pos != 0) { throw IndexOutOfBoundsException("BasicTNode::getFather() pos must be 0 for TNode", static_cast(pos), 0, 0); } return getFather(); } BasicTNode* BasicTNode::getFather(int pos) { if (pos != 0) { throw IndexOutOfBoundsException("BasicTNode::getFather() pos must be 0 for TNode", static_cast(pos), 0, 0); } return getFather(); } const BasicTNode* BasicTNode::getFather() const { return father_; } BasicTNode* BasicTNode::getFather() { return father_; } bool BasicTNode::isFather(const BasicTNode* node) const { if (father_ == node) return true; return false; } void BasicTNode::addFather(BasicTNode* node) { if (!node) throw NullPointerException("BasicTNode::addFather() Empty node given as input"); if (father_) throw Exception("BasicTNode::addFather() This node already has a father."); if (!isFather(node)) father_ = node; if (!node->isSon(this)) node->addSon(this); } BasicTNode* BasicTNode::removeFather() { if (hasFathers()) { BasicTNode* father = father_; father_ = 0; father->removeSon(this); return father; } return 0; } // Sons const BasicTNode* BasicTNode::getSon(int pos) const { if (pos < 0 || pos > static_cast(sons_.size()) - 1) { throw IndexOutOfBoundsException("BasicTNode::getSon() pos out of range", static_cast(pos), 0, sons_.size() - 1); } return sons_[static_cast(pos)]; } BasicTNode* BasicTNode::getSon(int pos) { if (pos < 0 || pos > static_cast(sons_.size()) - 1) { throw IndexOutOfBoundsException("BasicTNode::getSon() pos out of range", static_cast(pos), 0, sons_.size() - 1); } return sons_[static_cast(pos)]; } bool BasicTNode::isSon(const BasicTNode* node) const { for (size_t i = 0 ; i < sons_.size() ; i++) { if (sons_[i] == node) return true; } return false; } void BasicTNode::addSon(BasicTNode* node) { if (!node) throw NullPointerException("BasicTNode::addSon() Empty node given as input."); if (!isSon(node)) sons_.push_back(node); if (!node->isFather(this)) node->addFather(this); } void BasicTNode::removeSon(BasicTNode* node) { if (!node) throw NullPointerException("BasicTNode::removeSon() Empty node given as input."); for (size_t i = 0 ; i < sons_.size() ; i++) { if (sons_[i] == node) { sons_.erase(sons_.begin() + static_cast(i)); node->removeFather(); } } } BasicTNode* BasicTNode::removeSon(int pos) { if (pos < 0 || pos > static_cast(sons_.size() - 1)) throw IndexOutOfBoundsException("BasicTNode::removeSon() pos out of bound", static_cast(pos), 0, sons_.size() - 1); BasicTNode* node = sons_[static_cast(pos)]; sons_.erase(sons_.begin() + pos); node->removeFather(); return node; } bpp-core-2.2.0/src/Bpp/Graph/BasicONode.h000664 001750 001750 00000004074 12370705300 021400 0ustar00jdutheiljdutheil000000 000000 // // File: BasicONode.h // Author: Sylvain Gaillard // Created: 13/01/2011 16:34:44 // /* Copyright or © or Copr. Bio++ Development Team, (January 12, 2011) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BPP_GRAPH_BASICONODE_H_ #define _BPP_GRAPH_BASICONODE_H_ #include "ONode.h" namespace bpp { /** * @brief Simple implementation of ONode * * Contains only methods for node manipulation. * * @warning Class not implemented yet! * * @author Sylvain Gaillard */ class BasicONode: public ONode { public: BasicONode(); }; } #endif //_BPP_GRAPH_BASICONODE_H_ bpp-core-2.2.0/src/Bpp/Graph/BasicONode.cpp000664 001750 001750 00000003367 12370705300 021737 0ustar00jdutheiljdutheil000000 000000 // // File: BasicONode.cpp // Author: Sylvain Gaillard // Created: 14/01/2011 14:59:07 // /* Copyright or © or Copr. Bio++ Development Team, (January 12, 2011) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "BasicONode.h" using namespace bpp; BasicONode::BasicONode() {} bpp-core-2.2.0/src/Bpp/Graph/TNode.h000664 001750 001750 00000006407 12370705300 020445 0ustar00jdutheiljdutheil000000 000000 // // File: TNode.h // Author: Sylvain Gaillard // Created: 12/01/2011 08:43:15 // /* Copyright or © or Copr. CNRS, (January 12, 2011) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BPP_GRAPH_TNODE_H_ #define _BPP_GRAPH_TNODE_H_ #include "ONode.h" namespace bpp { /** * @brief Tree Node interface * * TNode is an interface for tree nodes (i.e. oriented nodes with only one * father). It is aimed to build trees. * * @author Sylvain Gaillard */ class TNode: public virtual ONode { public: /** * @name Neighbors * * @{ */ /** * @copydoc bpp::ONode::getNeighbor(int) const */ virtual const TNode * getNeighbor(int pos) const = 0; /** * @copydoc bpp::ONode::getNeighbor(int) */ virtual TNode * getNeighbor(int pos) = 0; /** @} */ /** * @name The Clonable interface. * * @{ */ #ifndef NO_VIRTUAL_COV TNode * clone() const = 0; #endif /** @} */ /** * @name Fathers * * @{ */ virtual const TNode * getFather(int pos) const = 0; virtual TNode * getFather(int pos) = 0; /** * @brief Get the father in const environment. */ virtual const TNode * getFather() const = 0; /** * @brief Get the father. */ virtual TNode * getFather() = 0; /** @} */ /** * @name Sons * * @{ */ virtual const TNode * getSon(int pos) const = 0; virtual TNode * getSon(int pos) = 0; /** @} */ /** * @name Operators * * @{ */ virtual const TNode * operator[] (int i) const = 0; virtual TNode * operator[] (int i) = 0; /** @} */ }; } #endif //_BPP_GRAPH_TNODE_H_ bpp-core-2.2.0/src/Bpp/Exceptions.cpp000664 001750 001750 00000010730 12370705300 021041 0ustar00jdutheiljdutheil000000 000000 // // File Exceptions.cpp // Created by: Guillaume Deuchst // Julien Dutheil // Sylvain Gaillard // Last modification : Thu Jul 22 2004 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "Exceptions.h" #include "Text/TextTools.h" using namespace bpp; using namespace std; /******************************************************************************/ BadIntegerException::BadIntegerException(const char* text, int badInt): Exception(string(text) + "(" + TextTools::toString(badInt) + ")"), badInt_(badInt) {} BadIntegerException::BadIntegerException(const std::string& text, int badInt): Exception(text + "(" + TextTools::toString(badInt) + ")"), badInt_(badInt) {} /******************************************************************************/ BadNumberException::BadNumberException(const char* text, double badNumber): Exception(string(text) + "(" + TextTools::toString(badNumber) + ")"), badNumber_(badNumber) {} BadNumberException::BadNumberException(const std::string& text, double badNumber): Exception(text + "(" + TextTools::toString(badNumber) + ")"), badNumber_(badNumber) {} /******************************************************************************/ NumberFormatException::NumberFormatException(const char* text, const std::string& badNumber): Exception(string(text) + "(" + badNumber + ")"), badNumber_(badNumber) {} NumberFormatException::NumberFormatException(const std::string& text, const std::string& badNumber): Exception(text + "(" + badNumber + ")"), badNumber_(badNumber) {} /******************************************************************************/ IndexOutOfBoundsException::IndexOutOfBoundsException(const std::string& text, size_t badInt, size_t lowerBound, size_t upperBound): Exception("out of [" + TextTools::toString(lowerBound) + ", " + TextTools::toString(upperBound) + "])" + text), badIndex_(badInt), lowerBound_(lowerBound), upperBound_(upperBound) {} vector IndexOutOfBoundsException::getBounds() const { vector bounds(2); bounds[0] = lowerBound_; bounds[1] = upperBound_; return bounds; } /******************************************************************************/ BadSizeException::BadSizeException(const std::string& text, size_t badSize, size_t correctSize): Exception("Incorrect size " + TextTools::toString(badSize) + ", expected " + TextTools::toString(correctSize) + ". " + text), badSize_(badSize), correctSize_(correctSize) {} /******************************************************************************/ OutOfRangeException::OutOfRangeException(const std::string& text, double badValue, double lowerBound, double upperBound): Exception(TextTools::toString(badValue) + " out of [" + TextTools::toString(lowerBound) + ", " + TextTools::toString(upperBound) + "])" + text), lowerBound_(lowerBound), upperBound_(upperBound) {} /******************************************************************************/ bpp-core-2.2.0/src/Bpp/App/NumCalcApplicationTools.h000664 001750 001750 00000011775 12370705300 023646 0ustar00jdutheiljdutheil000000 000000 // // File: NumCalcApplicationTools.h // Created by: Sylvain Gaillard // Created on: Tue Jan 14:58:50 CET 2009 // /* Copyright or © or Copr. CNRS, (January 13, 2009) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _NUMCALCAPPLICATIONTOOLS_H_ #define _NUMCALCAPPLICATIONTOOLS_H_ #include "../Text/StringTokenizer.h" #include "ApplicationTools.h" #include "../Numeric/VectorTools.h" #include "../Numeric/Function/FunctionTools.h" namespace bpp { class NumCalcApplicationTools { public: NumCalcApplicationTools(); virtual ~NumCalcApplicationTools(); public: /** * @brief Build a vector of integers as described by a string * * Build a vector of integers following a description like: * "2, 5, 7-10, 4" => [2, 5, 7, 8, 9, 10, 4] * * @author Sylvain Gaillard * @param s The string to parse. * @param delim Delimiter between elements. * @param seqdelim Delimiter between min and max for a sequence. * @return A vector containing the integers */ static std::vector seqFromString(const std::string& s, const std::string& delim = ",", const std::string& seqdelim = "-"); /** * @brief Build a vector of double from a structured text description. * * The syntax may be one of the following: * - Specified values: 1.23, 2.34, 3.45, 4.56 * - Sequence macro: seq(from=1.23,to=2.45,step=0.1) * or seq(from=1.23,to=2.45,size=5) * The meaning of these to form is equivalent as the R function: * The first one start from 1.23 and increment 0.1 until it reaches * the 2.45 value, wheras the seocnd one will compute 3 values at * equal distance from 1.23 and 2.45. the 'from' and 'to' values are * included, except for the first syntax when the interval is not an * exact multiple of the 'step' argument. * * @author Julien Dutheil * @param desc The string to parse. * @return A vector containing the corresponding values as double. * @throw Exception If the syntax describing the set is not correct. */ static std::vector getVector(const std::string& desc) throw (Exception); /** * @brief Returns the value of the Parameter of the given name * if it exists; otherwise returns the default value. * * @author Laurent Gueguen * @param pl A parameter list to look in. * @param name A string name * @param x A double value */ static double getDefaultValue(const ParameterList& pl, const std::string& name, double x); /** * @brief Design a parameter grid from input options. * * Example: * @code * grid.number_of_parameters=3 * grid.parameter1.name=x * grid.parameter1.values=0.1,0.2,0.3,0.4,0.5 * grid.parameter2.name=y * grid.parameter2.values=seq(from=0.1,to=0.5,step=0.1) * grid.parameter3.name=z * grid.parameter3.values=seq(from=0.1,to=0.5,size=5) * @endcode * * @param params The attribute map where options may be found. * @param suffix A suffix to be applied to the parameter name. * @param suffixIsOptional Tell if the suffix is absolutely required. * @param warn Tell if a warning must be sent in case the parameter is not found. * @return a parameter grid object. */ static ParameterGrid* getParameterGrid( std::map& params, const std::string& suffix = "", bool suffixIsOptional = true, bool warn = true) throw (Exception); }; } //End of namespace bpp. #endif //_NUMCALCAPPLICATIONTOOLS_H_ bpp-core-2.2.0/src/Bpp/App/NumCalcApplicationTools.cpp000664 001750 001750 00000012102 12370705300 024162 0ustar00jdutheiljdutheil000000 000000 // // File: NumCalcApplicationTools.cpp // Created by: Julien Dutheil // Created on: Sun Mar 29 15:13 2009 // /* Copyright or © or Copr. CNRS, (January 13, 2009) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "NumCalcApplicationTools.h" #include "../Numeric/NumConstants.h" #include "ApplicationTools.h" #include "../Text/KeyvalTools.h" using namespace bpp; using namespace std; vector NumCalcApplicationTools::seqFromString(const std::string& s, const std::string& delim, const std::string& seqdelim) { vector seq; StringTokenizer * st = new StringTokenizer(s, delim, true); while (st->hasMoreToken()) { StringTokenizer * st2 = new StringTokenizer(st->nextToken(), seqdelim, true); if (st2->numberOfRemainingTokens() > 1) { vector tmp = VectorTools::seq(TextTools::toInt(st2->getToken(0)), TextTools::toInt(st2->getToken(1)), 1); VectorTools::append(seq, tmp); } else { seq.push_back(TextTools::toInt(st2->getToken(0))); } } return seq; } vector NumCalcApplicationTools::getVector(const std::string& desc) throw (Exception) { vector values; string key, val; if(desc.substr(0,3) == "seq") // Bounds specified as sequence { map keyvals; KeyvalTools::multipleKeyvals(desc.substr(4, desc.size() - 5), keyvals); if(keyvals.find("from") == keyvals.end()) throw Exception("Unvalid sequence specification, missing 'from' key: " + desc.substr(3, desc.size() - 5)); if(keyvals.find("to") == keyvals.end()) throw Exception("Unvalid sequence specification, missing 'to' key: " + desc.substr(3, desc.size() - 5)); if(keyvals.find("step") == keyvals.end() && keyvals.find("size") == keyvals.end()) throw Exception("Unvalid sequence specification, missing 'step' or 'size' key: " + desc.substr(3, desc.size() - 5)); double start = TextTools::toDouble(keyvals["from"]); double end = TextTools::toDouble(keyvals["to"]); if(keyvals.find("step") != keyvals.end()) { double step = TextTools::toDouble(keyvals["step"]); for(double x = start; x <= end+NumConstants::TINY(); x += step) values.push_back(x); } else { int size = TextTools::toInt(keyvals["size"]); double step = (end - start) / (double)size; for(int i = 0; i < size - 1; i++) values.push_back(start + i * step); values.push_back(end); // for rounding purpose. } } else // Direct enumaration of values { StringTokenizer st(desc, ","); while(st.hasMoreToken()) values.push_back(TextTools::toDouble(st.nextToken())); } return values; } double NumCalcApplicationTools::getDefaultValue(const ParameterList& pl, const std::string& name, double x) { for(unsigned int i = 0; i < pl.size(); i++) { const Parameter& p = pl[i]; if(p.getName() == name) return p.getValue(); } return x; } ParameterGrid* NumCalcApplicationTools::getParameterGrid( map& params, const string& suffix, bool suffixIsOptional, bool warn) throw (Exception) { unsigned int nbParams = ApplicationTools::getParameter("grid.number_of_parameters", params, 1, suffix, suffixIsOptional, warn); ParameterGrid* grid = new ParameterGrid(); for(unsigned int i = 0; i < nbParams; i++) { string name = ApplicationTools::getStringParameter("grid.parameter" + TextTools::toString(i+1) + ".name", params, "", suffix, suffixIsOptional, warn); vector values = getVector(ApplicationTools::getStringParameter("grid.parameter" + TextTools::toString(i+1) + ".values", params, "", suffix, suffixIsOptional, warn)); grid->addDimension(name, values); } return grid; } bpp-core-2.2.0/src/Bpp/App/BppApplication.cpp000664 001750 001750 00000005515 12370705300 022352 0ustar00jdutheiljdutheil000000 000000 // // File: BppApplication.cpp // Created by: Julien Dutheil // Created on: Sat Aug 08 08:21 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide basal and utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "BppApplication.h" #include "../Utils/AttributesTools.h" #include "../Numeric/Random/RandomTools.h" #include "ApplicationTools.h" // From the STL: #include using namespace bpp; using namespace std; BppApplication::BppApplication(int argc, char* argv[], const std::string& name): appName_(name), params_(), timerStarted_(false) { cout << "Parsing options:" << endl; params_ = AttributesTools::parseOptions(argc, argv); ApplicationTools::warningLevel = ApplicationTools::getIntParameter("--warning", params_, 0, "", true, 3); bool noint = ApplicationTools::getBooleanParameter("--noninteractive", params_, false, "", true, 3); ApplicationTools::interactive = !noint; long seed = ApplicationTools::getParameter("--seed", params_, -1, "", true, 3); if (seed >= 0) { RandomTools::setSeed(seed); ApplicationTools::displayResult("Random seed set to", seed); } } void BppApplication::startTimer() { ApplicationTools::startTimer(); timerStarted_ = true; } void BppApplication::done() { cout << appName_ << "'s done. Bye." << endl; if (timerStarted_) ApplicationTools::displayTime("Total execution time:"); } bpp-core-2.2.0/src/Bpp/App/BppApplication.h000664 001750 001750 00000005130 12370705300 022010 0ustar00jdutheiljdutheil000000 000000 // // File: BppApplication.h // Created by: Julien Dutheil // Created on: Sat Aug 08 08:21 2009 // /* Copyright or © or Copr. Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide basal and utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BPPAPPLICATION_H_ #define _BPPAPPLICATION_H_ #include "../Exceptions.h" // From the STL: #include #include namespace bpp { class BppApplication { private: std::string appName_; mutable std::map params_; bool timerStarted_; public: BppApplication(int argc, char* argv[], const std::string& name); public: void startTimer(); void done(); std::map& getParams() { return params_; } const std::string& getParam(const std::string& name) const throw (Exception) { if (params_.find(name) == params_.end()) throw Exception("BppApplication::getParam(). Parameter '" + name + "' not found."); return params_[name]; } std::string& getParam(const std::string& name) { return params_[name]; } }; } //end of namespace bpp; #endif // _BPPAPPLICATION_H_ bpp-core-2.2.0/src/Bpp/App/ApplicationTools.h000664 001750 001750 00000051374 12377027445 022420 0ustar00jdutheiljdutheil000000 000000 // // File: ApplicationTools.h // Created by: Julien Dutheil // Created on: Fri Oct 21 16:19 2005 // From old file created on: Sun Dec 14 09:36:26 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide basal and utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _APPLICATIONTOOLS_H_ #define _APPLICATIONTOOLS_H_ #include "../Io/FileTools.h" #include "../Io/OutputStream.h" #include "../Text/TextTools.h" #include "../Text/StringTokenizer.h" #include "../Text/NestedStringTokenizer.h" #include "../Numeric/Matrix/Matrix.h" // From the STL: #include #include #include #include namespace bpp { /** * @brief This class provides some common tools for developping applications. * * These functions are designed for helping to parse an option file. * * The option files are supposed to follow this simple format:
* @code * parameterName = parameterContent * @endcode * with one parameter per line. * * In files, shell comments: * @code * # my comment line here * @endcode * C comments: * @code * / * my comment block here * / * @endcode * and C++ comments: * @code * // my comment line here * @endcode * are allowed, and ignored while parsing. * * Some methods for displaying information (messages, errors, warnings...) are also provided. * * Methods dealing with parameters takes as argument a map object * containing the parameters (names are the keys of the map, and values are... the values of the map!). * These map objects may be obtained from the AttributesTools utilitary class. */ class ApplicationTools { public: /** * @brief The output stream where errors have to be displayed. */ static OutputStream* error; /** * @brief The output stream where messages have to be displayed. */ static OutputStream* message; /** * @brief The output stream where warnings have to be displayed. */ static OutputStream* warning; /** * @brief Timer variable. */ static time_t startTime; /** * @brief The width of the output terminal (in character). */ static size_t terminalWidth; /** * @brief The fraction of terminal width dedicated to messages. */ static float terminalSplit; /** * @brief Tell if the program is interactive (typically run in foreground). Default to yes. */ static bool interactive; /** * @brief Specify the amount of warning to display. */ static int warningLevel; public: ApplicationTools() {} virtual ~ApplicationTools() {} public: /** * @brief Tells if a parameter have been specified. * * @param parameterName The name of the parameter. * @param params The parameter list. * @return True is the parameter of specified name is in the list. */ static bool parameterExists(const std::string& parameterName, std::map& params); static bool parameterExists(const std::string& parameterName, std::vector& params); /** * @brief Returns a vector of parameter names that match a given pattern. * * Only "*" wildcard is implemented now. * * @param pattern The pattern. * @param params The parameter list. * @return a vector of matching names. */ static std::vector matchingParameters(const std::string& pattern, std::map& params); static std::vector matchingParameters(const std::string& pattern, std::vector& params); /** * @brief Get a double parameter. * * @param parameterName The name of the corresponding parameter. * @param params The attribute map where options may be found. * @param defaultValue The default value to use if the parameter is not found. * @param suffix A suffix to be applied to the parameter name. * @param suffixIsOptional Tell if the suffix is absolutely required. * @param warn Tell if a warning must be sent in case the parameter is not found. * @return The corresponding value. */ static double getDoubleParameter( const std::string& parameterName, std::map& params, double defaultValue, const std::string& suffix = "", bool suffixIsOptional = true, int warn = 0); /** * @brief Get an integer parameter. * * @param parameterName The name of the corresponding parameter. * @param params The attribute map where options may be found. * @param defaultValue The default value to use if the parameter is not found. * @param suffix A suffix to be applied to the parameter name. * @param suffixIsOptional Tell if the suffix is absolutely required. * @param warn Tell if a warning must be sent in case the parameter is not found. * @return The corresponding value. */ static int getIntParameter( const std::string& parameterName, std::map& params, int defaultValue, const std::string& suffix = "", bool suffixIsOptional = true, int warn = 0); /** * @brief Get a string parameter. * * @param parameterName The name of the corresponding parameter. * @param params The attribute map where options may be found. * @param defaultValue The default value to use if the parameter is not found. * @param suffix A suffix to be applied to the parameter name. * @param suffixIsOptional Tell if the suffix is absolutely required. * @param warn Tell if a warning must be sent in case the parameter is not found. * @return The corresponding value. */ static std::string getStringParameter( const std::string& parameterName, std::map& params, const std::string& defaultValue, const std::string& suffix = "", bool suffixIsOptional = true, int warn = 0); /** * @brief Get a boolean parameter. * * @param parameterName The name of the corresponding parameter. * @param params The attribute map where options may be found. * @param defaultValue The default value to use if the parameter is not found. * @param suffix A suffix to be applied to the parameter name. * @param suffixIsOptional Tell if the suffix is absolutely required. * @param warn Tell if a warning must be sent in case the parameter is not found. * @return The corresponding value. */ static bool getBooleanParameter( const std::string& parameterName, std::map& params, bool defaultValue, const std::string& suffix = "", bool suffixIsOptional = true, int warn = 0); /** * @brief Get a parameter. * * @param parameterName The name of the corresponding parameter. * @param params The attribute map where options may be found. * @param defaultValue The default value to use if the parameter is not found. * @param suffix A suffix to be applied to the parameter name. * @param suffixIsOptional Tell if the suffix is absolutely required. * @param warn Tell if a warning must be sent in case the parameter is not found. * @return The corresponding value. */ template static T getParameter( const std::string& parameterName, std::map& params, T defaultValue, const std::string& suffix = "", bool suffixIsOptional = true, int warn = 0) { T tParam = defaultValue; if (parameterExists(parameterName + suffix, params)) { tParam = TextTools::to(params[parameterName + suffix]); } else if (suffixIsOptional && parameterExists(parameterName, params)) { tParam = TextTools::to(params[parameterName]); } else if (warn <= warningLevel) { displayWarning("Parameter " + parameterName + suffix + " not specified. Default used instead: " + TextTools::toString(defaultValue)); } return tParam; } /** * @brief Get a file path. * * @param parameter The name of the corresponding parameter. * @param params The attribute map where options may be found. * @param isRequired Tell if this path is strictly required or is optional * (in the first case, if the parameter is not found, the programm will * send an error and exit). * @param mustExist Tell if the corresponding file must already exist. * @param suffix A suffix to be applied to the parameter name. * @param suffixIsOptional Tell if the suffix is absolutely required. * @param defaultPath Path to use if no argument is provided. * @param warn Tell if a warning must be sent in case the parameter is not found. * @throw Exception If no file path is specified and isRequired is * true, or the file does not exist and mustExist * is set to true. */ static std::string getAFilePath( const std::string& parameter, std::map& params, bool isRequired = true, bool mustExist = true, const std::string& suffix = "", bool suffixIsOptional = false, const std::string& defaultPath = "none", int warn = 0) throw (Exception); /** * @brief Get a vector. * * @param parameterName The name of the corresponding parameter. * @param params The attribute map where options may be found. * @param separator The character used to delimit values. * @param defaultValue The default value to use if the parameter is not found. * @param suffix A suffix to be applied to the parameter name. * @param suffixIsOptional Tell if the suffix is absolutely required. * @param warn Tell if a warning must be sent in case the parameter is not found. * @return The corresponding value. */ template static std::vector getVectorParameter( const std::string& parameterName, std::map& params, char separator, const std::string& defaultValue, const std::string& suffix = "", bool suffixIsOptional = true, int warn = 0) { std::string s = getStringParameter(parameterName, params, defaultValue, suffix, suffixIsOptional, warn); if (TextTools::isEmpty(s)) return std::vector(0); if (s[0] == '(' && s[s.size() - 1] == ')') { //This is a delimited vector: s = s.substr(1, s.size() - 2); if (TextTools::isEmpty(s)) return std::vector(0); } NestedStringTokenizer st(s, "(", ")", TextTools::toString(separator)); size_t n = st.numberOfRemainingTokens(); std::vector v(n); for (size_t i = 0; i < n; i++) { v[i] = TextTools::fromString(st.nextToken()); } return v; } /** * @brief Get a vector. * * Similar to getVectorParameter, but dedicated to numerical values. * It allows the possibility to set range of values, which will be incremented by 1 (like the : operator in R). * * @param parameterName The name of the corresponding parameter. * @param params The attribute map where options may be found. * @param separator The character used to delimit values. * @param rangeOperator The character used to delimit ranges (the + 1 operator must be available for T). * @param defaultValue The default value to use if the parameter is not found. * @param suffix A suffix to be applied to the parameter name. * @param suffixIsOptional Tell if the suffix is absolutely required. * @param warn Tell if a warning must be sent in case the parameter is not found. * @return The corresponding value. */ template static std::vector getVectorParameter( const std::string& parameterName, std::map& params, char separator, char rangeOperator, const std::string& defaultValue, const std::string& suffix = "", bool suffixIsOptional = true, bool warn = true) { std::string s = getStringParameter(parameterName, params, defaultValue, suffix, suffixIsOptional, warn); if (s[0] == '(' && s[s.size() - 1] == ')') { //This is a delimited vector: s = s.substr(1, s.size() - 2); if (TextTools::isEmpty(s)) return std::vector(0); } StringTokenizer st(s, TextTools::toString(separator)); size_t n = st.numberOfRemainingTokens(); std::vector v; for (size_t i = 0; i < n; i++) { std::string token = st.nextToken(); std::string::size_type pos = token.find(rangeOperator); if (pos == std::string::npos) v.push_back(TextTools::fromString(token)); else { T d1 = TextTools::fromString(token.substr(0, pos)); T d2 = TextTools::fromString(token.substr(pos + 1)); for (T j = d1; j < d2; j++) { v.push_back(j); } v.push_back(d2); } } return v; } /** * @brief Get a RowMatrix. The input is made of embedded * parenthesis, such as ((1,2),(3,4)), where the matrix is filled by * lines. Here, the matrix would be: * \f[ * \begin{pmatrix} * 1 & 2 \\ * 3 & 4 \\ * \end{pmatrix} * \f] * * @param parameterName The name of the corresponding parameter. * @param params The attribute map where options may be found. * @param separator The character used to delimit values. * @param defaultValue The default value to use if the parameter is not found. * @param suffix A suffix to be applied to the parameter name. * @param suffixIsOptional Tell if the suffix is absolutely required. * @param warn Tell if a warning must be sent in case the parameter is not found. * @return The corresponding value. */ template static RowMatrix getMatrixParameter( const std::string& parameterName, std::map& params, char separator, const std::string& defaultValue, const std::string& suffix = "", bool suffixIsOptional = true, bool warn = true) { RowMatrix mat; std::string s = getStringParameter(parameterName, params, defaultValue, suffix, suffixIsOptional, warn); if (TextTools::isEmpty(s)) return RowMatrix(0,0); if (s[0] == '(' && s[s.size() - 1] == ')') { //This is a delimited vector: s = s.substr(1, s.size() - 2); if (TextTools::isEmpty(s)) return RowMatrix(0,0); } StringTokenizer st1(s, "()"); while (st1.hasMoreToken()) { std::string si=st1.nextToken(); StringTokenizer st2(si, TextTools::toString(separator)); size_t n = st2.numberOfRemainingTokens(); std::vector v(n); for (size_t i = 0; i < n; i++) { v[i] = TextTools::fromString(st2.nextToken()); } if (v.size()!=0) mat.addRow(v); } return mat; } /** * @name Output methods. * * @{ */ /** * @brief Print a message. * * @param text The text of the message. */ static void displayMessage(const std::string& text); /** * @brief Print an error message. * * @param text The text of the message. */ static void displayError(const std::string& text); /** * @brief Print a warning message. * * @param text The text of the message. */ static void displayWarning(const std::string& text); /** * @brief Print a task message. * * Display the message and flush the buffer, but do not end the current line. * * @param text The text of the message. * @param eof Insert a carriage return after displaying the message. */ static void displayTask(const std::string& text, bool eof = false); /** * @brief Print a task ended message. * * Print "Done." and go to next line. */ static void displayTaskDone(); /** * @brief Print a result message. * * Result will be aligned to 30 character from the begining of the message. * ex: text = "Here is what you get:" and result = "THAT" gives * "Here is what you get: THAT". * * @param text The text of the message. * @param result The result. */ template static void displayResult(const std::string& text, const T& result) { displayMessage(TextTools::resizeRight(text, static_cast(static_cast(terminalWidth) * terminalSplit - 1), '.') + ": " + TextTools::toString(result)); } /** * @brief Print a boolean result message ("yes" or "no"). * * Result will be aligned to 30 character from the begining of the message. * @param text The text of the message. * @param result The result. */ static void displayBooleanResult(const std::string& text, bool result) { displayResult(text, result ? std::string("yes") : std::string("no")); } /** * @brief Display a gauge. * * Show progress status. * @code * for(size_t i = 0; i < 1000; i++) * { * ApplicationTools::displayGauge(i, 999, '*'); * //Perform time consuming task... * } * @endcode * will result in something like: * @verbatim * [************************************] * @endverbatim * * @param iter The current iteration number. * @param total The total number of iteration. * @param symbol The character to display in the gauge. * @param mes A message to print before the gauge. */ static void displayGauge(size_t iter, size_t total, char symbol='>', const std::string& mes=""); /** * @brief Display a gauge for unefined amount of iterations. * * Show progress status. * @code * for(size_t i = 0; i < 1000; i++) * { * ApplicationTools::displayUnlimitedGauge(i); * //Perform time consuming task... * } * @endcode * will result in something like: * @verbatim * - 1 * / 2 * - 3 * \ 4 * - 5 * etc * @endverbatim * * @param iter The current iteration number. * @param mes A message to print before the gauge. */ static void displayUnlimitedGauge(size_t iter, const std::string& mes=""); /** @} */ /** * @brief Starts the timer. */ static void startTimer() { time(&startTime); } /** * @brief Display the current timer value to the 'message' stream. * * @param msg Message to display before time. */ static void displayTime(const std::string& msg); /** * @brief Get the current timer value. * * @return The number of seconds from when timer was started. */ static double getTime(); }; } //end of namespace bpp. #endif //_APPLICATIONTOOLS_H_ bpp-core-2.2.0/src/Bpp/App/ApplicationTools.cpp000664 001750 001750 00000031350 12370705300 022725 0ustar00jdutheiljdutheil000000 000000 // // File: ApplicationTools.cpp // Created by: Julien Dutheil // Created on: Fri Oct 21 16:19 2005 // From old file created on: Sun Dec 14 09:36:26 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide basal and utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "ApplicationTools.h" using namespace bpp; // From the STL: #include using namespace std; /******************************************************************************/ OutputStream* ApplicationTools::error = new StdErr(); OutputStream* ApplicationTools::message = new StdOut(); OutputStream* ApplicationTools::warning = new StdOut(); time_t ApplicationTools::startTime; size_t ApplicationTools::terminalWidth = 80; float ApplicationTools::terminalSplit = 0.5; bool ApplicationTools::interactive = true; int ApplicationTools::warningLevel = 0; /******************************************************************************/ bool ApplicationTools::parameterExists( const std::string & parameterName, std::map& params) { return (params.find(parameterName) != params.end() && !TextTools::isEmpty(params[parameterName])); } bool ApplicationTools::parameterExists( const std::string & parameterName, std::vector& params) { for (size_t i = 0; i < params.size(); ++i) if (params[i] == parameterName) return true; return false; } /******************************************************************************/ std::vector ApplicationTools::matchingParameters(const std::string& pattern, std::map& params) { vector retv; map::iterator it; for (it=params.begin(); it!=params.end(); it++) { StringTokenizer stj(pattern, "*", true, false); size_t pos1, pos2; string parn = it->first; bool flag(true); string g = stj.nextToken(); pos1 = parn.find(g); if (pos1 != 0) flag = false; pos1 += g.length(); while (flag && stj.hasMoreToken()) { g = stj.nextToken(); pos2 = parn.find(g, pos1); if (pos2 == string::npos) { flag = false; break; } pos1 = pos2 + g.length(); } if (flag && ((g.length() == 0) || (pos1 == parn.length()) || (parn.rfind(g) == parn.length() - g.length()))) retv.push_back(parn); } return retv; } std::vector ApplicationTools::matchingParameters(const std::string& pattern, std::vector& params) { vector retv; for (size_t i=0;i& params, bool isRequired, bool mustExist, const string& suffix, bool suffixIsOptional, const string& defaultPath, int warn) throw (Exception) { string filePath = getStringParameter(parameter, params, defaultPath, suffix, suffixIsOptional, warn); if (filePath == "") filePath = "none"; if (filePath == "none" && isRequired) { throw Exception("You must specify a file for this parameter: " + parameter + (suffixIsOptional ? "" : suffix)); } if(filePath == "none") return filePath; if(mustExist && !FileTools::fileExists(filePath)) { throw Exception("File does not exists: " + filePath); } return filePath; } /******************************************************************************/ double ApplicationTools::getDoubleParameter( const std::string& parameterName, std::map& params, double defaultValue, const std::string& suffix, bool suffixIsOptional, int warn) { double dParam = defaultValue; if (parameterExists(parameterName + suffix, params)) { dParam = TextTools::toDouble(params[parameterName + suffix]); } else if (suffixIsOptional && parameterExists(parameterName, params)) { dParam = TextTools::toDouble(params[parameterName]); } else if(warn <= warningLevel) { displayWarning("Parameter " + parameterName + suffix + " not specified. Default used instead: " + TextTools::toString(defaultValue)); } return dParam; } /******************************************************************************/ int ApplicationTools::getIntParameter( const std::string & parameterName, std::map & params, int defaultValue, const std::string & suffix, bool suffixIsOptional, int warn) { int iParam = defaultValue; if (parameterExists(parameterName + suffix, params)) { iParam = TextTools::toInt(params[parameterName + suffix]); } else if(suffixIsOptional && parameterExists(parameterName, params)) { iParam = TextTools::toInt(params[parameterName]); } else if (warn <= warningLevel) { displayWarning("Parameter " + parameterName + suffix + " not specified. Default used instead: " + TextTools::toString(defaultValue)); } return iParam; } /******************************************************************************/ std::string ApplicationTools::getStringParameter( const std::string& parameterName, std::map& params, const std::string& defaultValue, const std::string& suffix, bool suffixIsOptional, int warn) { string sParam = defaultValue; if (parameterExists(parameterName + suffix, params)) { sParam = params[parameterName + suffix]; } else if (suffixIsOptional && parameterExists(parameterName, params)) { sParam = params[parameterName]; } else if (warn <= warningLevel) { displayWarning("Parameter " + parameterName + " not specified. Default used instead: " + defaultValue); } return sParam; } /******************************************************************************/ bool ApplicationTools::getBooleanParameter( const std::string& parameterName, std::map& params, bool defaultValue, const std::string& suffix, bool suffixIsOptional, int warn) { string sParam; bool bParam = defaultValue; if (parameterExists(parameterName + suffix, params)) { sParam = params[parameterName + suffix]; } else if (suffixIsOptional && parameterExists(parameterName, params)) { sParam = params[parameterName]; } else { if (warn <= warningLevel) { displayWarning("Parameter " + parameterName + " not specified. Default used instead: " + TextTools::toString(defaultValue)); } return bParam; } if ((sParam == "true") || (sParam == "TRUE") || (sParam == "t") || (sParam == "T") || (sParam == "yes") || (sParam == "YES") || (sParam == "y") || (sParam == "Y") || (sParam == "1")) bParam = true; else if ((sParam == "false") || (sParam == "FALSE") || (sParam == "f") || (sParam == "F") || (sParam == "no") || (sParam == "NO") || (sParam == "n") || (sParam == "N") || (sParam == "0")) bParam = false; else throw Exception("ApplicationTools::getBooleanParameter. Wrong description:" + sParam); return bParam; } /******************************************************************************/ void ApplicationTools::displayMessage(const std::string& text) { if(message) (*message << text).endLine(); } void ApplicationTools::displayError(const std::string& text) { if(error) (*error << "ERROR!!! " << text).endLine(); } void ApplicationTools::displayWarning(const std::string& text) { if(warning) (*warning << "WARNING!!! " << text).endLine(); } void ApplicationTools::displayTask(const std::string& text, bool eof) { if (message) { *message << TextTools::resizeRight(text, static_cast(static_cast(terminalWidth) * terminalSplit - 1), '.') << ": "; if (eof) message->endLine(); else message->flush(); } } void ApplicationTools::displayTaskDone() { if(message) (*message << "Done.").endLine(); } /******************************************************************************/ void ApplicationTools::displayGauge(size_t iter, size_t total, char symbol, const std::string& mes) { if (!message) return; if (total == 0) return;//We do not display anything in that case. size_t width = static_cast(static_cast(terminalWidth) * terminalSplit - 2); string gauge = string(static_cast((1. * static_cast(iter) / static_cast(total)) * static_cast(width)), symbol); string info = mes; size_t step = static_cast(ceil(1. * static_cast(total) / static_cast(width))); size_t x = iter % step; if (interactive) { string fill = string(width - gauge.length(), ' '); gauge = "[" + gauge + fill + "] " + TextTools::resizeLeft(TextTools::toString(100 * iter / total), 3) + "%"; if (mes.size() > terminalWidth - gauge.size()) info = TextTools::resizeRight(mes, terminalWidth - gauge.size()); if (x == 0 || iter == total) { *message << '\r' + info + gauge; message->flush(); } } else { if (iter == 0) { *message << "["; message->flush(); return; } if (iter >= total) { size_t fill = static_cast(static_cast(terminalWidth) * terminalSplit) - (total - 1) / step - 1; *message << TextTools::resizeLeft("]", fill, symbol); message->flush(); return; } if (x == 0) { *message << symbol; message->flush(); } } } /******************************************************************************/ void ApplicationTools::displayUnlimitedGauge(size_t iter, const std::string& mes) { if (!message) return; string chars = "-/-\\"; string info = mes; if (interactive) { unsigned int i = iter % 4; *message << '\r' << info << chars[i] << " " << TextTools::toString(iter); message->flush(); } else { if (iter == 0) *message << info; *message << "*"; message->flush(); return; } } /******************************************************************************/ void ApplicationTools::displayTime(const std::string& msg) { time_t endTime; time(&endTime); if (message) { double nsec = difftime(endTime, startTime); double nmin = floor(nsec/60.); double nhou = floor(nmin/60.); double nday = floor(nhou/24.); nhou = nhou - nday * 24; nmin = nmin - (nday * 24 + nhou) * 60; nsec = nsec - ((nday * 24 + nhou) * 60 + nmin) * 60; *message << msg << " "; *message << nday << "d, "; *message << nhou << "h, "; *message << nmin << "m, "; *message << nsec << "s."; message->endLine(); } } /******************************************************************************/ double ApplicationTools::getTime() { time_t endTime; time(&endTime); return difftime(endTime, startTime); } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Io/IoParametrizable.h000664 001750 001750 00000010033 12370705300 022162 0ustar00jdutheiljdutheil000000 000000 // // File: IOParametrizable.h // Created by: Laurent Guéguen // Created on: lundi 3 septembre 2012, à 14h 35 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _IOPARAMETRIZABLE_H_ #define _IOPARAMETRIZABLE_H_ #include "../Numeric/ParameterAliasable.h" #include "IoFormat.h" #include "OutputStream.h" #include namespace bpp { /** * @brief General interface for parametrizable Output. */ class IOParametrizable: public virtual IOFormat { public: IOParametrizable() {} virtual ~IOParametrizable() {} public: virtual const std::string getDataType() const { return "Parametrizable"; } }; /** * @brief General interface writers. */ class OParametrizable: public virtual IOParametrizable { public: OParametrizable() {} virtual ~OParametrizable() {} public: /** * @brief Write a Parametrizable to a stream. * * @param parametrizable A pointer to a Parametrizable object; * @param out The output stream; * @param writtenNames is the vector of the written * parameters so far [in, out]; * @param printComma boolean if a comma should be written at the * beginning of the description. */ virtual void write(const Parametrizable* parametrizable, OutputStream& out, std::vector& writtenNames, bool printComma=false) const = 0; /** * @brief Write a ParameterAliasable to a stream. * * @param parametrizable A pointer to a Parametrizable object; * @param out The output stream; * @param globalAliases parameters linked to global alias; * @param names the names of the parameters to be written; * @param writtenNames is the vector of the written * parameters so far [in, out]; * @param printLocalAliases boolean if local aliases should be written; * @param printComma boolean if a comma should be written at the * beginning of the description. */ virtual void write(const ParameterAliasable* parametrizable, OutputStream& out, std::map& globalAliases, const std::vector& names, std::vector& writtenNames, bool printLocalAliases = true, bool printComma=false) const = 0; }; } //end of namespace bpp. #endif //_IOPARAMETRIZABLE_H_ bpp-core-2.2.0/src/Bpp/Io/BppOParametrizableFormat.cpp000664 001750 001750 00000010410 12370705300 024156 0ustar00jdutheiljdutheil000000 000000 // // File: BppOParametrizableFormat.cpp // Created by: Laurent Guéguen // Created on: lundi 3 septembre 2012, à 15h 37 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "BppOParametrizableFormat.h" using namespace bpp; // From the STL: #include #include using namespace std; void BppOParametrizableFormat::write(const Parametrizable* parametrizable, OutputStream& out, std::vector& writtenNames, bool printComma) const { ParameterList pl = parametrizable->getParameters(); int p = out.getPrecision(); out.setPrecision(12); bool flag = printComma; for (size_t i = 0; i < pl.size(); ++i) { if (find(writtenNames.begin(), writtenNames.end(), pl[i].getName()) == writtenNames.end()) { if (flag) out << ","; else flag = true; string pname = parametrizable->getParameterNameWithoutNamespace(pl[i].getName()); (out << pname << "=").enableScientificNotation(false) << pl[i].getValue(); } } out.setPrecision(p); } void BppOParametrizableFormat::write(const ParameterAliasable* parametrizable, OutputStream& out, std::map& globalAliases, const std::vector& names, std::vector& writtenNames, bool printLocalAliases, bool printComma) const { ParameterList pl = parametrizable->getIndependentParameters().subList(names); int p = out.getPrecision(); out.setPrecision(12); bool flag = printComma; for (size_t i = 0; i < pl.size(); ++i) { if (find(writtenNames.begin(), writtenNames.end(), pl[i].getName()) == writtenNames.end()) { if (flag) out << ","; else flag = true; string pname = parametrizable->getParameterNameWithoutNamespace(pl[i].getName()); // Check for global aliases: if (globalAliases.find(pl[i].getName()) == globalAliases.end()) { (out << pname << "=").enableScientificNotation(false) << pl[i].getValue(); } else out << pname << "=" << globalAliases[pl[i].getName()]; // Now check for local aliases: if (printLocalAliases) { vector aliases = parametrizable->getAlias(pname); for (size_t j = 0; j < aliases.size(); ++j) { out << ", " << aliases[j] << "=" << pname; } } writtenNames.push_back(pl[i].getName()); } } out.setPrecision(p); } bpp-core-2.2.0/src/Bpp/Io/BppODiscreteDistributionFormat.h000664 001750 001750 00000006707 12370705300 025041 0ustar00jdutheiljdutheil000000 000000 // // File: Bpp0DiscreteDistributionFormat.h // Created by: Laurent Guéguen // Created on: lundi 3 septembre 2012, à 14h 42 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BPPODISCRETEDISTRIBUTIONFORMAT_H_ #define _BPPODISCRETEDISTRIBUTIONFORMAT_H_ #include "IoDiscreteDistributionFactory.h" namespace bpp { /** * @brief Discrete Distribution I/O in BppO format. * * Creates a new discrete distribution object according to * distribution description syntax (see the Bio++ Progam Suite * manual for a detailed description of this syntax). * */ class BppODiscreteDistributionFormat : public virtual IDiscreteDistribution, public virtual ODiscreteDistribution { protected: bool verbose_; std::map unparsedArguments_; public: BppODiscreteDistributionFormat(bool verbose = true) : verbose_(verbose), unparsedArguments_() {} virtual ~BppODiscreteDistributionFormat() {} public: const std::string getFormatName() const { return "BppO"; } const std::string getFormatDescription() const { return "Bpp Options format."; } DiscreteDistribution* read(const std::string& distDescription, bool parseArguments = true); const std::map& getUnparsedArguments() const { return unparsedArguments_; } void write(const DiscreteDistribution& dist, OutputStream& out, std::map& globalAliases, std::vector& writtenNames) const; protected: /** * @brief Set parameter initial values of a given distribution according to options. * * Parameters actually depends on the distribution passed as argument. * * @param rDist The distribution to set up. * @throw Exception if an error occured. */ void initialize_(DiscreteDistribution& rDist) throw (Exception); }; } // end of namespace bpp. #endif // _BPPODISCRETEDISTRIBUTIONFORMAT_H_ bpp-core-2.2.0/src/Bpp/Io/BppODiscreteDistributionFormat.cpp000664 001750 001750 00000036252 12370705300 025372 0ustar00jdutheiljdutheil000000 000000 // // File: BppODiscreteDistributionFormatFormat.cpp // Created by: Laurent Guéguen // Created on: lundi 3 septembre 2012, à 14h 48 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "BppODiscreteDistributionFormat.h" #include "../Io/FileTools.h" #include "../Text/TextTools.h" #include "../Text/StringTokenizer.h" #include "../Text/KeyvalTools.h" #include "../Numeric/Prob/DiscreteDistribution.h" #include "../Numeric/Prob/InvariantMixedDiscreteDistribution.h" #include "../Numeric/Prob/ConstantDistribution.h" #include "../Numeric/Prob/SimpleDiscreteDistribution.h" #include "../Numeric/Prob/MixtureOfDiscreteDistributions.h" #include "../Numeric/Prob/GammaDiscreteDistribution.h" #include "../Numeric/Prob/GaussianDiscreteDistribution.h" #include "../Numeric/Prob/BetaDiscreteDistribution.h" #include "../Numeric/Prob/ExponentialDiscreteDistribution.h" #include "../Numeric/Prob/TruncatedExponentialDiscreteDistribution.h" #include "../Numeric/Prob/UniformDiscreteDistribution.h" #include "../Numeric/AutoParameter.h" #include "BppOParametrizableFormat.h" using namespace bpp; // From the STL: #include using namespace std; DiscreteDistribution* BppODiscreteDistributionFormat::read( const std::string& distDescription, bool parseArguments) { unparsedArguments_.clear(); string distName; auto_ptr rDist; map args; KeyvalTools::parseProcedure(distDescription, distName, args); if ((distName == "InvariantMixed") || (distName == "Invariant")) { // We have to parse the nested distribution first: string nestedDistDescription = args["dist"]; if (TextTools::isEmpty(nestedDistDescription)) throw Exception("BppODiscreteDistributionFormat::read. Missing argument 'dist' for distribution 'Invariant'."); if (verbose_) ApplicationTools::displayResult("Invariant Mixed distribution", distName ); BppODiscreteDistributionFormat nestedReader(verbose_); DiscreteDistribution* nestedDistribution = nestedReader.read(nestedDistDescription, true); map unparsedArgumentsNested(nestedReader.getUnparsedArguments()); // Now we create the Invariant rate distribution: rDist.reset(new InvariantMixedDiscreteDistribution(nestedDistribution, 0.1, 0.000001)); // Then we update the parameter set: for (map::iterator it = unparsedArgumentsNested.begin(); it != unparsedArgumentsNested.end(); it++) { unparsedArguments_["Invariant." + it->first] = it->second; } if (args.find("p") != args.end()) unparsedArguments_["Invariant.p"] = args["p"]; } else if (distName == "Constant") { if (args.find("value") == args.end()) throw Exception("Missing argument 'value' in Constant distribution"); rDist.reset(new ConstantDistribution(TextTools::to(args["value"]))); unparsedArguments_["Constant.value"] = args["value"]; } else if (distName == "Simple") { if (args.find("values") == args.end()) throw Exception("Missing argument 'values' in Simple distribution"); if (args.find("probas") == args.end()) throw Exception("Missing argument 'probas' in Simple distribution"); vector probas, values; string rf = args["values"]; StringTokenizer strtok(rf.substr(1, rf.length() - 2), ","); while (strtok.hasMoreToken()) values.push_back(TextTools::toDouble(strtok.nextToken())); rf = args["probas"]; StringTokenizer strtok2(rf.substr(1, rf.length() - 2), ","); while (strtok2.hasMoreToken()) probas.push_back(TextTools::toDouble(strtok2.nextToken())); std::map > ranges; if (args.find("ranges") != args.end()) { string rr = args["ranges"]; StringTokenizer strtok3(rr.substr(1, rr.length() - 2), ","); string desc; double deb, fin; unsigned int num; size_t po, pf, ppv; while (strtok3.hasMoreToken()) { desc = strtok3.nextToken(); po = desc.find("["); ppv = desc.find(";"); pf = desc.find("]"); num = (unsigned int)(TextTools::toInt(desc.substr(1, po - 1))); deb = TextTools::toDouble(desc.substr(po + 1, ppv - po - 1)); fin = TextTools::toDouble(desc.substr(ppv + 1, pf - ppv - 1)); vector vd; vd.push_back(deb); vd.push_back(fin); ranges[num] = vd; } } if (ranges.size() == 0) rDist.reset(new SimpleDiscreteDistribution(values, probas)); else rDist.reset(new SimpleDiscreteDistribution(values, ranges, probas)); vector v = rDist->getParameters().getParameterNames(); for (unsigned int i = 0; i < v.size(); i++) { unparsedArguments_[v[i]] = TextTools::toString(rDist->getParameterValue(rDist->getParameterNameWithoutNamespace(v[i]))); } } else if (distName == "Mixture") { if (args.find("probas") == args.end()) throw Exception("Missing argument 'probas' in Mixture distribution"); vector probas; vector v_pdd; DiscreteDistribution* pdd; string rf = args["probas"]; StringTokenizer strtok2(rf.substr(1, rf.length() - 2), ","); while (strtok2.hasMoreToken()) probas.push_back(TextTools::toDouble(strtok2.nextToken())); vector v_nestedDistrDescr; unsigned int nbd = 0; while (args.find("dist" + TextTools::toString(++nbd)) != args.end()) v_nestedDistrDescr.push_back(args["dist" + TextTools::toString(nbd)]); if (v_nestedDistrDescr.size() != probas.size()) throw Exception("Number of distributions (keyword 'dist" + TextTools::toString(probas.size()) + "') do not fit the number of probabilities"); BppODiscreteDistributionFormat nestedReader; for (unsigned i = 0; i < v_nestedDistrDescr.size(); i++) { pdd = nestedReader.read(v_nestedDistrDescr[i], true); map unparsedArgumentsNested(nestedReader.getUnparsedArguments()); for (map::iterator it = unparsedArgumentsNested.begin(); it != unparsedArgumentsNested.end(); it++) { unparsedArguments_[distName + "." + TextTools::toString(i + 1) + "_" + it->first] = it->second; } v_pdd.push_back(pdd); } rDist.reset(new MixtureOfDiscreteDistributions(v_pdd, probas)); } else { if (args.find("n") == args.end()) throw Exception("Missing argument 'n' (number of classes) in " + distName + " distribution"); unsigned int nbClasses = TextTools::to(args["n"]); if (distName == "Gamma") { rDist.reset(new GammaDiscreteDistribution(nbClasses, 1, 1)); if (args.find("alpha") != args.end()) unparsedArguments_["Gamma.alpha"] = args["alpha"]; if (args.find("beta") != args.end()) unparsedArguments_["Gamma.beta"] = args["beta"]; } else if (distName == "Gaussian") { rDist.reset(new GaussianDiscreteDistribution(nbClasses, 0, 1)); if (args.find("mu") != args.end()) unparsedArguments_["Gaussian.mu"] = args["mu"]; if (args.find("sigma") != args.end()) unparsedArguments_["Gaussian.sigma"] = args["sigma"]; } else if (distName == "Beta") { rDist.reset(new BetaDiscreteDistribution(nbClasses, 1, 1)); if (args.find("alpha") != args.end()) unparsedArguments_["Beta.alpha"] = args["alpha"]; if (args.find("beta") != args.end()) unparsedArguments_["Beta.beta"] = args["beta"]; } else if (distName == "Exponential") { rDist.reset(new ExponentialDiscreteDistribution(nbClasses, 1)); if (args.find("lambda") != args.end()) unparsedArguments_["Exponential.lambda"] = args["lambda"]; if (args.find("median") != args.end()) rDist->setMedian(true); } else if (distName == "TruncExponential") { rDist.reset(new TruncatedExponentialDiscreteDistribution(nbClasses, 1, 0)); if (args.find("median") != args.end()) rDist->setMedian(true); if (args.find("lambda") != args.end()) unparsedArguments_["TruncExponential.lambda"] = args["lambda"]; if (args.find("tp") != args.end()) unparsedArguments_["TruncExponential.tp"] = args["tp"]; } else if (distName == "Uniform") { if (args.find("begin") == args.end()) throw Exception("Missing argument 'begin' in Uniform distribution"); if (args.find("end") == args.end()) throw Exception("Missing argument 'end' in Uniform distribution"); rDist.reset(new UniformDiscreteDistribution( nbClasses, TextTools::to(args["begin"]), TextTools::to(args["end"]))); } else { throw Exception("Unknown distribution: " + distName + "."); } } if (verbose_) { ApplicationTools::displayResult("Distribution", distName); ApplicationTools::displayResult("Number of classes", TextTools::toString(rDist->getNumberOfCategories())); } if (parseArguments) initialize_(*rDist); return rDist.release(); } void BppODiscreteDistributionFormat::write(const DiscreteDistribution& dist, OutputStream& out, std::map& globalAliases, std::vector& writtenNames) const { bool comma = false; const DiscreteDistribution* pd; out << dist.getName() + "("; const InvariantMixedDiscreteDistribution* invar = dynamic_cast(&dist); if (invar) { pd = invar->getVariableSubDistribution(); out << "dist="; write(*pd, out, globalAliases, writtenNames); comma = true; } else { const MixtureOfDiscreteDistributions* mix = dynamic_cast(&dist); if (mix) { size_t nd = mix->getNumberOfDistributions(); for (unsigned int i = 0; i < nd; i++) { if (comma) out << ","; out << "dist" + TextTools::toString(i + 1) + "="; write(*mix->getNDistribution(i), out, globalAliases, writtenNames); comma = true; } out << ",probas=("; for (unsigned int i = 0; i < nd; i++) { out << mix->getNProbability(i); if (i != nd - 1) out << ","; } out << ")"; for (unsigned int i = 1; i < nd; i++) { writtenNames.push_back(mix->getNamespace() + "theta" + TextTools::toString(i)); } } } if (dynamic_cast(&dist) || dynamic_cast(&dist) || dynamic_cast(&dist) || dynamic_cast(&dist) || dynamic_cast(&dist) || dynamic_cast(&dist)) { if (comma) out << ","; out << "n=" << dist.getNumberOfCategories(); comma = true; } const ConstantDistribution* pc = dynamic_cast(&dist); if (pc && dist.getNumberOfParameters() == 0) { if (comma) out << ","; out << "value=" << pc->getLowerBound(); comma = true; } const SimpleDiscreteDistribution* ps = dynamic_cast(&dist); if (ps) { size_t nd = ps->getNumberOfCategories(); if (comma) out << ","; out << "values=("; for (unsigned int i = 0; i < nd; i++) { out << ps->getCategory(i); if (i != nd - 1) out << ","; } out << "),probas=("; for (size_t i = 0; i < nd; i++) { out << ps->getProbability(i); if (i != nd - 1) out << ","; } out << ")"; const std::map > range = ps->getRanges(); if (range.size() != 0) { out << ",ranges=("; std::map >::const_iterator it(range.begin()); while (it != range.end()) { out << "V" << TextTools::toString(it->first); out << "[" << TextTools::toString(it->second[0]) << ";" << TextTools::toString(it->second[1]) << "]"; it++; if (it != range.end()) out << ","; } } out << ")"; for (size_t i = 1; i < nd; i++) { writtenNames.push_back(ps->getNamespace() + "theta" + TextTools::toString(i)); } for (size_t i = 1; i < nd + 1; i++) { writtenNames.push_back(ps->getNamespace() + "V" + TextTools::toString(i)); } comma = true; } // Writing the parameters BppOParametrizableFormat bOP; bOP.write(dynamic_cast(&dist), out, globalAliases, dist.getIndependentParameters().getParameterNames(), writtenNames, true, comma); out << ")"; } void BppODiscreteDistributionFormat::initialize_( DiscreteDistribution& rDist) throw (Exception) { ParameterList pl = rDist.getIndependentParameters(); for (size_t i = 0; i < pl.size(); ++i) { AutoParameter ap(pl[i]); ap.setMessageHandler(ApplicationTools::warning); pl.setParameter(i, ap); } for (size_t i = 0; i < pl.size(); ++i) { const string pName = pl[i].getName(); double value = ApplicationTools::getDoubleParameter(pName, unparsedArguments_, pl[i].getValue()); pl[i].setValue(value); if (verbose_) ApplicationTools::displayResult("Parameter found", pName + "=" + TextTools::toString(pl[i].getValue())); } rDist.matchParametersValues(pl); if (verbose_) { for (size_t c = 0; c < rDist.getNumberOfCategories(); ++c) { ApplicationTools::displayResult("- Category " + TextTools::toString(c) + " (Pr = " + TextTools::toString(rDist.getProbability(c)) + ") rate", TextTools::toString(rDist.getCategory(c))); } } } bpp-core-2.2.0/src/Bpp/Io/IoFormat.h000664 001750 001750 00000005306 12370705300 020457 0ustar00jdutheiljdutheil000000 000000 // // File IoFormat.h // Author : Julien Dutheil // Created on: 2005 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _IOFORMAT_H_ #define _IOFORMAT_H_ #include "../Exceptions.h" // From STL: #include namespace bpp { /** * @brief The IOFormat interface. * * This is the most basal class of any format I/O implementation. */ class IOFormat { public: IOFormat() {} virtual ~IOFormat() {} public: /** * @brief Get the type of data this format deals with. * * @return The type of data. */ virtual const std::string getDataType() const = 0; /** * @brief Get the name of the file format. * * @return The name of the format implemented. */ virtual const std::string getFormatName() const = 0; /** * @brief Get a description of the file format. * * @return A description of the format implemented. */ virtual const std::string getFormatDescription() const = 0; }; } //end of namespace bpp. #endif // _IOFORMAT_H_ bpp-core-2.2.0/src/Bpp/Io/IoDiscreteDistributionFactory.cpp000664 001750 001750 00000004505 12370705300 025254 0ustar00jdutheiljdutheil000000 000000 // // File IoDiscreteDistributionFactory.cpp // Created by: Laurent Guéguen // Created on: lundi 3 septembre 2012, à 14h 44 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for sequences analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "BppODiscreteDistributionFormat.h" using namespace bpp; const std::string IoDiscreteDistributionFactory::BPPO_FORMAT = "Bpp0"; IDiscreteDistribution* IoDiscreteDistributionFactory::createReader(const std::string& format) throw (Exception) { if(format == BPPO_FORMAT) return new BppODiscreteDistributionFormat(); else throw Exception("Format " + format + " is not supported for input."); } ODiscreteDistribution* IoDiscreteDistributionFactory::createWriter(const std::string& format) throw (Exception) { if(format == BPPO_FORMAT) return new BppODiscreteDistributionFormat(); else throw Exception("Format " + format + " is not supported for output."); } bpp-core-2.2.0/src/Bpp/Io/FileTools.h000664 001750 001750 00000011415 12370705300 020635 0ustar00jdutheiljdutheil000000 000000 // // File FileTools.h // Created by: Guillaume Deuchst // Julien Dutheil // Last modification : Monday August 4 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _FILETOOLS_H_ #define _FILETOOLS_H_ // From the STL: #include #include #include #include #include //#include // required for directoryExists method namespace bpp { /** * @brief Some utilitary functions to deal with files. * * File paths default to unix, i.e. the directory seprator if '/'. * This character is stored in the variable 'DIR_SEP', and hence may be changed by * @code * FileTools::DIR_SEP='\\'; * @endcode * for windows programs. * * Methods dealing with pathes have an optional dirSep argument, which default to DIR_SEP. */ class FileTools { public: static char DIR_SEP; public: FileTools() {} virtual ~FileTools() {} public: /** * @brief Tells if a file exist. * * @param filename The path toward the file. * @return True if the file exists. */ static bool fileExists(const std::string& filename); /** * @brief Tells if a directory exist. * * NB: this is an alias for fileExists. * * @param path The path toward the file. * @return True if the file exists. */ static bool directoryExists(const std::string& path); /** * @brief Get the name of of a file, without extension. * * Example: * FileTools::getFileName("/path/file.ext") returns "file". * This method is not recursive, hence * FileTools::getfileName("/home/me/archive.tar.gz") returns "archive". * * An empty string is returned if 'path' is not a valid path toward a file. * * @param path A file path. * @param dirSep The directory separator. * @return The filename of the file specified by path. */ static std::string getFileName(const std::string& path, char dirSep = DIR_SEP); /** * @brief Get the size of a file. * * @param filename The path toward the file. * @return The size of the file. * @author Sylvain Gaillard */ static std::streampos getFileSize(const std::string& filename); /** * @brief Get the path of the parent directry of the given file/dir. * * @param path A file/directory path. * @param dirSep The directory separator. * @return The path towar dthe parent directory. */ static std::string getParent(const std::string& path, char dirSep = DIR_SEP); /** * @brief Get the extension of a file. * * Example: * FileTools::getExtension("/path/file.ext") returns "ext". * This method is not recursive, hence * FileTools::getExtension("/home/me/archive.tar.gz") returns "gz". * * @param path A file path. * @return The extension of the file specified by path. */ static std::string getExtension(const std::string& path); /** * @brief Reads a stream and write each line in a vector. * * @param input Input stream. * @return A vector of strings. */ static std::vector putStreamIntoVectorOfStrings(std::istream& input); /** * @brief Get the next non-blanck line of a stream. * * @param in Input stream. */ static std::string getNextLine(std::istream& in); }; } //end of namespace bpp. #endif // _FILETOOLS_H_ bpp-core-2.2.0/src/Bpp/Io/BppOParametrizableFormat.h000664 001750 001750 00000007734 12370705300 023642 0ustar00jdutheiljdutheil000000 000000 // // File: Bpp0ParametrizableFormat.h // Created by: Laurent Guéguen // Created on: lundi 3 septembre 2012, à 15h 30 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BPPOPARAMETRIZABLEFORMAT_H_ #define _BPPOPARAMETRIZABLEFORMAT_H_ #include "IoParametrizable.h" namespace bpp { /** * @brief Parametrizable output in BppO format. * * Writes a new parametrizable object according to BppO description * syntax (see the Bio++ Progam Suite manual for a detailed * description of this syntax). * */ class BppOParametrizableFormat: public OParametrizable { public: BppOParametrizableFormat() {} virtual ~BppOParametrizableFormat() {} public: const std::string getFormatName() const { return "BppO"; } const std::string getFormatDescription() const { return "Bpp Options format."; } /** * @brief Write a Parametrizable to a stream. * * @param parametrizable A pointer to a Parametrizable object; * @param out The output stream; * @param writtenNames is the vector of the written * parameters so far [in, out]; * @param printComma boolean if a comma should be written at the * beginning of the description. */ void write(const Parametrizable* parametrizable, OutputStream& out, std::vector& writtenNames, bool printComma = false) const; /** * @brief Write a ParameterAliasable to a stream. * * @param parametrizable A pointer to a Parametrizable object; * @param out The output stream; * @param globalAliases parameters linked to global alias; * @param names the names of the parameters to be written; * @param writtenNames is the vector of the written * parameters so far [in, out]; * @param printLocalAliases boolean if local aliases should be written; * @param printComma boolean if a comma should be written at the * beginning of the description. */ void write(const ParameterAliasable* parametrizable, OutputStream& out, std::map& globalAliases, const std::vector& names, std::vector& writtenNames, bool printLocalAliases = true, bool printComma = false) const; }; } //end of namespace bpp. #endif //_BPPOPARAMETRIZABLEFORMAT_H_ bpp-core-2.2.0/src/Bpp/Io/FileTools.cpp000664 001750 001750 00000011205 12406035116 021166 0ustar00jdutheiljdutheil000000 000000 // // File FileTools.cpp // Author : Guillaume Deuchst // Julien Dutheil // Last modification : Tuesday August 23 2005 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "FileTools.h" // class's header file #include "../Text/TextTools.h" #include using namespace bpp; using namespace std; /******************************************************************************/ char FileTools::DIR_SEP = '/'; /******************************************************************************/ bool FileTools::fileExists(const std::string& filename) { ifstream file(filename.c_str()); bool test = file ? true : false; //needed for CLang. file.close(); return test; } /******************************************************************************/ bool FileTools::directoryExists(const std::string& path) { ifstream file(path.c_str()); bool test = file ? true : false; //needed for CLang. file.close(); return test; } /******************************************************************************/ std::string FileTools::getFileName(const std::string& path, char dirSep) { ptrdiff_t end = static_cast(path.find_last_of(".")); ptrdiff_t begin = static_cast(path.find_last_of(dirSep) + 1); // Return an empty string if specified string isn't a path if (begin > end) return ""; // Copy path and deletion of directories and extension string result(path); result.erase(result.begin() + end, result.end()); result.erase(result.begin(), result.begin() + begin); // Send file name return result; } /******************************************************************************/ streampos FileTools::getFileSize(const std::string& filename) { std::ifstream stream; streampos size; stream.open(filename.c_str(), std::ios::ate); size = stream.tellg(); stream.close(); return size; } /******************************************************************************/ std::string FileTools::getParent(const std::string& path, char dirSep) { // Position of file name: ptrdiff_t begin = static_cast(path.find_last_of(dirSep)); // Copy string and delte filename: string result(path); result.erase(result.begin() + begin, result.end()); // Send directories return result; } /******************************************************************************/ std::string FileTools::getExtension(const std::string& path) { size_t end = path.find_last_of("."); return path.substr(end + 1); } /******************************************************************************/ std::vector FileTools::putStreamIntoVectorOfStrings(std::istream& input) { vector vs; string s = ""; while(input) { getline(input, s, '\n'); vs.push_back(s); } return vs; } /******************************************************************************/ std::string FileTools::getNextLine(std::istream& in) { if(in.eof()) return string(""); string temp(""); while(!in.eof() && TextTools::isEmpty(temp)) { getline(in, temp, '\n'); } return temp; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Io/IoDiscreteDistributionFactory.h000664 001750 001750 00000006436 12370705300 024726 0ustar00jdutheiljdutheil000000 000000 // // File IODiscreteDistributionFactory.h // Created by: Laurent Guéguen // Created on: lundi 3 septembre 2012, à 14h 45 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for sequences analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _IODISCRETEDISTRIBUTIONFACTORY_H_ #define _IODISCRETEDISTRIBUTIONFACTORY_H_ #include "../Numeric/Prob/DiscreteDistribution.h" #include "../Exceptions.h" #include "IoDiscreteDistribution.h" //From the STL: #include namespace bpp { /** * @brief Utilitary class for creating discrete distribution readers and * writers. */ class IoDiscreteDistributionFactory { public: static const std::string BPPO_FORMAT; public: /** * @brief Creates a new factory object. * * Example: * @code * IDiscreteDistribution* distReader = IoDiscreteDistributionFactory().createReader(IoDiscreteDistributionFactory::BPP_FORMAT); * DiscreteDistribution* dist = distReader->read(...); * delete distReader; * @endcode */ IoDiscreteDistributionFactory() {} virtual ~IoDiscreteDistributionFactory() {} /** * @brief Get a new dynamically created IDiscreteDistribution object. * * @param format The input file format. * @return A pointer toward a new IDiscreteDistribution object. * @throw Exception If the format name do not match any available format. */ virtual IDiscreteDistribution* createReader(const std::string& format) throw (Exception); /** * @brief Get a new dynamically created ODiscreteDistribution object. * * @param format The output file format. * @return A pointer toward a new ODiscreteDistribution object. * @throw Exception If the format name do not match any available format. */ virtual ODiscreteDistribution* createWriter(const std::string& format) throw (Exception); }; } //end of namespace bpp. #endif //_IODISCRETEDISTRIBUTIONFACTORY_H_ bpp-core-2.2.0/src/Bpp/Io/IoDiscreteDistribution.h000664 001750 001750 00000010152 12370705300 023364 0ustar00jdutheiljdutheil000000 000000 // // File: IoDiscreteDistribution.h // Created by: Laurent Guéguen // Created on: lundi 3 septembre 2012, à 14h 35 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _IODISCRETEDISTRIBUTION_H_ #define _IODISCRETEDISTRIBUTION_H_ #include "../Numeric/Prob/DiscreteDistribution.h" #include "../Exceptions.h" #include "IoFormat.h" #include "OutputStream.h" namespace bpp { /** * @brief General interface for model I/O. */ class IoDiscreteDistribution: public virtual IOFormat { public: IoDiscreteDistribution() {} virtual ~IoDiscreteDistribution() {} public: virtual const std::string getDataType() const { return "Discrete Distribution"; } }; /** * @brief General interface for distance matrix readers. */ class IDiscreteDistribution: public virtual IoDiscreteDistribution { public: IDiscreteDistribution() {} virtual ~IDiscreteDistribution() {} public: /** * @brief Read a discrete distribution from a string. * * @param distrDescription A string describing the distribution in the format. * @param parseArguments Attempt to parse function arguments. If not, only store them and use default values instead. * @return A new DiscreteDistribution object according to options specified. * @throw Exception if an error occured. */ virtual DiscreteDistribution* read( const std::string& distrDescription, bool parseArguments = true) = 0; /** * @return The arguments and their unparsed values from the last call of the read function, if there are any. */ virtual const std::map& getUnparsedArguments() const = 0; }; /** * @brief General interface writers. */ class ODiscreteDistribution: public virtual IoDiscreteDistribution { public: ODiscreteDistribution() {} virtual ~ODiscreteDistribution() {} public: /** * @brief Write a discrete distribution to a stream. * * @param dist A discrete distribution object; * @param out The output stream; * @param globalAliases parameters linked to global alias. * @param writtenNames is the vector of the written * parameters so far [in, out]; * @throw Exception if an error occured. */ virtual void write(const DiscreteDistribution& dist, OutputStream& out, std::map& globalAliases, std::vector& writtenNames) const = 0; }; } //end of namespace bpp. #endif //_IODISCRETEDISTRIBUTION_H_ bpp-core-2.2.0/src/Bpp/Io/OutputStream.h000664 001750 001750 00000031472 12370705300 021416 0ustar00jdutheiljdutheil000000 000000 // // File: OutputStream.h // Created by: Julien Dutheil // Created on: Mon Jan 25 17:41 2010 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _OUTPUTSTREAM_H_ #define _OUTPUTSTREAM_H_ #include "../Clonable.h" //From the STL: #include #include #include #include #include #include namespace bpp { /** * @brief OutputStream interface. * * This interface define several << operators for outputing messages. * Wrapper classes for the STL streams are available as special * implementations, but this interface can be used to redirect the output to * files or to graphical components for instance. */ class OutputStream : public virtual Clonable { public: virtual OutputStream& operator<<(const std::string& message) = 0; virtual OutputStream& operator<<(const char* message) = 0; virtual OutputStream& operator<<(const char& message) = 0; virtual OutputStream& operator<<(const int& message) = 0; virtual OutputStream& operator<<(const unsigned int& message) = 0; virtual OutputStream& operator<<(const long int& message) = 0; virtual OutputStream& operator<<(const unsigned long int& message) = 0; virtual OutputStream& operator<<(const double& message) = 0; virtual OutputStream& operator<<(const long double& message) = 0; virtual OutputStream& operator<<(const bool& message) = 0; virtual OutputStream& endLine() = 0; virtual OutputStream& flush() = 0; virtual OutputStream& setPrecision(int digit) = 0; virtual int getPrecision() const = 0; virtual OutputStream& enableScientificNotation(bool yn) = 0; virtual bool isScientificNotationEnabled() const = 0; /** * @name The Clonable interface. * * @{ */ #ifndef NO_VIRTUAL_COV OutputStream* clone() const = 0; #endif /** @} */ }; /** * @brief Helper implementation of the OutputStream interface. */ class AbstractOutputStream : public virtual OutputStream { private: int precision_; bool scienceNotation_; public: AbstractOutputStream() : precision_(6), scienceNotation_(false) {} public: OutputStream& setPrecision(int digit) { precision_ = digit; return *this; } int getPrecision() const { return precision_; } virtual OutputStream& enableScientificNotation(bool yn) { scienceNotation_ = yn; return *this; } virtual bool isScientificNotationEnabled() const { return scienceNotation_; } }; /** * @brief Null output stream (swich off output). */ class NullOutputStream : public AbstractOutputStream { public: NullOutputStream& operator<<(const std::string& message) { return *this; } NullOutputStream& operator<<(const char* message) { return *this; } NullOutputStream& operator<<(const char& message) { return *this; } NullOutputStream& operator<<(const int& message) { return *this; } NullOutputStream& operator<<(const unsigned int& message) { return *this; } NullOutputStream& operator<<(const long int& message) { return *this; } NullOutputStream& operator<<(const unsigned long int& message) { return *this; } NullOutputStream& operator<<(const double& message) { return *this; } NullOutputStream& operator<<(const long double& message) { return *this; } NullOutputStream& operator<<(const bool& message) { return *this; } NullOutputStream& endLine() { return *this; } NullOutputStream& flush() { return *this; } NullOutputStream* clone() const { return new NullOutputStream(*this); } }; /** * @brief STL output stream. * * This class wraps the std::ostream class. * It takes as input a pointer toward an existing stream that will then be * owned by the wrapper, as a smart pointer. * Any copy of this class will then result in an inactivation of the original * version (in other word, you can't have two wrappers for the same stream). */ class StlOutputStream : public AbstractOutputStream { private: mutable std::auto_ptr stream_; public: StlOutputStream(std::ostream* stream): stream_(stream) {} StlOutputStream(const StlOutputStream& stlos) : stream_(stlos.stream_) {} StlOutputStream& operator=(const StlOutputStream& stlos) { stream_ = stlos.stream_; return *this; } public: StlOutputStream& operator<<(const std::string& message) { if (stream_.get()) *stream_ << message; return *this; } StlOutputStream& operator<<(const char* message) { if (stream_.get()) *stream_ << message; return *this; } StlOutputStream& operator<<(const char& message) { if (stream_.get()) *stream_ << message; return *this; } StlOutputStream& operator<<(const int& message) { if (stream_.get()) *stream_ << message; return *this; } StlOutputStream& operator<<(const unsigned int& message) { if (stream_.get()) *stream_ << message; return *this; } StlOutputStream& operator<<(const long int& message) { if (stream_.get()) *stream_ << message; return *this; } StlOutputStream& operator<<(const unsigned long int& message) { if (stream_.get()) *stream_ << message; return *this; } StlOutputStream& operator<<(const double& message) { if (stream_.get()) *stream_ << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message; return *this; } StlOutputStream& operator<<(const long double& message) { if (stream_.get()) *stream_ << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message; return *this; } StlOutputStream& operator<<(const bool& message) { if (stream_.get()) *stream_ << message; return *this; } StlOutputStream& endLine() { if (stream_.get()) *stream_ << std::endl; return *this; } StlOutputStream& flush() { if (stream_.get()) stream_->flush(); return *this; } StlOutputStream* clone() const { return new StlOutputStream(*this); } }; /** * @brief STL wrapper for output stream. * * This class wraps the std::ostream class, by forwarding to the STL class. * It does not own the STL stream and won't delete it. */ class StlOutputStreamWrapper : public AbstractOutputStream { protected: std::ostream* stream_; public: StlOutputStreamWrapper(std::ostream* stream): stream_(stream) {} StlOutputStreamWrapper(const StlOutputStreamWrapper& stlos) : stream_(stlos.stream_) {} StlOutputStreamWrapper& operator=(const StlOutputStreamWrapper& stlos) { stream_ = stlos.stream_; return *this; } public: StlOutputStreamWrapper& operator<<(const std::string& message) { if (stream_) *stream_ << message; return *this; } StlOutputStreamWrapper& operator<<(const char* message) { if (stream_) *stream_ << message; return *this; } StlOutputStreamWrapper& operator<<(const char& message) { if (stream_) *stream_ << message; return *this; } StlOutputStreamWrapper& operator<<(const int& message) { if (stream_) *stream_ << message; return *this; } StlOutputStreamWrapper& operator<<(const unsigned int& message) { if (stream_) *stream_ << message; return *this; } StlOutputStreamWrapper& operator<<(const long int& message) { if (stream_) *stream_ << message; return *this; } StlOutputStreamWrapper& operator<<(const unsigned long int& message) { if (stream_) *stream_ << message; return *this; } StlOutputStreamWrapper& operator<<(const double& message) { if (stream_) *stream_ << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message; return *this; } StlOutputStreamWrapper& operator<<(const long double& message) { if (stream_) *stream_ << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message; return *this; } StlOutputStreamWrapper& operator<<(const bool& message) { if (stream_) *stream_ << message; return *this; } StlOutputStreamWrapper& endLine() { if (stream_) *stream_ << std::endl; return *this; } StlOutputStreamWrapper& flush() { if (stream_) stream_->flush(); return *this; } StlOutputStreamWrapper* clone() const { return new StlOutputStreamWrapper(*this); } }; /** * @brief Standard output stream. * * This class wraps the std::cout stream. */ class StdOut : public AbstractOutputStream { public: OutputStream& operator<<(const std::string& message) { std::cout << message; return *this; } OutputStream& operator<<(const char* message) { std::cout << message; return *this; } OutputStream& operator<<(const char& message) { std::cout << message; return *this; } OutputStream& operator<<(const int& message) { std::cout << message; return *this; } OutputStream& operator<<(const unsigned int& message) { std::cout << message; return *this; } OutputStream& operator<<(const long int& message) { std::cout << message; return *this; } OutputStream& operator<<(const unsigned long int& message) { std::cout << message; return *this; } OutputStream& operator<<(const double& message) { std::cout << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message; return *this; } OutputStream& operator<<(const long double& message) { std::cout << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message; return *this; } OutputStream& operator<<(const bool& message) { std::cout << message; return *this; } OutputStream& endLine() { std::cout << std::endl; return *this; } OutputStream& flush() { std::cout.flush(); return *this; } StdOut* clone() const { return new StdOut(*this); } }; /** * @brief Standard error stream. * * This class wraps the std::cerr stream. */ class StdErr : public AbstractOutputStream { public: OutputStream& operator<<(const std::string& message) { std::cerr << message; return *this; } OutputStream& operator<<(const char* message) { std::cerr << message; return *this; } OutputStream& operator<<(const char& message) { std::cerr << std::setprecision(getPrecision()) << message; return *this; } OutputStream& operator<<(const int& message) { std::cerr << std::setprecision(getPrecision()) << message; return *this; } OutputStream& operator<<(const unsigned int& message) { std::cerr << message; return *this; } OutputStream& operator<<(const long int& message) { std::cerr << std::setprecision(getPrecision()) << message; return *this; } OutputStream& operator<<(const unsigned long int& message) { std::cerr << message; return *this; } OutputStream& operator<<(const double& message) { std::cerr << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message; return *this; } OutputStream& operator<<(const long double& message) { std::cerr << std::setprecision(getPrecision()) << (isScientificNotationEnabled() ? std::scientific : std::fixed) << message; return *this; } OutputStream& operator<<(const bool& message) { std::cerr << message; return *this; } OutputStream& endLine() { std::cerr << std::endl; return *this; } OutputStream& flush() { std::cerr.flush(); return *this; } #ifndef NO_VIRTUAL_COV StdErr* clone() const { return new StdErr(*this); } #endif }; /** * @brief String output stream. * * This class wraps the std::ostringstream stream. */ class StdStr : public StlOutputStreamWrapper { public: StdStr(): StlOutputStreamWrapper(new std::ostringstream()){} std::string str() const { return dynamic_cast(stream_)->str();} ~StdStr() { delete stream_;} }; } // end of namespace bpp; #endif //_OUTPUTSTREAM_H_ bpp-core-2.2.0/src/Bpp/BppString.cpp000664 001750 001750 00000003465 12370705300 020637 0ustar00jdutheiljdutheil000000 000000 // // File: BppString.cpp // Created by: Julien Dutheil // Created on: Thu May 04 10:21 2006 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "BppString.h" using namespace bpp; std::ostream& bpp::operator<<(std::ostream& out, const BppString& s) { out << s.toSTL(); return out; } bpp-core-2.2.0/src/Bpp/Clonable.h000664 001750 001750 00000012232 12370705300 020103 0ustar00jdutheiljdutheil000000 000000 // // File: Clonable.h // Created by: Julien Dutheil // Created on: Wed Nov 12 15:55:03 2003 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _CLONABLE_H_ #define _CLONABLE_H_ /** * @mainpage * * @par * This library contains Bio++ core interfaces, classes and functions. * It provides a general interface called bpp::Clonable, which allows dynamic copy of objects. * Wrapper classes for numbers, strings and vectors that implement this interface are provided, and called * respectively bpp::Number, bpp::BppString and bpp::BppVector. * * @par * The bpp::Exception class is the most general exception class used in Bio++, and provides only a single text information. * Several more specialized exception classes are also provided, like * - bpp::IOException for input/output errors, usually when reading from or writing to files, * - bpp::NullPointerException when a NULL pointer is unexpectedly provided, * - bpp::BadNumberException and bpp::BadIntegerException, dealing with number problems (bounds, format, etc), * - and more... * * @par * This library also includes several submodules: * - The Text module contains: functions to deal with character strings (bpp::StringTokenizer and the bpp::TextTools static class), * like pattern matching, concatenation, number conversion, etc. * - The Graphics module provides support for graphical output. This includes the general bpp::GraphicDevice interface, with currently three implementations for XFig (bpp::XFigGraphicDevice), SVG (bpp::SVGGraphicDevice) and PGF (bpp::PGFGraphicDevice) formats. * Classes to deal with colors and fonts were created (see bpp::RGBColor, bpp::ColorSet, bpp::ColorTools and bpp::Font). * - The App module contains classes and tools that provide powerful methods to parse command-line options and more. * - The Numeric module is quite large and provides interfaces, classes and functions for numerical calculus. * The tools included are general enough to be useful beyond biology. * The originality of this module, unless many existing libraries, is to be fully object-oriented. * Available methods include: * - Vector operations, based on the stl::vector class, see bpp::VectorTools, * - Matrix data and operations, see the bpp::Matrix interface and bpp::MatrixTools class, * - Functions are implemented using several general classes: * - the bpp::Function interface and its derivatives, * - the bpp::Parameter, bpp::Constraint and bpp::ParameterList classes, and the bpp::Parametrizable interface * provide a very general way to deal with parameters * - Function operations, see the bpp::Optimizer interface, and the bpp::AbstractNumericalDerivative class for * numerical differenciation, * - Discrete probability distributions are implemented via the bpp::DiscreteDistribution interface * - Several random numbers generators are available through the bpp::RandomNumberFactory interface, and the * bpp::RandomTools static class provides useful methods to deal with random numbers. * . * . * . */ namespace bpp { /** * @brief The Clonable interface (allow an object to be cloned). * * A clone is a deep (or hard) copy of an object. * This interface provides a method that dynamically creates a copy of itself * and send a pointer toward it. * * This method allows an object to be copied when you do not now its class. */ class Clonable { public: Clonable() {} virtual ~Clonable() {} public: /** * @brief Create a copy of this object and send a pointer to it. * * @return A pointer toward the copy object. */ virtual Clonable * clone() const = 0; }; } //end of namespace bpp. #endif //_CLONABLE_H_ bpp-core-2.2.0/src/Bpp/BppBoolean.h000664 001750 001750 00000005012 12370705300 020403 0ustar00jdutheiljdutheil000000 000000 // // File: BppBoolean.h // Created by: Julien Dutheil // Created on: Fri 31 10:44 2010 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BPP_BOOLEAN_H_ #define _BPP_BOOLEAN_H_ #include "Clonable.h" // From the STL: #include #include namespace bpp { /** * @brief The BppBoolean object class. * * This class extends the bool type to support the Clonable interface. */ class BppBoolean: public virtual Clonable { private: bool value_; public: BppBoolean(): value_(false) {} BppBoolean(bool value): value_(value) {} virtual ~BppBoolean() {} public: /** * @name The Clonable interface. * * @{ */ #ifdef NO_VIRTUAL_COV Clonable* #else BppBoolean* #endif clone() const { return new BppBoolean(*this); } /** @} */ const bool getValue() const { return value_; } }; std::ostream& operator<<(std::ostream& out, const BppBoolean& s) { return out << s.getValue(); } } //end of namespace bpp. #endif //_BPP_BOOLEAN_H_ bpp-core-2.2.0/src/Bpp/Text/KeyvalTools.h000664 001750 001750 00000011001 12370705300 021555 0ustar00jdutheiljdutheil000000 000000 // // File: KeyvalTools.h // Created by: Julien Dutheil // Created on: Mon May 13:16 CET 2009 // /* Copyright or © or Copr. Bio++ Development Tools, (2009) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _KEYVALTOOLS_H_ #define _KEYVALTOOLS_H_ #include "StringTokenizer.h" #include "TextTools.h" #include "../Exceptions.h" //From the STL: #include namespace bpp { /** * @brief Exception thrown by the Keyval parser. */ class KeyvalException : public Exception { public: KeyvalException(const std::string& message) : Exception(message) {} }; /** * @brief Tools to deal with the keyval syntax. * * This class contains method to deal with parameter=value syntax procedure. * A keyval procedure takes the form * @code * proc(p1=v1,p2=v2,p3=v3,etc) * @endcode * where 'p' are parameter names, and 'v' are the corresponding values. * These values can be nested keyval procedures. */ class KeyvalTools { public: KeyvalTools(); virtual ~KeyvalTools(); public: /** * @brief Split a string into a key and a value (General purpose function). * * @param desc [in] A string descibing the keyval, with format key=val (space are considered normal character, that's up to you to deal with that afterward!). * @param key [out] Will contain the text of the key. * @param val [out] Will contain the text of the value. * @param split [in] The delimiter. Default is '=' but ':' can be used. * @throw KeyvalException If the syntax describing the keyval is not correct. */ static void singleKeyval(const std::string& desc, std::string& key, std::string& val, const std::string& split = "=") throw (KeyvalException); /** * @brief Split a string into several keys and corresponding values (General purpose function). * * @param desc [in] A string descibing the keyval, with format key1=val1,key2=val2,etc (space are considered normal character, that's up to you to deal with that afterward!). * @param keyvals [out] Will contain the text of the keys and their corresponding values. * @param split [in] The keyval delimiter.the default is a coma, but a space character can be used for instance. * @param nested [in] Tell if nested keyval procedures are expected. * @throw KeyvalException If the syntax describing the keyval is not correct. */ static void multipleKeyvals(const std::string& desc, std::map& keyvals, const std::string& split = ",", bool nested = true) throw (KeyvalException); /** * @brief Parse (not recursively) a procedure string. * * @param desc [in] A string descibing the keyval procedure. * @param name [out] Outputs the name of the procedure. * @param args [out] Fills a map with all keys and values for parameters. * @throw KeyvalException If the description is invalid (one parenthesis is missing for instance). */ static void parseProcedure(const std::string& desc, std::string& name, std::map& args) throw (KeyvalException); }; } //End of namespace bpp. #endif //_KEYVALTOOLS_H_ bpp-core-2.2.0/src/Bpp/Text/NestedStringTokenizer.cpp000664 001750 001750 00000012120 12370705300 024143 0ustar00jdutheiljdutheil000000 000000 // // File: NestedStringTokenizer.cpp // Author : Julien Dutheil // Last modification : Monday May 22 10:57 2006 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to map data onto a sequence or a phylogenetic tree. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "NestedStringTokenizer.h" #include "TextTools.h" using namespace bpp; //From the STL: #include using namespace std; NestedStringTokenizer::NestedStringTokenizer(const std::string& s, const std::string& open, const std::string& end, const std::string& delimiters, bool solid) throw (Exception): StringTokenizer() { int blocks = 0; string cache = ""; if (!solid) { string::size_type index = s.find_first_not_of(delimiters, 0); while (index != s.npos) { string::size_type newIndex = s.find_first_of(delimiters, index); bool endBlockFound = false; while (!endBlockFound) { if (newIndex != s.npos) { string token = s.substr(index, newIndex - index); blocks += static_cast(TextTools::count(token, open)) - static_cast(TextTools::count(token, end)); if (blocks == 0) { tokens_.push_back(cache + token); cache = ""; //reset cache. index = s.find_first_not_of(delimiters, newIndex); endBlockFound = true; } else { // Ignore this token untill closing block is found cache += s.substr(index, newIndex - index + 1); index = newIndex + 1; newIndex = s.find_first_of(delimiters, index); } } else { string token = s.substr(index); blocks += static_cast(TextTools::count(token, open)) - static_cast(TextTools::count(token, end)); if (blocks == 0) { tokens_.push_back(cache + token); cache = ""; //reset cache. index = newIndex; endBlockFound = true; } else throw Exception("NestedStringTokenizer (constructor). Unclosed block."); } } } } else { string::size_type index = 0; while (index != s.npos) { string::size_type newIndex = s.find(delimiters, index); bool endBlockFound = false; while (!endBlockFound) { if (newIndex != s.npos) { string token = s.substr(index, newIndex - index); blocks += static_cast(TextTools::count(token, open)) - static_cast(TextTools::count(token, end)); if (blocks == 0) { tokens_.push_back(cache + token); cache = ""; //reset cache. index = newIndex + delimiters.size(); endBlockFound = true; } else { // Ignore this token untill closing block is found cache += s.substr(index, newIndex - index + 1); index = newIndex + 1; newIndex = s.find(delimiters, index); } } else { string token = s.substr(index); blocks += static_cast(TextTools::count(token, open)) - static_cast(TextTools::count(token, end)); if (blocks == 0) { tokens_.push_back(cache + token); cache = ""; //reset cache. index = newIndex; endBlockFound = true; } else throw Exception("Unclosed block."); } } } } } const std::string& NestedStringTokenizer::nextToken() throw (Exception) { if (!hasMoreToken()) throw Exception("No more token in nested tokenizer."); return tokens_[currentPosition_++]; } bpp-core-2.2.0/src/Bpp/Text/TextTools.h000664 001750 001750 00000035245 12370705300 021266 0ustar00jdutheiljdutheil000000 000000 // // File: TextTools.h // Created by: Julien Dutheil // Created on: Fri Aug 8 12:57:50 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide basal and utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _TEXTTOOLS_H_ #define _TEXTTOOLS_H_ #include "../Exceptions.h" // From the STL: #include #include #include #include namespace bpp { /** * @brief Some utilitary functions that work on strings. */ class TextTools { public: /** * @brief Tell if a string is empty. * * A string is considered to be 'empty' if it is only made of white * spaces. * * @param s The string to check. * @return True if the string has only white characters. */ static bool isEmpty(const std::string& s); /** * @brief Make the string uppercase. * * @param s The string to analyse. * @return A copy of the string with all chars uppercase. */ static std::string toUpper(const std::string& s); /** * @brief Make the string lowercase. * * @param s The string to analyse. * @return A copy of the string with all chars lowercase. */ static std::string toLower(const std::string& s); /** * @brief Tell if a character is a white space or not. * * @param c The character to check. * @return True if c is one of the following: ' ', '\\t', '\\n', '\\r' or '\\f'. */ static bool isWhiteSpaceCharacter(char c); /** * @brief Remove all white spaces characters in a string. * * @param s The string to parse. * @return A copy of 's' without white spaces characters. */ static std::string removeWhiteSpaces (const std::string& s); /** * @brief Remove all white spaces characters at the beginning of a string. * * @param s The string to parse. * @return A copy of 's' beginning with the first non-white character. */ static std::string removeFirstWhiteSpaces (const std::string& s); /** * @brief Remove all white spaces characters at the end of a string. * * @param s The string to parse. * @return A copy of 's' ending with the last non-white character. */ static std::string removeLastWhiteSpaces (const std::string& s); /** * @brief Remove all white spaces characters at the beginning and the end of a string. * * @param s The string to parse. * @return A copy of 's' beginning with the first non-white character * and ending with the last one. */ static std::string removeSurroundingWhiteSpaces(const std::string& s); /** * @brief Tell if a character is a new line character or not. * * @param c The character to check. * @return True if c is one of the following: '\\n' or '\\r'. */ static bool isNewLineCharacter(char c); /** * @brief Remove all new line characters in a string. * * @param s The string to parse. * @return A copy of 's' without new line characters. */ static std::string removeNewLines (const std::string& s); /** * @brief Remove all new line characters at the end of a string. * * @param s The string to parse. * @return A copy of 's' ending with the last non-new line character. */ static std::string removeLastNewLines(const std::string& s); /** * @brief Tell is a given character describes a decimal number. * * @param c The character to check. * @return true if the given character is the reprensentation of a decimal number. */ static bool isDecimalNumber(char c); /** * @brief Tell is a given character string describes a decimal number. * * NB: for now, this parser will not recognize thousands delimiters, and not the scientific notation neither. * @param s The string to parse. * @param dec The decimal separator. * @param scientificNotation character to use for scientific notation (typically 'e' or 'E'). * @return true if the given string is the representation of a decimal number. */ static bool isDecimalNumber(const std::string& s, char dec = '.', char scientificNotation = 'e'); /** * @brief Tell is a given character string describes a decimal integer. * * NB: for now, this parser will not recognize thousands delimiters, and not the scientific notation neither. * @param s The string to parse. * @param scientificNotation character to use for scientific notation (typically 'e' or 'E'). * @return true if the given string is the representation of a decimal integer. */ static bool isDecimalInteger(const std::string& s, char scientificNotation = 'e'); /** * @brief General template method to convert to a string. * * @param t The object to convert. * @return A string equal to t. */ template static std::string toString(T t) { std::ostringstream oss; oss << t; return oss.str(); } /** * @brief Template string conversion. * * @param t The object to convert. * @param precision To use (for numbers). * @return A string equal to t. */ template static std::string toString(T t, int precision) { std::ostringstream oss; oss << std::setprecision(precision) << t; return oss.str(); } /** * @brief General template method to convert from string. * * @param s The string to convert. * @return An object from string t. */ template static T fromString(const std::string& s) { std::istringstream iss(s); T obj; iss >> obj; return obj; } /** * @brief Convert from int to string. * * @param i The integer to convert. * @return A string equal to i. */ static std::string toString(int i); /** * @brief Convert from char to string. * * @param c The character to convert. * @return A string equal to c. */ static std::string toString(char c); /** * @brief Convert from double to string. * * @param d The double to convert. * @param precision To use (for numbers). * @return A string equal to d. */ static std::string toString(double d, int precision = 6); /** * @brief Convert from string to int. * * @param s The string to parse. * @param scientificNotation character to use for scientific notation (typically 'e' or 'E'). * @return The integer corresponding to s. * @throw Exception if the string does not specify a valid number. */ static int toInt(const std::string& s, char scientificNotation = 'e') throw (Exception); /** * @brief Convert from string to double. * * @param s The string to parse. * @param dec The decimal separator. * @param scientificNotation character to use for scientific notation (typically 'e' or 'E'). * @return The double corresponding to s. * @throw Exception if the string does not specify a valid number. */ static double toDouble(const std::string& s, char dec = '.', char scientificNotation = 'e') throw (Exception); /** * @brief Template to string conversion. * * @param s The string to parse. * @return An object of class R corresponding to s. */ template static T to(const std::string& s) { std::istringstream iss(s); T t; iss >> t; return t; } /** * @brief Send a string of size 'newSize', which is a copy of 's' truncated or * filled with character 'fill' at the end. * * @param s The string to parse. * @param newSize The new string size. * @param fill The character to use to fill the string id length < newSize. * @return A string of size newsize which is a copy from the left of s. */ static std::string resizeRight(const std::string& s, size_t newSize, char fill = ' '); /** * @brief Send a string of size 'newSize', which is a copy of 's' truncated or * filled with character 'fill' at the beginning. * * @param s The string to parse. * @param newSize The new string size. * @param fill The character to use to fill the string id length < newSize. * @return A string of size newsize which is a copy from the right of s. */ static std::string resizeLeft(const std::string& s, size_t newSize, char fill = ' '); /** * @brief Split a string into parts of size 'n'. * * The last part may contain < n chars. * * @param s The string to parse. * @param n The number of tokens. * @return A vector of strings with all tokens. */ static std::vector split(const std::string& s, size_t n); /** * @brief Remove substrings from a string. * * All substrings beginning with blockBeginning * and ending with blockEnding will be removed. * Nesting blocks are allowed, the most extern block will be removed. * * @param s The string to parse. * @param blockBeginning The character specifying the beginning of each block. * @param blockEnding The character specifying the end of each block. * @return The string with all blocks removed. * @throw Exception If some blocks are not well formed. */ static std::string removeSubstrings(const std::string& s, char blockBeginning, char blockEnding) throw (Exception); /** * @brief Remove substrings from a string, unless they match some specific substrings. * * All substrings beginning with blockBeginning * and ending with blockEnding will be removed, except if they begin with * a string included in the vector exceptionsBeginning or end with a string * included in the vector exceptionsEnding. * Nesting blocks are allowed, the most extern block will be removed. * * @param s The string to parse. * @param blockBeginning The character specifying the beginning of each block. * @param blockEnding The character specifying the end of each block. * @param exceptionsBeginning A vector containing all strings specifying the beginning of blocks that should not be removed. * @param exceptionsEnding A vector containing all strings specifying the ending of blocks that should not be removed. * @return The string with all blocks removed. * @throw Exception If some blocks are not well formed. */ static std::string removeSubstrings(const std::string& s, char blockBeginning, char blockEnding, std::vector& exceptionsBeginning, std::vector& exceptionsEnding) throw (Exception); /** * @brief Remove all occurences of a character in a string. * * @param s The string to parse. * @param c The character to remove. * @return The string with all specified chars removed. */ static std::string removeChar(const std::string& s, char c); /** * @brief Count the occurences of a given pattern in a string. * * @param s The string to search. * @param pattern The pattern to use (this is a mere string, not a regexp!). * @return The number of occurences of 'pattern' in 's'. */ static unsigned int count(const std::string& s, const std::string& pattern); /** * @brief Tell is a string begins with a certain motif. * * @param s The string to search. * @param pattern The pattern to use (this is a mere string, not a regexp!). * @return true/false */ static bool startsWith(const std::string& s, const std::string& pattern); /** * @brief Tell is a string ends with a certain motif. * * @param s The string to search. * @param pattern The pattern to use (this is a mere string, not a regexp!). * @return true/false */ static bool endsWith(const std::string& s, const std::string& pattern); /** * @brief Tell is a string contains a certain motif. * * @param s The string to search. * @param pattern The pattern to use (this is a mere string, not a regexp!). * @return true/false */ static bool hasSubstring(const std::string& s, const std::string& pattern); /** * @brief Replacement of all non-overlapping occurrences of a certain motif in a string. * * @param target String to be modified * @param query The motif to look for * @param replacement The replacement string */ static void replaceAll(std::string& target, const std::string& query, const std::string& replacement); }; } //end of namespace bpp. #endif //_TEXTTOOLS_H_ bpp-core-2.2.0/src/Bpp/Text/StringTokenizer.cpp000664 001750 001750 00000007453 12370705300 023015 0ustar00jdutheiljdutheil000000 000000 // // File: StringTokenizer.cpp // Author : Julien Dutheil // Sylvain Gaillard // Last modification : Monday September 20 2004 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "StringTokenizer.h" using namespace bpp; using namespace std; StringTokenizer::StringTokenizer(const std::string& s, const std::string& delimiters, bool solid, bool allowEmptyTokens): tokens_(), splits_(), currentPosition_(0) { if (!solid) { string::size_type index = s.find_first_not_of(delimiters, 0); while( index != s.npos) { string::size_type newIndex = s.find_first_of(delimiters, index); if (newIndex != s.npos) { tokens_.push_back(s.substr(index, newIndex - index)); if (!allowEmptyTokens) index = s.find_first_not_of(delimiters, newIndex); else index = newIndex + 1; splits_.push_back(s.substr(newIndex, index - newIndex)); } else { tokens_.push_back(s.substr(index)); index = newIndex; } } } else { string::size_type index = 0; while (index != s.npos) { string::size_type newIndex = s.find(delimiters, index); if (newIndex != s.npos) { tokens_.push_back(s.substr(index, newIndex - index)); if (!allowEmptyTokens) { index = newIndex + delimiters.size(); while (index != string::npos && s.substr(index, delimiters.size()) == delimiters) index += delimiters.size(); } else index = newIndex + delimiters.size(); splits_.push_back(s.substr(newIndex, index - newIndex)); } else { tokens_.push_back(s.substr(index)); index = newIndex; } } } } const std::string& StringTokenizer::nextToken() throw (Exception) { if (!hasMoreToken()) throw Exception("No more token in tokenizer."); return tokens_[currentPosition_++]; } void StringTokenizer::removeEmptyTokens() { for (size_t i = tokens_.size(); i > currentPosition_; i--) { if (tokens_[i - 1] == "") tokens_.erase(tokens_.begin() + static_cast(i - 1)); } } std::string StringTokenizer::unparseRemainingTokens() const { string s; for (size_t i = currentPosition_; i < tokens_.size() - 1; ++i) { s += tokens_[i] + splits_[i]; } if (numberOfRemainingTokens() > 0) s += tokens_.back(); return s; } bpp-core-2.2.0/src/Bpp/Text/TextTools.cpp000664 001750 001750 00000034002 12370705300 021607 0ustar00jdutheiljdutheil000000 000000 // // File: TextTools.cpp // Created by: Julien Dutheil // Created on: Fri Aug 8 12:57:50 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "TextTools.h" using namespace bpp; #include #include #include using namespace std; /******************************************************************************/ bool TextTools::isEmpty(const std::string& s) { for (unsigned int i = 0; i < s.size(); i++) { char c = s[i]; if (c != ' ' && c != '\n' && c != '\t') return false; } return true; } /******************************************************************************/ std::string TextTools::toUpper(const std::string& s) { string result = ""; for (size_t i = 0; i < s.size(); i++) { result += static_cast(toupper(static_cast(s[i]))); } return result; } /******************************************************************************/ std::string TextTools::toLower(const std::string& s) { string result = ""; for (size_t i = 0; i < s.size(); i++) { result += static_cast(tolower(static_cast(s[i]))); } return result; } /******************************************************************************/ bool TextTools::isWhiteSpaceCharacter(char c) { return (c == ' ') || (c == '\t') || (c == '\n') || (c == '\r') || (c == '\f'); } /******************************************************************************/ std::string TextTools::removeWhiteSpaces(const std::string& s) { // Copy sequence string st (s); // For all sequence's characters for (unsigned int i = 0; i < st.size(); i++) { if (isWhiteSpaceCharacter(st[i])) { st.erase(st.begin() + i); // Remove character i--; } } // Send result return st; } /******************************************************************************/ std::string TextTools::removeFirstWhiteSpaces(const std::string& s) { // Copy sequence string st (s); while (st.size() > 0 && isWhiteSpaceCharacter(st[0])) { st.erase(st.begin()); } // Send result return st; } /******************************************************************************/ std::string TextTools::removeLastWhiteSpaces(const std::string& s) { // Copy sequence string st (s); while (st.size() > 0 && isWhiteSpaceCharacter(st[st.size() - 1])) { st.erase(st.end() - 1); } // Send result return st; } /******************************************************************************/ std::string TextTools::removeSurroundingWhiteSpaces(const std::string& s) { return removeFirstWhiteSpaces(removeLastWhiteSpaces(s)); } /******************************************************************************/ bool TextTools::isNewLineCharacter(char c) { return (c == '\n') || (c == '\r'); } /******************************************************************************/ std::string TextTools::removeNewLines(const std::string& s) { // Copy string string st (s); // For all string's characters for (unsigned int i = 0; i < st.size(); i++) { if (isNewLineCharacter(st[i])) { st.erase(st.begin() + i); // Remove character i--; } } // Send result return st; } /******************************************************************************/ std::string TextTools::removeLastNewLines(const std::string& s) { // Copy string string st (s); while (st.size() > 0 && isNewLineCharacter(st[st.size() - 1])) { st.erase(st.end() - 1); } // Send result return st; } /******************************************************************************/ bool TextTools::isDecimalNumber(char c) { if (c == '0' || c == '1' || c == '2' || c == '3' || c == '4' || c == '5' || c == '6' || c == '7' || c == '8' || c == '9') return true; else return false; } /******************************************************************************/ bool TextTools::isDecimalNumber(const std::string& s, char dec, char scientificNotation) { if (isEmpty(s)) return false; size_t sepCount = 0; size_t sciCount = 0; size_t i = 0; if (s[0] == '-') i = 1; for (; i < s.size(); ++i) { char c = s[i]; if (c == dec) sepCount++; else if (c == scientificNotation) { sciCount++; if (i == s.size() - 1) return false; //Must be sthg after scientific notation. c = s[i + 1]; if (c == '-' || c == '+') i++; if (i == s.size() - 1) return false; //Must be sthg after scientific notation. if (sepCount == 0) sepCount = 1; //We do not want any dec in the exponent. } else if (!isDecimalNumber(c)) return false; if (sepCount > 1 || sciCount > 1) return false; } return true; } /******************************************************************************/ bool TextTools::isDecimalInteger(const std::string& s, char scientificNotation) { if (isEmpty(s)) return false; size_t sciCount = 0; size_t i = 0; if (s[0] == '-') i = 1; for (; i < s.size(); ++i) { char c = s[i]; if (c == scientificNotation) { sciCount++; if (i == s.size() - 1) return false; //Must be sthg after scientific notation. c = s[i + 1]; if (c == '-') return false; //Not an integer then! if (c == '+') i++; if (i == s.size() - 1) return false; //Must be sthg after scientific notation. } else if (!isDecimalNumber(c)) return false; if (sciCount > 1) return false; } return true; } /******************************************************************************/ std::string TextTools::toString(int i) { ostringstream oss; oss << i; return oss.str(); } /******************************************************************************/ std::string TextTools::toString(char c) { ostringstream oss; oss << c; return oss.str(); } /******************************************************************************/ std::string TextTools::toString(double d, int precision) { ostringstream oss; oss << setprecision(precision) << d; return oss.str(); } /******************************************************************************/ int TextTools::toInt(const std::string& s, char scientificNotation) throw (Exception) { if (!isDecimalInteger(s, scientificNotation)) throw Exception("TextTools::toInt(). Invalid number specification: " + s); istringstream iss(s); int i; iss >> i; return i; } /******************************************************************************/ double TextTools::toDouble(const std::string& s, char dec, char scientificNotation) throw (Exception) { if (!isDecimalNumber(s, dec, scientificNotation)) throw Exception("TextTools::toDouble(). Invalid number specification: " + s); istringstream iss(s); double d; iss >> d; return d; } /******************************************************************************/ std::string TextTools::resizeRight(const std::string& s, size_t newSize, char fill) { if (s.size() > newSize) return s.substr(0, newSize); else return s + string(newSize - s.size(), fill); } /******************************************************************************/ std::string TextTools::resizeLeft(const std::string& s, size_t newSize, char fill) { if (s.size() > newSize) return s.substr(s.size() - newSize); else return string(newSize - s.size(), fill) + s; } /******************************************************************************/ std::vector TextTools::split(const std::string& s, size_t n) { vector v; string tmp = s; while (tmp.size() > n) { v.push_back(tmp.substr(0, n)); tmp = tmp.substr(n); } v.push_back(tmp); return v; } /******************************************************************************/ std::string TextTools::removeSubstrings(const std::string& s, char blockBeginning, char blockEnding) throw (Exception) { string t = ""; int blockCount = 0; size_t begPos = 0; for (size_t i = 0; i < s.size(); i++) { char current = s[i]; if (current == blockBeginning) { blockCount++; t += s.substr(begPos, i - begPos); } else if (current == blockEnding) { blockCount--; if (blockCount == 0) { begPos = i + 1; } else if (blockCount < 0) throw Exception("TextTools::removeSubstrings(). " + string("Ending block character without corresponding beginning one at position ") + toString((int)i) + "."); } } t += s.substr(begPos); return t; } /******************************************************************************/ std::string TextTools::removeSubstrings(const std::string& s, char blockBeginning, char blockEnding, std::vector& exceptionsBeginning, std::vector& exceptionsEnding) throw (Exception) { string t = ""; int blockCount = 0; size_t begPos = 0; for (size_t i = 0; i < s.size(); i++) { char current = s[i]; if (current == blockBeginning) { bool except = false; for (size_t j = 0; j < exceptionsBeginning.size(); j++) { size_t pos = exceptionsBeginning[j].find(blockBeginning); if (pos != string::npos) { size_t left = i - pos; size_t right = i + exceptionsBeginning[j].length() - pos; if ((right < s.length() - 1) && (hasSubstring (s.substr(left, right), exceptionsBeginning[j]))) { except = true; break; } } } if (!except) { blockCount++; t += s.substr(begPos, i - begPos); } } else if ( (current == blockEnding) && (blockCount > 0) ) { for (size_t j = 0; j < exceptionsEnding.size(); j++) { size_t pos = exceptionsEnding[j].find(blockEnding); if (pos != string::npos) { size_t left = i - pos; size_t right = i + exceptionsEnding[j].length() - pos; if ((right < s.length() - 1 ) && (hasSubstring (s.substr(left, right), exceptionsEnding[j]))) { break; } } } blockCount--; if (blockCount == 0) { begPos = i + 1; } else if (blockCount < 0) throw Exception("TextTools::removeSubstrings(). " + string("Ending block character without corresponding beginning one at position ") + toString((int)i) + "."); } } t += s.substr(begPos); return t; } /******************************************************************************/ std::string TextTools::removeChar(const std::string& s, char c) { // Copy sequence string st(s); // For all sequence's characters for (unsigned int i = 0; i < st.size(); i++) { if (st[i] == c) { st.erase(st.begin() + i); // Remove character i--; } } // Send result return st; } /******************************************************************************/ unsigned int TextTools::count(const std::string& s, const std::string& pattern) { unsigned int count = 0; string::size_type index = s.find(pattern); while (index != string::npos) { count++; index = s.find(pattern, index + 1); } return count; } /******************************************************************************/ bool TextTools::startsWith(const std::string& s, const std::string& pattern) { if (s.size() < pattern.size()) return false; return s.substr(0, pattern.size()) == pattern; } /******************************************************************************/ bool TextTools::endsWith(const std::string& s, const std::string& pattern) { if (s.size() < pattern.size()) return false; return s.substr(s.size() - pattern.size()) == pattern; } /******************************************************************************/ bool TextTools::hasSubstring(const std::string& s, const std::string& pattern) { if (s.size() < pattern.size()) return false; for (size_t i = 0; i < s.size() - pattern.size() + 1; ++i) { if (s.substr(i, pattern.size()) == pattern) return true; } return false; } /******************************************************************************/ void TextTools::replaceAll(std::string& target, const std::string& query, const std::string& replacement) { if (query.empty()) return; size_t pos = target.find(query); while (pos != string::npos) { target.replace(pos, query.length(), replacement); pos += replacement.length(); //We prevent recursivity! pos = target.find(query, pos); } } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Text/StringTokenizer.h000664 001750 001750 00000010502 12370705300 022447 0ustar00jdutheiljdutheil000000 000000 // // File: StringTokenizer.h // Author : Julien Dutheil // Sylvain Gaillard // Last modification : Monday September 20 2004 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _STRINGTOKENIZER_H_ #define _STRINGTOKENIZER_H_ #include #include #include #include "../Exceptions.h" namespace bpp { /** * @brief A tokenizer for strings. * * Splits a string according to a given (set of) delimiter(s). */ class StringTokenizer { protected: /** @brief Where the tokens are stored. */ std::deque tokens_; std::deque splits_; /** @brief the current position in the token list. */ size_t currentPosition_; public: /** * @brief Build a new StringTokenizer from a string. * * @param s The string to parse. * @param delimiters Chars that must be considered as delimiters. * @param solid If true, delimiters is considered as a single bloc delimiter. * @param allowEmptyTokens Tell if empty tokens are allowed or should be ignored. */ StringTokenizer(const std::string& s, const std::string& delimiters = " \t\n\f\r", bool solid = false, bool allowEmptyTokens = false); virtual ~StringTokenizer() {} public: StringTokenizer(): tokens_(), splits_(), currentPosition_(0) {} public: /** * @brief Get the next available token. * If no token is availbale, throw an Exception. * * @return The next token if there is one. */ const std::string& nextToken() throw (Exception); /** * @brief Tell if some tokens are still available. * @return True if some tokens are still available. */ bool hasMoreToken() const { return currentPosition_ < tokens_.size(); } /** * @brief Tell how many tokens are available. * * @return the number of tokens available. */ size_t numberOfRemainingTokens() const { return tokens_.size() - currentPosition_; } /** * @brief Get a particular token. * * Do not move the iterator. * * @param pos The index of the token. * @return the token at position 'pos'. */ const std::string& getToken(size_t pos) const { return tokens_[pos]; } /** * @brief Retrieve all tokens. * * @return A reference toward the vector of tokens. */ const std::deque& getTokens() const { return tokens_; } /** * @brief remove all empty token from the current position. */ void removeEmptyTokens(); /** * @return The remaining tokens as if the original corresponding string was not parsed. */ std::string unparseRemainingTokens() const; }; } //end of namespace bpp. #endif //_STRINGTOKENIZER_H_ bpp-core-2.2.0/src/Bpp/Text/KeyvalTools.cpp000664 001750 001750 00000010603 12370705300 022117 0ustar00jdutheiljdutheil000000 000000 // // File: KeyvalTools.cpp // Created by: Julien Dutheil // Created on: Mon May 13:16 CET 2009 // /* Copyright or © or Copr. Bio++ Development Team, (2009) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "KeyvalTools.h" #include "NestedStringTokenizer.h" //From the STL: #include using namespace bpp; using namespace std; void KeyvalTools::singleKeyval(const std::string& desc, std::string& key, std::string& val, const std::string& split) throw (KeyvalException) { string::size_type i = desc.find(split); if (i == string::npos) throw KeyvalException("Bad syntax! keyval should be of the form 'key" + split + "=value', found '" + desc + "'."); key = desc.substr(0, i); val = desc.substr(i+1); } void KeyvalTools::multipleKeyvals(const std::string& desc, std::map& keyvals, const std::string& split, bool nested) throw (KeyvalException) { auto_ptr st; if (nested) st.reset(new NestedStringTokenizer(desc, "(", ")", split)); else st.reset(new StringTokenizer(desc, split)); string key, val; vector tokens; //Check tokens: string token; while (st->hasMoreToken()) { token = st->nextToken(); if (token == "=") { //We need to merge the next token with the last one: if (tokens.size() == 0) throw KeyvalException("Invalid syntax, found '=' without argument name."); if (!st->hasMoreToken()) throw KeyvalException("Invalid syntax, found '=' without argument value."); string nextToken = st->nextToken(); if (nextToken == "=") throw KeyvalException("Invalid syntax, found a double '='."); tokens[tokens.size() - 1] += "=" + nextToken; } else { tokens.push_back(token); } } for (vector::iterator it = tokens.begin(); it != tokens.end(); it++) { singleKeyval(*it, key, val); key=TextTools::removeSurroundingWhiteSpaces(key); val=TextTools::removeSurroundingWhiteSpaces(val); keyvals[key] = val; } } void KeyvalTools::parseProcedure(const std::string& desc, std::string& name, std::map& args) throw (KeyvalException) { string::size_type begin = desc.find_first_of("("); string::size_type end = desc.find_last_of(")"); if (begin == string::npos && end == string::npos) { //Empty procedure: name = desc; return; } if (begin == string::npos && end != string::npos) throw KeyvalException("Bad keyval procedure, missing opening parenthesis."); if (begin == string::npos && end != string::npos) throw KeyvalException("Bad keyval procedure, missing closing parenthesis."); if (!TextTools::isEmpty(desc.substr(end + 1))) throw KeyvalException("Bad keyval procedure, extra characters after closing parenthesis: " + desc.substr(end + 1)); //Get the procedure name (without leading spaces): name = TextTools::removeFirstWhiteSpaces(desc.substr(0, begin)); multipleKeyvals(desc.substr(begin + 1, end - begin - 1), args); } bpp-core-2.2.0/src/Bpp/Text/NestedStringTokenizer.h000664 001750 001750 00000006341 12370705300 023620 0ustar00jdutheiljdutheil000000 000000 // // File: NestedStringTokenizer.h // Author : Julien Dutheil // Last modification : Monday May 22 10:57 2006 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to map data onto a sequence or a phylogenetic tree. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _NESTEDSTRINGTOKENIZER_H_ #define _NESTEDSTRINGTOKENIZER_H_ //From the STL: #include #include #include "StringTokenizer.h" #include "../Exceptions.h" namespace bpp { /** * @brief An improved tokenizer for strings. * * Splits a string according to a given (set of) delimiter(s). * Delimiters in certains blocks ({}, [], etc) are ignored. */ class NestedStringTokenizer: public StringTokenizer { public: /** * @brief Build a new StringTokenizer from a string. * * @param s The string to parse. * @param open Opening block. * @param end Ending block. * @param delimiters Chars that must be considered as delimiters. * @param solid If true, delimiters is considered as a single bloc delimiter. */ NestedStringTokenizer(const std::string& s, const std::string& open, const std::string& end, const std::string& delimiters = " \t\n\f\r", bool solid = false) throw (Exception); virtual ~NestedStringTokenizer() {} public: /** * @brief Get the next available token. * If no token is availbale, throw an Exception. * * @return The next token if there is one. */ const std::string& nextToken() throw (Exception); /** * @brief This function is not supported for nested tokenizers. * * @return An empty string. */ std::string unparseRemainingTokens() const { return ""; } }; } //end of namespace bpp; #endif //_NESTEDSTRINGTOKENIZER_H_ bpp-core-2.2.0/src/Bpp/BppString.h000664 001750 001750 00000005307 12370705300 020301 0ustar00jdutheiljdutheil000000 000000 // // File: BppString.h // Created by: Julien Dutheil // Created on: Thu May 04 10:21 2006 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BPP_STRING_H_ #define _BPP_STRING_H_ #include "Clonable.h" // From the STL: #include #include namespace bpp { /** * @brief The BppString object class. * * This class extends the stl::string class to support the Clonable interface. */ class BppString: public virtual Clonable { private: std::string text_; public: BppString(): text_() {} BppString(const char* value): text_(value) {} BppString(const std::string& value): text_(value) {} BppString& operator=(const char* value) { text_ = value; return *this; } BppString& operator=(const std::string& value) { text_ = value; return *this; } virtual ~BppString() {} public: /** * @name The Clonable interface. * * @{ */ #ifdef NO_VIRTUAL_COV Clonable* #else BppString* #endif clone() const { return new BppString(*this); } /** @} */ const std::string& toSTL() const { return text_; } }; std::ostream& operator<<(std::ostream& out, const BppString& s); } //end of namespace bpp. #endif //_BPP_STRING_H_ bpp-core-2.2.0/src/Bpp/BppVector.h000664 001750 001750 00000005624 12370705300 020277 0ustar00jdutheiljdutheil000000 000000 // // File: BppVector.h // Created by: Julien Dutheil // Created on: Mon Apr 07 15:14 2008 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BPPVECTOR_H_ #define _BPPVECTOR_H_ #include "Clonable.h" // From the STL: #include namespace bpp { /** * @brief The BppVector object class. * * This class extends the std::vector class to support the Clonable interface. */ template class BppVector: public Clonable { private: std::vector vector_; public: BppVector(): vector_() {} BppVector(typename std::vector::size_type num, const TYPE& val = TYPE() ): vector_(num, val) {} BppVector(typename std::vector::iterator start, typename std::vector::iterator end): vector_(start, end) {} virtual ~BppVector() {} public: /** * @name The Clonable interface. * * @{ */ #ifdef NO_VIRTUAL_COV Clonable* #else BppVector* #endif clone() const { return new BppVector(*this); } /** @} */ const std::vector& toSTL() const { return vector_; } std::vector& toSTL() { return vector_; } unsigned int size() const { return vector_.size(); } TYPE& operator[] (unsigned int i) { return vector_[i]; } const TYPE& operator[] (unsigned int i) const { return vector_[i]; } }; } //end of namespace bpp. #endif //_BPPVECTOR_H_ bpp-core-2.2.0/src/Bpp/Exceptions.h000664 001750 001750 00000023543 12370705300 020514 0ustar00jdutheiljdutheil000000 000000 // // File Exceptions.h // Created by: Guillaume Deuchst // Julien Dutheil // Sylvain Gaillard // Last modification : Thu Jul 22 2004 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _EXCEPTIONS_H_ #define _EXCEPTIONS_H_ #include #include #include namespace bpp { /** * @brief Exception base class. * * Overload exception constructor (to control the exceptions mechanism).

*/ class Exception: public std::exception { protected: std::string message_; public: /** * @brief Build a new Exception. * * @param text A message to be passed to the exception hierarchy. */ Exception(const char* text): message_(std::string(text)) {} /** * @brief Build a new Exception. * * @param text A message to be passed to the exception hierarchy. */ Exception(const std::string& text): message_(text) {} virtual ~Exception() throw() {} public: /** * @brief Method to get the message of the exception (STL method redefinition). * * @return The message passed to the exception hierarchy. */ const char* what() const throw() { return message_.c_str(); } }; /** * @brief The base class exception for IO error. */ class IOException: public Exception { public: // Class constructors and destructor: /** * @brief Build a new IOException. * * @param text A message to be passed to the exception hierarchy. */ IOException(const char* text): Exception(text) {} /** * @brief Build a new IOException. * * @param text A message to be passed to the exception hierarchy. */ IOException(const std::string& text): Exception(text) {} virtual ~IOException() throw() {} }; /** * @brief The base class exception for NULL pointer error. * * This exception may be thrown when an unexpected NULL pointer is found. */ class NullPointerException: public Exception { public: /** * @brief Build a new NullPointerException. * * @param text A message to be passed to the exception hierarchy. */ NullPointerException(const char* text): Exception(text) {} /** * @brief Build a new NullPointerException. * * @param text A message to be passed to the exception hierarchy. */ NullPointerException(const std::string& text): Exception(text) {} virtual ~NullPointerException() throw() {} }; /** * @brief The base class exception for zero division error. */ class ZeroDivisionException: public Exception { public: /** * @brief Build a new ZeroDivisionException. * * @param text A message to be passed to the exception hierarchy. */ ZeroDivisionException(const char* text): Exception(text) {} /** * @brief Build a new ZeroDivisionException. * * @param text A message to be passed to the exception hierarchy. */ ZeroDivisionException(const std::string& text): Exception(text) {} virtual ~ZeroDivisionException() throw() {} }; /** * @brief Number exception: integers. */ class BadIntegerException: public Exception { protected: int badInt_; public: /** * @brief Build a new BadIntegerException. * * @param text A message to be passed to the exception hierarchy. * @param badInt The faulty integer. */ BadIntegerException(const char* text, int badInt); /** * @brief Build a new BadIntegerException. * * @param text A message to be passed to the exception hierarchy. * @param badInt The faulty integer. */ BadIntegerException(const std::string& text, int badInt); virtual ~BadIntegerException() throw() {} public: /** * @brief Get the integer that threw this exception. * * @return The faulty integer. */ int getBadInteger() const { return badInt_; } }; /** * @brief Number exception: doubles. */ class BadNumberException: public Exception { protected: double badNumber_; public: /** * @brief Build a new BadNumberException. * * @param text A message to be passed to the exception hierarchy. * @param badNumber The faulty number. */ BadNumberException(const char* text, double badNumber); /** * @brief Build a new BadNumberException. * * @param text A message to be passed to the exception hierarchy. * @param badNumber The faulty number. */ BadNumberException(const std::string& text, double badNumber); virtual ~BadNumberException() throw() {} public: /** * @brief Get the number that threw this exception. * * @return The faulty number. */ double getBadNumber() const { return badNumber_; } }; /** * @brief Number format exception. */ class NumberFormatException: public Exception { protected: std::string badNumber_; public: /** * @brief Build a new NumberFormatException. * * @param text A message to be passed to the exception hierarchy. * @param badNumber The faulty number. */ NumberFormatException(const char* text, const std::string& badNumber); /** * @brief Build a new NumberFormatException. * * @param text A message to be passed to the exception hierarchy. * @param badNumber The faulty number. */ NumberFormatException(const std::string& text, const std::string& badNumber); virtual ~NumberFormatException() throw() {} public: /** * @brief Get the number that threw this exception. * * @return The faulty number. */ std::string getBadNumber() const { return badNumber_; } }; /** * @brief Index out of bounds exception class. */ class IndexOutOfBoundsException: public virtual Exception { protected: size_t badIndex_, lowerBound_, upperBound_; public: /** * @brief Build a new IndexOutOfBoundsException. * * @param text A message to be passed to the exception hierarchy. * @param badInt The faulty integer. * @param lowerBound Lower limit. * @param upperBound Upper limit. */ IndexOutOfBoundsException(const std::string& text, size_t badInt, size_t lowerBound, size_t upperBound); virtual ~IndexOutOfBoundsException() throw() {} public: /** * @brief Get the bounds. * * @return The bounds. */ std::vector getBounds() const; size_t getBadIndex() const { return badIndex_; } }; /** * @brief Wrong size exception class. */ class BadSizeException: public virtual Exception { protected: size_t badSize_, correctSize_; public: /** * @brief Build a new BadSizeException. * * @param text A message to be passed to the exception hierarchy. * @param badSize The faulty size. * @param correctSize The expected size. */ BadSizeException(const std::string& text, size_t badSize, size_t correctSize); virtual ~BadSizeException() throw() {} public: size_t getBadSize() const { return badSize_; } size_t getCorrectSize() const { return correctSize_; } }; /** * @brief Out of range exception class. */ class OutOfRangeException: public Exception { protected: double lowerBound_, upperBound_; public: /** * @brief Build a new OutOfRangeException. * * @param text A message to be passed to the exception hierarchy. * @param badValue The faulty value. * @param lowerBound Lower limit. * @param upperBound Upper limit. */ OutOfRangeException(const std::string& text, double badValue, double lowerBound, double upperBound); virtual ~OutOfRangeException() throw() {} public: /** * @return The lower bound. */ double getLowerBound() const { return lowerBound_; } /** * @return The upper bound. */ double getUpperBound() const { return upperBound_; } }; /** * @brief This expeption is sent when a given method is not implemented. */ class NotImplementedException: public Exception { public: /** * @brief Build a new NotImplementedException. * * @param text A message to be passed to the exception hierarchy. */ NotImplementedException(const std::string& text): Exception(text) {} virtual ~NotImplementedException() throw() {} }; } //end of namespace bpp. #endif // _EXCEPTIONS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Number.h000664 001750 001750 00000011562 12370705300 021223 0ustar00jdutheiljdutheil000000 000000 // // File: Number.h // Created by: Julien Dutheil // Created on: Thu Nov 13 16:29:03 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _NUMBER_H_ #define _NUMBER_H_ #include "../Clonable.h" #include namespace bpp { /** * @brief The Number interface. * * This template class may be used to deal with number in an object way. */ class BppNumberI: public Clonable { public: BppNumberI() {} virtual ~BppNumberI() {} public: virtual BppNumberI* clone() const = 0; public: virtual std::string toString() const = 0; }; class BppNotANumber: public virtual BppNumberI { public: BppNotANumber() {} virtual ~BppNotANumber() {} public: virtual BppNotANumber* clone() const { return new BppNotANumber(); } public: virtual std::string toString() const { return "NaN"; } }; /** * @brief The Number object template class. * * This template class may be used to deal with number in an object way. */ template class Number: public virtual BppNumberI { protected: /** @brief The value of this parameter. */ T value_; public: /** * @brief Build a new Number object with a specific value. * * @param value The value that the Number must have. */ Number(const T& value = 0): value_(value) {} virtual ~Number() {} Number & operator=(const T & t) { value_ = t; return *this; } public: /** * @name The Clonable interface. * * @{ */ Number* clone() const { return new Number(value_); } /** @} */ public: /** * @brief Get the value of this number. * * @return The value of this number. */ T getValue() const { return value_; } std::string toString() const { return TextTools::toString(value_); } }; /** * @brief An object wrapper for double values. */ class BppDouble: public virtual Number { public: /** * @brief Build a new BppDouble number object with a specific value. * * @param value The value that the Number must have. */ BppDouble(double value = 0): Number(value) {} virtual ~BppDouble() {} public: /** * @name The Clonable interface. * * @{ */ BppDouble* clone() const { return new BppDouble(*this); } /** @} */ }; /** * @brief An object wrapper for integer values. */ class BppInteger: public virtual Number { public: /** * @brief Build a new BppInteger number object with a specific value. * * @param value The value that the Number must have. */ BppInteger(int value = 0): Number(value) {} virtual ~BppInteger() {} public: /** * @name The Clonable interface. * * @{ */ BppInteger* clone() const { return new BppInteger(*this); } /** @} */ }; /** * @brief An object wrapper for unsigned integer values. */ class BppUnsignedInteger: public virtual Number { public: /** * @brief Build a new BppUnsignedInteger number object with a specific value. * * @param value The value that the Number must have. */ BppUnsignedInteger(unsigned int value = 0): Number(value) {} virtual ~BppUnsignedInteger() {} public: /** * @name The Clonable interface. * * @{ */ BppUnsignedInteger* clone() const { return new BppUnsignedInteger(*this); } /** @} */ }; } //end of namespace bpp. #endif //_NUMBER_H_ bpp-core-2.2.0/src/Bpp/Numeric/Stat/Mva/CorrespondenceAnalysis.cpp000664 001750 001750 00000007267 12370705300 026450 0ustar00jdutheiljdutheil000000 000000 // // File: CorrespondenceAnalysis.cpp // Created by: Mathieu Groussin // Created on: Sun Mar 06 10:03 2011 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "CorrespondenceAnalysis.h" #include "../../Matrix/Matrix.h" #include "../../Matrix/MatrixTools.h" #include "DualityDiagram.h" using namespace bpp; using namespace std; CorrespondenceAnalysis::CorrespondenceAnalysis( const Matrix& data, unsigned int nbAxes, double tol, bool verbose) throw (Exception) : DualityDiagram(), n_() { size_t nRow = data.getNumberOfRows(); size_t nCol = data.getNumberOfColumns(); double tmp = 0.; for (size_t i = 0; i < nRow; i++) { for (unsigned int j = 0; j < nCol; j++) { if (data(i, j) < 0.) throw Exception("CorrespondenceAnalysis (constructor). Negative value(s) in the input data. This is not allowed !"); tmp += data(i, j); } } n_ = tmp; if (n_ == 0) throw Exception("CorrespondenceAnalysis (constructor). All frequencies in the input data are zero..."); RowMatrix dataTmp(data); MatrixTools::scale(dataTmp, (1. / n_), 0.); vector rowWeights(nRow); vector colWeights(nCol); for (size_t i = 0; i < nRow; i++) { for (unsigned int j = 0; j < nCol; j++) { rowWeights[i] += dataTmp(i, j); colWeights[j] += dataTmp(i, j); } } vector tmpRowWeigths(nRow); vector tmpColWeigths(nCol); for (size_t i = 0; i < rowWeights.size(); i++) { if (rowWeights[i] == 0.) tmpRowWeigths[i] = 0.; else tmpRowWeigths[i] = 1. / rowWeights[i]; } for (size_t j = 0; j < colWeights.size(); j++) { if (colWeights[j] == 0.) tmpColWeigths[j] = 0.; else tmpColWeigths[j] = 1. / colWeights[j]; } RowMatrix tmpWeightedData(nRow, nCol); RowMatrix weightedData(nRow, nCol); MatrixTools::hadamardMult(dataTmp, tmpRowWeigths, tmpWeightedData, true); MatrixTools::hadamardMult(tmpWeightedData, tmpColWeigths, weightedData, false); MatrixTools::scale(weightedData, 1., -1.); setData(weightedData, rowWeights, colWeights, nbAxes, tol, verbose); } bpp-core-2.2.0/src/Bpp/Numeric/Stat/Mva/PrincipalComponentAnalysis.cpp000664 001750 001750 00000012020 12370705300 027262 0ustar00jdutheiljdutheil000000 000000 // // File: PrincipalComponentAnalysis.cpp // Created by: Mathieu Groussin // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "PrincipalComponentAnalysis.h" #include "../../Matrix/Matrix.h" #include "../../Matrix/MatrixTools.h" #include "../../VectorTools.h" #include "DualityDiagram.h" #include using namespace bpp; using namespace std; PrincipalComponentAnalysis::PrincipalComponentAnalysis( const Matrix& data, unsigned int nbAxes, const vector& rowW, const vector& colW, bool centered, bool scaled, double tol, bool verbose) throw (Exception) : DualityDiagram(), columnMeans_(), columnSd_() { RowMatrix tmpData = data; // Centering of data? if (centered) { center(tmpData, rowW); } // Scaling of data? if (scaled) { scale(tmpData, rowW); } setData(tmpData, rowW, colW, nbAxes, tol, verbose); } /******************************************************************************/ PrincipalComponentAnalysis::PrincipalComponentAnalysis( const Matrix& data, unsigned int nbAxes, bool centered, bool scaled, double tol, bool verbose) throw (Exception) : DualityDiagram(), columnMeans_(), columnSd_() { size_t nRow = data.getNumberOfRows(); size_t nCol = data.getNumberOfColumns(); vector rowW(nRow); vector colW(nCol); VectorTools::fill(rowW, 1. / static_cast(nRow)); VectorTools::fill(colW, 1.); RowMatrix tmpData = data; // Centering of data? if (centered) { center(tmpData, rowW); } // Scaling of data? if (scaled) { scale(tmpData, rowW); } setData(tmpData, rowW, colW, nbAxes, tol, verbose); } /******************************************************************************/ void PrincipalComponentAnalysis::center(Matrix& matrix, const vector& rowW) throw (Exception) { size_t nRow = matrix.getNumberOfRows(); size_t nCol = matrix.getNumberOfColumns(); if (nRow != rowW.size()) throw Exception("PrincipalComponentAnalysis::center. The number of row weigths have to be equal to the number of rows!"); double sumRowWeights = VectorTools::sum(rowW); vector columnMeans(nCol); for (unsigned int i = 0; i < nCol; i++) { double tmp = 0.; for (unsigned int j = 0; j < nRow; j++) { tmp += matrix(j, i) * rowW[j]; } columnMeans[i] = tmp / sumRowWeights; } for (unsigned int i = 0; i < nCol; i++) { for (unsigned int j = 0; j < nRow; j++) { matrix(j, i) -= columnMeans[i]; } } } /******************************************************************************/ void PrincipalComponentAnalysis::scale(Matrix& matrix, const vector& rowW) throw (Exception) { size_t nRow = matrix.getNumberOfRows(); size_t nCol = matrix.getNumberOfColumns(); if (nRow != rowW.size()) throw Exception("PrincipalComponentAnalysis::scale. The number of row weigths have to be equal to the number of rows!"); double sumRowWeights = VectorTools::sum(rowW); vector columnSd(nCol); for (size_t i = 0; i < nCol; i++) { double tmp = 0.; for (unsigned int j = 0; j < nRow; j++) { tmp += pow(matrix(j, i), 2) * rowW[j]; } columnSd[i] = sqrt(tmp / sumRowWeights); } for (size_t i = 0; i < nCol; i++) { for (unsigned int j = 0; j < nRow; j++) { if (columnSd[i] == 0.) matrix(j, i) = 0.; else matrix(j, i) /= columnSd[i]; } } } bpp-core-2.2.0/src/Bpp/Numeric/Stat/Mva/PrincipalComponentAnalysis.h000664 001750 001750 00000012500 12370705300 026732 0ustar00jdutheiljdutheil000000 000000 // // File: PrincipalComponentAnalysis.h // Created by: Mathieu Groussin // Created on: Thu Mar 03 10:13 2011 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide basal and utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _PRINCIPALCOMPONENTANALYSIS_H_ #define _PRINCIPALCOMPONENTANALYSIS_H_ #include "../../Matrix/Matrix.h" #include "DualityDiagram.h" namespace bpp { /** * @brief This class allows to perform a principal component analysis. * * Two constructors are available. The first one allows the user to specify the row and column weights. The second one specify default weights: * uniform weights unit weights are created for rows and columns respectively. * * The code of this class is deeply inspired from the R code of the dudi.pca function available in the ade4 package. */ class PrincipalComponentAnalysis: public DualityDiagram { private: std::vector columnMeans_; std::vector columnSd_; public: /** * @brief Build a new PrincipalComponentAnalysis object. * * @param data The input data (a RowMatrix) to analyse. * @param nbAxes The number of kept axes during the analysis. * @param rowW A vector of values specifying the weights of rows. * @param colW A vector of values specifying the weights of columns. * @param centered If true the input matrix is centered according to the column means. * @param scaled If true the input matrix is normalized according to the standard deviations of columns. * @param tol Tolerance threshold for null eigenvalues (a value less than tol times the first one is considered as null) * @param verbose Should warnings be dispayed. * @throw Exception if an error occured. */ PrincipalComponentAnalysis( const Matrix& data, unsigned int nbAxes, const std::vector& rowW, const std::vector& colW, bool centered = true, bool scaled = true, double tol = 0.0000001, bool verbose = true) throw (Exception); /** * @brief Build a new PrincipalComponentAnalysis object and specify default row and column weights. * * @param data The input data (a RowMatrix) to analyse. * @param nbAxes The number of kept axes during the analysis. * @param centered If true the input matrix is centered according to the column means. * @param scaled If true the input matrix is normalized according to the standard deviations of columns. * @param tol Tolerance threshold for null eigenvalues (a value less than tol times the first one is considered as null) * @param verbose Should warnings be dispayed. * @throw Exception if an error occured. */ PrincipalComponentAnalysis( const Matrix& data, unsigned int nbAxes, bool centered = true, bool scaled = true, double tol = 0.0000001, bool verbose = true) throw (Exception); virtual ~PrincipalComponentAnalysis() {} PrincipalComponentAnalysis* clone() const { return new PrincipalComponentAnalysis(*this); } public: /** * @brief This function allows to center an input matrix from its column means. * * @param matrix The input data (a Matrix) to center. * @param rowW A vector with row weights. */ static void center(Matrix& matrix, const std::vector& rowW) throw (Exception); /** * @brief This function allows to center an input matrix from its column means. * * @param matrix The input data (a Matrix) to center. * @param rowW A vector with row weights. */ static void scale(Matrix& matrix, const std::vector& rowW) throw (Exception); public: const std::vector& getColumnMeans() const throw (Exception) { return columnMeans_; } const std::vector& getColumnSd() const throw (Exception) { return columnSd_; } }; } // end of namespace bpp. #endif // _PRINCIPALCOMPONENTANALYSIS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Stat/Mva/CorrespondenceAnalysis.h000664 001750 001750 00000006267 12370705300 026114 0ustar00jdutheiljdutheil000000 000000 // // File: CorrespondenceAnalysis.h // Created by: Mathieu Groussin // Created on: Sun Mar 06 10:03 2011 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide basal and utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _CORRESPONDENCEANALYSIS_H_ #define _CORRESPONDENCEANALYSIS_H_ #include "../../Matrix/Matrix.h" #include "DualityDiagram.h" namespace bpp /** * @brief This class allows to perform a correspondence analysis. * * All values in the input table have to be non-negative. * The DualityDiagram class, core class of a multivariate analysis, is called internally. * * The code of this class is deeply inspired from the R code of the dudi.coa function available in the ade4 package. */ { class CorrespondenceAnalysis: public DualityDiagram { private: double n_; public: /** * @brief Build a new CorrespondenceAnalysis object. * * @param data The input data (a RowMatrix) to analyse. * @param nbAxes The number of kept axes during the analysis. * @param tol Tolerance threshold for null eigenvalues (a value less than tol times the first one is considered as null) * @param verbose Should warnings be dispayed. * @throw Exception if an error occured. */ CorrespondenceAnalysis( const Matrix& data, unsigned int nbAxes, double tol = 0.0000001, bool verbose = true) throw (Exception); virtual ~CorrespondenceAnalysis() {} #ifndef NO_VIRTUAL_COV CorrespondenceAnalysis* #else Clonable* #endif clone() const { return new CorrespondenceAnalysis(*this); } public: double getSumOfAllValues() const throw (Exception) { return n_; } }; } // end of namespace bpp. #endif // _CORRESPONDENCEANALYSIS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Stat/Mva/DualityDiagram.h000664 001750 001750 00000013663 12370705300 024335 0ustar00jdutheiljdutheil000000 000000 // // File: DualityDiagram.h // Created by: Mathieu Groussin // Created on: Sun Feb 27 22:03 2011 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide basal and utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _DUALITYDIAGRAM_H_ #define _DUALITYDIAGRAM_H_ #include "../../Matrix/Matrix.h" namespace bpp { /** * @brief The core class of a multivariate analysis. * * In the constructor, the eigen values and vectors of the variance-covariance or correlation matrix are calculated. * Eigen values and vectors are stored in the eigenValues_ and eigenVectors_ respectively. * Furthermore, four matrices are calculated: the row and column coordinates as well as the principal axes and components. * * The code of this class is deeply inspired from the R code of the as.dudi function available in the ade4 package. */ class DualityDiagram: public virtual Clonable { private: std::vector rowWeights_; std::vector colWeights_; size_t nbAxes_; std::vector eigenValues_; RowMatrix eigenVectors_; RowMatrix rowCoord_; RowMatrix colCoord_; RowMatrix ppalAxes_; RowMatrix ppalComponents_; public: /** * @brief Build an empty DualityDiagram object. * */ DualityDiagram() : rowWeights_(), colWeights_(), nbAxes_(), eigenValues_(), eigenVectors_(), rowCoord_(), colCoord_(), ppalAxes_(), ppalComponents_() {} /** * @brief Build a new DualityDiagram object. * * @param matrix The input data to analyse. * @param rowWeights A vector of values specifying the weights of rows. * @param colWeights A vector of values specifying the weights of columns. * @param nbAxes The number of kept axes during the analysis. * @param tol Tolerance threshold for null eigenvalues (a value less than tol times the first one is considered as null) * @param verbose Should warnings be dispayed. * @throw Exception if an error occured. */ DualityDiagram( const Matrix& matrix, const std::vector& rowWeights, const std::vector& colWeights, unsigned int nbAxes, double tol = 0.0000001, bool verbose = true) throw (Exception); virtual ~DualityDiagram(); #ifndef NO_VIRTUAL_COV DualityDiagram* #else Clonable* #endif clone() const { return new DualityDiagram(*this); } private: void check_( const Matrix& matrix, const std::vector& rowWeights, const std::vector& colWeights, unsigned int nbAxes) throw (Exception); void compute_(const Matrix& matrix, double tol, bool verbose); public: /** * @brief Set the data and perform computations. * * @param matrix The input data to analyse. * @param rowWeights A vector of values specifying the weights of rows. * @param colWeights A vector of values specifying the weights of columns. * @param nbAxes The number of kept axes during the analysis. * @param tol Tolerance threshold for null eigenvalues (a value less than tol times the first one is considered as null) * @param verbose Should warnings be dispayed. * @throw Exception if an error occured. */ void setData( const Matrix& matrix, const std::vector& rowWeights, const std::vector& colWeights, unsigned int nbAxes, double tol = 0.0000001, bool verbose = true) throw (Exception); std::vector computeVariancePercentagePerAxis() throw (Exception); size_t getNbOfKeptAxes() const throw (Exception) { return nbAxes_; } const std::vector getRowWeights() const throw (Exception) { return rowWeights_; } const std::vector getColumnWeights() const throw (Exception) { return colWeights_; } const std::vector& getEigenValues() const throw (Exception) { return eigenValues_; } const RowMatrix& getRowCoordinates() const throw (Exception) { return rowCoord_; } const RowMatrix& getColCoordinates() const throw (Exception) { return colCoord_; } const RowMatrix& getPrincipalAxes() const throw (Exception) { return ppalAxes_; } const RowMatrix& getPrincipalComponents() const throw (Exception) { return ppalComponents_; } }; } // end of namespace bpp. #endif // _DUALITYDIAGRAM_H_ bpp-core-2.2.0/src/Bpp/Numeric/Stat/Mva/DualityDiagram.cpp000664 001750 001750 00000023135 12370705300 024663 0ustar00jdutheiljdutheil000000 000000 // // File: DualityDiagram.cpp // Created by: Mathieu Groussin // /* Copyright or © or Copr. Bio++ Development Tools, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "DualityDiagram.h" #include "../../Matrix/Matrix.h" #include "../../Matrix/MatrixTools.h" #include "../../Matrix/EigenValue.h" #include "../../../App/ApplicationTools.h" #include using namespace bpp; using namespace std; DualityDiagram::DualityDiagram( const Matrix& matrix, const vector& rowWeights, const vector& colWeights, unsigned int nbAxes, double tol, bool verbose) throw (Exception) : rowWeights_(rowWeights), colWeights_(colWeights), nbAxes_(nbAxes), eigenValues_(), eigenVectors_(), rowCoord_(), colCoord_(), ppalAxes_(), ppalComponents_() { check_(matrix, rowWeights, colWeights, verbose); compute_(matrix, tol, verbose); } void DualityDiagram::check_( const Matrix& matrix, const vector& rowWeights, const vector& colWeights, unsigned int nbAxes) throw (Exception) { size_t rowNb = matrix.getNumberOfRows(); size_t colNb = matrix.getNumberOfColumns(); if (rowWeights.size() != rowNb) throw Exception("DualityDiagram::check_. The number of row weigths has to be equal to the number of rows!"); if (colWeights.size() != colNb) throw Exception("DualityDiagram::check_. The number of column weigths has to be equal to the number of columns!"); // All row weigths have to be positive for (vector::const_iterator it = rowWeights.begin(); it != rowWeights.end(); it++) { if (*it < 0.) throw Exception("DualityDiagram::check_. All row weights have to be positive"); } // All column weigths have to be positive for (vector::const_iterator it = colWeights.begin(); it != colWeights.end(); it++) { if (*it < 0.) throw Exception("DualityDiagram::check_. All column weights have to be positive"); } } void DualityDiagram::setData( const Matrix& matrix, const vector& rowWeights, const vector& colWeights, unsigned int nbAxes, double tol, bool verbose) throw (Exception) { check_(matrix, rowWeights, colWeights, verbose); rowWeights_ = rowWeights; colWeights_ = colWeights; nbAxes_ = nbAxes; compute_(matrix, tol, verbose); } void DualityDiagram::compute_(const Matrix& matrix, double tol, bool verbose) { size_t rowNb = matrix.getNumberOfRows(); size_t colNb = matrix.getNumberOfColumns(); // If there are less rows than columns, the variance-covariance or correlation matrix is obtain differently (see below) bool transpose = (rowNb < colNb); // The initial matrix is multiplied by the square root of the row weigths. vector rW(rowWeights_); for (unsigned int i = 0; i < rowWeights_.size(); i++) { rW[i] = sqrt(rowWeights_[i]); } RowMatrix M1(rowNb, colNb); MatrixTools::hadamardMult(matrix, rW, M1, true); // The resulting matrix is then multiplied by the square root of the column weigths. vector cW(colWeights_); for (unsigned int i = 0; i < colWeights_.size(); i++) { cW[i] = sqrt(colWeights_[i]); } RowMatrix M2; MatrixTools::hadamardMult(M1, cW, M2, false); // The variance-covariance (if the data is centered) or the correlation (if the data is centered and normalized) matrix is calculated RowMatrix tM2; MatrixTools::transpose(M2, tM2); RowMatrix M3; if (!transpose) MatrixTools::mult(tM2, M2, M3); else MatrixTools::mult(M2, tM2, M3); EigenValue eigen(M3); if (!eigen.isSymmetric()) throw Exception("DualityDiagram (constructor). The variance-covariance or correlation matrix should be symmetric..."); eigenValues_ = eigen.getRealEigenValues(); eigenVectors_ = eigen.getV(); // How many significant axes have to be conserved? size_t rank = 0; for (size_t i = eigenValues_.size(); i > 0; i--) { if ((eigenValues_[i - 1] / eigenValues_[eigenValues_.size() - 1]) > tol) rank++; } if (nbAxes_ <=0) { throw Exception("DualityDiagram (constructor). The number of axes to keep must be positive."); } if (nbAxes_ > rank) { if (verbose) ApplicationTools::displayWarning("The number of axes to kept has been reduced to conserve only significant axes"); nbAxes_ = rank; } /*The eigen values are initially sorted into ascending order by the 'eigen' function. Here the significant values are sorted in the other way around.*/ vector tmpEigenValues(nbAxes_); size_t cpt = 0; for (size_t i = eigenValues_.size(); i > (eigenValues_.size() - nbAxes_); i--) { tmpEigenValues[cpt] = eigenValues_[i-1]; cpt++; } eigenValues_ = tmpEigenValues; for (vector::iterator it = rowWeights_.begin(); it != rowWeights_.end(); it++) { if (*it == 0.) *it = 1.; } for (vector::iterator it = colWeights_.begin(); it != colWeights_.end(); it++) { if (*it == 0.) *it = 1.; } vector dval(nbAxes_); for (size_t i = 0; i < dval.size(); i++) { dval[i] = sqrt(eigenValues_[i]); } vector invDval(nbAxes_); for (size_t i = 0; i < invDval.size(); i++) { invDval[i] = 1. / sqrt(eigenValues_[i]); } // Calculation of the row and column coordinates as well as the principal axes and components: if (!transpose) { vector tmpColWeights(colNb); for (unsigned int i = 0; i < colWeights_.size(); i++) { tmpColWeights[i] = 1. / sqrt(colWeights_[i]); } // The eigen vectors are placed in the same order as their corresponding eigen value in eigenValues_. RowMatrix tmpEigenVectors; tmpEigenVectors.resize(eigenVectors_.getNumberOfRows(), nbAxes_); size_t cpt2 = 0; for (size_t i = eigenVectors_.getNumberOfColumns(); i > (eigenVectors_.getNumberOfColumns() - nbAxes_); i--) { for (unsigned int j = 0; j < eigenVectors_.getNumberOfRows(); j++) { tmpEigenVectors(j, cpt2) = eigenVectors_(j, i-1); } cpt2++; } // matrix of principal axes MatrixTools::hadamardMult(tmpEigenVectors, tmpColWeights, ppalAxes_, true); // matrix of row coordinates RowMatrix tmpRowCoord_; tmpRowCoord_.resize(rowNb, nbAxes_); MatrixTools::hadamardMult(matrix, colWeights_, tmpRowCoord_, false); MatrixTools::mult(tmpRowCoord_, ppalAxes_, rowCoord_); // matrix of column coordinates MatrixTools::hadamardMult(ppalAxes_, dval, colCoord_, false); // matrix of principal components MatrixTools::hadamardMult(rowCoord_, invDval, ppalComponents_, false); } else { vector tmpRowWeights(rowNb); for (unsigned int i = 0; i < rowWeights_.size(); i++) { tmpRowWeights[i] = 1. / sqrt(rowWeights_[i]); } // The eigen vectors are placed in the same order as their corresponding eigen value in eigenValues_. RowMatrix tmpEigenVectors; tmpEigenVectors.resize(eigenVectors_.getNumberOfRows(), nbAxes_); size_t cpt2 = 0; for (size_t i = eigenVectors_.getNumberOfColumns(); i > (eigenVectors_.getNumberOfColumns() - nbAxes_); i--) { for (size_t j = 0; j < eigenVectors_.getNumberOfRows(); j++) { tmpEigenVectors(j, cpt2) = eigenVectors_(j, i-1); } cpt2++; } // matrix of principal components MatrixTools::hadamardMult(tmpEigenVectors, tmpRowWeights, ppalComponents_, true); // matrix of column coordinates RowMatrix tmpColCoord_; tmpColCoord_.resize(colNb, nbAxes_); MatrixTools::hadamardMult(matrix, rowWeights_, tmpColCoord_, true); RowMatrix tTmpColCoord_; MatrixTools::transpose(tmpColCoord_, tTmpColCoord_); MatrixTools::mult(tTmpColCoord_, ppalComponents_, colCoord_); // matrix of row coordinates MatrixTools::hadamardMult(ppalComponents_, dval, rowCoord_, false); // matrix of principal axes MatrixTools::hadamardMult(colCoord_, invDval, ppalAxes_, false); } } /******************************************************************************/ DualityDiagram::~DualityDiagram() {} /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Stat/ContingencyTableTest.cpp000664 001750 001750 00000010646 12370705300 025333 0ustar00jdutheiljdutheil000000 000000 // // File: ContingencyTableTest.cpp // Created by: Julien Dutheil // Created on: Thu Dec 09 14:20 2010 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "ContingencyTableTest.h" #include "../Random/ContingencyTableGenerator.h" #include "../../App/ApplicationTools.h" #include "../VectorTools.h" #include "../Random/RandomTools.h" #include #include using namespace bpp; using namespace std; ContingencyTableTest::ContingencyTableTest(const std::vector< std::vector >& table, unsigned int nbPermutations, bool warn): statistic_(0), pvalue_(0), df_(0), margin1_(table.size()), margin2_(0) { //Compute marginals: size_t n = table.size(); if (n < 2) throw Exception("ContingencyTableTest. Table size should be at least 2x2!"); size_t m = table[0].size(); if (m < 2) throw Exception("ContingencyTableTest. Table size should be at least 2x2!"); margin2_.resize(m); for (size_t j = 0; j < m; ++j) margin2_[j] = 0; bool test = false; for (size_t i = 0; i < n; ++i) { if (table[i].size() != m) throw Exception("ContingencyTableTest. Input array has non-homogeneous dimensions!"); for (size_t j = 0; j < m; ++j) { size_t c = table[i][j]; if (c <= 5) test = true; margin1_[i] += c; margin2_[j] += c; } } for (size_t i = 0; i < n; ++i) if (margin1_[i] == 0) throw Exception("ContingencyTableTest. Row " + TextTools::toString(i) + " sums to 0."); for (size_t j = 0; j < m; ++j) if (margin2_[j] == 0) throw Exception("ContingencyTableTest. Column " + TextTools::toString(j) + " sums to 0."); size_t tot = VectorTools::sum(margin1_); df_ = static_cast((m - 1) * (n - 1)); RowMatrix expc(n, m); for (size_t i = 0; i < n; ++i) { for (size_t j = 0; j < m; ++j) { long double c = table[i][j]; long double e = static_cast(margin1_[i] * margin2_[j]) / static_cast(tot); expc(i, j) = e; statistic_ += static_cast(std::pow(c - e, 2.L) / e); } } if (nbPermutations > 0) { size_t count = 0; ContingencyTableGenerator ctgen(margin1_, margin2_); for (unsigned int k = 0; k < nbPermutations; ++k) { //Randomize: RowMatrix table_rep = ctgen.rcont2(); //Recompute statistic: double stat_rep = 0; for (size_t i = 0; i < n; ++i) { for (size_t j = 0; j < m; ++j) { long double c = table_rep(i , j); long double e = expc(i, j); stat_rep += static_cast(std::pow(c - e, 2.L) / e); } } if (stat_rep >= statistic_) count++; } pvalue_ = static_cast(count + 1) / static_cast(nbPermutations + 1); } else { if (test && warn) ApplicationTools::displayWarning("Unsufficient observations, p-value might be incorrect."); //Compute p-value: pvalue_ = 1. - RandomTools::pChisq(statistic_, df_); } } bpp-core-2.2.0/src/Bpp/Numeric/Stat/ContingencyTableTest.h000664 001750 001750 00000006306 12370705300 024776 0ustar00jdutheiljdutheil000000 000000 // // File: ContingencyTableTest.h // Created by: Julien Dutheil // Created on: Thu Dec 09 14:20 2010 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _CONTINGENCYTABLETEST_H_ #define _CONTINGENCYTABLETEST_H_ #include "StatTest.h" //From the STL: #include namespace bpp { /** * @brief Implements tests on contingency tables. * * Performs a chi square test on contingency tables. */ class ContingencyTableTest: public virtual StatTest { private: double statistic_; double pvalue_; double df_; std::vector margin1_; std::vector margin2_; public: /** * @brief Build a new test object and perform computations. * * @param table The input contingency table. * @param nbPermutations If greater than 0, performs a randomization test instead of using the chisquare approximation. * @param warn Should a warning message be displayed in case of unsufficient observations? */ ContingencyTableTest(const std::vector< std::vector >& table, unsigned int nbPermutations = 0, bool warn = true); virtual ~ContingencyTableTest() {} #ifndef NO_VIRTUAL_COV ContingencyTableTest* #else Clonable* #endif clone() const { return new ContingencyTableTest(*this); } public: std::string getName() const { return "Test on contingency table."; } double getStatistic() const { return statistic_; } double getPValue() const { return pvalue_; } double getDegreesOfFreedom() const { return df_; } const std::vector getMarginRows() const { return margin1_; } const std::vector getMarginColumns() const { return margin2_; } }; } //end of namespace bpp. #endif //_CONTINGENCYTABLETEST_H_ bpp-core-2.2.0/src/Bpp/Numeric/Stat/StatTools.h000664 001750 001750 00000006311 12370705300 022636 0ustar00jdutheiljdutheil000000 000000 // // File: StatTools.h // Created by: Julien Dutheil // Created on: Sun Jan 30 19:10 2011 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _STATTOOLS_H_ #define _STATTOOLS_H_ //From the STL: #include #include namespace bpp { /** * @brief Statistics tools and utilitary functions. */ class StatTools { private: struct PValue_ { double pvalue_; size_t index_; PValue_(double pvalue, size_t index): pvalue_(pvalue), index_(index) {} bool operator<(const PValue_& pvalue) const { return pvalue.pvalue_ < pvalue_; } }; public: /** * @brief Compute the false discovery rate for a set of input p-values, using Benjamini and Hochberg's 'FDR' method. * * The false discovery rate is computed by sorting all pvalues. * The FDR r is calculated with the formula * @f$ r = p * n / i@f$ * where p is the p-value, n is the number of tests (the size of the input vector) and i is the rank of the p-value, that is the index in the sorted array. * * References: * - Benjamini, Y and Hochberg, Y (1995). Controlling the false discovery rate: a practical and powerful approach to multiple testing. Journal of the Royal Statistical Society, Series B (Methodological) 57(1):289-300. * - Verhoeven, KJF; Simonsen, KL; M. McIntyre, LM (2005). Implementing false discovery rate control: increasing your power. Oikos. 108(3):643-647. * * @author Julien Dutheil * @param pvalues The input p-values. * @return The corresponding false discovery rates. */ static std::vector computeFdr(const std::vector& pvalues); }; } //end of namespace bpp. #endif //_STATTOOLS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Stat/StatTest.h000664 001750 001750 00000004266 12370705300 022464 0ustar00jdutheiljdutheil000000 000000 // // File: StatTest.h // Created by: Julien Dutheil // Created on: Tue Mar 18 13:56 2008 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _STATTEST_H_ #define _STATTEST_H_ #include "../../Clonable.h" //From the STL: #include namespace bpp { /** * @brief Interface for statistical test results. * * Specific test may add specific methods to the ones provided here. */ class StatTest: public virtual Clonable { public: StatTest() {} virtual ~StatTest() {} public: virtual std::string getName() const = 0; virtual double getStatistic() const = 0; virtual double getPValue() const = 0; }; } // end of namespace bpp; #endif //_STATTEST_H_ bpp-core-2.2.0/src/Bpp/Numeric/Stat/StatTools.cpp000664 001750 001750 00000004414 12370705300 023173 0ustar00jdutheiljdutheil000000 000000 // // File: StatTools.cpp // Created by: Julien Dutheil // Created on: Sun Jan 30 19:10 2011 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "StatTools.h" //From the STL: #include using namespace bpp; using namespace std; vector StatTools::computeFdr(const vector& pvalues) { size_t n = pvalues.size(); vector sortedPValues; for (size_t i = 0; i < n; ++i) { sortedPValues.push_back(PValue_(pvalues[i], i)); } sort(sortedPValues.begin(), sortedPValues.end()); vector fdr(pvalues.size()); for (size_t i = 0; i < sortedPValues.size(); ++i) { fdr[sortedPValues[i].index_] = sortedPValues[i].pvalue_ * static_cast(n) / ( static_cast(sortedPValues[i].index_ + 1)); } return fdr; } bpp-core-2.2.0/src/Bpp/Numeric/AbstractParameterAliasable.h000664 001750 001750 00000020305 12370705300 025170 0ustar00jdutheiljdutheil000000 000000 // // File: AbstractParameterAliasable.h // Created by: Julien Dutheil // Created on: Thu May 14 17:08 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _ABSTRACTPARAMETERALIASABLE_H_ #define _ABSTRACTPARAMETERALIASABLE_H_ #include "AbstractParametrizable.h" #include "ParameterAliasable.h" //From the STL: #include namespace bpp { /** * @brief Inner listener class used by AbstractParameterAliasable. */ class AliasParameterListener: public ParameterListener { private: std::string id_; size_t alias_; ParameterList *pl_; std::string name_; std::string from_; public: AliasParameterListener(const std::string& id, size_t alias, ParameterList* pl, const std::string& from): id_(id), alias_(alias), pl_(pl), name_(), from_(from) { //This allow us to check if the parameter position have changed at some point... name_ = (*pl_)[alias].getName(); } AliasParameterListener(const AliasParameterListener& apl): id_(apl.id_), alias_(apl.alias_), pl_(apl.pl_), name_(apl.name_), from_(apl.from_) {} AliasParameterListener& operator=(const AliasParameterListener& apl) { id_ = apl.id_; alias_ = apl.alias_; pl_ = apl.pl_; name_ = apl.name_; from_ = apl.from_; return *this; } AliasParameterListener* clone() const { return new AliasParameterListener(*this); } public: const std::string& getId() const { return id_; } const std::string& getFrom() const { return from_; } void setParameterList(ParameterList* pl) { pl_ = pl; } void parameterNameChanged(ParameterEvent& event) throw (Exception) {} void parameterValueChanged(ParameterEvent& event) throw (Exception) { Parameter* p = &(*pl_)[alias_]; if (p->getName() != name_) throw Exception("AbstractParameterAliasable::AliasParameterListener::parameterValueChanged. Error, aliased parameter have change, maybe because it was renamed, or a parameter was removed?"); p->setValue(event.getParameter()->getValue()); } const std::string& getName() const { return name_; } void rename(const std::string& name) { name_ = name; } const std::string& getAlias() const { return (*pl_)[alias_].getName(); } }; /** * @brief A partial implementation of the Parametrizable interface. * * Parameters are stored in a protected ParameterList object. * * The abstract fireParameterChanged() method is provided so that the derived class * know when a parameter has changed, and can be updated. * All methods call the corresponding method in ParameterList and then call the * fireParameterChanged() method. */ class AbstractParameterAliasable: public AbstractParametrizable, public virtual ParameterAliasable { private: mutable ParameterList independentParameters_; /** * Contains all parameter listeners for maintening alias relationships. * The registry will be updated appropriately upon cloning and deleting. */ std::map aliasListenersRegister_; public: AbstractParameterAliasable(const std::string& prefix) : AbstractParametrizable(prefix), independentParameters_(), aliasListenersRegister_() {} AbstractParameterAliasable(const AbstractParameterAliasable& ap); AbstractParameterAliasable& operator=(const AbstractParameterAliasable& ap); virtual ~AbstractParameterAliasable(); public: void setNamespace(const std::string& prefix); const ParameterList& getIndependentParameters() const { return independentParameters_; } size_t getNumberOfIndependentParameters() const { return independentParameters_.size(); } void aliasParameters(const std::string& p1, const std::string& p2) throw (ParameterNotFoundException, Exception); void unaliasParameters(const std::string& p1, const std::string& p2) throw (ParameterNotFoundException, Exception); /** * @brief alias the parameters following the links described in a * map, and update the object accordingly. Cycles in aliasing are * detected and forbidden. * * @param unparsedParams the map of the links : matches for A->B aliasing. * @param verbose verbosity * **/ void aliasParameters(std::map& unparsedParams, bool verbose); /** * @brief Return the list of the names of the parameters that are * aliased (directly or not) to one of the parameters of the list. * */ ParameterList getAliasedParameters(const ParameterList& pl) const; /** * @return The list of names of the parameters that are aliased with a given parameter. * The implementation is recursive, which means that in the case of A->B->C, getalias(C) will return both A and B. * @param name The name of the parameter to look for. */ std::vector getAlias(const std::string& name) const; /** * @return The name of the parameter from which a given parameter is aliased. * @param name The name of the parameter to look for. */ std::string getFrom(const std::string& name) const; void fireParameterChanged(const ParameterList& parameters) { independentParameters_.matchParametersValues(getParameters()); } protected: void addParameter_(Parameter* parameter) { AbstractParametrizable::addParameter_(parameter); independentParameters_.addParameter(parameter->clone()); } void addParameters_(const ParameterList& parameters) { AbstractParametrizable::addParameters_(parameters); independentParameters_.addParameters(parameters); } void deleteParameter_(size_t index) throw (IndexOutOfBoundsException) { std::string name = getParameter_(index).getName(); AbstractParametrizable::deleteParameter_(index); if (independentParameters_.hasParameter(name)) independentParameters_.deleteParameter(name); } void deleteParameter_(std::string& name) throw (IndexOutOfBoundsException) { AbstractParametrizable::deleteParameter_(name); if (independentParameters_.hasParameter(name)) independentParameters_.deleteParameter(name); } void deleteParameters_(const std::vector& names) { std::string x; for (size_t i=0; i namespace bpp { /** * @brief Exception thrown when a given name is not found is a DataTable object. */ class TableNameNotFoundException: public Exception { protected: std::string _name; public: TableNameNotFoundException(const std::string & text, const std::string & name) : Exception("TableNameNotFoundException: " + name + ". " + text), _name(name) {} virtual ~TableNameNotFoundException() throw() {} public: std::string getName() const { return _name; } }; /** * @brief Exception thrown when a given row name is not found is a DataTable object. */ class TableRowNameNotFoundException: public TableNameNotFoundException { public: TableRowNameNotFoundException(const std::string & text, const std::string & name) : TableNameNotFoundException("TableRowNameNotFoundException: " + name + ". " + text, name) {} virtual ~TableRowNameNotFoundException() throw() {} }; /** * @brief Exception thrown when a given column name is not found is a DataTable object. */ class TableColumnNameNotFoundException: public TableNameNotFoundException { public: TableColumnNameNotFoundException(const std::string & text, const std::string & name) : TableNameNotFoundException("TableColumnNameNotFoundException: " + name + ". " + text, name) {} virtual ~TableColumnNameNotFoundException() throw() {} }; /** * @brief Exception thrown when trying to retrieve a row by its name * and no row names have been specified. */ class NoTableRowNamesException: public Exception { public: NoTableRowNamesException(const std::string & text) : Exception("NoTableRowNamesException: "+text) {} virtual ~NoTableRowNamesException() throw() {} }; /** * @brief Exception thrown when trying to retrieve a column by its name * and no column names have been specified. */ class NoTableColumnNamesException: public Exception { public: NoTableColumnNamesException(const std::string & text) : Exception("NoTableColumnNamesException: "+text) {} virtual ~NoTableColumnNamesException() throw() {} }; /** * @brief General exception class dealing with row names. */ class TableRowNamesException: public Exception { public: TableRowNamesException(const std::string & text) : Exception("TableRowNamesException: "+text) {} virtual ~TableRowNamesException() throw() {} }; /** * @brief General exception class dealing with column names. */ class TableColumnNamesException: public Exception { public: TableColumnNamesException(const std::string & text) : Exception("TableColumnNamesException: "+text) {} virtual ~TableColumnNamesException() throw() {} }; /** * @brief Exception thrown when attempting to duplicate a row name. */ class DuplicatedTableRowNameException: public Exception { public: DuplicatedTableRowNameException(const std::string & text) : Exception("DuplicatedTableRowNameException: "+text) {} virtual ~DuplicatedTableRowNameException() throw() {} }; /** * @brief Excpetion thrown when attempting to duplicate a column name. */ class DuplicatedTableColumnNameException: public Exception { public: DuplicatedTableColumnNameException(const std::string & text) : Exception("DuplicatedTableColumnNameException: "+text) {} virtual ~DuplicatedTableColumnNameException() throw() {} }; } //end of namespace bpp. #endif //_DataTableExceptions_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/FivePointsNumericalDerivative.h000664 001750 001750 00000011421 12370705300 027523 0ustar00jdutheiljdutheil000000 000000 // // File: FivePointsNumericalDerivative.h // Created by: Julien Dutheil // Created on: Thu Aug 17 15:00 2006 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _FIVEPOINTSNUMERICALDERIVATIVE_H_ #define _FIVEPOINTSNUMERICALDERIVATIVE_H_ #include "Functions.h" #include "AbstractNumericalDerivative.h" // From the STL: #include #include #include namespace bpp { /** * @brief Five points numerical derivative function wrapper. * * Numerical derivatives use three points to compute the derivatives. * @f$x_0@f$ is the focus point, @f$x_{-2} = x_0-2h@f$, @f$x_{-1} = x_0-h@f$, @f$x_{+1}=x_0+h@f$ and @f$x_{+2} = x_0+2h@f$ * are other points, with function values @f$f_0@f$, @f$f_{-2}@f$, @f$f_{-1}@f$, @f$f_{+1}@f$ and @f$f_{+2}@f$ respectively. * The derivatives are then computed using the central formulas: * @f{eqnarray*} * \dfrac{\partial f}{\partial x } &=& \dfrac{f_{-2}-8f_{-1}+8f_{+1}-f_{+2}}{12h}\\ * \dfrac{\partial^2 f}{\partial x^2} &=& \dfrac{-f_{-2}+16f_{-1}-30f_0+16f_{+1}-f_{+2}}{12h^2}\\ * @f} * In case of border limit (when @f$x_{-2}@f$ or @f$x_{+2}@f$ are not computable), * the foreward and backward three points computations are performed, respectively: * @f{eqnarray*} * \dfrac{\partial f}{\partial x } &=& \dfrac{f_{+1}-f_0}{h}\\ * \dfrac{\partial^2 f}{\partial x^2} &=& \dfrac{f_{+2}-2f_{+1}+f_0}{h^2}\\ * @f} * and * @f{eqnarray*} * \dfrac{\partial f}{\partial x } &=& \dfrac{f_0-f_{-1}}{h}\\ * \dfrac{\partial^2 f}{\partial x^2} &=& \dfrac{f_0-2f_{-1}+f_{-2}}{h^2}\\ * @f} * * The @f$h@f$ parameter is computed in a parameter dependent manner: * @f$ h = x \times e@f$, with @f$x \neq 0@f$ being the current parameter value. * If @f$x = 0@f$, @f$h = e@f$. * Default value is provided for @f$e@f$ and corresponds to the _h field. * The default value works fine in most cases, but you may want to change it using the setInterval method. * * @warning cross second order derivatives are not implemented with the five points method. * @see AbstractNumericalDerivative */ class FivePointsNumericalDerivative : public AbstractNumericalDerivative { private: double f1_, f2_, f3_, f4_, f5_; public: FivePointsNumericalDerivative(Function* function) : AbstractNumericalDerivative(function), f1_(), f2_(), f3_(), f4_(), f5_() {} FivePointsNumericalDerivative(DerivableFirstOrder* function) : AbstractNumericalDerivative(function), f1_(), f2_(), f3_(), f4_(), f5_() {} FivePointsNumericalDerivative(DerivableSecondOrder* function) : AbstractNumericalDerivative(function), f1_(), f2_(), f3_(), f4_(), f5_() {} virtual ~FivePointsNumericalDerivative() {} FivePointsNumericalDerivative* clone() const { return new FivePointsNumericalDerivative(*this); } public: double getValue() const throw (Exception) { return f3_; } double getSecondOrderDerivative(const std::string& variable1, const std::string& variable2) const throw (Exception) { throw Exception("Unimplemented cross derivative."); } protected: void updateDerivatives(const ParameterList parameters) throw (ParameterNotFoundException, ConstraintException); }; } // end of namespace bpp. #endif // _FIVEPOINTSNUMERICALDERIVATIVE_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/NewtonOneDimension.h000664 001750 001750 00000005502 12370705300 025337 0ustar00jdutheiljdutheil000000 000000 // // File: NewtonOneDimension.h // Created by: Julien Dutheil // Created on: Thu Apr 26 14:16 2007 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _NEWTONONEDIMENSION_H_ #define _NEWTONONEDIMENSION_H_ #include "AbstractOptimizer.h" namespace bpp { /** * @brief Newton's optimization for one parameter. */ class NewtonOneDimension: public AbstractOptimizer { private: std::string _param; unsigned int _maxCorrection; public: NewtonOneDimension(DerivableSecondOrder* function = 0); virtual ~NewtonOneDimension() {} NewtonOneDimension* clone() const { return new NewtonOneDimension(*this); } public: const DerivableSecondOrder* getFunction() const { return dynamic_cast(AbstractOptimizer::getFunction()); } DerivableSecondOrder* getFunction() { return dynamic_cast(AbstractOptimizer::getFunction()); } void doInit(const ParameterList& params) throw (Exception); double doStep() throw (Exception); void setMaximumNumberOfCorrections(unsigned int mx) { _maxCorrection = mx; } protected: DerivableSecondOrder* getFunction_() { return dynamic_cast(AbstractOptimizer::getFunction_()); } }; } //end of namespace bpp. #endif //_NEWTONONEDIMENSION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/ReparametrizationFunctionWrapper.cpp000664 001750 001750 00000022771 12406004603 030664 0ustar00jdutheiljdutheil000000 000000 // // File: ReparametrizationFunctionWrapper.h // Created by: Julien Dutheil // Created on: Fri Jan 30 09:30 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "ReparametrizationFunctionWrapper.h" #include "../../App/ApplicationTools.h" #include using namespace bpp; using namespace std; void ReparametrizationFunctionWrapper::init_(bool verbose) { for (size_t i = 0; i < functionParameters_.size(); i++) { Parameter& p = functionParameters_[i]; Constraint* constraint = p.getConstraint(); const string name = p.getName(); double value = p.getValue(); if (!constraint) { if (verbose) ApplicationTools::displayMessage("Parameter " + name + " does not need to be transformed."); addParameter_(new PlaceboTransformedParameter(name, value)); } else { IntervalConstraint* interval = dynamic_cast(constraint); if (interval) { bool isInfinite = (!interval->finiteLowerBound()) || (!interval->finiteUpperBound()); if (!isInfinite) { if (!interval->strictLowerBound() && !interval->strictUpperBound()) { // Case 1: [a,b] // This solves an issue if the original value is at the bound. double correctedValue = value; if (abs(value - interval->getLowerBound()) < NumConstants::TINY()) correctedValue = interval->getLowerBound() + NumConstants::TINY(); if (abs(value - interval->getUpperBound()) < NumConstants::TINY()) correctedValue = interval->getUpperBound() - NumConstants::TINY(); IntervalTransformedParameter* pp = new IntervalTransformedParameter(name, correctedValue, interval->getLowerBound(), interval->getUpperBound()); addParameter_(pp); if (verbose) ApplicationTools::displayMessage("Parameter " + name + " was tanh transformed: " + TextTools::toString(value) + "->" + TextTools::toString(pp->getValue())); } else if (interval->strictLowerBound() && interval->strictUpperBound()) { // Case 2: ]a,b[ // We have to correct the bound in order to prevent numerical issues. // It can happens that the original bound is matched because of rounding errors. IntervalTransformedParameter* pp = new IntervalTransformedParameter(name, value, interval->getLowerBound() + NumConstants::TINY(), interval->getUpperBound() - NumConstants::TINY()); addParameter_(pp); if (verbose) ApplicationTools::displayMessage("Parameter " + name + " was tanh transformed: " + TextTools::toString(value) + "->" + TextTools::toString(pp->getValue())); } else if (!interval->strictLowerBound() && interval->strictUpperBound()) { // Case 3: [a,b[ // This solves an issue if the original value is at the bound. double correctedValue = value; if (abs(value - interval->getLowerBound()) < NumConstants::TINY()) correctedValue = interval->getLowerBound() + NumConstants::TINY(); IntervalTransformedParameter* pp = new IntervalTransformedParameter(name, correctedValue, interval->getLowerBound(), interval->getUpperBound() - NumConstants::TINY()); addParameter_(pp); if (verbose) ApplicationTools::displayMessage("Parameter " + name + " was tanh transformed: " + TextTools::toString(value) + "->" + TextTools::toString(pp->getValue())); } else if (interval->strictLowerBound() && !interval->strictUpperBound()) { // Case 4: ]a,b] // This solve an issue if the original value is at the bound. double correctedValue = value; if (abs(value - interval->getUpperBound()) < NumConstants::TINY()) correctedValue = interval->getUpperBound() - NumConstants::TINY(); IntervalTransformedParameter* pp = new IntervalTransformedParameter(name, correctedValue, interval->getLowerBound() + NumConstants::TINY(), interval->getUpperBound()); addParameter_(pp); if (verbose) ApplicationTools::displayMessage("Parameter " + name + " was tanh transformed: " + TextTools::toString(value) + "->" + TextTools::toString(pp->getValue())); } } else { if (interval->strictLowerBound() && !interval->finiteUpperBound()) { // Case 5: ]a, +inf[ RTransformedParameter* pp = new RTransformedParameter(name, value, interval->getLowerBound() + NumConstants::TINY(), true); addParameter_(pp); if (verbose) ApplicationTools::displayMessage("Parameter " + name + " was log transformed: " + TextTools::toString(value) + "->" + TextTools::toString(pp->getValue())); } else if (!interval->strictLowerBound() && !interval->finiteUpperBound()) { // Case 6: [a, +inf[ // This solve an issue if the original value is at the bound. double correctedValue = value; if (abs(value - interval->getLowerBound()) < NumConstants::TINY()) correctedValue = interval->getLowerBound() + NumConstants::TINY(); RTransformedParameter* pp = new RTransformedParameter(name, correctedValue, interval->getLowerBound(), true); addParameter_(pp); if (verbose) ApplicationTools::displayMessage("Parameter " + name + " was log transformed: " + TextTools::toString(value) + "->" + TextTools::toString(pp->getValue())); } else if (!interval->finiteLowerBound() && interval->strictUpperBound()) { // Case 7: ]-inf, a[ RTransformedParameter* pp = new RTransformedParameter(name, value, interval->getUpperBound() - NumConstants::TINY(), false); addParameter_(pp); if (verbose) ApplicationTools::displayMessage("Parameter " + name + " was log transformed: " + TextTools::toString(value) + "->" + TextTools::toString(pp->getValue())); } else if (!interval->finiteLowerBound() && !interval->strictUpperBound()) { // Case 8: ]-inf, a] // This solve an issue if the original value is at the bound. double correctedValue = value; if (abs(value - interval->getUpperBound()) < NumConstants::TINY()) correctedValue = interval->getUpperBound() - NumConstants::TINY(); RTransformedParameter* pp = new RTransformedParameter(name, correctedValue, interval->getUpperBound(), false); addParameter_(pp); if (verbose) ApplicationTools::displayMessage("Parameter " + name + " was log transformed: " + TextTools::toString(value) + "->" + TextTools::toString(pp->getValue())); } } } else { // Nothing found if (verbose) { ApplicationTools::displayWarning("No transformation found for this constraint '" + constraint->getDescription() + "'! Parameter " + p.getName()); } addParameter_(new PlaceboTransformedParameter(name, value)); } } } } void ReparametrizationFunctionWrapper::fireParameterChanged(const ParameterList& parameters) { // Recompute function parameters: // We could update only the parameter that actually changed, // but that would implied a quick sort on parameter names (nlog(n)) // whereas using a loop over the set is in o(n). It should hence be // more efficient in most cases. for (size_t i = 0; i < getNumberOfParameters(); ++i) { double x = dynamic_cast(getParameter_(i)).getOriginalValue(); try { functionParameters_[i].setValue(x); } catch (ConstraintException& ce) { (*ApplicationTools::error << "Oups, value " << x << " led to a constraint exception. The transformed value was " << getParameter_(i).getValue()).endLine(); throw ce; } } } bpp-core-2.2.0/src/Bpp/Numeric/Function/ThreePointsNumericalDerivative.cpp000664 001750 001750 00000020105 12370705300 030233 0ustar00jdutheiljdutheil000000 000000 // // File: ThreePointsNumericalDerivative.cpp // Created by: Julien Dutheil // Created on: Thu Aug 17 15:00 2006 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "ThreePointsNumericalDerivative.h" using namespace bpp; using namespace std; void ThreePointsNumericalDerivative::updateDerivatives(const ParameterList parameters) throw (ParameterNotFoundException, ConstraintException) { if (computeD1_ && variables_.size() > 0) { if (function1_) function1_->enableFirstOrderDerivatives(false); if (function2_) function2_->enableSecondOrderDerivatives(false); function_->setParameters(parameters); f2_ = function_->getValue(); if ((abs(f2_) >= NumConstants::VERY_BIG()) || isnan(f2_)) { for (size_t i = 0; i < variables_.size(); ++i) { der1_[i] = log(-1); der2_[i] = log(-1); } return; } string lastVar; bool functionChanged = false; ParameterList p; bool start = true; for (size_t i = 0; i < variables_.size(); ++i) { string var = variables_[i]; if (!parameters.hasParameter(var)) continue; if (!start) { vector vars(2); vars[0] = var; vars[1] = lastVar; p = parameters.subList(vars); } else { p = parameters.subList(var); start = false; } lastVar = var; functionChanged = true; double value = function_->getParameterValue(var); double h = -(1. + std::abs(value)) * h_; if (abs(h) < p[0].getPrecision()) h = h < 0 ? -p[0].getPrecision() : p[0].getPrecision(); double hf1(0), hf3(0); unsigned int nbtry = 0; // Compute f1_ while (hf1 == 0) { try { p[0].setValue(value + h); function_->setParameters(p); // also reset previous parameter... p = p.subList(0); f1_ = function_->getValue(); if ((abs(f1_) >= NumConstants::VERY_BIG()) || isnan(f1_)) throw ConstraintException("f1_ too large", &p[0], f1_); else hf1 = h; } catch (ConstraintException& ce) { if (++nbtry == 10) // no possibility to compute derivatives break; else if (h < 0) h = -h; // try on the right else h /= -2; // try again on the left with smaller interval } } if (hf1 != 0) { // Compute f3_ if (h < 0) h = -h; // on the right else h /= 2; // on the left with smaller interval nbtry = 0; while (hf3 == 0) { try { p[0].setValue(value + h); function_->setParameters(p); // also reset previous parameter... p = p.subList(0); f3_ = function_->getValue(); if ((abs(f3_) >= NumConstants::VERY_BIG()) || isnan(f3_)) throw ConstraintException("f3_ too large", &p[0], f3_); else hf3 = h; } catch (ConstraintException& ce) { if (++nbtry == 10) // no possibility to compute derivatives break; else if (h < 0) h = -h; // try on the right else h /= -2; // try again on the left with smaller interval } } } if (hf3 == 0) { der1_[i] = log(-1); der2_[i] = log(-1); } else { der1_[i] = (f1_ - f3_) / (hf1 - hf3); der2_[i] = ((f1_ - f2_) / hf1 - (f3_ - f2_) / hf3) * 2 / (hf1 - hf3); } } if (computeCrossD2_) { string lastVar1, lastVar2; for (unsigned int i = 0; i < variables_.size(); i++) { string var1 = variables_[i]; if (!parameters.hasParameter(var1)) continue; for (unsigned int j = 0; j < variables_.size(); j++) { if (j == i) { crossDer2_(i, j) = der2_[i]; continue; } string var2 = variables_[j]; if (!parameters.hasParameter(var2)) continue; vector vars(2); vars[0] = var1; vars[1] = var2; if (i > 0 && j > 0) { if (lastVar1 != var1 && lastVar1 != var2) vars.push_back(lastVar1); if (lastVar2 != var1 && lastVar2 != var2) vars.push_back(lastVar2); } p = parameters.subList(vars); double value1 = function_->getParameterValue(var1); double value2 = function_->getParameterValue(var2); double h1 = (1. + std::abs(value1)) * h_; double h2 = (1. + std::abs(value2)) * h_; // Compute 4 additional points: try { p[0].setValue(value1 - h1); p[1].setValue(value2 - h2); function_->setParameters(p); // also reset previous parameter... vector tmp(2); tmp[0] = 0; tmp[1] = 1; p = p.subList(tmp); // removed the previous parameters. f11_ = function_->getValue(); p[1].setValue(value2 + h2); function_->setParameters(p.subList(1)); f12_ = function_->getValue(); p[0].setValue(value1 + h1); function_->setParameters(p.subList(0)); f22_ = function_->getValue(); p[1].setValue(value2 - h2); function_->setParameters(p.subList(1)); f21_ = function_->getValue(); crossDer2_(i, j) = ((f22_ - f21_) - (f12_ - f11_)) / (4 * h1 * h2); } catch (ConstraintException& ce) { throw Exception("ThreePointsNumericalDerivative::setParameters. Could not compute cross derivatives at limit."); } lastVar1 = var1; lastVar2 = var2; } } } // Reset last parameter and compute analytical derivatives if any. if (function1_) function1_->enableFirstOrderDerivatives(computeD1_); if (function2_) function2_->enableSecondOrderDerivatives(computeD2_); if (functionChanged) function_->setParameters(parameters.subList(lastVar)); } else { // Reset initial value and compute analytical derivatives if any. if (function1_) function1_->enableFirstOrderDerivatives(computeD1_); if (function2_) function2_->enableSecondOrderDerivatives(computeD2_); function_->setParameters(parameters); // Just in case derivatives are not computed: f2_ = function_->getValue(); } } bpp-core-2.2.0/src/Bpp/Numeric/Function/MetaOptimizer.h000664 001750 001750 00000022025 12370705300 024345 0ustar00jdutheiljdutheil000000 000000 // // File: MetaOptimizer.h // Created by: Julien Dutheil // Created on: Fri Oct 12 16:05 2007 // From file: NewtonBrentMetaOptimizer.h // Created on: Tue Nov 17 17:22 2004 // // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef METAOPTIMIZER_H__ #define METAOPTIMIZER_H__ #include "AbstractOptimizer.h" // From the STL: #include namespace bpp { /** * @brief Provide a list of optimizer and corresponding options to be used with the MetaOptimizer class. */ class MetaOptimizerInfos: public virtual Clonable { public: static std::string IT_TYPE_STEP; static std::string IT_TYPE_FULL; private: std::vector names_; std::vector optimizers_; std::vector< std::vector > parameterNames_; std::vector derivatives_; std::vector itTypes_; public: MetaOptimizerInfos() : names_(), optimizers_(), parameterNames_(), derivatives_(), itTypes_() {} MetaOptimizerInfos(const MetaOptimizerInfos& infos) : names_(infos.names_), optimizers_(infos.optimizers_), parameterNames_(infos.parameterNames_), derivatives_(infos.derivatives_), itTypes_(infos.itTypes_) { for (unsigned int i = 0; i < optimizers_.size(); i++) optimizers_[i] = dynamic_cast(infos.optimizers_[i]->clone()); } MetaOptimizerInfos& operator=(const MetaOptimizerInfos& infos) { names_ = infos.names_; optimizers_ = infos.optimizers_; parameterNames_ = infos.parameterNames_; derivatives_ = infos.derivatives_; itTypes_ = infos.itTypes_; for (unsigned int i = 0; i < optimizers_.size(); i++) optimizers_[i] = dynamic_cast(infos.optimizers_[i]->clone()); return *this; } virtual ~MetaOptimizerInfos() { for(unsigned int i = 0; i < optimizers_.size(); i++) delete optimizers_[i]; } public: #ifndef NO_VIRTUAL_COV MetaOptimizerInfos* clone() const { return new MetaOptimizerInfos(*this); } #else Clonable* clone() const { return new MetaOptimizerInfos(*this); } #endif public: /** * @brief Add a new optimizer to the set. * * @param name the name of the optimizer. It is used for display only. * @param optimizer A pointer toward the optimizer to add. The set will own the underlying object, which will be destroyed together with the set. * @param params A list of parameter names to optimize with this optimizer. * @param derivatives 0, 1 or 2: does this parameter use no, first order or second order derivatives? * @param type For each optimization step, shall we perform a full optimization with this optimizer or only one step? */ virtual void addOptimizer(const std::string & name, Optimizer * optimizer, const std::vector & params, unsigned short derivatives = 0, const std::string & type = IT_TYPE_STEP) { names_.push_back(name); optimizers_.push_back(optimizer); parameterNames_.push_back(params); derivatives_.push_back(derivatives); itTypes_.push_back(type); } /** * @return The display name of the ith optimizer in the set. */ virtual const std::string& getName(size_t i) const { return names_[i]; } /** * @return The ith optimizer in the set. */ virtual Optimizer* getOptimizer(size_t i) { return optimizers_[i]; } /** * @return The ith optimizer in the set. */ virtual const Optimizer* getOptimizer(size_t i) const { return optimizers_[i]; } /** * @return The parameter names associated to the ith optimizer in the set. */ virtual std::vector& getParameterNames(size_t i) { return parameterNames_[i]; } /** * @return The parameter names associated to the ith optimizer in the set. */ virtual const std::vector& getParameterNames(size_t i) const { return parameterNames_[i]; } /** * @return The type of iteration to perform for the ith optimizer in the set. */ virtual std::string& getIterationType(size_t i) { return itTypes_[i]; } /** * @return The type of iteration to perform for the ith optimizer in the set. */ virtual const std::string& getIterationType(size_t i) const { return itTypes_[i]; } /** * @return True if the ith optimizer in the set requires first order derivatives. */ virtual bool requiresFirstOrderDerivatives(size_t i) const { return derivatives_[i] > 0; } /** * @return True if the ith optimizer in the set requires second order derivatives. */ virtual bool requiresSecondOrderDerivatives(size_t i) const { return derivatives_[i] > 1; } /** * @return The number of optimizers in the set. */ virtual size_t getNumberOfOptimizers() const { return optimizers_.size(); } }; /** * @brief Meta-optimizer. * * This optimizer uses a set of optimizers to applyied sequentially on distinct parameters. * The set of optimizers is fully specified by a MetaOptimizerInfos object. * * To decrease the optimization time, the precision of the optimizers can be increased progressively: * if @f$\varepsilon@f$ is the final precision required, one may consider using a precision increment of @f$\sigma=\log_10(\varepsilon/n)@f$, where @f$n@f$ is the number of progressive steps. * During the first step optimization step, the precisions of type 1 and 2 optimizers are set to @f$10^{\sigma}@f$, @f$10^{2\sigma}@f$ for step 2, ... until precision @f$10^{n\sigma}=\varepsilon@f$ at step @f$n@f$ and later. * This saves some time spending in the first steps of the estimation. * The number of steps @f$n@f$ is set in the constructor of the optimizer. * * This optimizer can be used with numerical derivatives. * * @see MetaOptimizerInfos. */ class MetaOptimizer: public AbstractOptimizer { private: MetaOptimizerInfos* optDesc_; std::vector optParameters_; std::vector nbParameters_; unsigned int n_; double precisionStep_; unsigned int stepCount_; double initialValue_; public: /** * @brief Build a new MetaOptimizer object. * * @param function The function to be optimized. * @param desc A MetaOptimizerInfos object describing the optimizers to use. * The optimizer will own the instance of the MetaOptimizerInfos object. * @param n The number of progressive steps to use in optimization). */ MetaOptimizer(Function* function, MetaOptimizerInfos* desc, unsigned int n = 1); virtual ~MetaOptimizer(); MetaOptimizer(const MetaOptimizer& opt); MetaOptimizer& operator=(const MetaOptimizer& opt); MetaOptimizer* clone() const { return new MetaOptimizer(*this); } public: void setFunction(Function* function) { AbstractOptimizer::setFunction(function); for(unsigned int i = 0; i < optDesc_->getNumberOfOptimizers(); i++) optDesc_->getOptimizer(i)->setFunction(function); } void doInit(const ParameterList& parameters) throw (Exception); double doStep() throw (Exception); /** * @return The MetaOptimizerInfos object associated to this optimizer. */ MetaOptimizerInfos* getOptimizers() { return optDesc_; } /** * @return The MetaOptimizerInfos object associated to this optimizer. */ const MetaOptimizerInfos* getOptimizers() const { return optDesc_; } }; } //end of namespace bpp. #endif //METAOPTIMIZER_H__ bpp-core-2.2.0/src/Bpp/Numeric/Function/SimpleMultiDimensions.h000664 001750 001750 00000006004 12370705300 026050 0ustar00jdutheiljdutheil000000 000000 // // File: SimpleMultiDimensions.h // Created by: Julien Dutheil // Created on: Tue Nov 16 17:51 2004 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _SIMPLEMULTIDIMENSIONS_H_ #define _SIMPLEMULTIDIMENSIONS_H_ #include "AbstractOptimizer.h" #include "BrentOneDimension.h" namespace bpp { /** * @brief This Optimizer is a very simple multi-dimensions optimizer, calling * a one dimensional optimizer on each parameter. * * The one-dimensional optimizer used is BrentOneDimension. * Consider using PowellMultiDimensions optimizer for a more efficient modified version of the algorithm. */ class SimpleMultiDimensions: public AbstractOptimizer { private: size_t nbParams_; BrentOneDimension optimizer_; // One dimensional optimizer. public: SimpleMultiDimensions(Function* function); virtual ~SimpleMultiDimensions() {} SimpleMultiDimensions* clone() const { return new SimpleMultiDimensions(*this); } public: /** * @name The Optimizer interface. * * @{ */ void setFunction(Function * function); /** @} */ void doInit(const ParameterList& params) throw (Exception); double doStep() throw (Exception); /** * @return The optimizer used to optimize each parameter. */ Optimizer& getOneDimensionOptimizer() { return optimizer_; } /** * @return The optimizer used to optimize each parameter. */ const Optimizer& getOneDimensionOptimizer() const { return optimizer_; } }; } //end of namespace bpp. #endif //_SIMPLEMULTIDIMENSIONS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/PowellMultiDimensions.cpp000664 001750 001750 00000013454 12370705300 026423 0ustar00jdutheiljdutheil000000 000000 // // File: PowellMultiDimensions.cpp // Created by: Julien Dutheil // Created on: Mon Nov 17 15:16:45 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "PowellMultiDimensions.h" #include "BrentOneDimension.h" #include "OneDimensionOptimizationTools.h" #include "../NumTools.h" using namespace bpp; /******************************************************************************/ bool PowellMultiDimensions::PMDStopCondition::isToleranceReached() const { callCount_++; if (callCount_ <= burnin_) return false; return getCurrentTolerance() < tolerance_; } double PowellMultiDimensions::PMDStopCondition::getCurrentTolerance() const { // NRC Test for done: const PowellMultiDimensions* pmd = dynamic_cast(optimizer_); double fp = pmd->fp_; double fret = pmd->fret_; return 2.0 * NumTools::abs(fp - fret) / (NumTools::abs(fp) + NumTools::abs(fret)); } /******************************************************************************/ PowellMultiDimensions::PowellMultiDimensions(Function* function) : AbstractOptimizer(function), fp_(0), fret_(0), pt_(), xi_(), ncom_(0), pcom_(), xicom_(), f1dim_(function) { setDefaultStopCondition_(new PMDStopCondition(this)); setStopCondition(*getDefaultStopCondition()); } /******************************************************************************/ void PowellMultiDimensions::doInit(const ParameterList& params) throw (Exception) { // Build the initial matrix: size_t n = params.size(); xi_.resize(n); for (size_t i = 0; i < n; i++) { // Copy the parameter list: xi_[i].resize(n); for(unsigned int j = 0; j < n; j++) { // Set the directions to unit vectors: xi_[i][j] = (j == i) ? 1 : 0; } } // Starting point: fret_ = getFunction()->f(getParameters()); pt_ = getParameters(); } /******************************************************************************/ double PowellMultiDimensions::doStep() throw (Exception) { size_t n = getParameters().size(); fp_ = fret_; unsigned int ibig = 0; double del = 0.0; // Will be the biggest function decrease Vdouble xit(n); // In each iteration, loop over all directions in the set. double fptt; for(unsigned int i = 0; i < n; i++) { // Copy the direction: for(unsigned int j = 0; j < n; j++) { xit[j] = xi_[j][i]; } fptt = fret_; nbEval_ += OneDimensionOptimizationTools::lineMinimization(f1dim_, getParameters_(), xit, getStopCondition()->getTolerance(), 0, getMessageHandler(), getVerbose() > 0 ? getVerbose() - 1 : 0); fret_ = getFunction()->f(getParameters()); if (getVerbose() > 2) printPoint(getParameters(), fret_); if (fret_ > fp_) throw Exception("DEBUG: PowellMultiDimensions::doStep(). Line minimization failed!"); if (fptt - fret_ > del) { del = fptt - fret_; ibig = i; } } ParameterList ptt = getParameters(); for (unsigned int j = 0; j < n; j++) { ptt[j].setValue(2.0 * getParameters()[j].getValue() - pt_[j].getValue()); xit[j] = getParameters()[j].getValue() - pt_[j].getValue(); pt_[j].setValue(getParameters()[j].getValue()); } fptt = getFunction()->f(ptt); if (fptt < fp_) { double t = 2.0 * (fp_ - 2.0 * fret_ + fptt) * NumTools::sqr(fp_ - fret_ - del) - del * NumTools::sqr(fp_ - fptt); if (t < 0.0) { //cout << endl << "New direction: drection " << ibig << " removed." << endl; nbEval_ += OneDimensionOptimizationTools::lineMinimization(f1dim_, getParameters_(), xit, getStopCondition()->getTolerance(), 0, getMessageHandler(), getVerbose() > 0 ? getVerbose() - 1 : 0); fret_ = getFunction()->f(getParameters()); if (fret_ > fp_) throw Exception("DEBUG: PowellMultiDimensions::doStep(). Line minimization failed!"); for (unsigned int j = 0; j < n; j++) { xi_[j][ibig] = xi_[j][n - 1]; xi_[j][n - 1] = xit[j]; } } } else getFunction()->setParameters(getParameters()); return fret_; } /******************************************************************************/ double PowellMultiDimensions::optimize() throw (Exception) { AbstractOptimizer::optimize(); // Apply best parameter: return getFunction()->f(getParameters()); } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/SimpleNewtonMultiDimensions.h000664 001750 001750 00000005737 12370705300 027257 0ustar00jdutheiljdutheil000000 000000 // // File: SimpleNewtonMultiDimensions.h // Created by: Julien Dutheil // Created on: Thu Apr 26 15:29 2007 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _SIMPLENEWTONMULTIDIMENSIONS_H_ #define _SIMPLENEWTONMULTIDIMENSIONS_H_ #include "AbstractOptimizer.h" #include "NewtonOneDimension.h" namespace bpp { /** * @brief This Optimizer is a simple multi-dimensions optimizer, calling * the Newton one dimensional optimizer on each parameter. * * The one-dimensional optimizer used is NewtonOneDimension. */ class SimpleNewtonMultiDimensions: public AbstractOptimizer { private: size_t nbParams_; NewtonOneDimension optimizer_; // One dimensional optimizer. public: SimpleNewtonMultiDimensions(DerivableSecondOrder* function); virtual ~SimpleNewtonMultiDimensions() {}; SimpleNewtonMultiDimensions* clone() const { return new SimpleNewtonMultiDimensions(*this); } public: /** * @name The Optimizer interface. * * @{ */ void setFunction(Function* function); /** @} */ void doInit(const ParameterList& params) throw (Exception); double doStep() throw (Exception); /** * @return The optimizer used to optimize each parameter. */ Optimizer& getOneDimensionOptimizer() { return optimizer_; } /** * @return The optimizer used to optimize each parameter. */ const Optimizer& getOneDimensionOptimizer() const { return optimizer_; } }; } //end of namespace bpp. #endif //_SIMPLENEWTONMULTIDIMENSIONS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/ConjugateGradientMultiDimensions.cpp000664 001750 001750 00000010253 12370705300 030550 0ustar00jdutheiljdutheil000000 000000 // // File: ConjugateGradientMultiDimensions.cpp // Created by: Julien Dutheil // Created on: Wed Apr 11 16:51 2007 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "ConjugateGradientMultiDimensions.h" #include "OneDimensionOptimizationTools.h" using namespace bpp; /******************************************************************************/ ConjugateGradientMultiDimensions::ConjugateGradientMultiDimensions(DerivableFirstOrder* function): AbstractOptimizer(function), optimizer_(function), xi_(), h_(), g_(), f1dim_(function) { setDefaultStopCondition_(new FunctionStopCondition(this)); setStopCondition(*getDefaultStopCondition()); } /******************************************************************************/ void ConjugateGradientMultiDimensions::doInit(const ParameterList & params) throw (Exception) { size_t nbParams = params.size(); g_.resize(nbParams); h_.resize(nbParams); xi_.resize(nbParams); getFunction_()->enableFirstOrderDerivatives(true); getFunction_()->setParameters(params); getGradient(xi_); for(size_t i = 0; i < nbParams; i++) { g_[i] = -xi_[i]; xi_[i] = h_[i] = g_[i]; } } /******************************************************************************/ double ConjugateGradientMultiDimensions::doStep() throw (Exception) { double gg, gam, f, dgg; size_t n = getParameters().size(); //Loop over iterations. getFunction_()->enableFirstOrderDerivatives(false); nbEval_ += OneDimensionOptimizationTools::lineMinimization(f1dim_, getParameters_(), xi_, getStopCondition()->getTolerance(), 0, 0, getVerbose() > 0 ? getVerbose() - 1 : 0); getFunction_()->enableFirstOrderDerivatives(true); f = getFunction()->f(getParameters()); if (tolIsReached_) { return f; } getGradient(xi_); dgg = gg = 0.0; for (unsigned j = 0; j < n; j++) { gg += g_[j] * g_[j]; /* dgg += xi[j] * xi[j]; */ //This statement for Fletcher-Reeves. dgg += (xi_[j] + g_[j]) * xi_[j]; //This statement for Polak-Ribiere. } if (gg == 0.0) { //Unlikely. If gradient is exactly zero then return f; } gam = dgg / gg; if (!(std::isnan(gam) || std::isinf(gam))) { for(unsigned int j = 0; j < n; j++) { g_[j] = -xi_[j]; xi_[j] = h_[j] = g_[j] + gam * h_[j]; } } return f; } /******************************************************************************/ void ConjugateGradientMultiDimensions::getGradient(std::vector& gradient) const { for (size_t i = 0; i < gradient.size(); ++i) { gradient[i] = getFunction()->getFirstOrderDerivative(getParameters()[i].getName()); } } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/AbstractOptimizer.cpp000664 001750 001750 00000025754 12370705300 025571 0ustar00jdutheiljdutheil000000 000000 // // File: AbstractOptimizer.cpp // Created by: Julien Dutheil // Created on: Mon Dec 22 12:18:09 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "AbstractOptimizer.h" #include "../AutoParameter.h" #include "../../Text/TextTools.h" #include "../../App/ApplicationTools.h" // From the STL: #include #include using namespace std; using namespace bpp; /******************************************************************************/ AbstractOptimizer::AbstractOptimizer(Function* function): function_(function), parameters_(), messageHandler_(ApplicationTools::message), profiler_(ApplicationTools::message), constraintPolicy_(AutoParameter::CONSTRAINTS_KEEP), stopCondition_(0), defaultStopCondition_(0), verbose_(true), isInitialized_(false), startTime_(), listeners_(), updateParameters_(false), stepChar_("*"), nbEvalMax_(1000000), nbEval_(0), currentValue_(0), tolIsReached_(false) { } /******************************************************************************/ AbstractOptimizer::AbstractOptimizer(const AbstractOptimizer& opt): function_(opt.function_), parameters_(opt.parameters_), messageHandler_(opt.messageHandler_), profiler_(opt.profiler_), constraintPolicy_(opt.constraintPolicy_), stopCondition_(0), defaultStopCondition_(0), verbose_(opt.verbose_), isInitialized_(opt.isInitialized_), startTime_(opt.startTime_), listeners_(), //We do not copy listeners! updateParameters_(opt.updateParameters_), stepChar_(opt.stepChar_), nbEvalMax_(opt.nbEvalMax_), nbEval_(opt.nbEval_), currentValue_(opt.currentValue_), tolIsReached_(opt.tolIsReached_) { if (opt.stopCondition_) { stopCondition_ = dynamic_cast(opt.stopCondition_->clone()); stopCondition_->setOptimizer(this); } else stopCondition_ = 0; if (opt.defaultStopCondition_) { defaultStopCondition_ = dynamic_cast(opt.defaultStopCondition_->clone()); defaultStopCondition_->setOptimizer(this); } else defaultStopCondition_ = 0; //In case of AutoParameter instances, we must actualize the pointers toward _messageHandler: if (isInitialized_) { if(constraintPolicy_ == AutoParameter::CONSTRAINTS_AUTO) autoParameter(); else if(constraintPolicy_ == AutoParameter::CONSTRAINTS_IGNORE) ignoreConstraints(); } } /******************************************************************************/ AbstractOptimizer& AbstractOptimizer::operator=(const AbstractOptimizer& opt) { function_ = opt.function_; parameters_ = opt.parameters_; messageHandler_ = opt.messageHandler_; profiler_ = opt.profiler_; constraintPolicy_ = opt.constraintPolicy_; tolIsReached_ = opt.tolIsReached_; if (opt.stopCondition_) { stopCondition_ = dynamic_cast(opt.stopCondition_->clone()); stopCondition_->setOptimizer(this); } else stopCondition_ = 0; if (opt.defaultStopCondition_) { defaultStopCondition_ = dynamic_cast(opt.defaultStopCondition_->clone()); defaultStopCondition_->setOptimizer(this); } else defaultStopCondition_ = 0; nbEvalMax_ = opt.nbEvalMax_; nbEval_ = opt.nbEval_; verbose_ = opt.verbose_; isInitialized_ = opt.isInitialized_; //In case of AutoParameter instances, we must actualize the pointers toward messageHandler_: if (isInitialized_) { if (constraintPolicy_ == AutoParameter::CONSTRAINTS_AUTO) autoParameter(); else if (constraintPolicy_ == AutoParameter::CONSTRAINTS_IGNORE) ignoreConstraints(); } startTime_ = opt.startTime_; listeners_.resize(0); //Reset listener list, do not copy it! updateParameters_ = opt.updateParameters_; stepChar_ = opt.stepChar_; return *this; } /******************************************************************************/ void AbstractOptimizer::init(const ParameterList& params) throw (Exception) { if (!function_) throw Exception("AbstractOptimizer::init. Optimizer currently has no function."); //We do this in order to keep original constraints: parameters_ = params; //More secure, but too slow: //parameters_ = function_->getParameters().subList(params.getParameterNames()); //parameters_.matchParametersValues(params); if (constraintPolicy_ == AutoParameter::CONSTRAINTS_AUTO) autoParameter(); else if (constraintPolicy_ == AutoParameter::CONSTRAINTS_IGNORE) ignoreConstraints(); doInit(params); nbEval_ = 0; tolIsReached_ = false; isInitialized_ = true; time(&startTime_); currentValue_ = function_->getValue(); profile("Step\t"); for (unsigned int i = 0; i < parameters_.size(); i++) { profile(parameters_[i].getName() + "\t"); } profileln("Function\tTime"); //Parameters must be assigned by doInit: printPoint(parameters_, currentValue_); // Initialize the StopCondition: stopCondition_->init(); fireOptimizationInitializationPerformed(OptimizationEvent(this)); } /******************************************************************************/ double AbstractOptimizer::step() throw (Exception) { currentValue_ = doStep(); printPoint(parameters_, currentValue_); fireOptimizationStepPerformed(OptimizationEvent(this)); if (listenerModifiesParameters()) { if (!updateParameters_) parameters_.matchParametersValues(function_->getParameters()); //else already done! //_currentValue = function_->getValue(); //Often useless, but avoid some bizare behaviour in particular cases: currentValue_ = function_->f(parameters_); } tolIsReached_ = tolIsReached_ || stopCondition_->isToleranceReached(); return currentValue_; } /**************************************************************************/ double AbstractOptimizer::optimize() throw (Exception) { if (!isInitialized_) throw Exception("AbstractOptimizer::optimize. Optimizer not initialized: call the 'init' method first!"); tolIsReached_ = false; for (nbEval_ = 1; nbEval_ < nbEvalMax_ && ! tolIsReached_; nbEval_++) { if (verbose_) ApplicationTools::displayUnlimitedGauge(nbEval_, "Optimizing... "); step(); } return currentValue_; } /******************************************************************************/ void AbstractOptimizer::profile(double v) { if (profiler_) *profiler_ << v; } /******************************************************************************/ void AbstractOptimizer::profileln(double v) { if (profiler_) (*profiler_ << v).endLine(); } /******************************************************************************/ void AbstractOptimizer::profile(unsigned int v) { if (profiler_) *profiler_ << v; } /******************************************************************************/ void AbstractOptimizer::profileln(unsigned int v) { if (profiler_) (*profiler_ << v).endLine(); } /******************************************************************************/ void AbstractOptimizer::profile(const std::string& s) { if (profiler_) *profiler_ << s; } /******************************************************************************/ void AbstractOptimizer::profileln(const std::string& s) { if (profiler_) (*profiler_ << s).endLine(); } /******************************************************************************/ void AbstractOptimizer::printPoint(const ParameterList& params, double value) { size_t ndim = params.size(); profile(nbEval_); profile("\t"); for (size_t j = 0; j < ndim; j++) { profile(TextTools::toString(params[j].getValue())); profile("\t"); } profile(value); profile("\t"); time_t seconds; time(&seconds); profileln(difftime(seconds, startTime_)); } /******************************************************************************/ void AbstractOptimizer::printMessage(const std::string& message) { if (messageHandler_) (*messageHandler_ << message).endLine(); } /******************************************************************************/ void AbstractOptimizer::autoParameter() { for (unsigned int i = 0; i < parameters_.size(); i++) { AutoParameter ap(parameters_[i]); ap.setMessageHandler(messageHandler_); parameters_.setParameter(i, ap); } } /******************************************************************************/ void AbstractOptimizer::ignoreConstraints() { for (unsigned int i = 0; i < parameters_.size(); i++) { parameters_[i].removeConstraint(); } } /******************************************************************************/ void AbstractOptimizer::fireOptimizationInitializationPerformed(const OptimizationEvent& event) { for (unsigned int i = 0; i < listeners_.size(); i++) { listeners_[i]->optimizationInitializationPerformed(event); } } /******************************************************************************/ void AbstractOptimizer::fireOptimizationStepPerformed(const OptimizationEvent& event) { for (unsigned int i = 0; i < listeners_.size(); i++) { listeners_[i]->optimizationStepPerformed(event); } } /******************************************************************************/ bool AbstractOptimizer::listenerModifiesParameters() const { for (unsigned int i = 0; i < listeners_.size(); i++) { if (listeners_[i]->listenerModifiesParameters()) return true; } return false; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/FivePointsNumericalDerivative.cpp000664 001750 001750 00000012200 12370705300 030052 0ustar00jdutheiljdutheil000000 000000 // // File: FivePointsNumericalDerivative.cpp // Created by: Julien Dutheil // Created on: Thu Aug 17 15:00 2006 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "FivePointsNumericalDerivative.h" using namespace bpp; using namespace std; void FivePointsNumericalDerivative::updateDerivatives(const ParameterList parameters) throw (ParameterNotFoundException, ConstraintException) { if (computeD1_ && variables_.size() > 0) { if (function1_) function1_->enableFirstOrderDerivatives(false); if (function2_) function2_->enableSecondOrderDerivatives(false); function_->setParameters(parameters); f3_ = function_->getValue(); string lastVar; bool functionChanged = false; ParameterList p; bool start = true; for (unsigned int i = 0; i < variables_.size(); i++) { string var = variables_[i]; if (!parameters.hasParameter(var)) continue; if (!start) { vector vars(2); vars[0] = var; vars[1] = lastVar; p = parameters.subList(vars); } else { p = parameters.subList(var); start = true; } lastVar = var; functionChanged = true; double value = function_->getParameterValue(var); double h = (1. + std::abs(value)) * h_; // Compute four other points: try { p[0].setValue(value - 2 * h); function_->setParameters(p); f1_ = function_->getValue(); try { p[0].setValue(value + 2 * h); function_->setParameters(p); f5_ = function_->getValue(); // No limit raised, use central approximation: p[0].setValue(value - h); function_->setParameters(p); f2_ = function_->getValue(); p[0].setValue(value + h); function_->setParameters(p); f4_ = function_->getValue(); der1_[i] = (f1_ - 8. * f2_ + 8. * f4_ - f5_) / (12. * h); der2_[i] = (-f1_ + 16. * f2_ - 30. * f3_ + 16. * f4_ - f5_) / (12. * h * h); } catch (ConstraintException& ce) { // Right limit raised, use backward approximation: p[0].setValue(value - h); function_->setParameters(p); f2_ = function_->getValue(); p[0].setValue(value - 2 * h); function_->setParameters(p); f1_ = function_->getValue(); der1_[i] = (f3_ - f2_) / h; der2_[i] = (f3_ - 2. * f2_ + f1_) / (h * h); } } catch (ConstraintException& ce) { // Left limit raised, use forward approximation: p[0].setValue(value + h); function_->setParameters(p); f4_ = function_->getValue(); p[0].setValue(value + 2 * h); function_->setParameters(p); f5_ = function_->getValue(); der1_[i] = (f4_ - f3_) / h; der2_[i] = (f5_ - 2. * f4_ + f3_) / (h * h); } } // Reset last parameter and compute analytical derivatives if any. if (function1_) function1_->enableFirstOrderDerivatives(computeD1_); if (function2_) function2_->enableSecondOrderDerivatives(computeD2_); if (functionChanged) function_->setParameters(parameters.subList(lastVar)); } else { // Reset initial value and compute analytical derivatives if any. if (function1_) function1_->enableFirstOrderDerivatives(computeD1_); if (function2_) function2_->enableSecondOrderDerivatives(computeD2_); function_->setParameters(parameters); // Just in case derivatives are not computed: f3_ = function_->getValue(); } } bpp-core-2.2.0/src/Bpp/Numeric/Function/GoldenSectionSearch.cpp000664 001750 001750 00000014550 12370705300 025776 0ustar00jdutheiljdutheil000000 000000 // // File: GoldenSectionSearch.cpp // Created by: Julien Dutheil // Created on: Mon Nov 10 10:42:17 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "GoldenSectionSearch.h" #include "OneDimensionOptimizationTools.h" #include "../NumTools.h" #include "../NumConstants.h" #include "../../Text/TextTools.h" using namespace bpp; /******************************************************************************/ bool GoldenSectionSearch::GSSStopCondition::isToleranceReached() const { callCount_++; if (callCount_ <= burnin_) return false; return getTolerance() <= tolerance_; } /******************************************************************************/ double GoldenSectionSearch::GSSStopCondition::getCurrentTolerance() const { // NRC Test for done: const GoldenSectionSearch* gss = dynamic_cast(optimizer_); return NumTools::abs(gss->x3 - gss->x0) / (NumTools::abs(gss->x1) + NumTools::abs(gss->x2)); } /******************************************************************************/ GoldenSectionSearch::GoldenSectionSearch(Function* function) : AbstractOptimizer(function), f1(0), f2(0), x0(0), x1(0), x2(0), x3(0), xinf_(0), xsup_(0), isInitialIntervalSet_(false) { nbEvalMax_ = 10000; setDefaultStopCondition_(new GSSStopCondition(this)); setStopCondition(*getDefaultStopCondition()); } /******************************************************************************/ void GoldenSectionSearch::doInit(const ParameterList& params) throw (Exception) { // Set the initial value (no use here! Use setInitialValues() instead). if(params.size() != 1) throw Exception("GoldenSectionSearch::init(). This optimizer only deals with one parameter."); // Bracket the minimum. Bracket bracket = OneDimensionOptimizationTools::bracketMinimum(xinf_, xsup_, getFunction(), getParameters()); if (getVerbose() > 0) { printMessage("Initial bracketing:"); printMessage("A: x = " + TextTools::toString(bracket.a.x) + ", f = " + TextTools::toString(bracket.a.f)); printMessage("B: x = " + TextTools::toString(bracket.b.x) + ", f = " + TextTools::toString(bracket.b.f)); printMessage("C: x = " + TextTools::toString(bracket.c.x) + ", f = " + TextTools::toString(bracket.c.f)); } // At any given time we will keep track of four points, x0, x1, x2 and x3. x0 = bracket.a.x; x3 = bracket.c.x; if (NumTools::abs(bracket.c.x - bracket.b.x) > NumTools::abs(bracket.b.x - bracket.a.x)) { // Make x0 to x1 the smaller segment, x1 = bracket.b.x; // and fill in the new point to be tried. x2 = bracket.b.x + NumConstants::GOLDEN_RATIO_C() * (bracket.c.x - bracket.b.x); } else { x2 = bracket.b.x; x1 = bracket.b.x - NumConstants::GOLDEN_RATIO_C() * (bracket.b.x - bracket.a.x); } // The initial function evaluations. // Note that we never need to evaluate the function at the original endpoints. getParameter_(0).setValue(x1); f1 = getFunction()->f(getParameters()); getParameter_(0).setValue(x2); f2 = getFunction()->f(getParameters()); } /******************************************************************************/ void GoldenSectionSearch::setInitialInterval(double inf, double sup) { if(sup > inf) { xinf_ = inf; xsup_ = sup; } else { xinf_ = sup; xsup_ = inf; } isInitialIntervalSet_ = true; } /******************************************************************************/ double GoldenSectionSearch::doStep() throw (Exception) { if (!isInitialIntervalSet_) throw Exception("GoldenSectionSearch::step. Initial interval not set: call the 'setInitialInterval' method first!"); nbEval_++; if (f2 < f1) { // One possible outcome, its housekeeping, NumTools::shift(x0, x1, x2); x2 = NumConstants::GOLDEN_RATIO_R() * x1 + NumConstants::GOLDEN_RATIO_C() * x3; // and a new function evaluation. getParameter_(0).setValue(x2); tolIsReached_ = nbEval_ > 2 && getStopCondition()->isToleranceReached(); NumTools::shift(f1, f2, getFunction()->f(getParameters())); return f2; } else { // The other outcome, NumTools::shift(x3, x2, x1); x1 = NumConstants::GOLDEN_RATIO_R() * x2 + NumConstants::GOLDEN_RATIO_C() * x0; // and its new function evaluation. getParameter_(0).setValue(x1); tolIsReached_ = nbEval_ > 2 && getStopCondition()->isToleranceReached(); NumTools::shift(f2, f1, getFunction()->f(getParameters())); return f1; } } /******************************************************************************/ double GoldenSectionSearch::getFunctionValue() const throw (NullPointerException) { if (!hasFunction()) throw NullPointerException("GoldenSectionSearch::getFunctionValue. No function associated to this optimizer."); //return NumTools::min(f1, f2); return currentValue_; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/Functions.h000664 001750 001750 00000047204 12370705300 023532 0ustar00jdutheiljdutheil000000 000000 // // File: Functions.h // Created by: Julien Dutheil // Created on: Sun Nov 9 23:11:00 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _FUNCTIONS_H_ #define _FUNCTIONS_H_ #include "../ParameterList.h" #include "../Parametrizable.h" #include "../AbstractParametrizable.h" #include "../ParameterExceptions.h" // From Utils: #include "../../Clonable.h" #include "../../Exceptions.h" // From the STL: #include namespace bpp { /** * @brief This is the function abstract class. * * This class provides the interface for function objet * and a default implementation of the f() function. * * The f() function sends the value of the function according to a * given set of parameters. * * However for complexe function like likelihood for instance, * computing the function value takes some time, and one do not want * to perform several times the computation for an identical set of * parameters. * The setParameters() method hence allows to set the parameter value * for which the function is to be computed, perform the computation * and store the results. * The getValue() methods send the result of the computation. * One may hence access to the result of the computation by calling the * getvalue() method without re-computating the function. * The f(parameters) function is a shortcut for * @code * setParameters(parameters); * return getValue(); * @endcode * for convinience. * * @see Parameter, ParameterList */ class Function: public virtual Parametrizable { public: Function() {} virtual ~Function() {} public: /** * @brief Set the point where the function must be computed. * * @param parameters The parameter set to pass to the function. */ virtual void setParameters(const ParameterList& parameters) throw (ParameterNotFoundException, ConstraintException, Exception) = 0; /** * @brief Get the value of the function at the current point. * * @return The value of the function. * @throw Exception If no point is specified or if an error occured. */ virtual double getValue() const throw (Exception) = 0; /** * @brief Get the value of the function according to a given set of parameters. * * @param parameters The parameter set to pass to the function. * @return The value of the function with the given parameter set. * @throw Exception If an error occured. */ virtual double f(const ParameterList& parameters) throw (Exception) { setParameters(parameters); return getValue(); } }; /** * @brief This is the abstract class for first order derivable functions. * * This class adds the getFirstOrderDerivative() and df() shortcut functions. */ class DerivableFirstOrder: public virtual Function { public: DerivableFirstOrder() {} virtual ~DerivableFirstOrder() {} #if defined(NO_VIRTUAL_COV) Clonable* clone() const = 0; #else DerivableFirstOrder* clone() const = 0; #endif public: /** * @brief Tell if derivatives must be computed. * * @param yn yes/no */ virtual void enableFirstOrderDerivatives(bool yn) = 0; /** * @brief Tell if derivatives must be computed. * * @return yes/no */ virtual bool enableFirstOrderDerivatives() const = 0; /** * @brief Get the derivative of the function at the current point. * * @param variable The name of the @f$ x @f$ variable in @f$ \frac{df}{dx} @f$. * @return The value of the function. * @throw Exception If no point is specified or if an error occured. */ virtual double getFirstOrderDerivative(const std::string& variable) const throw (Exception) = 0; /** * @brief Get the value of the first derivative of the function * according to a given set of parameters. * * @param variable The name of the @f$ x @f$ variable in @f$ \frac{df}{dx} @f$. * @param parameters The parameter set to pass to the function. * @return The value of the function with the given parameter set. * @throw Exception If an error occured. */ virtual double df(const std::string& variable, const ParameterList& parameters) throw (Exception) { setParameters(parameters); return getFirstOrderDerivative(variable); } }; /** * @brief This is the abstract class for second order derivable functions. * * This class adds the getSecondOrderDerivative() and d2f() shortcut functions. * Cross derivative functions are also provided. */ class DerivableSecondOrder: public virtual DerivableFirstOrder { public: DerivableSecondOrder() {} virtual ~DerivableSecondOrder() {} #if defined(NO_VIRTUAL_COV) Clonable* clone() const = 0; #else DerivableSecondOrder* clone() const = 0; #endif public: /** * @brief Tell if derivatives must be computed. * * @param yn yes/no */ virtual void enableSecondOrderDerivatives(bool yn) = 0; /** * @brief Tell if derivatives must be computed. * * @return yes/no */ virtual bool enableSecondOrderDerivatives() const = 0; /** * @brief Get the second order derivative of the function at the current point. * * @param variable The name of the @f$ x @f$ variable in @f$ \frac{\partial^2 f}{\partial x^2} @f$. * @return The value of the function. * @throw Exception If no point is specified or if an error occured. */ virtual double getSecondOrderDerivative(const std::string& variable) const throw (Exception) = 0; /** * @brief Get the value of the second order derivative of the function * according to a given set of parameters. * * @param variable The name of the @f$ x @f$ variable in @f$ \frac{\partial^2 f}{\partial x^2} @f$. * @param parameters The parameter set to pass to the function. * @return The value of the function with the given parameter set. * @throw Exception If an error occured. */ virtual double d2f(const std::string& variable, const ParameterList& parameters) throw (Exception) { setParameters(parameters); return getSecondOrderDerivative(variable); } /** * @brief Get the value of the cross derivative of the function * according to a given set of parameters. * * @param variable1 The name of the @f$ x @f$ variable in @f$ \frac{\partial^2 f}{\partial x \partial y} @f$. * @param variable2 The name of the @f$ y @f$ variable in @f$ \frac{\partial^2 f}{\partial x \partial y} @f$. * @return The value of the function with the given parameter set. * @throw Exception If an error occured. */ virtual double getSecondOrderDerivative(const std::string& variable1, const std::string& variable2) const throw (Exception) = 0; /** * @brief Get the value of the cross derivative of the function * according to a given set of parameters. * * @param variable1 The name of the @f$ x @f$ variable in @f$ \frac{\partial^2 f}{\partial x \partial y} @f$. * @param variable2 The name of the @f$ y @f$ variable in @f$ \frac{\partial^2 f}{\partial x \partial y} @f$. * @param parameters The parameter set to pass to the function. * @return The value of the function with the given parameter set. * @throw Exception If an error occured. */ virtual double d2f(const std::string& variable1, const std::string& variable2, const ParameterList& parameters) throw (Exception) { setParameters(parameters); return getSecondOrderDerivative(variable1, variable2); } }; /** * @brief General class that wraps a function into another one. * This class is meant to be derivated and just provides a general framework. */ class FunctionWrapper: public virtual Function { protected: Function* function_; public: FunctionWrapper(Function* function) : function_(function) {} FunctionWrapper(const FunctionWrapper& fw) : function_(fw.function_) {} FunctionWrapper& operator=(const FunctionWrapper& fw) { function_ = fw.function_; return *this; } public: bool hasParameter(const std::string& name) const { return function_->hasParameter(name); } void setParameters(const ParameterList & parameters) throw (ParameterNotFoundException, ConstraintException) { function_->setParameters(parameters); } const ParameterList& getParameters() const throw (Exception) { return function_->getParameters(); } const Parameter& getParameter(const std::string & name) const throw (ParameterNotFoundException) { return function_->getParameter(name); } double getValue() const throw (Exception) { return function_->getValue(); } double f(const ParameterList& parameters) throw (Exception) { return function_->f(parameters); } double getParameterValue(const std::string& name) const throw (ParameterNotFoundException) { return function_->getParameterValue(name); } void setAllParametersValues(const ParameterList & parameters) throw (ParameterNotFoundException, ConstraintException) { function_->setAllParametersValues(parameters); } void setParameterValue(const std::string& name, double value) throw (ParameterNotFoundException, ConstraintException) { function_->setParameterValue(name, value); } void setParametersValues(const ParameterList& parameters) throw (ParameterNotFoundException, ConstraintException) { function_->setParametersValues(parameters); } bool matchParametersValues(const ParameterList& parameters) throw (ConstraintException) { return function_->matchParametersValues(parameters); } size_t getNumberOfParameters() const { return function_->getNumberOfParameters(); } void setNamespace(const std::string& prefix) { function_->setNamespace(prefix); } std::string getNamespace() const { return function_->getNamespace(); } std::string getParameterNameWithoutNamespace(const std::string& name) const { return function_->getParameterNameWithoutNamespace(name); } }; /** * @brief General class that wraps a function into another one. * This class is meant to be derivated and just provides a general framework. */ class DerivableFirstOrderWrapper: public FunctionWrapper, public virtual DerivableFirstOrder { public: DerivableFirstOrderWrapper(DerivableFirstOrder* function) : FunctionWrapper(function) {} public: void enableFirstOrderDerivatives(bool yn) { dynamic_cast(function_)->enableFirstOrderDerivatives(yn); } bool enableFirstOrderDerivatives() const { return dynamic_cast(function_)->enableFirstOrderDerivatives(); } double getFirstOrderDerivative(const std::string& variable) const throw (Exception) { return dynamic_cast(function_)->getFirstOrderDerivative(variable); } }; /** * @brief General class that wraps a function into another one. * This class is meant to be derivated and just provides a general framework. */ class DerivableSecondOrderWrapper: public DerivableFirstOrderWrapper, public virtual DerivableSecondOrder { public: DerivableSecondOrderWrapper(DerivableSecondOrder* function) : DerivableFirstOrderWrapper(function) {} public: void enableSecondOrderDerivatives(bool yn) { dynamic_cast(function_)->enableSecondOrderDerivatives(yn); } bool enableSecondOrderDerivatives() const { return dynamic_cast(function_)->enableSecondOrderDerivatives(); } double getSecondOrderDerivative(const std::string& variable) const throw (Exception) { return dynamic_cast(function_)->getSecondOrderDerivative(variable); } double getSecondOrderDerivative(const std::string& variable1, const std::string& variable2) const throw (Exception) { return dynamic_cast(function_)->getSecondOrderDerivative(variable1, variable2); } }; /** * @brief Wrapper class for optimization under constraints. * * Catch any ConstraintException thrown and send +inf. */ class InfinityFunctionWrapper: public FunctionWrapper { protected: mutable bool constraintMatch_; public: InfinityFunctionWrapper(Function* function) : FunctionWrapper(function), constraintMatch_(false) {} virtual ~InfinityFunctionWrapper() {} #if defined(NO_VIRTUAL_COV) Clonable* clone() const { return new InfinityFunctionWrapper(*this); } #else InfinityFunctionWrapper* clone() const { return new InfinityFunctionWrapper(*this); } #endif public: void setParameters(const ParameterList& parameters) throw (ParameterNotFoundException, ConstraintException) { try { function_->setParameters(parameters); constraintMatch_ = false; } catch(ConstraintException& ce) { constraintMatch_ = true; } } double getValue() const throw (Exception) { return constraintMatch_ ? -log(0.) : function_->getValue(); } double f(const ParameterList& parameters) throw (Exception) { setParameters(parameters); return getValue(); } void setAllParametersValues(const ParameterList & parameters) throw (ParameterNotFoundException, ConstraintException) { try { function_->setAllParametersValues(parameters); constraintMatch_ = false; } catch(ConstraintException& ce) { constraintMatch_ = true; } } void setParameterValue(const std::string& name, double value) throw (ParameterNotFoundException, ConstraintException) { try { function_->setParameterValue(name, value); constraintMatch_ = false; } catch(ConstraintException& ce) { constraintMatch_ = true; } } void setParametersValues(const ParameterList& parameters) throw (ParameterNotFoundException, ConstraintException) { try { function_->setParametersValues(parameters); constraintMatch_ = false; } catch(ConstraintException& ce) { constraintMatch_ = true; } } bool matchParametersValues(const ParameterList& parameters) throw (ConstraintException) { try { bool test = function_->matchParametersValues(parameters); constraintMatch_ = false; return test; } catch (ConstraintException& ce) { constraintMatch_ = true; return false; } } }; /** * @brief Wrapper class for optimization under constraints. * * Catch any ConstraintException thrown and send +inf. */ class InfinityDerivableFirstOrderWrapper : public virtual InfinityFunctionWrapper { public: InfinityDerivableFirstOrderWrapper(DerivableFirstOrder* function) : InfinityFunctionWrapper(function) {} virtual ~InfinityDerivableFirstOrderWrapper() {} #if defined(NO_VIRTUAL_COV) Clonable* clone() const { return new InfinityDerivableFirstOrderWrapper(*this); } #else InfinityDerivableFirstOrderWrapper* clone() const { return new InfinityDerivableFirstOrderWrapper(*this); } #endif public: double getFirstOrderDerivative(const std::string& variable) const throw (Exception) { return constraintMatch_ ? -log(0.) : (dynamic_cast(function_)->getFirstOrderDerivative(variable)); } double df(const std::string& variable, const ParameterList& parameters) throw (Exception) { setParameters(parameters); return getFirstOrderDerivative(variable); } }; /** * @brief Wrapper class for optimization under constraints. * * Catch any ConstraintException thrown and send +inf. */ class InfinityDerivableSecondOrderWrapper : public virtual InfinityDerivableFirstOrderWrapper { public: InfinityDerivableSecondOrderWrapper(DerivableFirstOrder* function): InfinityFunctionWrapper(function), InfinityDerivableFirstOrderWrapper(function) {} virtual ~InfinityDerivableSecondOrderWrapper() {} #if defined(NO_VIRTUAL_COV) Clonable* clone() const { return new InfinityDerivableSecondOrderWrapper(*this); } #else InfinityDerivableSecondOrderWrapper* clone() const { return new InfinityDerivableSecondOrderWrapper(*this); } #endif public: double getSecondOrderDerivative(const std::string& variable) const throw (Exception) { return constraintMatch_ ? -log(0.) : (dynamic_cast(function_)->getSecondOrderDerivative(variable)); } double d2f(const std::string & variable, const ParameterList& parameters) throw (Exception) { setParameters(parameters); return getSecondOrderDerivative(variable); } double getSecondOrderDerivative(const std::string& variable1, const std::string& variable2) const throw (Exception) { return constraintMatch_ ? -log(0.) : (dynamic_cast(function_)->getSecondOrderDerivative(variable1, variable2)); } double d2f(const std::string & variable1, const std::string& variable2, const ParameterList& parameters) throw (Exception) { setParameters(parameters); return getSecondOrderDerivative(variable1, variable2); } }; /** * @brief A simple funciton with two parameters, mostly for testing and debugging :) * * @author Julien Dutheil. */ class TestFunction : public virtual Function, public AbstractParametrizable { public: TestFunction(double x = 0, double y = 0) : AbstractParametrizable("") { addParameter_(new Parameter("x", x)); addParameter_(new Parameter("y", y)); } Clonable* clone() const { return new TestFunction(*this); } void setParameters(const ParameterList& parameters) throw (Exception) { matchParametersValues(parameters); } double getValue() const throw (Exception) { double x = getParameter("x").getValue(); double y = getParameter("y").getValue(); return (x*x + y*y); } void fireParameterChanged(const ParameterList& parameters) {} }; } //end of namespace bpp. #endif //_FUNCTIONS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/BrentOneDimension.cpp000664 001750 001750 00000015515 12370705300 025477 0ustar00jdutheiljdutheil000000 000000 // // File: BrentOneDimension.cpp // Created by: Julien Dutheil // Created on: Mon Nov 17 11:45:58 2003 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "BrentOneDimension.h" #include "OneDimensionOptimizationTools.h" #include "../NumTools.h" #include "../NumConstants.h" #include "../../Text/TextTools.h" using namespace bpp; /******************************************************************************/ bool BrentOneDimension::BODStopCondition::isToleranceReached() const { callCount_++; if (callCount_ <= burnin_) return false; const BrentOneDimension* bod = dynamic_cast(optimizer_); return getCurrentTolerance() <= (bod->tol2 - 0.5 * (bod->b - bod->a)); } /******************************************************************************/ double BrentOneDimension::BODStopCondition::getCurrentTolerance() const { // NRC Test for done: const BrentOneDimension* bod = dynamic_cast(optimizer_); return NumTools::abs(bod->x - bod->xm); } /******************************************************************************/ BrentOneDimension::BrentOneDimension(Function* function) : AbstractOptimizer(function), a(0), b(0), d(0), e(0), etemp(0), fu(0), fv(0), fw(0), fx(0), p(0), q(0), r(0), tol1(0), tol2(0), u(0), v(0), w(0), x(0), xm(0), _xinf(0), _xsup(0), isInitialIntervalSet_(false) { setDefaultStopCondition_(new BODStopCondition(this)); setStopCondition(*getDefaultStopCondition()); setMaximumNumberOfEvaluations(10000); } /******************************************************************************/ double BrentOneDimension::ZEPS = 1.0e-10; /******************************************************************************/ void BrentOneDimension::doInit(const ParameterList& params) throw (Exception) { if (params.size() != 1) throw Exception("BrentOneDimension::init(). This optimizer only deals with one parameter."); // Bracket the minimum. Bracket bracket = OneDimensionOptimizationTools::bracketMinimum(_xinf, _xsup, getFunction(), getParameters()); if (getVerbose() > 0) { printMessage("Initial bracketing:"); printMessage("A: x = " + TextTools::toString(bracket.a.x) + ", f = " + TextTools::toString(bracket.a.f)); printMessage("B: x = " + TextTools::toString(bracket.b.x) + ", f = " + TextTools::toString(bracket.b.f)); printMessage("C: x = " + TextTools::toString(bracket.c.x) + ", f = " + TextTools::toString(bracket.c.f)); } // This will be the distance moved on the step before last. e = 0.0; // a and b must be in ascending order, but input abscissa need not be. a = (bracket.a.x < bracket.c.x ? bracket.a.x : bracket.c.x); b = (bracket.a.x > bracket.c.x ? bracket.a.x : bracket.c.x); // Initializations... fw = fv = fx = getFunction()->f(getParameters()); if (fx < bracket.b.f) { //We don't want to lose our initial guess! x = w = v = bracket.b.x = getParameters()[0].getValue(); } else { x = w = v = bracket.b.x; getParameter_(0).setValue(x); fw = fv = fx = getFunction()->f(getParameters()); } } /******************************************************************************/ void BrentOneDimension::setInitialInterval(double inf, double sup) { if(sup > inf) { _xinf = inf; _xsup = sup; } else { _xinf = sup; _xsup = inf; } isInitialIntervalSet_ = true; } /******************************************************************************/ double BrentOneDimension::doStep() throw (Exception) { xm = 0.5 * (a + b); tol2 = 2.0 * (tol1 = getStopCondition()->getTolerance() * NumTools::abs(x) + ZEPS); if(NumTools::abs(e) > tol1) { r = (x - w) * (fx - fv); q = (x - v) * (fx - fw); p = (x - v) * q - (x - w) * r; q = 2.0 * (q - r); if (q > 0.0) p = -p; q = NumTools::abs(q); etemp = e; e = d; if (NumTools::abs(p) >= NumTools::abs(0.5 * q * etemp) || p <= q * (a - x) || p >= q * (b - x)) d = NumConstants::GOLDEN_RATIO_C() * (e = (x >= xm ? a - x : b - x)); else { d = p / q; u = x + d; if (u - a < tol2 || b - u < tol2) d = NumTools::sign(tol1, xm - x); } } else { d = NumConstants::GOLDEN_RATIO_C() * (e = (x >= xm ? a - x : b - x)); } u = (NumTools::abs(d) >= tol1 ? x + d : x + NumTools::sign(tol1, d)); // Function evaluaton: ParameterList pl = getParameters(); pl[0].setValue(u); fu = getFunction()->f(pl); if (fu <= fx) { if (u >= x) a = x; else b = x; NumTools::shift(v, w, x, u); NumTools::shift(fv, fw, fx, fu); } else { if (u < x) a = u; else b = u; if (fu <= fw || w == x) { v = w; w = u; fv = fw; fw = fu; } else if (fu <= fv || v == x || v == w) { v = u; fv = fu; } } // Store results for this step: getParameter_(0).setValue(x); return fx; } /******************************************************************************/ double BrentOneDimension::optimize() throw (Exception) { if (!isInitialIntervalSet_) throw Exception("BrentOneDimension::optimize. Initial interval not set: call the 'setInitialInterval' method first!"); AbstractOptimizer::optimize(); // Apply parameters and evaluate function at minimum point: currentValue_ = getFunction()->f(getParameters()); return currentValue_; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/BfgsMultiDimensions.cpp000664 001750 001750 00000017036 12370705300 026042 0ustar00jdutheiljdutheil000000 000000 // // File: BfgsMultiDimensions.cpp // Created by: Laurent Guéguen // Created on: Dec 16 13:49 2010 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "BfgsMultiDimensions.h" #include "OneDimensionOptimizationTools.h" using namespace bpp; /******************************************************************************/ BfgsMultiDimensions::BfgsMultiDimensions(DerivableFirstOrder* function) : AbstractOptimizer(function), //gtol_(gtol), slope_(0), Up_(), Lo_(), p_(), gradient_(), xi_(), dg_(), hdg_(), hessian_(), f1dim_(function) { setDefaultStopCondition_(new FunctionStopCondition(this)); setStopCondition(*getDefaultStopCondition()); setOptimizationProgressCharacter("."); } /******************************************************************************/ void BfgsMultiDimensions::doInit(const ParameterList& params) throw (Exception) { size_t nbParams = params.size(); p_.resize(nbParams); gradient_.resize(nbParams); xi_.resize(nbParams); dg_.resize(nbParams); hdg_.resize(nbParams); Up_.resize(nbParams); Lo_.resize(nbParams); hessian_.resize(nbParams); for (size_t i = 0; i < nbParams; i++) { hessian_[i].resize(nbParams); } for (size_t i = 0; i < nbParams; i++) { const Constraint* cp = params[i].getConstraint(); if (!cp) { Up_[i] = NumConstants::VERY_BIG(); Lo_[i] = -NumConstants::VERY_BIG(); } else { Up_[i] = cp->getAcceptedLimit(NumConstants::VERY_BIG()) - NumConstants::TINY(); Lo_[i] = cp->getAcceptedLimit(-NumConstants::VERY_BIG()) + NumConstants::TINY(); } } getFunction_()->enableFirstOrderDerivatives(true); getFunction_()->setParameters(params); getGradient(gradient_); for (size_t i = 0; i < nbParams; i++) { p_[i] = getParameters()[i].getValue(); for (unsigned int j = 0; j < nbParams; j++) { hessian_[i][j] = 0.0; } hessian_[i][i] = 1.0; } double sum = 0; for (size_t i = 0; i < nbParams; i++) { sum += p_[i] * p_[i]; } } /******************************************************************************/ double BfgsMultiDimensions::doStep() throw (Exception) { double f; size_t n = getParameters().size(); // Loop over iterations. unsigned int i; for (i = 0; i < n; i++) { p_[i] = getParameters()[i].getValue(); } setDirection(); getFunction()->enableFirstOrderDerivatives(false); nbEval_ += OneDimensionOptimizationTools::lineSearch(f1dim_, getParameters_(), xi_, gradient_, // getStopCondition()->getTolerance(), 0, 0, getVerbose() > 0 ? getVerbose() - 1 : 0); getFunction()->enableFirstOrderDerivatives(true); for (i = 0; i < n; i++) { xi_[i] = getParameters_()[i].getValue() - p_[i]; } f = getFunction()->f(getParameters()); if (f > currentValue_) { printMessage("!!! Function increase !!!"); printMessage("!!! Optimization might have failed. Try to reparametrize your function to remove constraints."); tolIsReached_ = true; return f; } if (tolIsReached_) { return f; } //double temp, test = 0.0; //for (i = 0; i < n; i++) //{ // temp = xi_[i]; // if (p_[i] > 1.0) // temp /= p_[i]; // if (temp > test) // test = temp; //} //if (test < 1e-7) //{ // tolIsReached_ = true; // return f; //} for (i = 0; i < n; i++) { dg_[i] = gradient_[i]; } getGradient(gradient_); //test = 0.0; //for (i = 0; i < n; i++) //{ // temp = abs(gradient_[i]); // if (abs(p_[i]) > 1.0) // temp /= p_[i]; // if (temp > test) // test = temp; //} //if (f > 1.0) // test /= f; //if (test < gtol_) //{ // tolIsReached_ = true; // return f; //} for (i = 0; i < n; i++) { dg_[i] = gradient_[i] - dg_[i]; } for (i = 0; i < n; i++) { hdg_[i] = 0; for (unsigned int j = 0; j < n; j++) { hdg_[i] += hessian_[i][j] * dg_[j]; } } double fae(0), fac(0), sumdg(0), sumxi(0); for (i = 0; i < n; i++) { fac += dg_[i] * xi_[i]; fae += dg_[i] * hdg_[i]; sumdg += dg_[i] * dg_[i]; sumxi += xi_[i] * xi_[i]; } if (fac > sqrt(1e-7 * sumdg * sumxi)) { fac = 1.0 / fac; double fad = 1.0 / fae; for (i = 0; i < n; i++) { dg_[i] = fac * xi_[i] - fad * hdg_[i]; } for (i = 0; i < n; i++) { for (unsigned int j = i; j < n; j++) { hessian_[i][j] += fac * xi_[i] * xi_[j] - fad * hdg_[i] * hdg_[j] + fae * dg_[i] * dg_[j]; hessian_[j][i] = hessian_[i][j]; } } } return f; } /******************************************************************************/ void BfgsMultiDimensions::getGradient(std::vector& gradient) const { for (unsigned int i = 0; i < gradient.size(); i++) { gradient[i] = getFunction()->getFirstOrderDerivative(getParameters()[i].getName()); } } /******************************************************************************/ void BfgsMultiDimensions::setDirection() { size_t nbParams = getParameters().size(); for (size_t i = 0; i < nbParams; i++) { xi_[i] = 0; for (unsigned int j = 0; j < nbParams; j++) { xi_[i] -= hessian_[i][j] * gradient_[j]; } } double v = 1, alpmax = 1; for (size_t i = 0; i < nbParams; i++) { if ((xi_[i] > 0) && (p_[i] + NumConstants::TINY() * xi_[i] < Up_[i])) v = (Up_[i] - p_[i]) / xi_[i]; else if ((xi_[i] < 0) && (p_[i] + NumConstants::TINY() * xi_[i] > Lo_[i])) v = (Lo_[i] - p_[i]) / xi_[i]; if (v < alpmax) alpmax = v; } for (size_t i = 0; i < nbParams; i++) { if (p_[i] + NumConstants::TINY() * xi_[i] >= Up_[i]) xi_[i] = Up_[i] - p_[i]; else if (p_[i] + NumConstants::TINY() * xi_[i] <= Lo_[i]) xi_[i] = Lo_[i] - p_[i]; else xi_[i] *= alpmax; } } bpp-core-2.2.0/src/Bpp/Numeric/Function/ReparametrizationFunctionWrapper.h000664 001750 001750 00000025525 12406006302 030327 0ustar00jdutheiljdutheil000000 000000 // // File: ReparametrizationFunctionWrapper.h // Created by: Julien Dutheil // Created on: Fri Jan 30 09:30 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _REPARAMETRIZATIONFUNCTIONWRAPPER_H_ #define _REPARAMETRIZATIONFUNCTIONWRAPPER_H_ #include "Functions.h" #include "../AbstractParametrizable.h" #include "../TransformedParameter.h" namespace bpp { /** * @brief Function wrapper that remove simple constraints on parameters. * * This function takes as input another function and reparametrize it when possible. * currently, only constraint of the type ]a, b[ where a and b can be +/- inf. */ class ReparametrizationFunctionWrapper: public virtual Function, public AbstractParametrizable { private: Function* function_; ParameterList functionParameters_; public: /** * @brief Build a new reparametrization wrapper for the given function, using all available parameters. * * @param function The function to reparametrize. * @param verbose Print some information. */ ReparametrizationFunctionWrapper(Function* function, bool verbose=true) : AbstractParametrizable(function->getNamespace()), function_(function), functionParameters_(function->getParameters()) { init_(verbose); } /** * @brief Build a new reparametrization wrapper for the given function, using only the specified parameters. * * @param function The function to reparametrize. * @param parameters The list of parameters that will be reparametrized. The intersection with the * list of function parameters will be used in the reparametrized function. Any other parameters * (in the given list or in the original function) will be ignored. * @param verbose Print some information. */ ReparametrizationFunctionWrapper(Function* function, const ParameterList& parameters, bool verbose=true) : AbstractParametrizable(function->getNamespace()), function_(function), functionParameters_(function->getParameters().getCommonParametersWith(parameters)) { init_(verbose); } ReparametrizationFunctionWrapper(const ReparametrizationFunctionWrapper& rfw) : AbstractParametrizable(rfw), function_(rfw.function_), functionParameters_(rfw.functionParameters_) {} ReparametrizationFunctionWrapper& operator=(const ReparametrizationFunctionWrapper& rfw) { AbstractParametrizable::operator=(rfw), function_ = rfw.function_; functionParameters_ = rfw.functionParameters_; return *this; } virtual ~ReparametrizationFunctionWrapper() {} #if defined(NO_VIRTUAL_COV) Clonable* clone() const { return new ReparametrizationFunctionWrapper(*this); } #else ReparametrizationFunctionWrapper* clone() const { return new ReparametrizationFunctionWrapper(*this); } #endif private: void init_(bool verbose); public: virtual const Function& getFunction() const { return *function_; } virtual Function& getFunction() { return *function_; } void setParameters(const ParameterList& parameters) throw (ParameterNotFoundException, ConstraintException) { // parameters.printParameters(std::cout); matchParametersValues(parameters); //We only set parameters that have been changed: // functionParameters_.printParameters(std::cout); function_->setParameters(functionParameters_.subList(parameters.getParameterNames())); } double getValue() const throw (Exception) { return function_->getValue(); } void fireParameterChanged (const ParameterList ¶meters); }; /** * @brief Function wrapper that remove simple constraints on parameters. Also transform first order derivatives. * * This function takes as input another function and reparametrize it when possible. * currently, only constraint of the type ]a, b[ where a and b can be +/- inf. */ class ReparametrizationDerivableFirstOrderWrapper: public virtual DerivableFirstOrder, public ReparametrizationFunctionWrapper { public: /** * @brief Build a new reparametrization wrapper for the given function, using all available parameters. * * @param function The function to reparametrize. * @param verbose Print some information. */ ReparametrizationDerivableFirstOrderWrapper(DerivableFirstOrder* function, bool verbose=true) : ReparametrizationFunctionWrapper(function, verbose) {} /** * @brief Build a new reparametrization wrapper for the given function, using only the specified parameters. * * @param function The function to reparametrize. * @param parameters The list of parameters that will be reparametrized. The intersection with the * list of function parameters will be used in the reparametrized function. Any other parameters * (in the given list or in the original function) will be ignored. * @param verbose Print some information. */ ReparametrizationDerivableFirstOrderWrapper(DerivableFirstOrder* function, const ParameterList& parameters, bool verbose=true) : ReparametrizationFunctionWrapper(function, parameters, verbose) {} virtual ~ReparametrizationDerivableFirstOrderWrapper() {} #if defined(NO_VIRTUAL_COV) Clonable* clone() const { return new ReparametrizationDerivableFirstOrderWrapper(*this); } #else ReparametrizationDerivableFirstOrderWrapper* clone() const { return new ReparametrizationDerivableFirstOrderWrapper(*this); } #endif private: void init_(bool verbose); public: void enableFirstOrderDerivatives(bool yn) { dynamic_cast(getFunction()).enableFirstOrderDerivatives(yn); } bool enableFirstOrderDerivatives() const { return dynamic_cast(getFunction()).enableFirstOrderDerivatives(); } double getFirstOrderDerivative(const std::string& variable) const throw (Exception) { return dynamic_cast(getFunction()).getFirstOrderDerivative(variable) * dynamic_cast(getParameter(variable)).getFirstOrderDerivative(); } }; /** * @brief Function wrapper that remove simple constraints on parameters. Also transform first and second order derivatives. * * This function takes as input another function and reparametrize it when possible. * currently, only constraint of the type ]a, b[ where a and b can be +/- inf. */ class ReparametrizationDerivableSecondOrderWrapper: public virtual DerivableSecondOrder, public ReparametrizationDerivableFirstOrderWrapper { public: /** * @brief Build a new reparametrization wrapper for the given function, using all available parameters. * * @param function The function to reparametrize. * @param verbose Print some information. */ ReparametrizationDerivableSecondOrderWrapper(DerivableSecondOrder* function, bool verbose=true) : ReparametrizationDerivableFirstOrderWrapper(function, verbose) {} /** * @brief Build a new reparametrization wrapper for the given function, using only the specified parameters. * * @param function The function to reparametrize. * @param parameters The list of parameters that will be reparametrized. The intersection with the * list of function parameters will be used in the reparametrized function. Any other parameters * (in the given list or in the original function) will be ignored. * @param verbose Print some information. */ ReparametrizationDerivableSecondOrderWrapper(DerivableSecondOrder* function, const ParameterList& parameters, bool verbose=true) : ReparametrizationDerivableFirstOrderWrapper(function, parameters, verbose) {} virtual ~ReparametrizationDerivableSecondOrderWrapper() {} #if defined(NO_VIRTUAL_COV) Clonable* clone() const { return new ReparametrizationDerivableSecondOrderWrapper(*this); } #else ReparametrizationDerivableSecondOrderWrapper* clone() const { return new ReparametrizationDerivableSecondOrderWrapper(*this); } #endif private: void init_(bool verbose); public: void enableSecondOrderDerivatives(bool yn) { dynamic_cast(getFunction()).enableSecondOrderDerivatives(yn); } bool enableSecondOrderDerivatives() const { return dynamic_cast(getFunction()).enableSecondOrderDerivatives(); } double getSecondOrderDerivative(const std::string& variable) const throw (Exception) { return dynamic_cast(getFunction()).getSecondOrderDerivative(variable) * pow(dynamic_cast(getParameter(variable)).getFirstOrderDerivative(), 2) + dynamic_cast(getFunction()).getFirstOrderDerivative(variable) * dynamic_cast(getParameter(variable)).getSecondOrderDerivative(); } double getSecondOrderDerivative(const std::string& variable1, const std::string& variable2) const throw (Exception) { return dynamic_cast(getFunction()).getSecondOrderDerivative(variable1, variable2) * dynamic_cast(getParameter(variable1)).getFirstOrderDerivative() * dynamic_cast(getParameter(variable2)).getFirstOrderDerivative(); } }; } //end of namespace bpp. #endif //_REPARAMETRIZATIONFUNCTIONWRAPPER_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/NewtonOneDimension.cpp000664 001750 001750 00000012067 12370705300 025676 0ustar00jdutheiljdutheil000000 000000 // // File: NewtonOneDimension.cpp // Created by: Julien Dutheil // Created on: Thu Apr 26 14:16 2007 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "NewtonOneDimension.h" #include "../NumTools.h" #include "../../Text/TextTools.h" using namespace bpp; /******************************************************************************/ NewtonOneDimension::NewtonOneDimension(DerivableSecondOrder* function) : AbstractOptimizer(function), _param(), _maxCorrection(10) { setDefaultStopCondition_(new FunctionStopCondition(this)); setStopCondition(*getDefaultStopCondition()); nbEvalMax_ = 10000; } /******************************************************************************/ void NewtonOneDimension::doInit(const ParameterList& params) throw (Exception) { // Set the initial value (no use here! Use setInitialValues() instead). if (params.size() != 1) throw Exception("NewtonOneDimension::init(). This optimizer only deals with one parameter."); _param = params[0].getName(); currentValue_ = getFunction()->f(getParameters()); getStopCondition()->init(); } /******************************************************************************/ double NewtonOneDimension::doStep() throw (Exception) { double movement; ParameterList newPoint = getParameters(); ParameterList bckPoint = getFunction()->getParameters(); double newValue; double firstOrderDerivative = getFunction()->getFirstOrderDerivative(_param); double secondOrderDerivative = getFunction()->getSecondOrderDerivative(_param); if (secondOrderDerivative <= 0) { printMessage("!!! Second order derivative is negative (" + TextTools::toString(getParameters()[0].getValue()) + "). No move performed."); //movements[i] = 0; // We want to reach a minimum, not a maximum! // My personnal improvement: movement = -firstOrderDerivative / secondOrderDerivative; } else movement = firstOrderDerivative / secondOrderDerivative; if (std::isnan(movement)) { printMessage("!!! Non derivable point. No move performed. (f=" + TextTools::toString(currentValue_) + ", d1=" + TextTools::toString(firstOrderDerivative) + ", d2=" + TextTools::toString(secondOrderDerivative) + ")."); movement = 0; // Either first or second order derivative is infinity. This may happen when the function == inf at this point. } newPoint[0].setValue(getParameters()[0].getValue() - movement); newValue = getFunction()->f(newPoint); // Check newValue: unsigned int count = 0; while (newValue > currentValue_) { //Restore previous point (all parameters in case of global constraint): getFunction()->setParameters(bckPoint); count++; if (count >= _maxCorrection) { printMessage("!!! Felsenstein-Churchill correction applied too much time. Stopping here. Convergence probably not reached."); tolIsReached_ = true; return currentValue_; //throw Exception("NewtonOneDimension::step(). Felsenstein-Churchill correction applied more than 10000 times."); } printMessage("!!! Function at new point is greater than at current point: " + TextTools::toString(newValue) + ">" + TextTools::toString(currentValue_) + ". Applying Felsenstein-Churchill correction, value = " + TextTools::toString(newPoint[0].getValue())); movement = movement / 2; newPoint[0].setValue(getParameters()[0].getValue() - movement); newValue = getFunction()->f(newPoint); } getParameters_() = newPoint; // Function as been set to newPoint by the call of f(newPoint). return newValue; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/DirectionFunction.h000664 001750 001750 00000010170 12370705300 025200 0ustar00jdutheiljdutheil000000 000000 // // File: DirectionFunction.h // Created by: Julien Dutheil // Created on: Wed Apr 11 17:28 2007 // From file PowellMultiDimensions.h // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _DIRECTIONFUNCTION_H_ #define _DIRECTIONFUNCTION_H_ #include "Functions.h" #include "../Parametrizable.h" #include "../AutoParameter.h" #include "../../App/ApplicationTools.h" #include "../../Io/OutputStream.h" namespace bpp { class DirectionFunction: public Function, public ParametrizableAdapter { private: mutable ParameterList params_, p_, xt_; std::vector xi_; Function* function_; std::string constraintPolicy_; OutputStream* messenger_; public: DirectionFunction(Function* function = 0) : params_(), p_(), xt_(), xi_(), function_(function), constraintPolicy_(AutoParameter::CONSTRAINTS_KEEP), messenger_(ApplicationTools::message) {} DirectionFunction(const DirectionFunction& df) : ParametrizableAdapter(df), params_(df.params_), p_(df.p_), xt_(df.p_), xi_(df.xi_), function_(df.function_), constraintPolicy_(df.constraintPolicy_), messenger_(df.messenger_) {} DirectionFunction& operator=(const DirectionFunction& df) { ParametrizableAdapter::operator=(df); params_ = df.params_; p_ = df.p_; xt_ = df.p_; xi_ = df.xi_; function_ = df.function_; constraintPolicy_ = df.constraintPolicy_; messenger_ = df.messenger_; return *this; } virtual ~DirectionFunction() {} DirectionFunction* clone() const { return new DirectionFunction(*this); } public: // Function interface implementation: void setParameters(const ParameterList& parameters) throw (ParameterNotFoundException, ConstraintException); double getValue() const throw (Exception); const ParameterList & getParameters() const throw (Exception); public: // Specific methods: void init(const ParameterList & p, const std::vector & xi); void autoParameter(); void ignoreConstraints(); void setConstraintPolicy(const std::string & constraintPolicy) { constraintPolicy_ = constraintPolicy; } std::string getConstraintPolicy() const { return constraintPolicy_; } void setMessageHandler(OutputStream* messenger) { messenger_ = messenger; } Function * getFunction() const { return function_; } /** * @return The set of parameters associated to the function, as specified by the init() method. */ ParameterList getFunctionParameters() const { return p_; } size_t getNumberOfParameters() const { return p_.size(); } }; } //end of namespace bpp. #endif //_DIRECTIONFUNCTION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/FunctionTools.h000664 001750 001750 00000010516 12370705300 024364 0ustar00jdutheiljdutheil000000 000000 // // File: FunctionTools.h // Created by: Julien Dutheil // Created on: Mon Apr 13 10:00 2009 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _FUNCTIONTOOLS_H_ #define _FUNCTIONTOOLS_H_ #include "Functions.h" #include "../VectorTools.h" namespace bpp { /** * @brief This class is a data structure to specify a set of parameter values (most likely for evaluation by a Function) * * @see FunctionTools */ class ParameterGrid { private: std::vector names_; VVdouble grid_; public: ParameterGrid(): names_(), grid_() {} virtual ~ParameterGrid() {} public: /** * @brief Add a new dimension (parameter name + corresponding values). * * @param name The name of the dimension (parameter name). * @param values The values the parameter will take. * @throw Exception in case the dimension is note valid (duplicated parameter name for instance). */ void addDimension(const std::string& name, const Vdouble& values) throw (Exception); const std::vector& getDimensionNames() const { return names_; } const std::string& getDimensionName(unsigned int i) const throw (IndexOutOfBoundsException) { if (i >= names_.size()) throw IndexOutOfBoundsException("ParameterGrid::getDimensionName().", i, 0, names_.size()-1); return names_[i]; } size_t getNumberOfDimensions() const { return names_.size(); } /** * @return The total number of points in the grid, that is the product of all dimension sizes. */ size_t getTotalNumberOfPoints() const; const VVdouble& getPoints() const { return grid_; } const Vdouble& getPointsForDimension(unsigned int i) const throw (IndexOutOfBoundsException); const Vdouble& getPointsForDimension(const std::string& name) const throw (Exception); }; /** * @brief This class contains static methods to deal with Function objects. */ class FunctionTools { public: /** * @brief Evaluates a function on all points in a given grid. * * @param function The function to use for the evaluation. * @param grid The grid defining the set of points to evaluate. * @return A pointer toward a dynamically created vector of vector * of doubles. Each row correpsonds to a combination of parameters * and the corresponding function value. There is hence one column * per parameter, and one additional column containing the * corresponding function evaluations. When DataTable supports * different column type, we will probably return a DataTable instead. * @throw Exception If the parameter names in the grid do not match * the ones in the function, or a constraint is matched, etc. */ static VVdouble* computeGrid( Function& function, const ParameterGrid& grid) throw (Exception); }; } //end of namespace bpp #endif //_FUNCTIONTOOLS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/AbstractNumericalDerivative.h000664 001750 001750 00000023737 12370705300 027215 0ustar00jdutheiljdutheil000000 000000 // // File: AbstractNumericalDerivative.h // Created by: Julien Dutheil // Created on: Thu Aug 17 15:00 2006 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _ABSTRACTNUMERICALDERIVATIVE_H_ #define _ABSTRACTNUMERICALDERIVATIVE_H_ #include "Functions.h" #include "../Matrix/Matrix.h" //From the STL: #include #include #include namespace bpp { /** * @brief Numerical derivative function wrapper, partial implementation. * * This class provides a wrapper for Function object, implementing the DerivableSecondOrder interface * (Although no cross derivative is implemented for now). * Derivations of this class can be used as full DerivableSecondOrder objects, with derivative functions. * * Three kinds of constructors are provided: one with a Function object, another with a DerivableFirstOrder object, and one with a DerivableSecondOrder object. * In the first case, all derivatives will be computed numerically. * In the second case, first order derivative will be computed numerically only if no appropriate analytical derivative is available, second order derivative will always be computed numerically. * In the last case, first and second order derivative will be computed numerically only if no appropriate analytical derivative is available. */ class AbstractNumericalDerivative: public DerivableSecondOrder, public FunctionWrapper { protected: DerivableFirstOrder *function1_; DerivableSecondOrder *function2_; double h_; std::vector variables_; mutable std::map index_; //Store positions in array corresponding to variable names. std::vector der1_; std::vector der2_; RowMatrix crossDer2_; bool computeD1_, computeD2_, computeCrossD2_; public: AbstractNumericalDerivative(Function* function): FunctionWrapper(function), function1_(0), function2_(0), h_(0.0001), variables_(), index_(), der1_(), der2_(), crossDer2_(), computeD1_(true), computeD2_(true), computeCrossD2_(false) {} AbstractNumericalDerivative(DerivableFirstOrder* function): FunctionWrapper(function), function1_(function), function2_(0), h_(0.0001), variables_(), index_(), der1_(), der2_(), crossDer2_(), computeD1_(true), computeD2_(true), computeCrossD2_(false) {} AbstractNumericalDerivative(DerivableSecondOrder* function): FunctionWrapper(function), function1_(function), function2_(function), h_(0.0001), variables_(), index_(), der1_(), der2_(), crossDer2_(), computeD1_(true), computeD2_(true), computeCrossD2_(false) {} AbstractNumericalDerivative(const AbstractNumericalDerivative& ad): FunctionWrapper(ad), function1_(ad.function1_), function2_(ad.function2_), h_(ad.h_), variables_(ad.variables_), index_(ad.index_), der1_(ad.der1_), der2_(ad.der2_), crossDer2_(ad.crossDer2_), computeD1_(ad.computeD1_), computeD2_(ad.computeD2_), computeCrossD2_(ad.computeCrossD2_) {} AbstractNumericalDerivative& operator=(const AbstractNumericalDerivative& ad) { FunctionWrapper::operator=(ad); function1_ = ad.function1_; function2_ = ad.function2_; h_ = ad.h_; variables_ = ad.variables_; index_ = ad.index_; der1_ = ad.der1_; der2_ = ad.der2_; crossDer2_ = ad.crossDer2_; computeD1_ = ad.computeD1_; computeD2_ = ad.computeD2_; computeCrossD2_ = ad.computeCrossD2_; return *this; } virtual ~AbstractNumericalDerivative() {} AbstractNumericalDerivative* clone() const = 0; public: /** * @brief Set the interval value used in numerical approximation. * * Default value is 0.0001. * * @param h Interval value. */ void setInterval(double h) { h_ = h; } /** * @return The interval value used in numerical approximation. */ double getInterval() const { return h_; } /** * @brief Set the list of parameters to derivate. * * @param variables A list of all parameter names. */ void setParametersToDerivate(const std::vector& variables) { variables_ = variables; index_.clear(); for(size_t i = 0; i < variables_.size(); i++) index_[variables_[i]] = i; der1_.resize(variables_.size()); der2_.resize(variables_.size()); crossDer2_.resize(variables_.size(), variables_.size()); } /** * @name The DerivableFirstOrder interface * * @{ */ void enableFirstOrderDerivatives(bool yn) { computeD1_ = yn; } bool enableFirstOrderDerivatives() const { return computeD1_; } double getFirstOrderDerivative(const std::string& variable) const throw (Exception) { if (function1_) { try { return function1_->getFirstOrderDerivative(variable); } catch (Exception& e) {} } std::map::iterator it = index_.find(variable); if (computeD1_ && it != index_.end()) return der1_[it->second]; else throw Exception("First order derivative not computed for variable " + variable + "."); } /** @} */ /** * @name The DerivableSecondOrder interface * * @{ */ void enableSecondOrderDerivatives(bool yn) { computeD2_ = yn; } bool enableSecondOrderDerivatives() const { return computeD2_; } double getSecondOrderDerivative(const std::string& variable) const throw (Exception) { if (function2_) { try { return function2_->getSecondOrderDerivative(variable); } catch(Exception & e) {} } std::map::iterator it = index_.find(variable); if(computeD2_ && it != index_.end()) return der2_[it->second]; else throw Exception("Second order derivative not computed for variable " + variable + "."); } double getSecondOrderDerivative(const std::string& variable1, const std::string& variable2) const throw (Exception) { if (function2_) { try { return function2_->getSecondOrderDerivative(variable1, variable2); } catch(Exception & e) {} } std::map::iterator it1 = index_.find(variable1); std::map::iterator it2 = index_.find(variable2); if(computeCrossD2_ && it1 != index_.end() && it2 != index_.end()) return crossDer2_(it1->second, it2->second); else throw Exception("Cross second order derivative not computed for variables " + variable1 + " and " + variable2 + "."); } /** @} */ /** * @name The Parametrizable interface. * * @{ */ double f(const ParameterList& parameters) throw (Exception) { setParameters(parameters); return getValue(); } void setParameters(const ParameterList& parameters) throw (ParameterNotFoundException, ConstraintException) { function_->setParameters(parameters); updateDerivatives(parameters); } void setAllParametersValues(const ParameterList& parameters) throw (ParameterNotFoundException, ConstraintException) { function_->setAllParametersValues(parameters); updateDerivatives(parameters); } void setParameterValue(const std::string& name, double value) throw (ParameterNotFoundException, ConstraintException) { function_->setParameterValue(name, value); updateDerivatives(function_->getParameters().subList(name)); } void setParametersValues(const ParameterList& parameters) throw (ParameterNotFoundException, ConstraintException) { function_->setParametersValues(parameters); updateDerivatives(parameters); } bool matchParametersValues(const ParameterList& parameters) throw (ConstraintException) { bool test = function_->matchParametersValues(parameters); updateDerivatives(parameters); return test; } /** @} */ void enableSecondOrderCrossDerivatives(bool yn) { computeCrossD2_ = yn; } bool enableSecondOrderCrossDerivatives() const { return computeCrossD2_; } protected: /** * @brief Compute derivatives. * * @param parameters The point where to compute derivatives. It is NOT passed as references, * as the inner parameters of the function will be changed when computing the numerical derivatives. */ virtual void updateDerivatives(const ParameterList parameters) = 0; }; } //end of namespace bpp. #endif //_ABSTRACTNUMERICALDERIVATIVE_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/ThreePointsNumericalDerivative.h000664 001750 001750 00000010753 12370705300 027710 0ustar00jdutheiljdutheil000000 000000 // // File: ThreePointsNumericalDerivative.h // Created by: Julien Dutheil // Created on: Thu Aug 17 15:00 2006 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _THREEPOINTSNUMERICALDERIVATIVE_H_ #define _THREEPOINTSNUMERICALDERIVATIVE_H_ #include "Functions.h" #include "AbstractNumericalDerivative.h" // From the STL: #include #include #include namespace bpp { /** * @brief Three points numerical derivative function wrapper. * * Numerical derivatives use three points to compute the derivatives. * @f$x_0@f$ is the focus point, @f$x_{-1} = x_0-h@f$ and @f$x_{+1} = x_0+h@f$ * are other points, with function values @f$f_0@f$, @f$f_{-1}@f$ and @f$f_{+1}@f$ respectively. * The derivatives are then computed using the central formulas: * @f{eqnarray*} * \dfrac{\partial f}{\partial x } &=& \dfrac{f_{+1}-f_{-1}}{2h}\\ * \dfrac{\partial^2 f}{\partial x^2} &=& \dfrac{f_{+1}-2f_0+f_{-1}}{h^2}\\ * @f} * In case of border limit (when @f$x_{-1}@f$ or @f$x_{+1}@f$ are not computable), * the foreward and backward computations are performed, respectively: * @f{eqnarray*} * \dfrac{\partial f}{\partial x } &=& \dfrac{f_{+1}-f_0}{h}\\ * \dfrac{\partial^2 f}{\partial x^2} &=& \dfrac{f_{+2}-2f_{+1}+f_0}{h^2}\\ * @f} * and * @f{eqnarray*} * \dfrac{\partial f}{\partial x } &=& \dfrac{f_0-f_{-1}}{h}\\ * \dfrac{\partial^2 f}{\partial x^2} &=& \dfrac{f_0-2f_{-1}+f_{-2}}{h^2}\\ * @f} * * The @f$h@f$ parameter is computed in a parameter dependent manner: * @f$ h = x \times e@f$, with @f$x \neq 0@f$ being the current parameter value. * If @f$x = 0@f$, @f$h = e@f$. * Default value is provided for @f$e@f$ and corresponds to the _h field. * The default value works fine in most cases, but you may want to change it using the setInterval method. * * @see AbstractNumericalDerivative */ class ThreePointsNumericalDerivative : public AbstractNumericalDerivative { private: double f1_, f2_, f3_, f11_, f22_, f12_, f21_; public: ThreePointsNumericalDerivative (Function* function) : AbstractNumericalDerivative(function), f1_(), f2_(), f3_(), f11_(), f22_(), f12_(), f21_() {} ThreePointsNumericalDerivative (DerivableFirstOrder* function) : AbstractNumericalDerivative(function), f1_(), f2_(), f3_(), f11_(), f22_(), f12_(), f21_() {} ThreePointsNumericalDerivative (DerivableSecondOrder* function) : AbstractNumericalDerivative(function), f1_(), f2_(), f3_(), f11_(), f22_(), f12_(), f21_() {} virtual ~ThreePointsNumericalDerivative() {} ThreePointsNumericalDerivative* clone() const { return new ThreePointsNumericalDerivative(*this); } public: double getValue() const throw (Exception) { return f2_; } protected: void updateDerivatives(const ParameterList parameters) throw (ParameterNotFoundException, ConstraintException); }; } // end of namespace bpp. #endif // _THREEPOINTSNUMERICALDERIVATIVE_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/TwoPointsNumericalDerivative.h000664 001750 001750 00000010370 12370705300 027405 0ustar00jdutheiljdutheil000000 000000 // // File: TwoPointsNumericalDerivative.h // Created by: Julien Dutheil // Created on: Mon May 28 10:33 2007 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _TWOPOINTSNUMERICALDERIVATIVE_H_ #define _TWOPOINTSNUMERICALDERIVATIVE_H_ #include "Functions.h" #include "AbstractNumericalDerivative.h" // From the STL: #include #include #include namespace bpp { /** * @brief Two points numerical derivative function wrapper. * * Numerical derivatives use two points to compute the (first order) derivatives. * @f$x_0@f$ is the focus point and @f$x_{+1} = x_0+h@f$ (or @f$x_0-h@f$, if constrained on the right). * Corresponding function values are @f$f_0@f$, @f$f_{-1}@f$ and @f$f_{+1/-1}@f$ respectively. * The derivatives are then computed using the central formulas: * @f{eqnarray*} * \dfrac{\partial f}{\partial x } &=& \dfrac{f_{+1}-f_{0}}{h}\mathrm{\ or}\\ * \dfrac{\partial f}{\partial x } &=& \dfrac{f_{0}-f_{-1}}{h}\\ * @f} * This class does not allow computation of second order derivatives. * * The @f$h@f$ parameter is computed in a parameter dependent manner: * @f$ h = x \times e@f$, with @f$x \neq 0@f$ being the current parameter value. * If @f$x = 0@f$, @f$h = e@f$. * Default value is provided for @f$e@f$ and corresponds to the _h field. * The default value works fine in most cases, but you may want to change it using the setInterval method. * * @see AbstractNumericalDerivative, ThreePointsNumericalDerivative, FivePointsNumericalDerivative */ class TwoPointsNumericalDerivative : public AbstractNumericalDerivative { private: double f1_, f2_; public: TwoPointsNumericalDerivative(Function* function) : AbstractNumericalDerivative(function), f1_(), f2_() {} TwoPointsNumericalDerivative(DerivableFirstOrder* function) : AbstractNumericalDerivative(function), f1_(), f2_() {} virtual ~TwoPointsNumericalDerivative() {} TwoPointsNumericalDerivative* clone() const { return new TwoPointsNumericalDerivative(*this); } public: double getValue() const throw (Exception) { return f1_; } /** * @name The DerivableSecondOrder interface * * @{ */ double getSecondOrderDerivative(const std::string& variable) const throw (Exception) { throw Exception("Second order derivative not avalaible with two points method."); } double getSecondOrderDerivative(const std::string& variable1, const std::string& variable2) const throw (Exception) { throw Exception("Unimplemented cross derivative."); } /** @} */ protected: void updateDerivatives(const ParameterList parameters) throw (ParameterNotFoundException, ConstraintException); }; } // end of namespace bpp. #endif // _TWOPOINTSNUMERICALDERIVATIVE_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/OptimizationStopCondition.h000664 001750 001750 00000023467 12370705300 026772 0ustar00jdutheiljdutheil000000 000000 // // File: OptimizationStopCondition.h // Created by: Julien Dutheil // Created on: Tue Dec 23 11:51:31 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _OPTIMIZATIONSTOPCONDITION_H_ #define _OPTIMIZATIONSTOPCONDITION_H_ #include "../ParameterList.h" using namespace std; namespace bpp { class Optimizer; /******************************************************************************/ /** * @brief Interface for otimization stop condition objet. * * Classes implementing the OptimizationStopCondition interface * provides the isToleranceReached() function that tells when * the optimization process reached a given tolerance parameter. * This parameter may be set or retrieve using the setTolerance() * and getTolerance() functions. * * OptimizationStopCondition implementations may be general and work on * parameter (@see ParametersStopCondition) or function (@see FunctionStopCondition) values, * or be specific to a given optimization method. */ class OptimizationStopCondition: public virtual Clonable { public: OptimizationStopCondition() {} virtual ~OptimizationStopCondition() {} #ifndef NO_VIRTUAL_COV OptimizationStopCondition * #else Clonable* #endif clone() const = 0; public: /** * @return The optimizer to which this instance belongs to. */ virtual const Optimizer* getOptimizer() const = 0; /** * @brief Set the optimizer attached to this instance. * * @param optimizer The optimizer to which this instance belongs to. */ virtual void setOptimizer(const Optimizer* optimizer) = 0; /** * @brief Initialize the condition. */ virtual void init() = 0; /** * @brief Tell if the we reached the desired tolerance with a given * new set of estimates. * * The new parameter list is compared to the last estimates, * and the lastParameterEstimates list is actulaized with the newParameters list. * * @return True if the tolerance level is reached. */ virtual bool isToleranceReached() const = 0; /** * @brief Set the tolerance parameter. * * @param tolerance The tolerance parameter. */ virtual void setTolerance(double tolerance) = 0; /** * @brief Get the tolerance parameter. * * @return The tolerance parameter. */ virtual double getTolerance() const = 0; /** * @brief Get the current tolerance. * * This is computed from the last check performed. * Initially, it is equal to the tolerance parameter. * * @return The current tolerance achieved. */ virtual double getCurrentTolerance() const = 0; }; /******************************************************************************/ /** * @brief Partial implementation of the OptimizationStopCondition interface. * * This class provides: * - A pointer toward the Optimizer this objet deals with, * - A tolerance value, * - A counter of the number of calls toward the isToleranceReached() function, * - A burnin function, that prohibe the optimization to stop prematurely. */ class AbstractOptimizationStopCondition: public virtual OptimizationStopCondition { protected: const Optimizer* optimizer_; double tolerance_; /** * @brief Count the number of times the isToleranceReached() function * has been called. */ mutable double callCount_; int burnin_; public: AbstractOptimizationStopCondition(const Optimizer* optimizer): optimizer_(optimizer), tolerance_(0.000001), callCount_(0), burnin_(0) {} AbstractOptimizationStopCondition(const Optimizer* optimizer, double tolerance): optimizer_(optimizer), tolerance_(tolerance), callCount_(0), burnin_(0) {} AbstractOptimizationStopCondition(const Optimizer* optimizer, int burnin): optimizer_(optimizer), tolerance_(0.000001), callCount_(0), burnin_(burnin) {} AbstractOptimizationStopCondition(const Optimizer* optimizer, double tolerance, int burnin): optimizer_(optimizer), tolerance_(tolerance), callCount_(0), burnin_(burnin) {} AbstractOptimizationStopCondition(const AbstractOptimizationStopCondition& aosc): optimizer_(aosc.optimizer_), tolerance_(aosc.tolerance_), callCount_(aosc.callCount_), burnin_(aosc.burnin_) {} AbstractOptimizationStopCondition& operator=(const AbstractOptimizationStopCondition& aosc) { optimizer_ = aosc.optimizer_; tolerance_ = aosc.tolerance_; callCount_ = aosc.callCount_; burnin_ = aosc.burnin_; return *this; } virtual ~AbstractOptimizationStopCondition() {} public: const Optimizer* getOptimizer() const { return optimizer_; } void setOptimizer(const Optimizer* optimizer) { optimizer_ = optimizer; } void setTolerance(double tolerance) { tolerance_ = tolerance; } double getTolerance() const { return tolerance_; } void init() { resetCounter(); } virtual void resetCounter() { callCount_ = 0; } virtual void setBurnin(int burnin) { burnin_ = burnin; } virtual int getBurnin() const { return burnin_; } }; /******************************************************************************/ /** * @brief Stop condition on parameters. * * This stops the optimization when \f$\forall i\; |\lambda_{i,t}-\lambda_{i,t-1}| \leq \mbox{tolerance}\f$, * where \f$\lambda_{i, t}\f$ is the value of the ith parameter at iteration \f$t\f$, * and \f$\lambda_{i, t-1}\f$ is the value of the ith parameter at iteration \f$t-1\f$. */ class ParametersStopCondition: public AbstractOptimizationStopCondition { private: /** * @brief The last estimates of the parameters. * * This is used by the isToleranceReached() method. */ mutable ParameterList lastParametersEstimates_; /** * @brief The new estimates of the parameters. * * This is used by the isToleranceReached() method. */ mutable ParameterList newParametersEstimates_; public: ParametersStopCondition(const Optimizer* optimizer); ParametersStopCondition(const Optimizer* optimizer, double tolerance); ParametersStopCondition(const Optimizer* optimizer, int burnin); ParametersStopCondition(const Optimizer* optimizer, double tolerance, int burnin); virtual ~ParametersStopCondition() {} ParametersStopCondition* clone() const { return new ParametersStopCondition(*this); } public: void init(); bool isToleranceReached() const; double getCurrentTolerance() const; }; /******************************************************************************/ /** * @brief Stop condition on function value. * * This stops the optimization when \f$|f\left(\left\{\lambda_{i,t}\right\}\right)-f\left(\left\{\lambda_{i,t-1}\right\}\right)| \leq \mbox{tolerance}\f$, * where \f$f\left(\left\{\lambda_{i, t}\right\}\right)\f$ is the value of the function given the parameter values at iteration \f$t\f$, * and \f$f\left(\left\{\lambda_{i, t-1}\right\}\right)\f$ is the value of the function given the parameter velues at iteration \f$t-1\f$. */ class FunctionStopCondition: public AbstractOptimizationStopCondition { private: /** * @brief The last value of the function. * * This is used by the isToleranceReached() method. */ mutable double lastFunctionValue_; /** * @brief The new value of the function. * * This is used by the isToleranceReached() method. */ mutable double newFunctionValue_; public: FunctionStopCondition(const Optimizer* optimizer); FunctionStopCondition(const Optimizer* optimizer, double tolerance); FunctionStopCondition(const Optimizer* optimizer, int burnin); FunctionStopCondition(const Optimizer* optimizer, double tolerance, int burnin); virtual ~FunctionStopCondition(); #ifndef NO_VIRTUAL_COV FunctionStopCondition* #else Clonable* #endif clone() const { return new FunctionStopCondition(*this); } public: void init(); bool isToleranceReached() const; double getCurrentTolerance() const; }; } //end of namespace bpp. #endif //_OPTIMIZATIONSTOPCONDITION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/BrentOneDimension.h000664 001750 001750 00000010021 12370705300 025127 0ustar00jdutheiljdutheil000000 000000 // // File: BrentOneDimension.h // Created by: Julien Dutheil // Created on: Mon Nov 17 11:45:58 2003 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BRENTONEDIMENSION_H_ #define _BRENTONEDIMENSION_H_ #include "AbstractOptimizer.h" namespace bpp { /** * @brief Brent's optimization for one parameter. * * A description of the algorithm can be found in: * 
 * NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING
 * (ISBN 0-521-43108-5)
 *
* or there: http://en.wikipedia.org/wiki/Brent's_method. */ class BrentOneDimension: public AbstractOptimizer { public: class BODStopCondition: public AbstractOptimizationStopCondition { public: BODStopCondition(BrentOneDimension* bod): AbstractOptimizationStopCondition(bod) { tolerance_ = bod->tol2; burnin_ = 3; } virtual ~BODStopCondition() {} BODStopCondition* clone() const { return new BODStopCondition(*this); } public: bool isToleranceReached() const; double getCurrentTolerance() const; }; friend class BODStopCondition; protected: double a, b, d, e, etemp, fu, fv, fw, fx, p, q, r, tol1, tol2, u, v, w, x, xm; double _xinf, _xsup; bool isInitialIntervalSet_; public: BrentOneDimension(Function* function = 0); virtual ~BrentOneDimension() {} BrentOneDimension* clone() const { return new BrentOneDimension(*this); } public: /** * @name The Optimizer interface. * * @{ */ /** * @brief Initialize optimizer. * * Brent's algorithm needs 2 initial guesses, so you must call the * setInitialInterval() method first. This function actually performs: *
    *
  • Parameter list actualisation;
    • *
  • Initial bracketting;
    • *
  • Function evaluation count reseting.
    • *
*/ double optimize() throw (Exception); //redefinition /** @} */ void doInit(const ParameterList& params) throw (Exception); double doStep() throw (Exception); public: /** * @name Specific method * * @{ */ /** * @brief Set intial search interval. * * @param inf Minimum value. * @param sup Maximum value. */ void setInitialInterval(double inf, double sup); /** @} */ /** * @return 'true' if the initial interval has been correctly set. */ bool isInitialIntervalSet() const { return isInitialIntervalSet_; } public: static double ZEPS; }; } //end of namespace bpp. #endif //_BRENTONEDIMENSION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/Optimizer.h000664 001750 001750 00000027523 12370705300 023546 0ustar00jdutheiljdutheil000000 000000 // // File: Optimizer.h // Created by: Julien Dutheil // Created on: Tue Nov 4 16:01:27 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _OPTIMIZER_H_ #define _OPTIMIZER_H_ #include "Functions.h" #include "../ParameterList.h" #include "OptimizationStopCondition.h" #include "../../Clonable.h" #include "../../Io/OutputStream.h" namespace bpp { /** * @brief An event object which indicates that an optimization event occured. */ class OptimizationEvent { private: Optimizer* optimizer_; public: /** * @param optimizer A pointer toward the optimizer that launched the event. */ OptimizationEvent(Optimizer* optimizer): optimizer_(optimizer) {} OptimizationEvent(const OptimizationEvent& oe): optimizer_(oe.optimizer_) {} OptimizationEvent& operator=(const OptimizationEvent& oe) { optimizer_ = oe.optimizer_; return *this; } virtual ~OptimizationEvent() {} public: /** * @return A pointer toward the optimizer that launched the event. */ Optimizer* getOptimizer() { return optimizer_; } /** * @return A pointer toward the optimizer that launched the event. */ const Optimizer* getOptimizer() const { return optimizer_; } }; /** * @brief The listener interface for receiving optimization events. * * The class that is interested in processing an optimization event implements this interface, * and the object created with that class is registered with a component, * using the component's addOptimizationListener method. * More kinds of events may be processed in the future. */ class OptimizationListener { public: OptimizationListener() {} virtual ~OptimizationListener() {} public: virtual void optimizationInitializationPerformed(const OptimizationEvent& event) = 0; virtual void optimizationStepPerformed(const OptimizationEvent& event) = 0; /** * @return 'true' If this listener modifies the parameter set. */ virtual bool listenerModifiesParameters() const = 0; }; /** * @brief This is the basal interface for all optimization methods. * * An optimizer deals with Function objects. * Optimizer objects are event-driven: they notify listeners when a step is performed. */ class Optimizer: public virtual Clonable { public: Optimizer() {} virtual ~Optimizer() {} #if defined(NO_VIRTUAL_COV) Clonable* clone() const = 0; #else Optimizer* clone() const = 0; #endif public: /** * @brief Set the initial values of the parameters. * * @param params The initial values of parameters. * @throw Exception If a problem occured during initialization. */ virtual void init(const ParameterList& params) throw (Exception) = 0; /** * @return 'true' if this optimizer has been initialized. */ virtual bool isInitialized() const = 0; /** * @brief Perform an optimization step. * * @return the value of the function after this step. * @throw Exception If a problem occured during optimization or if the optimizer has not been initialized. */ virtual double step() throw (Exception) = 0; /** * @return The parameters with their current values. */ virtual const ParameterList& getParameters() const = 0; /** * @return The value associated with a given parameter name. */ virtual double getParameterValue(const std::string& name) const = 0; /** * @brief Get the current function value. * * @return The value of the function at the point specified by _parameters. * @throw NullPointerException If no function is associated with this optimizer. */ virtual double getFunctionValue() const throw (NullPointerException) = 0; /** * @brief Perform as many optimization steps untill the stop condition is met. * * @return The value of the function after optimization is completed. * @throw Exception If a problem occured during optimization or if the optimizer has not been initialized. */ virtual double optimize() throw (Exception) = 0; /** * @brief Set the function to optimize. * * @param function The function to optimize. */ virtual void setFunction(Function* function) = 0; /** * @brief Get the current function being optimized. * * @return A const pointer toward the function being optimized. */ virtual const Function* getFunction() const = 0; /** * @brief Get the current function being optimized. * * @return A const pointer toward the function being optimized. */ virtual Function* getFunction() = 0; /** * @brief Tell if a funciton is associatied to this optimizer. * * @return True if a function has been associated to this optimizer. */ virtual bool hasFunction() const = 0; /** * @brief Set the message handler for this optimizer. * * The message handler keeps all messages that the optimizer may send. * The default handler is set to standard output, but you can pass any * ostream object (cerr, ofstream, etc.). * * A NULL pointer disables message output. * * @param mh The message handler to use. */ virtual void setMessageHandler(OutputStream* mh) = 0; /** * @return The stream used for handling messages, if any. */ virtual OutputStream* getMessageHandler() const = 0; /** * @brief Set the profiler for this optimizer. * * The profiler keeps all the intermediate values taken by the parameters. * The default profiler is set to standard output, but you can pass any * ostream object (cerr, ofstream, etc.). * * A NULL pointer disables message output. * * @param profiler The profiler to use. */ virtual void setProfiler(OutputStream* profiler) = 0; /** * @return The stream used for profiling, if any. */ virtual OutputStream* getProfiler() const = 0; /** * @brief Get the number of function evaluations performed since the * call of the init function. * * @return The number of function evaluations. */ virtual unsigned int getNumberOfEvaluations() const = 0; /** * @brief Set the stop condition of the optimization algorithm. * * @param stopCondition The stop condition to use while optimizing. * @see OptimizationStopCondition. */ virtual void setStopCondition(const OptimizationStopCondition& stopCondition) = 0; /** * @brief Get the stop condition of the optimization algorithm. * * @return The stop condition used while optimizing. */ virtual OptimizationStopCondition* getStopCondition() = 0; /** * @brief Get the stop condition of the optimization algorithm. * * @return The stop condition used while optimizing. */ virtual const OptimizationStopCondition* getStopCondition() const = 0; /** * @brief Get the default stop condition of the optimization algorithm. * * @return The default stop condition used while optimizing. */ virtual OptimizationStopCondition* getDefaultStopCondition() = 0; /** * @brief Get the default stop condition of the optimization algorithm. * * @return The default stop condition used while optimizing. */ virtual const OptimizationStopCondition* getDefaultStopCondition() const = 0; /** * @brief Tell if the tolerance level is reached. * * @return Whether the tolerance is reached or not. * @see OptimizationStopCondition */ virtual bool isToleranceReached() const = 0; /** * @brief Tell if the maximum number of function evaluations is reached. * * @return Whether the maximum number of function evaluations is reached or not. */ virtual bool isMaximumNumberOfEvaluationsReached() const = 0; /** * @brief Set the maximum number of function evaluation to perform during optimization. * * @param max The maximum number of evaluations to perform. */ virtual void setMaximumNumberOfEvaluations(unsigned int max) = 0; /** * @brief Set the verbose level. * * 0 = off * 1 = on * 2 = more verbose * 3 = even more, etc. * * In most cases, only the 0 and 1 levels are implemented. * * @param v verbose level. */ virtual void setVerbose(unsigned int v) = 0; /** * @brief Get the verbose level. * * @return verbose level. */ virtual unsigned int getVerbose() const = 0; /** * @brief Set the constraint policy for this optimizer. * * @param constraintPolicy The constraint policy. */ virtual void setConstraintPolicy(const std::string & constraintPolicy) = 0; /** * @brief Get the constraint policy for this optimizer. * * @return The constraint policy. */ virtual std::string getConstraintPolicy() const = 0; /** * @brief Register a listener to this class. * * All registered listeners will be informed when an optimization event occur. * See the documentation of the class to know what kind of events are supported. * * @param listener A listener to be registered with. */ virtual void addOptimizationListener(OptimizationListener * listener) = 0; }; /** * @brief Save intermediate optimization results to file. */ class BackupListener: public OptimizationListener { private: std::string backupFile_; public: BackupListener(const string& backupFile): backupFile_(backupFile) {} virtual ~BackupListener() {} public: void optimizationInitializationPerformed(const OptimizationEvent& event) {} void optimizationStepPerformed(const OptimizationEvent& event) { std::ofstream bck(backupFile_.c_str(), std::ios::out); bck << "f(x)=" << setprecision(20) << event.getOptimizer()->getFunction()->getValue() << endl; ParameterList pl = event.getOptimizer()->getFunction()->getParameters(); for (unsigned int i = 0; i < pl.size(); ++i) { bck << pl[i].getName() << "=" << setprecision(20) << pl[i].getValue() << std::endl; } bck.close(); } bool listenerModifiesParameters() const { return false; }; }; } //end of namespace bpp. #endif //_OPTIMIZER_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/SimpleMultiDimensions.cpp000664 001750 001750 00000010226 12370705300 026404 0ustar00jdutheiljdutheil000000 000000 // // File: SimpleMultiDimensions.cpp // Created by: Julien Dutheil // Created on: Tue Nov 16 17:51 2004 // /* Copyright or © or Copr. CNRS, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ /******************************************************************************/ #include "SimpleMultiDimensions.h" using namespace bpp; using namespace std; /******************************************************************************/ SimpleMultiDimensions::SimpleMultiDimensions(Function* function): AbstractOptimizer(function), nbParams_(0), optimizer_(function) { setDefaultStopCondition_(new FunctionStopCondition(this)); setStopCondition(*getDefaultStopCondition()); setOptimizationProgressCharacter(""); } /******************************************************************************/ void SimpleMultiDimensions::setFunction(Function* function) { AbstractOptimizer::setFunction(function); optimizer_.setFunction(function); getStopCondition()->init(); } /******************************************************************************/ void SimpleMultiDimensions::doInit(const ParameterList& params) throw (Exception) { nbParams_ = params.size(); if (nbParams_ == 0) return; // Initialize optimizers: unsigned int nbEvalMax = nbEvalMax_ / static_cast(nbParams_); optimizer_.setMaximumNumberOfEvaluations(nbEvalMax); optimizer_.setProfiler(getProfiler()); optimizer_.setMessageHandler(getMessageHandler()); optimizer_.getStopCondition()->setTolerance(getStopCondition()->getTolerance()); optimizer_.setConstraintPolicy(getConstraintPolicy()); optimizer_.setVerbose(getVerbose() > 0 ? getVerbose() - 1 : 0); optimizer_.setInitialInterval(0., 1.); getFunction()->setParameters(getParameters()); } /******************************************************************************/ double SimpleMultiDimensions::doStep() throw (Exception) { double f = getFunction()->getValue(); for (unsigned int i = 0; i < nbParams_; i++) { if (getVerbose() > 0) { cout << getParameters()[i].getName() << ":"; cout.flush(); } // Re-init optimizer according to new values: double v = getParameters()[i].getValue(); double t = std::max(0.000001, std::min(std::abs(v), getStopCondition()->getTolerance())); optimizer_.setInitialInterval(v - t, v + t); optimizer_.init(getParameters().subList(i)); // Optimize through this dimension: f = optimizer_.optimize(); if (getVerbose() > 0) cout << endl; getParameters_().matchParametersValues(getFunction()->getParameters()); nbEval_ += optimizer_.getNumberOfEvaluations(); } tolIsReached_ = nbParams_ <= 1; return f; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/MetaOptimizer.cpp000664 001750 001750 00000016450 12370705300 024705 0ustar00jdutheiljdutheil000000 000000 // // File: MetaOptimizer.cpp // Created by: Julien Dutheil // Created on: Fri Oct 12 16:05 2007 // From file: NewtonBrentMetaOptimizer.cpp // Created on: Tue Nov 17 17:22 2004 // // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ /**************************************************************************/ #include "MetaOptimizer.h" #include "../../App/ApplicationTools.h" using namespace bpp; using namespace std; /**************************************************************************/ string MetaOptimizerInfos::IT_TYPE_STEP = "step"; string MetaOptimizerInfos::IT_TYPE_FULL = "full"; /**************************************************************************/ MetaOptimizer::MetaOptimizer( Function* function, MetaOptimizerInfos* desc, unsigned int n): AbstractOptimizer(function), optDesc_(desc), optParameters_(desc->getNumberOfOptimizers()), nbParameters_(desc->getNumberOfOptimizers()), n_(n), precisionStep_(-1.), stepCount_(0), initialValue_(-1.) { setDefaultStopCondition_(new FunctionStopCondition(this)); setStopCondition(*getDefaultStopCondition()); precisionStep_ = log10(getStopCondition()->getTolerance()) / n_; setOptimizationProgressCharacter(""); } /**************************************************************************/ MetaOptimizer::MetaOptimizer( const MetaOptimizer& opt): AbstractOptimizer(opt), optDesc_(dynamic_cast(opt.optDesc_->clone())), optParameters_(opt.optParameters_), nbParameters_(opt.nbParameters_), n_(opt.n_), precisionStep_(opt.precisionStep_), stepCount_(opt.stepCount_), initialValue_(opt.initialValue_) {} /**************************************************************************/ MetaOptimizer& MetaOptimizer::operator=( const MetaOptimizer& opt) { AbstractOptimizer::operator=(opt); optDesc_ = dynamic_cast(opt.optDesc_->clone()); optParameters_ = opt.optParameters_; nbParameters_ = opt.nbParameters_; n_ = opt.n_; precisionStep_ = opt.precisionStep_; stepCount_ = opt.stepCount_; initialValue_ = opt.initialValue_; return *this; } /**************************************************************************/ MetaOptimizer::~MetaOptimizer() { // Delete all optimizers: delete optDesc_; } /**************************************************************************/ void MetaOptimizer::doInit(const ParameterList& parameters) throw (Exception) { optParameters_.resize(optDesc_->getNumberOfOptimizers()); for (unsigned int i = 0; i < optDesc_->getNumberOfOptimizers(); i++) { optParameters_[i].reset(); for (size_t j = 0; j < optDesc_->getParameterNames(i).size(); j++) { string pname = optDesc_->getParameterNames(i)[j]; if (parameters.hasParameter(pname)) { optParameters_[i].addParameter(parameters.getParameter(pname)); } } nbParameters_[i] = optParameters_[i].size(); } // Initialize optimizers: for (unsigned int i = 0; i < optDesc_->getNumberOfOptimizers(); i++) { if (nbParameters_[i] > 0) { Optimizer * opt = optDesc_->getOptimizer(i); dynamic_cast(opt)->updateParameters(updateParameters()); opt->setProfiler(getProfiler()); opt->setMessageHandler(getMessageHandler()); opt->setConstraintPolicy(getConstraintPolicy()); opt->setVerbose(getVerbose() > 0 ? getVerbose() - 1 : 0); } } // Actualize parameters: getParameters_().matchParametersValues(getFunction()->getParameters()); getFunction()->setParameters(getParameters()); initialValue_ = getFunction()->getValue(); // Reset counter: stepCount_ = 1; // Recompute step if precision has changed: precisionStep_ = (log10(getStopCondition()->getTolerance()) - log10(initialValue_)) / n_; } /**************************************************************************/ double MetaOptimizer::doStep() throw (Exception) { stepCount_++; int tolTest = 0; double tol = getStopCondition()->getTolerance(); if (stepCount_ <= n_) { tol = initialValue_ * pow(10, stepCount_ * precisionStep_); } for (unsigned int i = 0; i < optDesc_->getNumberOfOptimizers(); i++) { if (nbParameters_[i] > 0) { if (getVerbose() > 1 && ApplicationTools::message) { (ApplicationTools::message->endLine() << optDesc_->getName(i)).endLine(); ApplicationTools::message->flush(); } if (optDesc_->requiresFirstOrderDerivatives(i)) dynamic_cast(getFunction())->enableFirstOrderDerivatives(true); if (optDesc_->requiresSecondOrderDerivatives(i)) dynamic_cast(getFunction())->enableSecondOrderDerivatives(true); optParameters_[i].matchParametersValues(getParameters()); Optimizer * opt = optDesc_->getOptimizer(i); opt->getStopCondition()->setTolerance(tol); opt->init(optParameters_[i]); if (optDesc_->getIterationType(i) == MetaOptimizerInfos::IT_TYPE_STEP) opt->step(); else if (optDesc_->getIterationType(i) == MetaOptimizerInfos::IT_TYPE_FULL) opt->optimize(); else throw Exception("MetaOptimizer::step. Unknown iteration type specified."); nbEval_ += opt->getNumberOfEvaluations(); if (optDesc_->requiresFirstOrderDerivatives(i)) dynamic_cast(getFunction())->enableFirstOrderDerivatives(false); if (optDesc_->requiresSecondOrderDerivatives(i)) dynamic_cast(getFunction())->enableSecondOrderDerivatives(false); if (getVerbose() > 1) cout << endl; getParameters_().matchParametersValues(opt->getParameters()); } tolTest += nbParameters_[i] > 0 ? 1 : 0; } tolIsReached_ = (tolTest == 1); return getFunction()->getValue(); } /**************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/OptimizationStopCondition.cpp000664 001750 001750 00000016470 12370705300 027321 0ustar00jdutheiljdutheil000000 000000 // // File: OptimizationStopCondition.cpp // Created by: Julien Dutheil // Created on: Tue Dec 23 11:51:31 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "OptimizationStopCondition.h" #include "Optimizer.h" #include "../VectorTools.h" #include "../NumTools.h" using namespace bpp; using namespace std; /******************************************************************************/ ParametersStopCondition::ParametersStopCondition( const Optimizer* optimizer) : AbstractOptimizationStopCondition(optimizer), lastParametersEstimates_(), newParametersEstimates_() { init(); if (newParametersEstimates_.size() == 0) { cout << "DEBUG: WARNING!!! No parameter passed to ParametersStopCondition constructor. " << "Be sure to have initialized the Optimizer first!" << endl; } } ParametersStopCondition::ParametersStopCondition( const Optimizer* optimizer, double tolerance) : AbstractOptimizationStopCondition(optimizer, tolerance), lastParametersEstimates_(), newParametersEstimates_() { init(); if (newParametersEstimates_.size() == 0) { cout << "DEBUG: WARNING!!! No parameter passed to ParametersStopCondition constructor. " << "Be sure to have initialized the Optimizer first!" << endl; } } ParametersStopCondition::ParametersStopCondition( const Optimizer* optimizer, int burnin) : AbstractOptimizationStopCondition(optimizer, burnin), lastParametersEstimates_(), newParametersEstimates_() { init(); if (newParametersEstimates_.size() == 0) { cout << "DEBUG: WARNING!!! No parameter passed to ParametersStopCondition constructor. " << "Be sure to have initialized the Optimizer first!" << endl; } } ParametersStopCondition::ParametersStopCondition( const Optimizer* optimizer, double tolerance, int burnin) : AbstractOptimizationStopCondition(optimizer, tolerance, burnin), lastParametersEstimates_(), newParametersEstimates_() { init(); if (newParametersEstimates_.size() == 0) { cout << "DEBUG: WARNING!!! No parameter passed to ParametersStopCondition constructor. " << "Be sure to have initialized the Optimizer first!" << endl; } } /******************************************************************************/ void ParametersStopCondition::init() { AbstractOptimizationStopCondition::init(); if (optimizer_->getFunction() != 0) newParametersEstimates_ = optimizer_->getParameters(); } /******************************************************************************/ bool ParametersStopCondition::isToleranceReached() const { callCount_++; lastParametersEstimates_ = newParametersEstimates_; newParametersEstimates_ = optimizer_->getParameters(); if (callCount_ <= burnin_) return false; for (unsigned int i = 0; i < newParametersEstimates_.size(); i++) { Parameter& p = newParametersEstimates_[i]; double lastEstimate = lastParametersEstimates_.getParameter(p.getName()).getValue(); double newEstimate = p.getValue(); double tol = NumTools::abs(newEstimate - lastEstimate); if (tol > tolerance_) { return false; } } return true; } /******************************************************************************/ double ParametersStopCondition::getCurrentTolerance() const { if (callCount_ > burnin_) { double maxTol = 0.; for (unsigned int i = 0; i < newParametersEstimates_.size(); i++) { Parameter& p = newParametersEstimates_[i]; double lastEstimate = lastParametersEstimates_.getParameter(p.getName()).getValue(); double newEstimate = p.getValue(); double tol = NumTools::abs(newEstimate - lastEstimate); if (tol > maxTol) maxTol = tol; } return maxTol; } else { return std::max(tolerance_, 1.); } } /******************************************************************************/ FunctionStopCondition::FunctionStopCondition( const Optimizer* optimizer) : AbstractOptimizationStopCondition(optimizer), lastFunctionValue_(-log(0.)), newFunctionValue_(-log(0.)) { init(); } FunctionStopCondition::FunctionStopCondition( const Optimizer* optimizer, double tolerance) : AbstractOptimizationStopCondition(optimizer, tolerance), lastFunctionValue_(-log(0.)), newFunctionValue_(-log(0.)) { init(); } FunctionStopCondition::FunctionStopCondition( const Optimizer* optimizer, int burnin) : AbstractOptimizationStopCondition(optimizer, burnin), lastFunctionValue_(-log(0.)), newFunctionValue_(-log(0.)) { init(); } FunctionStopCondition::FunctionStopCondition( const Optimizer* optimizer, double tolerance, int burnin) : AbstractOptimizationStopCondition(optimizer, tolerance, burnin), lastFunctionValue_(-log(0.)), newFunctionValue_(-log(0.)) { init(); } FunctionStopCondition::~FunctionStopCondition() {} /******************************************************************************/ void FunctionStopCondition::init() { AbstractOptimizationStopCondition::init(); newFunctionValue_ = -log(0.); if (optimizer_->getFunction() != 0) { newFunctionValue_ = optimizer_->getFunctionValue(); } } /******************************************************************************/ bool FunctionStopCondition::isToleranceReached() const { callCount_++; lastFunctionValue_ = newFunctionValue_; newFunctionValue_ = optimizer_->getFunctionValue(); if (callCount_ <= burnin_) return false; double tol = NumTools::abs(newFunctionValue_ - lastFunctionValue_); return tol < tolerance_; } /******************************************************************************/ double FunctionStopCondition::getCurrentTolerance() const { if (callCount_ > burnin_) return NumTools::abs(newFunctionValue_ - lastFunctionValue_); else return std::max(tolerance_, 1.); } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/FunctionTools.cpp000664 001750 001750 00000011744 12370705300 024723 0ustar00jdutheiljdutheil000000 000000 // // File: FunctionTools.cpp // Created by: Julien Dutheil // Created on: Mon Apr 13 10:47 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "FunctionTools.h" #include "../../App/ApplicationTools.h" using namespace bpp; //From the STL; #include using namespace std; void ParameterGrid::addDimension(const std::string& name, const Vdouble& values) throw (Exception) { if (find(names_.begin(), names_.end(), name) != names_.end()) throw Exception("ParameterGrid::addDimension(). A dimension with name '" + name + "' already exists in the grid."); if (values.size() == 0) throw Exception("ParameterGrid::addDimension(). Empty vector given! The dimension should at least contain one point."); names_.push_back(name); grid_.push_back(values); } const Vdouble& ParameterGrid::getPointsForDimension(const std::string& name) const throw (Exception) { for(unsigned int i = 0; i < names_.size(); i++) if (names_[i] == name) return grid_[i]; throw Exception("ParameterGrid::getPointsForDimension(). No dimension with name '" + name + "' was found in the grid."); } const Vdouble& ParameterGrid::getPointsForDimension(unsigned int i) const throw (IndexOutOfBoundsException) { if (i >= names_.size()) throw IndexOutOfBoundsException("ParameterGrid::getPointsForDimension().", i, 0, names_.size() - 1); return grid_[i]; } size_t ParameterGrid::getTotalNumberOfPoints() const { if (grid_.size() == 0) return 0; size_t n = 1; for (size_t i = 0; i < grid_.size(); i++) n *= grid_[i].size(); return n; } VVdouble* FunctionTools::computeGrid( Function& function, const ParameterGrid& grid) throw (Exception) { //Init stuff... size_t n = grid.getNumberOfDimensions(); VVdouble* data = new VVdouble(); if(n == 0) return data; //Empty data table returned. VVdouble points = grid.getPoints(); //Get the parameter list. this may throw an exception if the grid does not //match the function parameters... ParameterList pl = function.getParameters().subList(grid.getDimensionNames()); for(unsigned int i = 0; i < n; i++) pl.setParameterValue(grid.getDimensionName(i), grid.getPointsForDimension(i)[0]); //Iterate over all dimensions: unsigned int currentDimension = 0; vector currentPointInDimension(n); vector row(n + 1); size_t nbPoints = grid.getTotalNumberOfPoints(); ApplicationTools::displayMessage("Computing likelihood profile..."); for (unsigned int i = 0; true ; i++) { ApplicationTools::displayGauge(i, nbPoints - 1, '='); //We start by adding the current point to the table: for (unsigned int j = 0; j < n; j++) row[j] = pl[j].getValue(); row[n] = function.f(pl); data->push_back(row); //Now increment iterator: bool dimensionChanged = false; while (currentDimension < n && currentPointInDimension[currentDimension] == points[currentDimension].size() - 1) { currentDimension++; dimensionChanged = true; } //Stopping condition: if (currentDimension == n) break; currentPointInDimension[currentDimension]++; if (dimensionChanged) { for (unsigned int j = 0; j < currentDimension; j++) currentPointInDimension[j] = 0; currentDimension = 0; } //Set the new parameter value: for (unsigned int j = 0; j < points.size(); j++) { pl.setParameterValue(grid.getDimensionName(j), points[j][currentPointInDimension[j]]); } } ApplicationTools::displayMessage("\n"); //and we are done: return data; } bpp-core-2.2.0/src/Bpp/Numeric/Function/PowellMultiDimensions.h000664 001750 001750 00000006337 12370705300 026072 0ustar00jdutheiljdutheil000000 000000 // // File: PowellMultiDimensions.h // Created by: Julien Dutheil // Created on: Mon Nov 17 15:16:45 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". zs a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef POWELLMULTIDIMENSIONS_H__ #define POWELLMULTIDIMENSIONS_H__ #include "DirectionFunction.h" #include "AbstractOptimizer.h" #include "../VectorTools.h" namespace bpp { /** * @brief Powell's multi-dimensions optimization algorithm for one parameter. * * A description of the algorithm can be found for example in: * 
 * NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING
 * (ISBN 0-521-43108-5)
 *
*/ class PowellMultiDimensions: public AbstractOptimizer { public: class PMDStopCondition: public AbstractOptimizationStopCondition { public: PMDStopCondition(PowellMultiDimensions* pmd): AbstractOptimizationStopCondition(pmd) {} virtual ~PMDStopCondition() {} PMDStopCondition* clone() const { return new PMDStopCondition(*this); } public: bool isToleranceReached() const; double getCurrentTolerance() const; }; friend class PMDStopCondition; protected: double fp_; double fret_; ParameterList pt_; VVdouble xi_; unsigned int ncom_; ParameterList pcom_, xicom_; DirectionFunction f1dim_; public: PowellMultiDimensions(Function* function); virtual ~PowellMultiDimensions() {} PowellMultiDimensions* clone() const { return new PowellMultiDimensions(*this); } public: /** * @name The Optimizer interface. * * @{ */ double optimize() throw (Exception); /** @} */ void doInit(const ParameterList & params) throw (Exception); double doStep() throw (Exception); }; } //end of namespace bpp. #endif //_POWELLMULTIDIMENSIONS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/BfgsMultiDimensions.h000664 001750 001750 00000007150 12370705300 025503 0ustar00jdutheiljdutheil000000 000000 // // File: BfgsMultiDimensions.h // Created by: Laurent Guéguen // Created on: Dec 16 13:49 2010 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BFGSMULTIDIMENSIONS_H_ #define _BFGSMULTIDIMENSIONS_H_ #include "AbstractOptimizer.h" #include "DirectionFunction.h" #include "../VectorTools.h" namespace bpp { /** * @brief Broyden–Fletcher–Goldfarb–Shanno (BFGS) optimization method. * * with a modification on the bounds taken from: * An active set limited memory BFGS algorithm for large-scale bound * constrained optimization, Yunhai Xiao & Dong-Hui Li. Math Meth * Oper Res (2008) 67:443­454 */ class BfgsMultiDimensions: public AbstractOptimizer { protected: //double gtol_; double slope_; // vectors of the Lower & Upper bounds of the parameters Vdouble Up_, Lo_; mutable Vdouble p_, gradient_, xi_, dg_, hdg_; mutable VVdouble hessian_; mutable DirectionFunction f1dim_; public: BfgsMultiDimensions(DerivableFirstOrder* function); virtual ~BfgsMultiDimensions() {} BfgsMultiDimensions* clone() const { return new BfgsMultiDimensions(*this); } public: /** * @name From AbstractOptimizer. * * @{ */ const DerivableFirstOrder* getFunction() const { return dynamic_cast(AbstractOptimizer::getFunction()); } DerivableFirstOrder* getFunction() { return dynamic_cast(AbstractOptimizer::getFunction()); } void doInit(const ParameterList& params) throw (Exception); double doStep() throw (Exception); /** @} */ void getGradient(std::vector& gradient) const; protected: DerivableFirstOrder* getFunction_() { return dynamic_cast(AbstractOptimizer::getFunction_()); } private: /** * Sets the direction for linesearch in case of bounds * To be used after gradient_ & pi_ are computed */ void setDirection(); }; } //end of namespace bpp. #endif //_BFGSMULTIDIMENSIONS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/GoldenSectionSearch.h000664 001750 001750 00000007676 12370705300 025456 0ustar00jdutheiljdutheil000000 000000 // // File: GoldenSectionSearch.h // Created by: Julien Dutheil // Created on: Mon Nov 10 10:42:17 2003 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _GOLDENSECTIONSEARCH_H_ #define _GOLDENSECTIONSEARCH_H_ #include "AbstractOptimizer.h" namespace bpp { /** * @brief Golden Section Search optimization algorithm for one parameter. * * A description of the algorithm can be found in: * 
 * NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING
 * (ISBN 0-521-43108-5)
 *
* or there: * http://en.wikipedia.org/wiki/Golden_section_search. */ class GoldenSectionSearch: public AbstractOptimizer { public: class GSSStopCondition: public AbstractOptimizationStopCondition { public: GSSStopCondition(GoldenSectionSearch* gss): AbstractOptimizationStopCondition(gss) {} virtual ~GSSStopCondition() {} GSSStopCondition* clone() const { return new GSSStopCondition(*this); } public: bool isToleranceReached() const; double getCurrentTolerance() const; }; friend class GSSStopCondition; private: double f1, f2, x0, x1, x2, x3; double xinf_, xsup_; bool isInitialIntervalSet_; public: GoldenSectionSearch(Function* function); virtual ~GoldenSectionSearch() {} GoldenSectionSearch* clone() const { return new GoldenSectionSearch(*this); } public: /** * @name The Optimizer interface. * * @{ */ /** * @brief Initialize optimizer. * * The golden section search needs 2 initial guesses, so you must call the * setInitialInterval() method first. This function actually performs: *
    *
  • Parameter list actualisation;
    • *
  • Initial bracketting;
    • *
  • Function evaluation count reseting.
    • *
*/ double getFunctionValue() const throw (NullPointerException); /** @} */ void doInit(const ParameterList & params) throw (Exception); double doStep() throw (Exception); /** * @name Specific method * * @{ */ /** * @brief Set intial search interval. * * @param inf Minimum value. * @param sup Maximum value. */ void setInitialInterval(double inf, double sup); /** @} */ /** * @return 'true' if the initial interval has been correctly set. */ bool isInitialIntervalSet() const { return isInitialIntervalSet_; } protected: }; } //end of namespace bpp. #endif //_GOLDENSECTIONSEARCH_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/NewtonBacktrackOneDimension.h000664 001750 001750 00000007603 12370705300 027151 0ustar00jdutheiljdutheil000000 000000 // // File: NewtonBacktrackOneDimension.h // Created by: Laurent Guéguen // Created on: jeudi 16 décembre 2010, à 15h 43 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _NEWTONBACKTRACKONEDIMENSION_H_ #define _NEWTONBACKTRACKONEDIMENSION_H_ #include "AbstractOptimizer.h" namespace bpp { /** * @brief Newton's backtrack nearly optimization for one parameter. * * * This algorithm looks for a value that 'sufficiently low' enough * near the minimum of the function, but does not look for the * minimum. It needs the first derivative of a function. * * Search a 'sufficiently low' value for a function in a given * direction. * * This function implements the algorithm described for example in page 385 of * * 
   * NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING
   * (ISBN 0-521-43108-5)
   *
*/ class NewtonBacktrackOneDimension: public AbstractOptimizer { public: class NBODStopCondition: public AbstractOptimizationStopCondition { public: NBODStopCondition(NewtonBacktrackOneDimension* bod): AbstractOptimizationStopCondition(bod) {} virtual ~NBODStopCondition() {} NBODStopCondition* clone() const { return new NBODStopCondition(*this); } public: void init() {} bool isToleranceReached() const { return false; } double getCurrentTolerance() const { return 0; } }; friend class NBODStopCondition; public: /* *@brief Constructor @param function a pointer to the function @param slope the slope of the backtrack @param test the inverse factor on the stop tolerance * */ NewtonBacktrackOneDimension(Function* function, double slope, double test); virtual ~NewtonBacktrackOneDimension() {} NewtonBacktrackOneDimension* clone() const { return new NewtonBacktrackOneDimension(*this); } private: double fold_, f_, a_, alam_, alamin_, alam2_, b_, disc_, f2_, rhs1_, rhs2_, slope_, test_, tmplam_; public: void doInit(const ParameterList& params) throw (Exception); double doStep() throw (Exception); protected: DerivableFirstOrder* getFunction_() { return dynamic_cast(AbstractOptimizer::getFunction_()); } }; } //end of namespace bpp. #endif //_NEWTONBACKTRACKONEDIMENSION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/DownhillSimplexMethod.cpp000664 001750 001750 00000016023 12370705300 026373 0ustar00jdutheiljdutheil000000 000000 // // File: DownhillSimplexMethod.cpp // Created by: Julien Dutheil // Created on: Tue Nov 4 17:10:05 2003 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "DownhillSimplexMethod.h" #include "../NumTools.h" using namespace bpp; using namespace std; /******************************************************************************/ double DownhillSimplexMethod::DSMStopCondition::getCurrentTolerance() const { const DownhillSimplexMethod* dsm = dynamic_cast(optimizer_); double rTol = 2.0 * NumTools::abs(dsm->y_[dsm->iHighest_] - dsm->y_[dsm->iLowest_]) / (NumTools::abs(dsm->y_[dsm->iHighest_]) + NumTools::abs(dsm->y_[dsm->iLowest_])); return rTol; } /******************************************************************************/ DownhillSimplexMethod::DownhillSimplexMethod(Function* function): AbstractOptimizer(function), simplex_(), y_(), pSum_(), iHighest_(0), iNextHighest_(0), iLowest_(0) { // Default values: nbEvalMax_ = 5000; setDefaultStopCondition_(new DSMStopCondition(this)); setStopCondition(*getDefaultStopCondition()); } /******************************************************************************/ void DownhillSimplexMethod::doInit(const ParameterList& params) throw (Exception) { size_t nDim = getParameters().size(); nbEval_ = 0; // Initialize the simplex: simplex_.resize(nDim + 1); y_.resize(nDim + 1); double lambda = 0.2; //20% of the parameter value. for(unsigned int i = 1; i < nDim + 1; i++) { // Copy the vector... simplex_[i] = getParameters(); // ... and set the initial values. for(unsigned int j = 0; j < nDim; j++) { //Hummm... that does not work when the first point is 0!!! where does this come from??? //simplex_[i][j].setValue(getParameters()[j].getValue() * (1. + (j == i - 1 ? lambda : 0.))); simplex_[i][j].setValue(getParameters()[j].getValue() + (j == i - 1 ? lambda : 0.)); } //Compute the corresponding f value: y_[i] = getFunction()->f(simplex_[i]); nbEval_++; } //Last function evaluation, setting current value: simplex_[0] = getParameters(); y_[0] = getFunction()->f(simplex_[0]); nbEval_++; pSum_ = getPSum(); } /******************************************************************************/ double DownhillSimplexMethod::doStep() throw (Exception) { // The number of dimensions of the parameter space: size_t nDim = simplex_.getDimension(); size_t mpts = nDim + 1; iLowest_ = 0; // First we must determine which point is the highest (worst), // next-highest, and lowest (best), by looping over the points // in the simplex. if(y_[0] > y_[1]) { iHighest_ = 0; iNextHighest_ = 1; } else { iHighest_ = 1; iNextHighest_ = 0; } for(unsigned int i = 0; i < mpts; i++) { if (y_[i] <= y_[iLowest_]) iLowest_ = i; if (y_[i] > y_[iHighest_]) { iNextHighest_ = iHighest_; iHighest_ = i; } else if(y_[i] > y_[iNextHighest_] && i != iHighest_) iNextHighest_ = i; } // Set current best point: getParameters_() = simplex_[iLowest_]; // Begin a new iteration. // First extrapolate by a factor -1 through the face of the simplex // across from high point, i.e., reflect the simplex from the high point.

double yTry = tryExtrapolation(-1.0); if (yTry <= y_[iLowest_]) { // Expansion. yTry = tryExtrapolation(2.0); } else if (yTry >= y_[iNextHighest_]) { // Contraction. double ySave = y_[iHighest_]; yTry = tryExtrapolation(0.5); if (yTry >= ySave) { for (size_t i = 0; i < mpts; i++) { if (i != iLowest_) { for (size_t j = 0; j < nDim; j++) { pSum_[j].setValue(0.5 * (simplex_[i][j].getValue() + simplex_[iLowest_][j].getValue())); simplex_[i][j].setValue(pSum_[j].getValue()); } y_[i] = getFunction()->f(pSum_); nbEval_++; } } nbEval_ += static_cast(nDim); pSum_ = getPSum(); } } return y_[iLowest_]; } /******************************************************************************/ double DownhillSimplexMethod::optimize() throw (Exception) { AbstractOptimizer::optimize(); // set best shot: return getFunction()->f(simplex_[iLowest_]); } /******************************************************************************/ ParameterList DownhillSimplexMethod::getPSum() { size_t ndim = simplex_.getDimension(); size_t mpts = ndim + 1; // Get a copy... ParameterList pSum = getParameters(); // ... and initializes it. for (size_t j = 0; j < ndim; j++) { double sum = 0.; for (size_t i = 0; i < mpts; i++) { sum += simplex_[i][j].getValue(); } pSum[j].setValue(sum); } return pSum; } /******************************************************************************/ double DownhillSimplexMethod::tryExtrapolation(double fac) { size_t ndim = simplex_.getDimension(); double fac1, fac2, yTry; fac1 = (1.0 - fac) / static_cast(ndim); fac2 = fac1 - fac; // Get a copy... ParameterList pTry = getParameters(); // and initialize it: for (size_t j = 0; j < ndim; j++) { pTry[j].setValue(pSum_[j].getValue() * fac1 - simplex_[iHighest_][j].getValue() * fac2); } // Now compute the function for this new set of parameters: yTry = getFunction()->f(pTry); nbEval_++; // Then test this new point: if (yTry < y_[iHighest_]) { y_[iHighest_] = yTry; for (size_t j = 0; j < ndim; j++) { pSum_[j].setValue(pSum_[j].getValue() + pTry[j].getValue() - simplex_[iHighest_][j].getValue()); simplex_[iHighest_][j].setValue(pTry[j].getValue()); } } return yTry; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/NewtonBacktrackOneDimension.cpp000664 001750 001750 00000010121 12370705300 027471 0ustar00jdutheiljdutheil000000 000000 // // File: NewtonBacktrackOneDimension.cpp // Created by: Laurent Guéguen // Created on: jeudi 16 décembre 2010, à 15h 45 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "NewtonBacktrackOneDimension.h" #include "../NumTools.h" #include "../../Text/TextTools.h" using namespace bpp; /******************************************************************************/ NewtonBacktrackOneDimension::NewtonBacktrackOneDimension(Function* function, double slope, double test) : AbstractOptimizer(function), fold_(0), f_(0), a_(0), alam_(0), alamin_(0), alam2_(0), b_(0), disc_(0), f2_(0), rhs1_(0), rhs2_(0), slope_(slope), test_(test), tmplam_(0) { setDefaultStopCondition_(new NBODStopCondition(this)); setStopCondition(*getDefaultStopCondition()); setMaximumNumberOfEvaluations(10000); } /******************************************************************************/ void NewtonBacktrackOneDimension::doInit(const ParameterList& params) throw (Exception) { // Set the initial value (no use here! Use setInitialValues() instead). if(params.size() != 1) throw Exception("NewtonBacktrackOneDimension::init(). This optimizer only deals with one parameter."); fold_ = getFunction()->f(getParameters()); getStopCondition()->setTolerance(getStopCondition()->getTolerance()/test_); alamin_=getStopCondition()->getTolerance(); alam_=1; } /******************************************************************************/ double NewtonBacktrackOneDimension::doStep() throw (Exception) { if (alam_f(getParameters()); if (f_<=fold_+alam_*0.0001*slope_){ tolIsReached_=true; return f_; } if (alam_==1){ tmplam_=-slope_/(2.0*(f_-fold_-slope_)); f2_=f_; alam_=tmplam_>0.1?tmplam_:0.1; return f_; } rhs1_= f_-fold_-alam_*slope_; rhs2_= f2_-fold_-alam2_*slope_; a_=(rhs1_/(alam_*alam_)-rhs2_/(alam2_*alam2_))/(alam_-alam2_); b_=(-alam2_*rhs1_/(alam_*alam_)+alam_*rhs2_/(alam2_*alam2_))/(alam_-alam2_); if (a_==0.0) tmplam_= -slope_/(2.0*b_); else { disc_=b_*b_-3.0*a_*slope_; if (disc_<0.0) tmplam_=0.5*alam_; else if (b_<=0) tmplam_=(-b_+sqrt(disc_))/(3.0*a_); else tmplam_=-slope_/(b_+sqrt(disc_)); } if (tmplam_> 0.5* alam_) tmplam_=0.5*alam_; alam2_=alam_; f2_=f_; alam_=tmplam_>0.1*alam_?tmplam_:0.1*alam_; return f_; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/DownhillSimplexMethod.h000664 001750 001750 00000011477 12370705300 026050 0ustar00jdutheiljdutheil000000 000000 // // File: DownhillSimplexMethod.h // Created by: Julien Dutheil // Created on: Tue Nov 4 17:10:05 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _DOWNHILLSIMPLEXMETHOD_H_ #define _DOWNHILLSIMPLEXMETHOD_H_ #include "AbstractOptimizer.h" #include "../VectorTools.h" // From the STL: #include namespace bpp { /** * @brief This implements the Downhill Simplex method in multidimensions. * * A description of the algorithm can be found in: * 
 * NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING
 * (ISBN 0-521-43108-5)
 *
* or there: * http://en.wikipedia.org/wiki/Nelder-Mead_method. */ class DownhillSimplexMethod: public AbstractOptimizer { public: class DSMStopCondition: public AbstractOptimizationStopCondition { public: DSMStopCondition(DownhillSimplexMethod * dsm): AbstractOptimizationStopCondition(dsm) {} virtual ~DSMStopCondition() {} DSMStopCondition* clone() const { return new DSMStopCondition(*this); } public: bool isToleranceReached() const { return (getCurrentTolerance() < tolerance_); } double getCurrentTolerance() const; }; friend class DSMStopCondition; private: class Simplex { private: std::vector parameters_; public: // Class constructor and destructor: Simplex(): parameters_() {} virtual ~Simplex() {} public: // Methods: const ParameterList& operator[](size_t i) const { return parameters_[i]; } ParameterList& operator[](size_t i) { return parameters_[i]; } void resize(size_t size) { parameters_.resize(size); } size_t getDimension() const { return parameters_[0].size(); } }; protected: Simplex simplex_; Vdouble y_; ParameterList pSum_; unsigned int iHighest_, iNextHighest_, iLowest_; public: /** * @brief Build a new Downhill Simplex optimizer. * * @param function A pointer toward an object implementing the Optimizable interface. */ DownhillSimplexMethod(Function * function); virtual ~DownhillSimplexMethod() {} #ifndef NO_VIRTUAL_COV DownhillSimplexMethod* #else Clonable* #endif clone() const { return new DownhillSimplexMethod(*this); } public: /** * @name The Optimizer interface. * * @{ */ /** * @brief Multidimensional minimization of the function function_ by the * downhill simplex method of Nelder and Mead. */ double optimize() throw (Exception); /** @} */ void doInit(const ParameterList& params) throw (Exception); double doStep() throw (Exception); protected: /** * @name Specific inner methods * * @{ */ /** * @brief Update the pSum_ variable. */ ParameterList getPSum(); /** * @brief Extrapolates by a factor fac through the face of the simplex from the high point. * Try the new point and replaces the high point if it is better. * * @param fac Extrapolation factor. * @return The value of the function for the new point. */ double tryExtrapolation(double fac); /** @} */ }; } //end of namespace bpp. #endif //_DOWNHILLSIMPLEXMETHOD_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/ConjugateGradientMultiDimensions.h000664 001750 001750 00000006724 12370705300 030225 0ustar00jdutheiljdutheil000000 000000 // // File: ConjugateGradientMultiDimensions.h // Created by: Julien Dutheil // Created on: Wed Apr 11 16:51 2007 // /* Copyright or © or Copr. CNRS, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _CONJUGATEGRADIENTMULTIDIMENSIONS_H_ #define _CONJUGATEGRADIENTMULTIDIMENSIONS_H_ #include "AbstractOptimizer.h" #include "BrentOneDimension.h" #include "DirectionFunction.h" namespace bpp { /** * @brief Conjugate gradient optimization method. * * A description of the algorithm can be found in: * 
   * NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING
   * (ISBN 0-521-43108-5)
   *
* or there: * http://en.wikipedia.org/wiki/Conjugate_gradient. */ class ConjugateGradientMultiDimensions: public AbstractOptimizer { protected: BrentOneDimension optimizer_; //One dimensional optimizer. std::vector xi_, h_, g_; DirectionFunction f1dim_; public: ConjugateGradientMultiDimensions(DerivableFirstOrder* function); virtual ~ConjugateGradientMultiDimensions() {} ConjugateGradientMultiDimensions* clone() const { return new ConjugateGradientMultiDimensions(*this); } public: /** * @name From AbstractOptimizer. * * @{ */ const DerivableFirstOrder* getFunction() const { return dynamic_cast(AbstractOptimizer::getFunction()); } DerivableFirstOrder* getFunction() { return dynamic_cast(AbstractOptimizer::getFunction()); } void doInit(const ParameterList& params) throw (Exception); double doStep() throw (Exception); /** @} */ void getGradient(std::vector& gradient) const; protected: DerivableFirstOrder* getFunction_() { return dynamic_cast(AbstractOptimizer::getFunction_()); } }; } //end of namespace bpp. #endif //_CONJUGATEGRADIENTMULTIDIMENSIONS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/SimpleNewtonMultiDimensions.cpp000664 001750 001750 00000007770 12370705300 027611 0ustar00jdutheiljdutheil000000 000000 // // File: SimpleNewtonMultiDimensions.cpp // Created by: Julien Dutheil // Created on: Thu Apr 26 15:29 2007 // /* Copyright or © or Copr. CNRS, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ /******************************************************************************/ #include "SimpleNewtonMultiDimensions.h" using namespace bpp; using namespace std; /******************************************************************************/ SimpleNewtonMultiDimensions::SimpleNewtonMultiDimensions(DerivableSecondOrder* function): AbstractOptimizer(function), nbParams_(0), optimizer_(function) { setDefaultStopCondition_(new FunctionStopCondition(this)); setStopCondition(*getDefaultStopCondition()); setOptimizationProgressCharacter(""); } /******************************************************************************/ void SimpleNewtonMultiDimensions::setFunction(Function* function) { AbstractOptimizer::setFunction(function); optimizer_.setFunction(function); } /******************************************************************************/ void SimpleNewtonMultiDimensions::doInit(const ParameterList& params) throw (Exception) { nbParams_ = params.size(); if (nbParams_ == 0) return; // Initialize optimizers: unsigned int nbEvalMax = nbEvalMax_ / static_cast(nbParams_); optimizer_.setMaximumNumberOfEvaluations(nbEvalMax); optimizer_.setProfiler(getProfiler()); optimizer_.setMessageHandler(getMessageHandler()); optimizer_.getStopCondition()->setTolerance(getStopCondition()->getTolerance()); optimizer_.setConstraintPolicy(getConstraintPolicy()); optimizer_.setVerbose(getVerbose() > 0 ? getVerbose() - 1 : 0); optimizer_.setMaximumNumberOfCorrections(10); getFunction()->setParameters(getParameters()); } /******************************************************************************/ double SimpleNewtonMultiDimensions::doStep() throw (Exception) { double f = getFunction()->getValue(); for (unsigned int i = 0; i < nbParams_; i++) { if (getVerbose() > 0) { cout << getParameters()[i].getName() << ":"; cout.flush(); } // Re-init optimizer according to new values: optimizer_.init(getParameters().subList(i)); // Optimize through this dimension: f = optimizer_.optimize(); if (getVerbose() > 0) cout << endl; getParameters_().matchParametersValues(getFunction()->getParameters()); nbEval_ += optimizer_.getNumberOfEvaluations(); } tolIsReached_ = nbParams_ <= 1; return f; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/OneDimensionOptimizationTools.cpp000664 001750 001750 00000023160 12370705300 030127 0ustar00jdutheiljdutheil000000 000000 // // File: OneDimensionOptimizationTools.cpp // Created by: Julien Dutheil // Created on: Mon Nov 17 11:15:22 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This file is part of the Bio++ project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "NewtonBacktrackOneDimension.h" #include "BrentOneDimension.h" #include "OneDimensionOptimizationTools.h" #include "../NumTools.h" #include "../NumConstants.h" using namespace bpp; using namespace std; /****************************************************************************** * The Point class * ******************************************************************************/ inline void BracketPoint::set(double xval, double fval) { this->x = xval; this->f = fval; } /****************************************************************************** * The Bracket class * ******************************************************************************/ inline void Bracket::setA(double xa, double fa) { a.set(xa, fa); } inline void Bracket::setB(double xb, double fb) { b.set(xb, fb); } inline void Bracket::setC(double xc, double fc) { c.set(xc, fc); } /******************************************************************************/ Bracket OneDimensionOptimizationTools::bracketMinimum( double a, double b, Function* function, ParameterList parameters) { Bracket bracket; // Copy the parameter to use. bracket.a.x = a; parameters[0].setValue(bracket.a.x); bracket.a.f = function->f(parameters); bracket.b.x = b; parameters[0].setValue(bracket.b.x); bracket.b.f = function->f(parameters); if (bracket.b.f > bracket.a.f) { // Switch roles of first and second point so that we can go downhill // in the direction from a to b. NumTools::swap(bracket.a.x, bracket.b.x); NumTools::swap(bracket.a.f, bracket.b.f); } // First guess for third point: bracket.c.x = bracket.b.x + NumConstants::GOLDEN_RATIO_PHI() * (bracket.b.x - bracket.a.x); parameters[0].setValue(bracket.c.x); bracket.c.f = function->f(parameters); // Keep returning here until we bracket: while (bracket.b.f > bracket.c.f) { // Compute xu by parabolic extrapolation from a, b, c. TINY is used to prevent // any possible division by 0. double r = (bracket.b.x - bracket.a.x) * (bracket.b.f - bracket.c.f); double q = (bracket.b.x - bracket.c.x) * (bracket.b.f - bracket.a.f); double xu = bracket.b.x - ((bracket.b.x - bracket.c.x) * q - (bracket.b.x - bracket.a.x) * r) / (2.0 * NumTools::sign(NumTools::max(NumTools::abs(q - r), NumConstants::VERY_TINY()), q - r)); double xulim = (bracket.b.x) + GLIMIT * (bracket.c.x - bracket.b.x); double fu; // We don't go farther than this. // Test various possibilities: if ((bracket.b.x - xu) * (xu - bracket.c.x) > 0.0) { parameters[0].setValue(xu); fu = function->f(parameters); if (fu < bracket.c.f) { bracket.setA(bracket.b.x, bracket.b.f); bracket.setB(xu, fu); return bracket; } else if (fu > bracket.b.f) { bracket.setC(xu, fu); return bracket; } // Parabolic fit was no use. // Use default magnification. xu = bracket.c.x + NumConstants::GOLDEN_RATIO_PHI() * (bracket.c.x - bracket.b.x); parameters[0].setValue(xu); fu = function->f(parameters); } else if ((bracket.c.x - xu) * (xu - xulim) > 0.0) { // Parabolic fit is between point 3 and its allowed limit. parameters[0].setValue(xu); fu = function->f(parameters); if (fu < bracket.c.f) { NumTools::shift(bracket.b.x, bracket.c.x, xu, bracket.c.x + NumConstants::GOLDEN_RATIO_PHI() * (bracket.c.x - bracket.b.x)); parameters[0].setValue(xu); NumTools::shift(bracket.b.f, bracket.c.f, fu, function->f(parameters)); } } else if ((xu - xulim) * (xulim - bracket.c.x) >= 0.0) { // Limit parabolic xu to maximum allowed value. xu = xulim; parameters[0].setValue(xu); fu = function->f(parameters); } else { // Reject parabolic xu, use default magnification. xu = bracket.c.x + NumConstants::GOLDEN_RATIO_PHI() * (bracket.c.x - bracket.b.x); parameters[0].setValue(xu); fu = function->f(parameters); } // Eliminate oldest point and continue. NumTools::shift(bracket.a.x, bracket.b.x, bracket.c.x, xu); NumTools::shift(bracket.a.f, bracket.b.f, bracket.c.f, fu); } return bracket; } /******************************************************************************/ unsigned int OneDimensionOptimizationTools::lineMinimization( DirectionFunction& f1dim, ParameterList& parameters, std::vector& xi, double tolerance, OutputStream* profiler, OutputStream* messenger, unsigned int verbose) { // Initial guess for brackets: double ax = 0.; double xx = 0.01; f1dim.setConstraintPolicy(AutoParameter::CONSTRAINTS_AUTO); f1dim.setMessageHandler(messenger); f1dim.init(parameters, xi); BrentOneDimension bod(&f1dim); bod.setMessageHandler(messenger); bod.setProfiler(profiler); bod.setVerbose(verbose >= 1 ? 1 : 0); bod.setOptimizationProgressCharacter("."); bod.getStopCondition()->setTolerance(0.01); bod.setInitialInterval(ax, xx); bod.setConstraintPolicy(AutoParameter::CONSTRAINTS_KEEP); ParameterList singleParameter; singleParameter.addParameter(Parameter("x", 0.0)); bod.init(singleParameter); bod.optimize(); // Update parameters: // parameters.matchParametersValues(f1dim.getFunction()->getParameters()); double xmin = f1dim.getParameters()[0].getValue(); for (size_t j = 0; j < parameters.size(); j++) { xi[j] *= xmin; parameters[j].setValue(parameters[j].getValue() + xi[j]); } return bod.getNumberOfEvaluations(); } /******************************************************************************/ unsigned int OneDimensionOptimizationTools::lineSearch(DirectionFunction& f1dim, ParameterList& parameters, std::vector& xi, std::vector& gradient, OutputStream* profiler, OutputStream* messenger, unsigned int verbose) { size_t size = xi.size(); f1dim.setConstraintPolicy(AutoParameter::CONSTRAINTS_AUTO); f1dim.setMessageHandler(messenger); f1dim.init(parameters, xi); double slope = 0; for (size_t i = 0; i < size; i++) { slope += xi[i] * gradient[i]; } // if (slope>=0) // throw Exception("Slope problem in OneDimensionOptimizationTools::lineSearch. Slope="+TextTools::toString(slope)); double x, temp, test = 0; for (size_t i = 0; i < size; ++i) { x = abs(parameters[i].getValue()); temp = abs(xi[i]); if (x > 1.0) temp /= x; if (temp > test) test = temp; } NewtonBacktrackOneDimension nbod(&f1dim, slope, test); nbod.setMessageHandler(messenger); nbod.setProfiler(profiler); nbod.setVerbose(verbose >= 1 ? 1 : 0); nbod.setOptimizationProgressCharacter("."); nbod.getStopCondition()->setTolerance(0.0001); // nbod.setInitialInterval(ax, xx); nbod.setConstraintPolicy(AutoParameter::CONSTRAINTS_KEEP); ParameterList singleParameter; singleParameter.addParameter(Parameter("x", 0.0)); nbod.init(singleParameter); nbod.optimize(); // Update parameters: // parameters.matchParametersValues(f1dim.getFunction()->getParameters()); double xmin = f1dim.getParameters()[0].getValue(); for (unsigned int j = 0; j < parameters.size(); j++) { xi[j] *= xmin; parameters[j].setValue(parameters[j].getValue() + xi[j]); } return nbod.getNumberOfEvaluations(); } /******************************************************************************/ double OneDimensionOptimizationTools::GLIMIT = 100.0; /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/DirectionFunction.cpp000664 001750 001750 00000007112 12370705300 025535 0ustar00jdutheiljdutheil000000 000000 // // File: DirectionFunction.cpp // Created by: Julien Dutheil // Created on: Wed Apr 11 17:28 2007 // From file PowellMultiDimensions.cpp // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "DirectionFunction.h" using namespace bpp; using namespace std; /******************************************************************************/ void DirectionFunction::setParameters(const ParameterList & params) throw (ParameterNotFoundException, ConstraintException) { params_ = params; double x = params_[0].getValue(); for(unsigned int j = 0; j < p_.size(); j++) { // cout << p_[j].getValue() << " " << x << " " << xi_[j] << endl; xt_[j].setValue((p_[j].getValue()) + x * xi_[j]); } function_->setParameters(xt_); } /******************************************************************************/ double DirectionFunction::getValue() const throw (Exception) { return function_->getValue(); } /******************************************************************************/ const ParameterList & DirectionFunction::getParameters() const throw (Exception) { return params_; } /******************************************************************************/ void DirectionFunction::init(const ParameterList & p, const vector & xi) { p_ = p; xi_ = xi; if(constraintPolicy_ == AutoParameter::CONSTRAINTS_AUTO) autoParameter(); else if(constraintPolicy_ == AutoParameter::CONSTRAINTS_IGNORE) ignoreConstraints(); xt_ = p_; } /******************************************************************************/ void DirectionFunction::autoParameter() { for(unsigned int i = 0; i < p_.size(); i++) { AutoParameter ap(p_[i]); ap.setMessageHandler(messenger_); p_.setParameter(i, ap); } } /******************************************************************************/ void DirectionFunction::ignoreConstraints() { for(unsigned int i = 0; i < p_.size(); i++) { p_[i].removeConstraint(); } } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Function/OneDimensionOptimizationTools.h000664 001750 001750 00000010770 12370705300 027577 0ustar00jdutheiljdutheil000000 000000 // // File: OneDimensionOptimizationTools.h // Created by: Julien Dutheil // Created on: Mon Nov 17 11:15:22 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This file is part of the Bio++ project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _ONEDIMENSIONOPTIMIZATIONTOOLS_H_ #define _ONEDIMENSIONOPTIMIZATIONTOOLS_H_ #include "Functions.h" #include "DirectionFunction.h" #include "../../Io/OutputStream.h" namespace bpp { class BracketPoint { public: double x; double f; public: // Constructor and destructor: BracketPoint() : x(0), f(0) {} BracketPoint(double xval, double fval) : x(xval), f(fval) {} virtual ~BracketPoint() {} public: void set(double x, double f); }; class Bracket { public: // Constructor and destructor:: Bracket() : a(), b(), c() {} virtual ~Bracket() {} public: // Methods: void setA(double xa, double fa); void setB(double xb, double fb); void setC(double xc, double fc); public: BracketPoint a, b, c; }; /** * @brief Tools of one parameter-functions optimizations. * * For now, contains only one method to bracket a minimum. */ class OneDimensionOptimizationTools { public: OneDimensionOptimizationTools() {} virtual ~OneDimensionOptimizationTools() {} public: /** * @brief Bracket a minimum. * * Given a function func, and given distinct initial points x1 and x2, * this routine searches in the downhill direction (defined by the function as * evaluated at the initial points) and returns a Bracket object with new points * a.x, b.x and c.x that bracket a minimum of the function. Also returned are the * function values at the three points, a.f, b.f and c.f. * * @param a, b Two initial values for the parameter. * @param function The function to bracket. * @param parameters The parameter to use as a variable. * @return A bracket object. */ static Bracket bracketMinimum(double a, double b, Function* function, ParameterList parameters); static unsigned int lineMinimization(DirectionFunction& f1dim, ParameterList& parameters, std::vector& xi, double tolerance, OutputStream* profiler = 0, OutputStream* messenger = 0, unsigned int verbose = 2); /** * @brief Search a 'sufficiently low' value for a function in a given direction. * * This function performs a similar computation as the lnsrch function defined at page 385 of * * 
   * NUMERICAL RECIPES IN C: THE ART OF SCIENTIFIC COMPUTING
   * (ISBN 0-521-43108-5)
   *
* * without the stpmax argument, since the steps are bounded in another way. */ static unsigned int lineSearch(DirectionFunction& f1dim, ParameterList& parameters, std::vector& xi, std::vector& gradient, OutputStream* profiler = 0, OutputStream* messenger = 0, unsigned int verbose = 2); public: /** * @brief Maximum magnification allowed for a parabolic-fit step. */ static double GLIMIT; }; } // end of namespace bpp. #endif // _ONEDIMENSIONOPTIMIZATIONTOOLS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Function/TwoPointsNumericalDerivative.cpp000664 001750 001750 00000010342 12370705300 027737 0ustar00jdutheiljdutheil000000 000000 // // File: TwoPointsNumericalDerivative.cpp // Created by: Julien Dutheil // Created on: Mon May 28 10:33 2007 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "TwoPointsNumericalDerivative.h" using namespace bpp; using namespace std; void TwoPointsNumericalDerivative::updateDerivatives(const ParameterList parameters) throw (ParameterNotFoundException, ConstraintException) { if (computeD1_ && variables_.size() > 0) { if (function1_) function1_->enableFirstOrderDerivatives(false); if (function2_) function2_->enableSecondOrderDerivatives(false); function_->setParameters(parameters); f1_ = function_->getValue(); string lastVar; bool functionChanged = false; bool start = true; for (unsigned int i = 0; i < variables_.size(); i++) { string var = variables_[i]; if (!parameters.hasParameter(var)) continue; ParameterList p; if (!start) { vector vars(2); vars[0] = var; vars[1] = lastVar; lastVar = var; functionChanged = true; p = parameters.subList(vars); } else { p = parameters.subList(var); lastVar = var; functionChanged = true; start = false; } double value = function_->getParameterValue(var); double h = (1 + std::abs(value)) * h_; // Compute one other point: try { p[0].setValue(value + h); function_->setParameters(p); f2_ = function_->getValue(); } catch (ConstraintException& ce1) { // Right limit raised, use backward approximation: try { p[0].setValue(value - h); function_->setParameters(p); f2_ = function_->getValue(); der1_[i] = (f1_ - f2_) / h; } catch (ConstraintException& ce2) { // PB: can't compute derivative, because of a two narrow interval (lower than h) throw ce2; } } // No limit raised, use forward approximation: der1_[i] = (f2_ - f1_) / h; } // Reset last parameter and compute analytical derivatives if any: if (function1_) function1_->enableFirstOrderDerivatives(computeD1_); if (functionChanged) function_->setParameters(parameters.subList(lastVar)); } else { // Reset initial value and compute analytical derivatives if any. if (function1_) function1_->enableFirstOrderDerivatives(computeD1_); if (function2_) function2_->enableSecondOrderDerivatives(computeD2_); // Just in case derivatives are not computed: function_->setParameters(parameters); f1_ = function_->getValue(); } } bpp-core-2.2.0/src/Bpp/Numeric/Function/AbstractOptimizer.h000664 001750 001750 00000030061 12370705300 025221 0ustar00jdutheiljdutheil000000 000000 // // File: AbstractOptimizer.h // Created by: Julien Dutheil // Created on: Mon Dec 22 12:18:09 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _ABSTRACTOPTIMIZER_H_ #define _ABSTRACTOPTIMIZER_H_ #include "Optimizer.h" namespace bpp { /** * @brief Partial implementation of the Optimizer interface. * * This implementation is designed for unconstrained or simple-bounded optimization. * You should not use it with global contraints. * It also enables the gestion of listeners by maintaining a vector of pointers toward the listener. * Important note: this list of listener is not duplicated in cas of copy of the Optimizer, as * listeners are expected to be bounded ot a particular instance.:if expand("%") == ""|browse confirm w|else|confirm w|endif * * */ class AbstractOptimizer: public virtual Optimizer { private: /** * @brief The function to optimize. */ Function* function_; /** * @brief The parameters that will be optimized. */ ParameterList parameters_; /** * @brief The message handler. */ OutputStream* messageHandler_; /** * @brief The profiler. */ OutputStream* profiler_; /** * @brief The constraint policy. * * Must be one the following: * - CONSTRAINTS_KEEP: keep the constraint associated to the parameters (default). * - CONSTRAINTS_IGNORE: remove all constraints. * - CONSTRAINTS_AUTO: use AutoParameters to deal with constraints. * * @see AutoParameter */ std::string constraintPolicy_; /** * @brief The stoping condition to use while optimizing. */ OptimizationStopCondition* stopCondition_; /** * @brief The default stoping condition to use while optimizing. */ OptimizationStopCondition* defaultStopCondition_; /** * @brief State of the verbose mode: > 0 = enabled. * * This may not be used by the Optimizer. */ unsigned int verbose_; /** * @brief Check if the optimizer have been feeded with initial parameters values. */ bool isInitialized_; time_t startTime_; std::vector listeners_; bool updateParameters_; std::string stepChar_; protected: /** * @brief The maximum number of function evaluations allowed. */ unsigned int nbEvalMax_; /** * @brief The current number of function evaluations achieved. */ unsigned int nbEval_; /** * @brief The current value of the function. */ double currentValue_; /** * @brief Tell if the tolerance level has been reached. * * This field is initilaised by the init() method, maintained by the * step() method and used in the optimize() method. */ bool tolIsReached_; public: AbstractOptimizer(Function* function = 0); AbstractOptimizer(const AbstractOptimizer& opt); AbstractOptimizer& operator=(const AbstractOptimizer& opt); virtual ~AbstractOptimizer() { delete stopCondition_; delete defaultStopCondition_; } public: /** * @name The Optimizer interface. * * @{ */ /** * @brief Basic implementation. * * Store all parameters, call the doInit method, print to profiler, initialize timer and notify all listeners. */ void init(const ParameterList& params) throw (Exception); /** * @brief Basic implementation. * * Check if the optimizer is initialized, check if parameters need update because of listeners, call the doStep method, print the current point to the profiler, notify all listeners and return the current value of the function. */ double step() throw (Exception); /** * @brief Basic implementation. * * Call the step method untill tolerance is reached. */ double optimize() throw (Exception); bool isInitialized() const { return isInitialized_; } const ParameterList& getParameters() const { return parameters_; } double getParameterValue(const std::string& name) const { return parameters_.getParameterValue(name); } void setFunction(Function* function) { function_ = function; if (function) stopCondition_->init(); } const Function* getFunction() const { return function_; } Function* getFunction() { return function_; } bool hasFunction() const { return function_ != 0; } double getFunctionValue() const throw (NullPointerException) { if (!function_) throw NullPointerException("AbstractOptimizer::getFunctionValue. No function associated to this optimizer."); return currentValue_; } void setMessageHandler(OutputStream* mh) { messageHandler_ = mh; } OutputStream* getMessageHandler() const { return messageHandler_; } void setProfiler(OutputStream* profiler) { profiler_ = profiler; } OutputStream* getProfiler() const { return profiler_; } unsigned int getNumberOfEvaluations() const { return nbEval_; } void setStopCondition(const OptimizationStopCondition& stopCondition) { stopCondition_ = dynamic_cast(stopCondition.clone()); } OptimizationStopCondition* getStopCondition() { return stopCondition_; } const OptimizationStopCondition* getStopCondition() const { return stopCondition_; } OptimizationStopCondition* getDefaultStopCondition() { return defaultStopCondition_; } const OptimizationStopCondition* getDefaultStopCondition() const { return defaultStopCondition_; } bool isToleranceReached() const { return tolIsReached_; } bool isMaximumNumberOfEvaluationsReached() const { return nbEval_ >= nbEvalMax_; } void setMaximumNumberOfEvaluations(unsigned int max) { nbEvalMax_ = max; } void setVerbose(unsigned int v) { verbose_ = v; } unsigned int getVerbose() const { return verbose_; } void setConstraintPolicy(const std::string& constraintPolicy) { constraintPolicy_ = constraintPolicy; } std::string getConstraintPolicy() const { return constraintPolicy_; } void addOptimizationListener(OptimizationListener* listener) { if (listener) listeners_.push_back(listener); } /** @} */ /** * @brief Tell if we shall update all parameters after one optimization step. * * This is required only for functions that have non-independent parameters, * which means that setting one parameter value may modify one or several other parameters. * Depending on the optimizer, this may have no effect. * * @param yn true/false */ void updateParameters(bool yn) { updateParameters_ = yn; } /** * @brief Tell if we shall update all parameters after one optimization step. * * This is required only for functions that have non-independent parameters, * which means that setting one parameter value may modify one or several other parameters. * Depending on the optimizer, this may have no effect. * * @return yn true/false */ bool updateParameters() const { return updateParameters_; } /** * @brief Set the character to be displayed during optimization. * * @param c A character. */ void setOptimizationProgressCharacter(const std::string& c) { stepChar_ = c; } /** * @return The character to be displayed during optimization. */ const std::string& getOptimizationProgressCharacter() const { return stepChar_; } protected: /** * @brief This function is called by the init() method and contains all calculations. * * @param params The parameters to use for initialization. */ virtual void doInit(const ParameterList& params) throw (Exception) = 0; /** * @brief This function is called by the step() method and contains all calculations. * * @return The value of the function after the optimization step. */ virtual double doStep() throw (Exception) = 0; /** * @name Inner utilitary functions * * @{ */ /** * @brief Build a list of AutoParameter instead of Parameter. */ void autoParameter(); /** * @brief Remove the constraints of all the arguments. */ void ignoreConstraints(); /** * @brief Print to the profile if there is one. * * @param v The double value to print. */ void profile(double v); /** * @brief Print to the profile if there is one. * * @param v The unsigned int value to print. */ void profile(unsigned int v); /** * @brief Print to the profile if there is one. * * @param s The string to print to the profile. */ void profile(const std::string& s); /** * @brief Print to the profile if there is one and end line. * * @param v The double value to print. */ void profileln(double v); /** * @brief Print to the profile if there is one and end line. * * @param v The unsigned int value to print. */ void profileln(unsigned int v); /** * @brief Print to the profile if there is one and end line. * * @param s The string to print to the profile. */ void profileln(const std::string& s); /** * @brief Print parameters and corresponding function evaluation to profiler. * * @param params The parameters to print. * @param value The function evaluation. */ void printPoint(const ParameterList& params, double value); /** * @brief Give a message to print to the message handler. * * @param message The message to print. */ void printMessage(const std::string& message); /** * @brief Notify all listeners that optimizer initialization was performed. * * This method should be called by the init method. * * @param event An OptimizationEvent object. */ void fireOptimizationInitializationPerformed(const OptimizationEvent& event); /** * @brief Notify all listeners that an optimization step was performed. * * This method should be called by the step method. * * @param event An OptimizationEvent object. */ void fireOptimizationStepPerformed(const OptimizationEvent& event); bool listenerModifiesParameters() const; /** @} */ protected: ParameterList& getParameters_() { return parameters_; } Parameter& getParameter_(size_t i) { return parameters_[i]; } Function* getFunction_() { return function_; } void setDefaultStopCondition_(OptimizationStopCondition* osc) { defaultStopCondition_ = osc; } }; } //end of namespace bpp. #endif //_ABSTRACTOPTIMIZER_H_ bpp-core-2.2.0/src/Bpp/Numeric/ParameterAliasable.h000664 001750 001750 00000015105 12370705300 023506 0ustar00jdutheiljdutheil000000 000000 // // File: ParameterAliasable.h // Created by: Julien Dutheil // Created on: Thu May 14 16:53 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _PARAMETERALIASABLE_H_ #define _PARAMETERALIASABLE_H_ #include "Parametrizable.h" #include "ParameterExceptions.h" #include "ParameterList.h" //From the STL: #include #include namespace bpp { /** * @brief Extend the Parametrizable interface with support for parameter aliases. * * Parameter aliases allows several parameter to be constrained together, and * for instance, be jointly estimated. * The alias relationship is not symmetric: * @code * aliasParameters("a","b"); * @endcode * results in the value of "b" being updated when a is modified, but a will not be updated upon modification of "a". * "b" will also be removed of the list of "independent" parameters. * Furthermore, a parameter can only be aliased with another one: * @code * aliasParameters("a","b"); * aliasParameters("c","b"); //ERROR, throws an exception. * @endcode * However, several parameters can be aliased to the same one: * @code * aliasParameters("a","b"); * aliasParameters("a","c"); * @endcode * In this case, modifying "a" will automatically update the values of "b" and "c", and "b" and "c" are removed from the list of indepedent parameters. * Finally, parameters can be chained: * @code * aliasParameters("a","b"); * aliasParameters("b","c"); * @endcode * is equivallent to the previous example. */ class ParameterAliasable : public virtual Parametrizable { public: ParameterAliasable() {} virtual ~ParameterAliasable() {} public: /** * @brief Get the number of independent parameters. * * @return The number of independent parameters. * If no parameters are aliased, this is equivalent to the getNumberOfParameters() method. */ virtual size_t getNumberOfIndependentParameters() const = 0; /** * @brief Set two parameters as 'aliased'. * * The values of the two parameters will be synchronized, so that setting the value of one parameter will automatically set the value of the other one accordingly. * @param p1 Original parameter. * @param p2 Aliased parameter. * @throw ParameterNotFoundException if p1 or p2 do not correspond to existing parameters. * @throw Exception when trying to perform non-valid association. */ virtual void aliasParameters(const std::string & p1, const std::string & p2) throw (ParameterNotFoundException, Exception) = 0; /** * @brief alias the parameters following the links described in a * map, and update the object accordingly. Cycles in aliasing are * detected and forbidden. * * @param unparsedParams the map of the links : matches for A->B aliasing. * @param verbose verbosity * **/ virtual void aliasParameters(std::map& unparsedParams, bool verbose) = 0; /** * @brief Detach two parameters previously set as 'aliased'. * * The values of the two parameters will now be independent. * @param p1 Original parameter. * @param p2 Aliased parameter. * @throw ParameterNotFoundException if p1 or p2 do not correspond to existing parameters. * @throw Exception when trying to perform non-valid dissociation. */ virtual void unaliasParameters(const std::string & p1, const std::string & p2) throw (ParameterNotFoundException, Exception) = 0; /** * @brief Get the minimal list of parameters to set the model. * * If no parameters are aliased, this is the same a getParameters(). * * @return A minimal set of parameters. */ virtual const ParameterList & getIndependentParameters() const = 0; /** * @return The list of names of the parameters that are aliased with a given parameter. * Depending on the implementation, the function may be recursive or not... * @param name The name of the parameter to look for. */ virtual std::vector getAlias(const std::string& name) const = 0; }; /** * @brief A low-level implementation of the ParameterAliasable interface with void functions. * * @see Parameter, ParameterList, ParameterAliasable */ class ParameterAliasableAdapter: public ParametrizableAdapter { public: ParameterAliasableAdapter() {} virtual ~ParameterAliasableAdapter() {} public: /** * @name The ParameterAliasable interface. * * @{ */ const ParameterList & getIndependentParameters() const { return getParameters(); } void aliasParameters(const std::string & p1, const std::string & p2) throw (ParameterNotFoundException, Exception) {} void unaliasParameters(const std::string & p1, const std::string & p2) throw (ParameterNotFoundException, Exception) {} unsigned int getNumberOfIndependentParameters() const{ return 0; } std::vector getAlias(const std::string& name) const { return std::vector(); } /** @} */ }; } // end of namespace bpp. #endif // _PARAMETERALIASABLE_H_ bpp-core-2.2.0/src/Bpp/Numeric/Constraints.h000664 001750 001750 00000030561 12370705300 022302 0ustar00jdutheiljdutheil000000 000000 // // File: Constraints.h // Created by: Julien Dutheil // Created on: Thu Dec 25 19:35:17 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _CONSTRAINTS_H_ #define _CONSTRAINTS_H_ // From the STL: #include #include #include // From Utils: #include "../Clonable.h" #include "../Text/TextTools.h" #include "../Exceptions.h" #include "NumConstants.h" namespace bpp { /** * @brief The constraint interface. * * It provides a method that tells if a given value is correct. */ class Constraint : public Clonable { public: Constraint() {} virtual ~Constraint() {} Constraint* clone() const = 0; public: /** * @brief Tell if a given value is correct. * * @param value The value to test. * @return True is the value is correct. */ virtual bool isCorrect(double value) const = 0; /** * @brief Tell if all the values in a given interval are correct. * * @param min, max The bounds of the interval. * @return True is the value is correct. */ virtual bool includes(double min, double max) const = 0; /** * @brief Give the nearest limit for a bad value. * * @param value The bad value. * @return The nearer limit. */ virtual double getLimit(double value) const = 0; /** * @brief Give the nearest accepted limit for a bad value. * * The difference with getLimit() is when the Constraint is open at * the limit, in which case the retruned value is the limit +- 1e-12. * * @param value The bad value. * @return The nearer limit. */ virtual double getAcceptedLimit(double value) const = 0; /** * @brief Give a short description on the type of constraint. * * @return A string which describes the constraint. */ virtual std::string getDescription() const = 0; /** * @brief Intersect this Constraint with another one * * @param c the intersected Constraint * @return the intersection */ virtual Constraint* operator&(const Constraint& c) const = 0; /** * @brief Tells if this constraints defines an empty set */ virtual bool isEmpty() const = 0; }; /** * @brief An interval, either bounded or not, which can also have infinite bounds. * * The upper and lower bound can be included or not (strict bound), finite or infinite (in that case, equal to a very large value). * Despite the mathematical non-sense, and infinite bound can be either excluded or included. */ class IntervalConstraint : public Constraint { protected: /** * @brief The boundaries of the interval * **/ double lowerBound_, upperBound_; /** * @brief Boolean flags are true if the boundaries are included * **/ bool inclLowerBound_, inclUpperBound_; /** * * @brief the accepted precision on the boundary (default: 1e-12) **/ double precision_; public: IntervalConstraint() : lowerBound_(NumConstants::MINF()), upperBound_(NumConstants::PINF()), inclLowerBound_(true), inclUpperBound_(true), precision_(NumConstants::TINY()) {} IntervalConstraint(double lowerBound, double upperBound, bool inclLower, bool inclUpper, double precision = NumConstants::TINY()) : lowerBound_(lowerBound), upperBound_(upperBound), inclLowerBound_(inclLower), inclUpperBound_(inclUpper), precision_(precision) {} /** * @brief Create an interval with an infinite lower/upper bound. * * The infinite bound will not be included, following mathematical conventions. * * @param isPositive Tell if the infinite bound is positive or negative. * @param bound The finite bound. * @param incl Tell if the finite bound is included or not. * @param precision Parameter precision. */ IntervalConstraint(bool isPositive, double bound, bool incl, double precision = NumConstants::TINY()) : lowerBound_(isPositive ? bound : NumConstants::MINF()), upperBound_(isPositive ? NumConstants::PINF() : bound), inclLowerBound_(isPositive ? incl : false), inclUpperBound_(isPositive ? false : incl), precision_(precision) {} /** * @brief Create an interval from a string description, using * readDescription method. * **/ IntervalConstraint(std::string& desc) : lowerBound_(NumConstants::MINF()), upperBound_(NumConstants::PINF()), inclLowerBound_(true), inclUpperBound_(true), precision_(NumConstants::TINY()) { readDescription(desc); } virtual ~IntervalConstraint() {} IntervalConstraint* clone() const { return new IntervalConstraint(*this); } public: void setLowerBound(double lowerBound, bool strict) { lowerBound_ = lowerBound; inclLowerBound_ = !strict; } void setUpperBound(double upperBound, bool strict) { upperBound_ = upperBound; inclUpperBound_ = !strict; } double getLowerBound() const { return lowerBound_; } double getUpperBound() const { return upperBound_; } bool strictLowerBound() const { return !inclLowerBound_; } bool strictUpperBound() const { return !inclUpperBound_; } bool finiteLowerBound() const { return lowerBound_ > NumConstants::MINF(); } bool finiteUpperBound() const { return upperBound_ < NumConstants::PINF(); } bool includes(double min, double max) const { return (inclLowerBound_ ? min >= getLowerBound() : min > getLowerBound()) && (inclUpperBound_ ? max <= getUpperBound() : max < getUpperBound()); } virtual bool isCorrect(double value) const { return (inclLowerBound_ ? value >= getLowerBound() : value > getLowerBound()) && (inclUpperBound_ ? value <= getUpperBound() : value < getUpperBound()); } bool operator<(double value) const { return inclUpperBound_ ? upperBound_ < value : upperBound_ <= value; } bool operator>(double value) const { return inclLowerBound_ ? lowerBound_ > value : lowerBound_ >= value; } bool operator<=(double value) const { return upperBound_ <= value; } bool operator>=(double value) const { return lowerBound_ >= value; } double getLimit(double value) const { return isCorrect(value) ? value : (*this >= value ? lowerBound_ : upperBound_); } double getAcceptedLimit(double value) const { return isCorrect(value) ? value : (*this >= value ? strictLowerBound() ? lowerBound_ + precision_ : lowerBound_ : strictUpperBound() ? upperBound_ - precision_ : upperBound_); } double getPrecision() const { return precision_; } std::string getDescription() const { return (inclLowerBound_ ? "[ " : "]") + (finiteLowerBound() ? TextTools::toString(lowerBound_) : "-inf") + "; " + (finiteUpperBound() ? TextTools::toString(upperBound_) : "+inf") + (inclUpperBound_ ? "] " : "["); } /** * * @brief Sets the bounds of the interval from a string. * * @param desc the description in interval-like syntax, with signs * "[", ";", "]" as well as floats and "-inf" and "inf". * **/ void readDescription(std::string& desc) { size_t pdp=desc.find(";"); size_t dc=desc.find_first_of("[]",1); if (dc==std::string::npos || pdp==std::string::npos || (desc[0]!=']' && desc[0]!='[') || (pdp >=dc)) throw Exception("Constraints::readDescription. Wrong description:" + desc); std::string deb=desc.substr(1,pdp-1); std::string fin=desc.substr(pdp+1, dc-pdp-1); inclLowerBound_=(desc[0]=='['); inclUpperBound_=(desc[dc]==']'); lowerBound_ = (deb=="-inf")?NumConstants::MINF():TextTools::toDouble(deb); upperBound_ = ((fin=="+inf") || (fin=="inf"))?NumConstants::PINF():TextTools::toDouble(fin); } /** * @brief Intersect this IntervalConstraint with another one * * @param c the intersected IntervalConstraint * @return the intersection, or NULL if c is not an IntervalConstraint. The * resulting precision is the maximum of both precisions. */ Constraint* operator&(const Constraint& c) const { double lowerBound, upperBound; bool inclLowerBound, inclUpperBound; const IntervalConstraint* pi = dynamic_cast(&c); if (pi) { if (lowerBound_ <= pi->lowerBound_) { lowerBound = pi->lowerBound_; inclLowerBound = pi->inclLowerBound_; } else { lowerBound = lowerBound_; inclLowerBound = inclLowerBound_; } if (upperBound_ >= pi->upperBound_) { upperBound = pi->upperBound_; inclUpperBound = pi->inclUpperBound_; } else { upperBound = upperBound_; inclUpperBound = inclUpperBound_; } return new IntervalConstraint(lowerBound, upperBound, inclLowerBound, inclUpperBound, (precision_>pi->getPrecision())?precision_:pi->getPrecision()); } else return 0; } /** * @brief Intersect this IntervalConstraint with another constraint * * @param c the intersected constraint * @return this IntervalConstraint modified, or not modified if c is not an * IntervalConstraint. The precision is set to the maximum of bith precisions. */ IntervalConstraint& operator&=(const Constraint& c) { try { const IntervalConstraint& pi = dynamic_cast(c); if (lowerBound_ <= pi.lowerBound_) { lowerBound_ = pi.lowerBound_; inclLowerBound_ = pi.inclLowerBound_; } if (upperBound_ >= pi.upperBound_) { upperBound_ = pi.upperBound_; inclUpperBound_ = pi.inclUpperBound_; } if (pi.getPrecision() > precision_) precision_ = pi.getPrecision(); } catch(std::bad_cast&) {} return *this; } /** * @brief Tells if this interval equals another one * * @param i the compared IntervalConstraint */ bool operator==(const IntervalConstraint& i) const { return lowerBound_ == i.lowerBound_ && inclLowerBound_ == i.inclLowerBound_ && upperBound_ == i.upperBound_ && inclUpperBound_ == i.inclUpperBound_; } /** * @brief Tells if this interval is different from another one * * @param i the compared IntervalConstraint */ bool operator!=(const IntervalConstraint& i) const { return lowerBound_ != i.lowerBound_ || inclLowerBound_ != i.inclLowerBound_ || upperBound_ != i.upperBound_ || inclUpperBound_ != i.inclUpperBound_; } /** * @brief Tells if this interval is included or equal in another one * * @param i the compared IntervalConstraint */ bool operator<=(const IntervalConstraint& i) const { return lowerBound_ >= i.lowerBound_ && upperBound_ <= i.upperBound_; } /** * @brief Tells if this interval is empty */ bool isEmpty() const { return ((lowerBound_ > upperBound_) || ((lowerBound_ > upperBound_) && inclUpperBound_ && inclLowerBound_)); } }; } // end of namespace bpp. #endif // _CONSTRAINTS_H_ bpp-core-2.2.0/src/Bpp/Numeric/ParameterList.h000664 001750 001750 00000032401 12370705300 022542 0ustar00jdutheiljdutheil000000 000000 // // File: ParameterList.h // Created by: Julien Dutheil // Created on: Wed Oct 15 18:17:29 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _PARAMETERLIST_H_ #define _PARAMETERLIST_H_ #include "Parameter.h" #include "../Clonable.h" #include "../Io/OutputStream.h" // From STL: #include #include #include namespace bpp { /** * @brief The parameter list object. * * @author Julien Dutheil, Laurent Gueguen * This is a vector of Parameter with a few additional methods, mainly for giving * name access. */ class ParameterList : public Clonable { private: std::vector parameters_; public: /** * @brief Build a new ParameterList object. */ ParameterList() : parameters_() {} /** * @brief Copy constructor * * All parameters in the list will be cloned. */ ParameterList(const ParameterList& pl); ParameterList& operator=(const ParameterList& pl); ParameterList* clone() const { return new ParameterList(*this); } virtual ~ParameterList(); public: /** * @return The number of parameters in the list. */ size_t size() const { return parameters_.size(); } /** * @return The parameter at a given position. * @warning No check is performed on the validity of the index given as input! */ virtual const Parameter& operator[](size_t i) const { return *parameters_[i]; } virtual Parameter& operator[](size_t i) { return *parameters_[i]; } /** * @brief Get the parameter with name name. * * @param name The name of the parameter to look for. * @return A const reference toward the parameter with name name. * @throw ParameterNotFoundException If no parameter with the given name is found. */ virtual const Parameter& getParameter(const std::string& name) const throw (ParameterNotFoundException); /** * @brief Get the value of the parameter with name name. * * @param name The name of the parameter to look for. * @return A value of the parameter with name name. * @throw ParameterNotFoundException If no parameter with the given name is found. */ virtual double getParameterValue(const std::string& name) const throw (ParameterNotFoundException); /** * @brief Get the parameter with name name. * * @param name The name of the parameter to look for. * @return A reference toward the parameter with name name. * @throw ParameterNotFoundException If no parameter with the given name is found. */ virtual Parameter& getParameter(const std::string& name) throw (ParameterNotFoundException); /** * @brief Get given parameters as a sublist. * * @param names Name of the parameters to be included in the list. * @return A list with all parameters specified. * @throw ParameterNotFoundException If at least one name does not correspond to a parameter in the list. */ virtual ParameterList subList(const std::vector& names) const throw (ParameterNotFoundException); /** * @brief Get given parameter as a sublist. * * @param name Name of the parameter to be included in the list. * @return A list with the parameter specified. * @throw ParameterNotFoundException If no parameter with the given name is found. */ virtual ParameterList subList(const std::string& name) const throw (ParameterNotFoundException); /** * @brief Get given parameters as a sublist. * * @param parameters Positions of the parameters to be included in the list. * @return A list with all parameters specified. */ virtual ParameterList subList(const std::vector& parameters) const; /** * @brief Get given parameter as a sublist. * * @param parameter Position of the parameters to be included in the list. * @return A list with the parameter specified. */ virtual ParameterList subList(size_t parameter) const; /** * @brief Get the sublist containing all common parameter between this list and pl. * * @param params The list to compare to. * @return A list with all common parameters. */ virtual ParameterList getCommonParametersWith(const ParameterList& params) const; /** * @brief Get all parameter names in the list. * * @return A vector with all names in the same order as the parameters in the list. */ virtual std::vector getParameterNames() const; /** * @brief Get all parameter names matching with the given name. Up * to now, only "*" jokers are available. * * @param pattern a pattern of name * @return A vector of matching names */ virtual std::vector getMatchingParameterNames(const std::string& pattern) const; /** * @brief Add a new parameter at the end of the list. * * @param param The parameter to add to the list. */ virtual void addParameter(const Parameter& param) throw (ParameterException); /** * @brief Add a new parameter at the end of the list. * * This function is more efficient than its reference counterpart, * as it avoid an object copy. The ParameterList will own the pointer * after addition, if it is successful. * * @param param A ppointer toward the parameter to add to the list. */ virtual void addParameter(Parameter* param) throw (ParameterException); /** * @brief Change given parameter. * * @param index The position of the parameter to alter. * @param param The parameter to add to the list. * @throw IndexOutOfBoundsException if the index is not valid. */ virtual void setParameter(size_t index, const Parameter& param) throw (IndexOutOfBoundsException); /** * @brief Add new parameters at the end of the list. * * @param params The parameter list containing the new paramters to add to the list. */ virtual void addParameters(const ParameterList& params) throw (ParameterException); /** * @brief Add parameters to the list. If the parameter already * exists, only the value is updated, otherwise the new parameter is * added at the end of the list. * * @param params The parameter list containing the new paramters to add to the list. */ virtual void includeParameters(const ParameterList& params); /** * @brief Set the value of parameter with name name to be equal to value. * * @param name the name of the parameter to set. * @param value The value of the parameter. * @throw ParameterNotFoundException If no parameter with the given name is found in the list. * @throw ConstraintException If the value is incorrect. */ virtual void setParameterValue(const std::string& name, double value) throw (ParameterNotFoundException, ConstraintException); /** * @brief Set the parameters to be equals to params. * * The list must contain exactly the same parameters (ie same names) * than the parameters available. * * @param params A list with all parameters. * @see setParameters(), matchParameters(); * @throw ParameterNotFoundException If at least one name does not correspond to a parameter in the list. * @throw ConstraintException If one value is incorrect (and the two parameter list do not have the same constraints). */ virtual void setAllParametersValues(const ParameterList& params) throw (ParameterNotFoundException, ConstraintException); /** * @brief Update the parameters from the ones in params * that have matching names. * * @param params A list containing all parameters to update. * @see setAllParameters(), matchParameters() * @throw ConstraintException If one value is incorrect (and the two parameter list do not have the same constraints). */ virtual void setParametersValues(const ParameterList& params); /** * @brief Returns true if the Parameter of the given name exists. * * @name A string name */ virtual bool hasParameter(const std::string& name) const; /** * @brief Tests the parameters from params. * * Only common parameters with params are compared. * * @param params A list of parameters. * @return true iff a least one parameter value is different. */ virtual bool testParametersValues(const ParameterList& params) const; /** * @brief Update the parameters from params. * * Only common parameters with params will be updated. * * @param params A list of parameters. * @param updatedParameters An optional pointer toward a vector which will * store the indices of parameters for which a value has changed. * Indices are relative on the input parameter list "params". * @return true iff a least one parameter value has been changed. * @see setParameters(), setAllParameters() */ virtual bool matchParametersValues(const ParameterList& params, std::vector* updatedParameters = 0) throw (ConstraintException); /** * @brief Set the parameters to be equals to params. * * The list must contain exactly the same parameters (ie same names) * than the parameters available. * * @param params A list with all parameters. * @see setParameters(), matchParameters(); */ virtual void setAllParameters(const ParameterList& params) throw (ParameterNotFoundException); /** * @brief Update the parameters from params. * * params must be a subset of all parameters available. * * @param params A list containing all parameters to update. * @see setAllParameters(), matchParameters() */ virtual void setParameters(const ParameterList& params) throw (ParameterNotFoundException); /** * @brief Update the parameters from params. * * Only common parameters with params will be updated. * * @param params A list of parameters. * @see setParameters(), setAllParameters() */ virtual void matchParameters(const ParameterList& params); /** * @brief Delete a parameter from the list. * * @param name The name of the parameter to delete from the list. */ virtual void deleteParameter(const std::string& name) throw (ParameterNotFoundException); /** * @brief Delete several parameters from the list. * * @param names The names of the parameters to delete from the list. * @param mustExist If true, an exception is thrown if a name does * not match an extant parameter. */ virtual void deleteParameters(const std::vector& names, bool mustExist = true) throw (ParameterNotFoundException); /** * @brief Delete a parameter from the list. * * @param index The position of the parameter to delete in the list. */ virtual void deleteParameter(size_t index) throw (IndexOutOfBoundsException); /** * @brief Delete several parameters from the list. * * @param indices The positions of the parameters to delete in the list. * Duplicated positions will be considered only one time. */ virtual void deleteParameters(const std::vector& indices) throw (IndexOutOfBoundsException); /** * @brief Get the position of a given parameter according to its name. * * @param name The name of the parameter to look for. * @return The position of the parameter if found. If several parameters exist with the given name, * the position of the first one is returned. * @throw ParameterNotFoundException If no parameter with the given name is found. */ virtual size_t whichParameterHasName(const std::string& name) const throw (ParameterNotFoundException); /** * @brief Print all parameters. */ virtual void printParameters(OutputStream& out) const; virtual void printParameters(std::ostream& out) const { StlOutputStreamWrapper os(&out); printParameters(os); } /** * @brief Reset the list: delete all parameters. */ virtual void reset(); }; } // end of namespace bpp. #endif // _PARAMETERLIST_H_ bpp-core-2.2.0/src/Bpp/Numeric/NumConstants.h000664 001750 001750 00000007302 12370705300 022424 0ustar00jdutheiljdutheil000000 000000 // // File: NumConstants.h // Created by: Julien Dutheil // Created on: Tue Feb 03 14:21 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This file is part of the Bio++ project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _NUMCONSTANTS_H_ #define _NUMCONSTANTS_H_ #include #include namespace bpp { /** * @brief this static class contains several useful constant values. * * This classe uses function in order to avoid the infamous "static initialization order fiasco". * C++0x solves this... */ class NumConstants { public: /** * @name Golden ratio. * * The golden ratio, @f$\phi@f$ is equal to @f$\frac{1+\sqrt{5}}{2} = 1.6180339887498948482\ldots@f$. * We also define @f$R=\phi-1@f$ and @f$C = 1 - R@f$. * @{ */ static double GOLDEN_RATIO_PHI() { return (1. + sqrt(5.)) / 2.; } static double GOLDEN_RATIO_R() { return GOLDEN_RATIO_PHI() - 1.; } static double GOLDEN_RATIO_C() { return 1. - GOLDEN_RATIO_R(); } /** @} */ static double MEGA() { return 1e6; } static double KILO() { return 1e3; } static double DECI() { return 1e-1; } static double CENTI() { return 1e-2; } static double MILLI() { return 1e-3; } static double MICRO() { return 1e-6; } static double NANO() { return 1e-9; } static double PICO() { return 1e-12; } static double SMALL() { return 1e-6; } static double TINY() { return 1e-12; } static double VERY_TINY() { return 1e-20; } static double VERY_BIG() { return static_cast(1.7E+23); } /** * @name Define those constants in case they would not be available in stl/limits. * * @{ */ static double INF() { return std::numeric_limits::has_infinity ? -log(0) : std::numeric_limits::max(); } static double PINF() { return std::numeric_limits::has_infinity ? -log(0) : std::numeric_limits::max(); } static double MINF() { return std::numeric_limits::has_infinity ? log(0) : std::numeric_limits::min(); } static double NaN() { return NAN; } /** @} */ static double PI() { return 3.141593; } }; }//end of namespace bpp. #endif //_NUMCONSTANTS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Random/Uniform01K.cpp000664 001750 001750 00000006243 12370705300 023441 0ustar00jdutheiljdutheil000000 000000 // // File Uniform01K.cpp // Author : Sylvain Gaillard // Last modification : Friday September 24 2004 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "Uniform01K.h" #include "../NumTools.h" using namespace bpp; const long Uniform01K::MAXNUMBER = 1000000000; const long Uniform01K::ZERO = 0; const long Uniform01K::MODSEED = 256434901; //** Class constructor: *******************************************************/ Uniform01K::Uniform01K(long seed) : _it1(), _it2() { setSeed(seed); } //** Class destructor: *******************************************************/ Uniform01K::~Uniform01K() {} //** Other methodes: *********************************************************/ void Uniform01K::setSeed(long seed) { long tmp1, tmp2; unsigned short i, ii, j; tmp1 = NumTools::abs(MODSEED - NumTools::abs(seed)); tmp1 %= MAXNUMBER; _tab[55] = tmp1; tmp2 = 1; for (i = 1 ; i <= 54 ; i++) { ii = static_cast((21 * i) % 55); _tab[ii] = tmp2; tmp2 = tmp1 - tmp2; if (tmp2 < ZERO) tmp2 += MAXNUMBER; tmp1 = _tab[ii]; } for (j=1 ; j<=4 ; j++) for (i=1 ; i<=55 ; i++) { _tab[i] -= _tab[1 + (i + 30) % 55]; if (_tab[i] < ZERO) _tab[i] += MAXNUMBER; } _it1 = 0; _it2 = 31; } double Uniform01K::drawNumber() const { if (++_it1 == 56) _it1 = 1; if (++_it2 == 56) _it2 = 1; long tmp = _tab[_it1] - _tab[_it2]; if (tmp < ZERO) tmp += MAXNUMBER; _tab[_it2] = tmp; double r = static_cast(static_cast(tmp) / MAXNUMBER); //if (r < 0.) return drawNumber(); // In case of negative number, take the next one in the serie. //if (r > 1.) return drawNumber(); // In case of number > 1, take the next one in the serie. return r; } bpp-core-2.2.0/src/Bpp/Numeric/Random/RandomTools.h000664 001750 001750 00000050127 12372466114 023465 0ustar00jdutheiljdutheil000000 000000 // // File RandomTools.h // Author : Julien Dutheil // Sylvain Gaillard // Last modification : Thu November 6 2008 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _RANDOMTOOLS_H_ #define _RANDOMTOOLS_H_ #include "RandomFactory.h" #include "../VectorExceptions.h" #include "../VectorTools.h" #include "../../Exceptions.h" // From the STL: #include #include #include #include namespace bpp { /** * @brief Utilitary function dealing with random numbers. * * This class uses Uniform01K generator by default. * It is possible to change this by setting the DEFAULT_GENERATOR variable. * * This class is adapted from Pupko's SEMPHY library. * It also borrow some code from Yang's PAML package. * * @see RandomFactory */ class RandomTools { public: RandomTools() {} virtual ~RandomTools() {} private: /** *@brief functions for the computation of incompleteBeta */ static double incompletebetafe(double a, double b, double x, double big, double biginv); static double incompletebetafe2(double a, double b, double x, double big, double biginv); static double incompletebetaps(double a, double b, double x, double maxgam); public: static RandomFactory* DEFAULT_GENERATOR; /** * @brief Get a double random value (between 0 and specified range). * * Note : the number you get is between 0 and entry not including entry ! * @param entry Max number to reach. * @param generator Random number generator to use. */ static double giveRandomNumberBetweenZeroAndEntry(double entry, const RandomFactory& generator = *DEFAULT_GENERATOR); /** * @brief Get a boolean random value. * * @param generator Random number generator to use. */ static bool flipCoin(const RandomFactory& generator = *DEFAULT_GENERATOR); /** * @brief Get an integer random value (between 0 and specified range). * * Note : the number you get is between 0 and entry not including entry ! * @param entry Max number to reach. * @param generator Random number generator to use. */ template static intType giveIntRandomNumberBetweenZeroAndEntry(intType entry, const RandomFactory& generator = *DEFAULT_GENERATOR) { return static_cast(giveRandomNumberBetweenZeroAndEntry(static_cast(entry), generator)); } /** * @brief Set the default generator seed. * * @param seed New seed. */ static void setSeed(long seed); /** * @return A random number drawn from a normal distribution. * @param mean The mean of the law. * @param variance The variance of the law. * @param generator The uniform generator to use. */ static double randGaussian(double mean, double variance, const RandomFactory& generator = *DEFAULT_GENERATOR); /** * @return A random number drawn from a gamma distribution with unit scale (beta=1). * @param dblAlpha The alpha parameter. * @param generator The uniform generator to use. */ static double randGamma(double dblAlpha, const RandomFactory& generator = *DEFAULT_GENERATOR); /** * @return A random number drawn from a gamma distribution. * @param alpha The alpha parameter. * @param beta The beta parameter. * @param generator The uniform generator to use. */ static double randGamma(double alpha, double beta, const RandomFactory& generator = *DEFAULT_GENERATOR); /** * @return A random number drawn from a beta distribution. * @param alpha The alpha parameter. * @param beta The beta parameter. * @param generator The uniform generator to use. */ static double randBeta(double alpha, double beta, const RandomFactory& generator = *DEFAULT_GENERATOR); /** * @return A random number drawn from an exponential distribution. * @param mean The mean of the distribution. * @param generator The uniform generator to use. */ static double randExponential(double mean, const RandomFactory& generator = *DEFAULT_GENERATOR); /** * @brief Pick one element in a vector * * Pick one element randomly in a vector and return it. * * @param v The vector of elements. * @param replace If set to yes, then elements are allowed to be picked more than once, and therefore can be re-"placed" in the final sample.(default: false) * @return On element of the vector. * @throw EmptyVectorException if the vector is empty. * * @author Sylvain Gaillard */ template static T pickOne(std::vector& v, bool replace = false) throw (EmptyVectorException) { if (v.empty()) throw EmptyVectorException("RandomTools::pickOne: input vector is empty", &v); size_t pos = RandomTools::giveIntRandomNumberBetweenZeroAndEntry(v.size()); if (replace) return v[pos]; else { T e = v[pos]; v[pos] = v.back(); v.pop_back(); return e; } } template static T pickOne(const std::vector& v) throw (EmptyVectorException) { if (v.empty()) throw EmptyVectorException("RandomTools::pickOne: input vector is empty", &v); size_t pos = RandomTools::giveIntRandomNumberBetweenZeroAndEntry(v.size()); return v[pos]; } /** * @brief Sample a vector. * * The sample is a new vector of the specified size. * If the size of the sample is identical to the original vector, * the result is a shuffle of the original vector. * * @param vin The vector to sample. * @param vout [out] The output vector to fill, with the appropriate size. * @param replace Should sampling be with replacement? * @return A vector which is a sample of v. * @throw IndexOutOfBoundException if the sample size exceeds the original * size when sampling without replacement. * @throw EmptyVectorException if the vector is empty. * * @author Sylvain Gaillard */ template static void getSample(const std::vector& vin, std::vector& vout, bool replace = false) throw (EmptyVectorException, IndexOutOfBoundsException) { if (vout.size() > vin.size() && !replace) throw IndexOutOfBoundsException("RandomTools::getSample: size exceeded v.size.", vout.size(), 0, vin.size()); std::vector hat(vin.size()); for (size_t i = 0 ; i < vin.size() ; i++) hat[i] = i; for (size_t i = 0 ; i < vout.size() ; i++) vout[i] = vin[pickOne(hat, replace)]; } /** * @brief Pick one element in a vector, with associated probability weights * * Pick one element randomly in a vector and return it. * If you choose to make the picking without replacement the element is * removed from the vector, and so is the corresponding weight * * @param v The vector of elements. * @param w The vector of weight associated to the v elements. * @param replace Should pick with replacement? (default: false) * @return On element of the vector. * @throw EmptyVectorException if the vector is empty. * * @author Julien Dutheil */ template static T pickOne(std::vector& v, std::vector& w, bool replace = false) throw (EmptyVectorException) { if (v.empty()) throw EmptyVectorException("RandomTools::pickOne (with weight): input vector is empty", &v); //Compute cumulative sum of weights: std::vector sumw = VectorTools::cumSum(w); //Convert to cumulative distribution: sumw /= sumw.back(); //Get random positions: double prob = RandomTools::giveRandomNumberBetweenZeroAndEntry(1.0); size_t pos = v.size() - 1; for (size_t i = 0; i < v.size(); ++i) { if (prob < sumw[i]) { pos = i; break; } } if (replace) return v[pos]; else { T e = v[pos]; v[pos] = v.back(); v.pop_back(); w[pos] = w.back(); w.pop_back(); return e; } } /** * @brief Sample a vector, with associated probability weights. * * The sample is a new vector of the specified size. * If the size of the sample is identical to the original vector, * the result is a shuffle of the original vector. * * It has to be noted that in case of sampling without replacement, * the effect of the weighting scheme will be weaker as the sample size becomes * close to the population size. In case the two are equal (pure permutations), * the weigths have no effect at all. * * @param vin The vector to sample. * @param w The vector of weights. * @param vout [out] The output vector to fill, with the appropriate size. * @param replace Should sampling be with replacement? * @return A vector which is a sample of v. * @throw IndexOutOfBoundException if the sample size exceeds the original * size when sampling without replacement. * @throw EmptyVectorException if the vector is empty. * @warning: For large sampling with replacement, the function is not efficient, * as it recomputes the some of weights for each element picked. * @author Julien Dutheil */ template static void getSample(const std::vector& vin, const std::vector& w, std::vector& vout, bool replace = false) throw (EmptyVectorException, IndexOutOfBoundsException) { if (vout.size() > vin.size() && !replace) throw IndexOutOfBoundsException("RandomTools::getSample (with weights): size exceeded v.size.", vout.size(), 0, vin.size()); std::vector hat(vin.size()); for (size_t i = 0 ; i < vin.size() ; i++) hat[i] = i; std::vector w2(w); //non const copy for (size_t i = 0 ; i < vout.size() ; i++) vout[i] = vin[pickOne(hat, w2, replace)]; } /** * @brief Get a random state from a set of probabilities/scores. * * The input probabilities are scaled so that they sum to one. * If 'x' probabilities are provided as input, the output vector will contain values between 0 and 'x-1'. * * @param n The sample size. * @param probs The set of intput probabilities. * @return A vector of int values corresponding to the output states. States are supposed to be in the same order as the input probabilities, the first state being '0'. */ static std::vector randMultinomial(size_t n, const std::vector& probs); /** * @name Probability functions. * * @{ * Adapted from Yang's PAML package. * */ /** * @brief Normal quantile function. * * Returns z so that Prob{x0, accurate to 10 decimal places. * Stirling's formula is used for the central polynomial part of the procedure. * Pike MC & Hill ID (1966) Algorithm 291: Logarithm of the gamma function. * Communications of the Association for Computing Machinery, 9:684 * * @param alpha Alpha parameter. * @return \f$ln\left(\Gamma\left(\alpha\right)\right)\f$ */ static double lnGamma (double alpha); /** * @brief Returns the incomplete gamma ratio I(x,alpha). * * X is the upper limit of the integration and alpha is the shape parameter. * returns (-1) if in error * ln_gamma_alpha = ln(Gamma(alpha)), is almost redundant. * (1) series expansion if (alpha>x || x<=1) * (2) continued fraction otherwise * RATNEST FORTRAN by * Bhattacharjee GP (1970) The incomplete gamma integral. Applied Statistics, * 19: 285-287 (AS32) * * @param x the upper limit of the integration. * @param alpha the shape parameter. * @param ln_gamma_alpha ln(Gamma(alpha)). */ static double incompleteGamma(double x, double alpha, double ln_gamma_alpha); /** * @brief \f$\chi^2\f$ quantile function. * * returns z so that Prob{x0 and beta>0. * * @param alpha, beta Alpha and Beta parameters. * @return \f$ln\left(Beta\left(\alpha,\beta\right)\right)\f$ */ static double lnBeta (double alpha, double beta); /** * @brief Returns the regularized incomplete beta function * @f$I_x(\alpha,\beta) = pbeta(x,\alpha,\beta@f$ * * alpha and beta are the parameters of the function. * * Adapted From Cephes Math Library Release 2.8: June, 2000 * Copyright by Stephen L. Moshier * Under GPL License * * @param x the upper limit of the integration. * @param alpha, beta the shape parameters. */ static double incompleteBeta(double x, double alpha, double beta); static double pBeta(double x, double alpha, double beta) { return incompleteBeta(x,alpha,beta); } /** * @brief The Beta quantile function. * * An adaptation from the C code of R * Copyright (C) 1995, 1996 Robert Gentleman and Ross Ihaka * Copyright (C) 1998--2007 The R Development Core Team * based on code (C) 1979 and later Royal Statistical Society * * @param prob The probability. * @param alpha Alpha parameter. * @param beta Beta parameter. * @return The quantile corresponding to prob. */ static double qBeta(double prob, double alpha, double beta); /** @} */ private: static double DblGammaGreaterThanOne(double dblAlpha, const RandomFactory& generator); static double DblGammaLessThanOne(double dblAlpha, const RandomFactory& generator); }; } //end of namespace bpp. #endif //_RANDOMTOOLS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Random/Uniform01QD.cpp000664 001750 001750 00000003635 12370705300 023555 0ustar00jdutheiljdutheil000000 000000 // // File Uniform01QD.cpp // Author : Sylvain Gaillard // Last modification : Friday September 24 2004 // /* Copyright or © or Copr. Bio++ Development TeamCNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "Uniform01QD.h" using namespace bpp; #include using namespace std; double Uniform01QD::drawNumber() const { seed_ = seed_ * 1103515245 + 12345; if (seed_ < 0) seed_ = -seed_; return static_cast(seed_ / 2147483648.0L); } bpp-core-2.2.0/src/Bpp/Numeric/Random/Uniform01K.h000664 001750 001750 00000005635 12370705300 023112 0ustar00jdutheiljdutheil000000 000000 // // File Uniform01K.h // Author : Sylvain Gaillard // Last modification : Friday September 24 2004 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _UNIFORM01K_H_ #define _UNIFORM01K_H_ #include "RandomFactory.h" namespace bpp { /** * @brief A uniform random number generator. * * This is a uniform generator which draw double between 0 and 1 excluding * the end points. * This generator is based on an algorithm described by D.E. Knuth, 1981, * "Seminumerical Algorithms" 2nd ed., vol.2 of "The Art of Computer * Programming" (Reading, MA: Addison-Wesley), §§3.2-3.3. * * The algorithm used here is the one described in "Numerical Recipes in C". */ class Uniform01K : public virtual RandomFactory { public: // Constructors and destructor /** * @brief Create a Random Number Generator. * * @param seed The seed for the random numbers. */ Uniform01K(long seed); /** * @brief Destroy the generator. */ virtual ~Uniform01K(); public: /** * @brief Set the seed for a new set of random numbers. */ void setSeed(long seed); /** * @brief Get a random number between 0.0 and 1.0 (exclusive of the end point values). */ double drawNumber() const; private: static const long MAXNUMBER; static const long ZERO; static const long MODSEED; mutable long _tab[56]; mutable unsigned int _it1; mutable unsigned int _it2; }; } //end of namespace bpp. #endif // _UNIFORM01K_H_ bpp-core-2.2.0/src/Bpp/Numeric/Random/Uniform01QD.h000664 001750 001750 00000005177 12370705300 023225 0ustar00jdutheiljdutheil000000 000000 // // File Uniform01QD.h // Author : Sylvain Gaillard // Last modification : Friday September 24 2004 // // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _UNIFORM01QD_H_ #define _UNIFORM01QD_H_ #include "RandomFactory.h" namespace bpp { /** * @brief A quick and dirty uniform random number generator. * * This is a congruential uniform generator which draw double between 0 and 1 excluding * the end points. * * WARNING!!! Only works on 32bits architectures! */ class Uniform01QD : public virtual RandomFactory { public: // Constructors and destructor /** * @brief Create a Random Number Generator. * * @param seed The seed for the random numbers. */ Uniform01QD(long seed): seed_(seed) {} /** * @brief Destroy the generator. */ virtual ~Uniform01QD() {} public: /** * @brief Set the seed for a new set of random numbers. */ void setSeed(long seed) { seed_ = seed; } /** * @brief Get a random number between 0.0 and 1.0 (exclusive of the end point values). */ double drawNumber() const; private: mutable long seed_; }; } //end of namespace bpp. #endif // _UNIFORM01QD_H_ bpp-core-2.2.0/src/Bpp/Numeric/Random/RandomTools.cpp000664 001750 001750 00000061007 12370705300 024006 0ustar00jdutheiljdutheil000000 000000 // // File RandomTools.cpp // Author : Julien Dutheil // Last modification : Friday Septembre 24 2004 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "RandomTools.h" #include "Uniform01K.h" #include "../VectorTools.h" #include "../NumConstants.h" #include using namespace bpp; using namespace std; RandomFactory* RandomTools::DEFAULT_GENERATOR = new Uniform01K(time(NULL)); // Initiate random seed : // RandomTools::RandInt RandomTools::r = time(NULL) ; void RandomTools::setSeed(long seed) { DEFAULT_GENERATOR->setSeed(seed); } // Method to get a double random value (between 0 and specified range) // Note : the number you get is between 0 and entry not including entry ! double RandomTools::giveRandomNumberBetweenZeroAndEntry(double entry, const RandomFactory& generator) { // double tm = r.drawFloatNumber(); double tm = generator.drawNumber(); return tm * entry; } // Method to get a boolean random value bool RandomTools::flipCoin(const RandomFactory& generator) { return (RandomTools::giveRandomNumberBetweenZeroAndEntry(1.0, generator) - 0.5) > 0; } double RandomTools::randGaussian(double mean, double variance, const RandomFactory& generator) { return RandomTools::qNorm(generator.drawNumber(), mean, sqrt(variance)); } double RandomTools::randGamma(double dblAlpha, const RandomFactory& generator) { assert(dblAlpha > 0.0); if (dblAlpha < 1.0) return RandomTools::DblGammaLessThanOne(dblAlpha, generator); else if (dblAlpha > 1.0) return RandomTools::DblGammaGreaterThanOne(dblAlpha, generator); return -log(RandomTools::giveRandomNumberBetweenZeroAndEntry(1.0, generator)); } double RandomTools::randGamma(double alpha, double beta, const RandomFactory& generator) { double x = RandomTools::randGamma(alpha, generator) / beta; return x; } double RandomTools::randExponential(double mean, const RandomFactory& generator) { return -mean* log(RandomTools::giveRandomNumberBetweenZeroAndEntry(1, generator)); } std::vector RandomTools::randMultinomial(size_t n, const std::vector& probs) { double s = VectorTools::sum(probs); double r; double cumprob; vector sample(n); for (unsigned int i = 0; i < n; i++) { r = RandomTools::giveRandomNumberBetweenZeroAndEntry(1); cumprob = 0; bool test = true; for (unsigned int j = 0; test &(j < probs.size()); j++) { cumprob += probs[j] / s; if (r <= cumprob) { sample[i] = j; test = false; } } // This test should never be true if probs sum to one: if (test) sample[i] = probs.size(); } return sample; } // ------------------------------------------------------------------------------ double RandomTools::DblGammaGreaterThanOne(double dblAlpha, const RandomFactory& generator) { // Code adopted from David Heckerman // ----------------------------------------------------------- // DblGammaGreaterThanOne(dblAlpha) // // routine to generate a gamma random variable with unit scale and // alpha > 1 // reference: Ripley, Stochastic Simulation, p.90 // Chang and Feast, Appl.Stat. (28) p.290 // ----------------------------------------------------------- double rgdbl[6]; rgdbl[1] = dblAlpha - 1.0; rgdbl[2] = (dblAlpha - (1.0 / (6.0 * dblAlpha))) / rgdbl[1]; rgdbl[3] = 2.0 / rgdbl[1]; rgdbl[4] = rgdbl[3] + 2.0; rgdbl[5] = 1.0 / sqrt(dblAlpha); for ( ; ; ) { double dblRand1; double dblRand2; do { dblRand1 = RandomTools::giveRandomNumberBetweenZeroAndEntry(1.0, generator); dblRand2 = RandomTools::giveRandomNumberBetweenZeroAndEntry(1.0, generator); if (dblAlpha > 2.5) dblRand1 = dblRand2 + rgdbl[5] * (1.0 - 1.86 * dblRand1); } while (!(0.0 < dblRand1 && dblRand1 < 1.0)); double dblTemp = rgdbl[2] * dblRand2 / dblRand1; if (rgdbl[3] * dblRand1 + dblTemp + 1.0 / dblTemp <= rgdbl[4] || rgdbl[3] * log(dblRand1) + dblTemp - log(dblTemp) < 1.0) { return dblTemp * rgdbl[1]; } } assert(false); return 0.0; } double RandomTools::DblGammaLessThanOne(double dblAlpha, const RandomFactory& generator) { // routine to generate a gamma random variable with // unit scale and alpha < 1 // reference: Ripley, Stochastic Simulation, p.88 double dblTemp; const double dblexp = exp(1.0); for ( ; ; ) { double dblRand0 = giveRandomNumberBetweenZeroAndEntry(1.0, generator); double dblRand1 = giveRandomNumberBetweenZeroAndEntry(1.0, generator); if (dblRand0 <= (dblexp / (dblAlpha + dblexp))) { dblTemp = pow(((dblAlpha + dblexp) * dblRand0) / dblexp, 1.0 / dblAlpha); if (dblRand1 <= exp(-1.0 * dblTemp)) return dblTemp; } else { dblTemp = -1.0 * log((dblAlpha + dblexp) * (1.0 - dblRand0) / (dblAlpha * dblexp)); if (dblRand1 <= pow(dblTemp, dblAlpha - 1.0)) return dblTemp; } } assert(false); return 0.0; } /******************************************************************************/ // From Yang's PAML package: /******************************************************************************/ double RandomTools::qNorm(double prob) { double a0 = -.322232431088, a1 = -1, a2 = -.342242088547, a3 = -.0204231210245; double a4 = -.453642210148e-4, b0 = .0993484626060, b1 = .588581570495; double b2 = .531103462366, b3 = .103537752850, b4 = .0038560700634; double y, z = 0, p = prob, p1; p1 = (p < 0.5 ? p : 1 - p); if (p1 < 1e-20) return -9999; y = sqrt (log(1 / (p1 * p1))); z = y + ((((y * a4 + a3) * y + a2) * y + a1) * y + a0) / ((((y * b4 + b3) * y + b2) * y + b1) * y + b0); return p < 0.5 ? -z : z; } double RandomTools::qNorm(double prob, double mu, double sigma) { return RandomTools::qNorm(prob) * sigma + mu; } double RandomTools::lnGamma (double alpha) { double x = alpha, f = 0, z; if (x < 7) { f = 1; z = x - 1; while (++z < 7) f *= z; x = z; f = -log(f); } z = 1 / (x * x); return f + (x - 0.5) * log(x) - x + .918938533204673 + (((-.000595238095238 * z + .000793650793651) * z - .002777777777778) * z + .083333333333333) / x; } double RandomTools::incompleteGamma (double x, double alpha, double ln_gamma_alpha) { size_t i; double p = alpha, g = ln_gamma_alpha; double accurate = 1e-8, overflow = 1e30; double factor, gin = 0, rn = 0, a = 0, b = 0, an = 0, dif = 0, term = 0; vector pn(6); if (x == 0) return 0; if (x < 0 || p <= 0) return -1; factor = exp(p * log(x) - x - g); if (x > 1 && x >= p) goto l30; /* (1) series expansion */ gin = 1; term = 1; rn = p; l20: rn++; term *= x / rn; gin += term; if (term > accurate) goto l20; gin *= factor / p; goto l50; l30: /* (2) continued fraction */ a = 1 - p; b = a + x + 1; term = 0; pn[0] = 1; pn[1] = x; pn[2] = x + 1; pn[3] = x * b; gin = pn[2] / pn[3]; l32: a++; b += 2; term++; an = a * term; for (i = 0; i < 2; i++) { pn[i + 4] = b * pn[i + 2] - an * pn[i]; } if (pn[5] == 0) goto l35; rn = pn[4] / pn[5]; dif = fabs(gin - rn); if (dif > accurate) goto l34; if (dif <= accurate * rn) goto l42; l34: gin = rn; l35: for (i = 0; i < 4; i++) { pn[i] = pn[i + 2]; } if (fabs(pn[4]) < overflow) goto l32; for (i = 0; i < 4; i++) { pn[i] /= overflow; } goto l32; l42: gin = 1 - factor * gin; l50: return gin; } double RandomTools::qChisq(double prob, double v) { double e = .5e-6, aa = .6931471805, p = prob, g; double xx, c, ch, a = 0, q = 0, p1 = 0, p2 = 0, t = 0, x = 0, b = 0, s1, s2, s3, s4, s5, s6; if (p < .000002 || p > .999998 || v <= 0) return -1; g = lnGamma (v / 2); xx = v / 2; c = xx - 1; if (v >= -1.24 * log(p)) goto l1; ch = pow((p * xx * exp(g + xx * aa)), 1 / xx); if (ch - e < 0) return ch; goto l4; l1: if (v > .32) goto l3; ch = 0.4; a = log(1 - p); l2: q = ch; p1 = 1 + ch * (4.67 + ch); p2 = ch * (6.73 + ch * (6.66 + ch)); t = -0.5 + (4.67 + 2 * ch) / p1 - (6.73 + ch * (13.32 + 3 * ch)) / p2; ch -= (1 - exp(a + g + .5 * ch + c * aa) * p2 / p1) / t; if (fabs(q / ch - 1) - .01 <= 0) goto l4; else goto l2; l3: x = qNorm (p); p1 = 0.222222 / v; ch = v * pow((x * sqrt(p1) + 1 - p1), 3.0); if (ch > 2.2 * v + 6) ch = -2 * (log(1 - p) - c * log(.5 * ch) + g); l4: q = ch; p1 = .5 * ch; if ((t = incompleteGamma (p1, xx, g)) < 0) { std::cerr << "err IncompleteGamma" << std::endl; return -1; } p2 = p - t; t = p2 * exp(xx * aa + g + p1 - c * log(ch)); b = t / ch; a = 0.5 * t - b * c; s1 = (210 + a * (140 + a * (105 + a * (84 + a * (70 + 60 * a))))) / 420; s2 = (420 + a * (735 + a * (966 + a * (1141 + 1278 * a)))) / 2520; s3 = (210 + a * (462 + a * (707 + 932 * a))) / 2520; s4 = (252 + a * (672 + 1182 * a) + c * (294 + a * (889 + 1740 * a))) / 5040; s5 = (84 + 264 * a + c * (175 + 606 * a)) / 2520; s6 = (120 + c * (346 + 127 * c)) / 5040; ch += t * (1 + 0.5 * t * s1 - b * c * (s1 - b * (s2 - b * (s3 - b * (s4 - b * (s5 - b * s6)))))); if (fabs(q / ch - 1) > e) goto l4; return ch; } double RandomTools::pNorm(double x, double mu, double sigma) { return RandomTools::pNorm((x - mu) / sigma); } double RandomTools::pNorm(double x) { const static double a[5] = { 2.2352520354606839287, 161.02823106855587881, 1067.6894854603709582, 18154.981253343561249, 0.065682337918207449113 }; const static double b[4] = { 47.20258190468824187, 976.09855173777669322, 10260.932208618978205, 45507.789335026729956 }; const static double c[9] = { 0.39894151208813466764, 8.8831497943883759412, 93.506656132177855979, 597.27027639480026226, 2494.5375852903726711, 6848.1904505362823326, 11602.651437647350124, 9842.7148383839780218, 1.0765576773720192317e-8 }; const static double d[8] = { 22.266688044328115691, 235.38790178262499861, 1519.377599407554805, 6485.558298266760755, 18615.571640885098091, 34900.952721145977266, 38912.003286093271411, 19685.429676859990727 }; const static double p[6] = { 0.21589853405795699, 0.1274011611602473639, 0.022235277870649807, 0.001421619193227893466, 2.9112874951168792e-5, 0.02307344176494017303 }; const static double q[5] = { 1.28426009614491121, 0.468238212480865118, 0.0659881378689285515, 0.00378239633202758244, 7.29751555083966205e-5 }; double xden, xnum, temp, del, eps, xsq, y, cum; int i; eps = 1e-20; y = fabs(x); if (y <= 0.67448975) /* qnorm(3/4) = .6744.... -- earlier had 0.66291 */ { if (y > eps) { xsq = x * x; xnum = a[4] * xsq; xden = xsq; for (i = 0; i < 3; ++i) { xnum = (xnum + a[i]) * xsq; xden = (xden + b[i]) * xsq; } } else xnum = xden = 0.0; temp = x * (xnum + a[3]) / (xden + b[3]); cum = 0.5 + temp; } else if (y <= sqrt(32)) { /* Evaluate pnorm for 0.674.. = qnorm(3/4) < |x| <= sqrt(32) ~= 5.657 */ xnum = c[8] * y; xden = y; for (i = 0; i < 7; ++i) { xnum = (xnum + c[i]) * y; xden = (xden + d[i]) * y; } temp = (xnum + c[7]) / (xden + d[7]); xsq = trunc(y * 16) / 16; del = (y - xsq) * (y + xsq); cum = exp(-xsq * xsq * 0.5) * exp(-del * 0.5) * temp; if (x > 0.) cum = 1 - cum; } else if (-37.5193 < x && x < 8.2924) { xsq = 1.0 / (x * x); xnum = p[5] * xsq; xden = xsq; for (i = 0; i < 4; ++i) { xnum = (xnum + p[i]) * xsq; xden = (xden + q[i]) * xsq; } temp = xsq * (xnum + p[4]) / (xden + q[4]); temp = (1 / sqrt(2 * M_PI) - temp) / y; xsq = trunc(x * 16) / 16; del = (x - xsq) * (x + xsq); cum = exp(-xsq * xsq * 0.5) * exp(-del * 0.5) * temp; if (x > 0.) cum = 1. - cum; } else /* no log_p , large x such that probs are 0 or 1 */ { if (x > 0) cum = 1.; else cum = 0.; } return cum; } double RandomTools::lnBeta(double alpha, double beta) { return lnGamma(alpha) + lnGamma(beta) - lnGamma(alpha + beta); } double RandomTools::randBeta(double alpha, double beta, const RandomFactory& generator) { return RandomTools::qBeta(generator.drawNumber(), alpha, beta); } double RandomTools::qBeta(double prob, double alpha, double beta) { double lower = NumConstants::VERY_TINY(); double upper = 1 - NumConstants::VERY_TINY(); double const1 = 2.30753; double const2 = 0.27061; double const3 = 0.99229; double const4 = 0.04481; int swap_tail, i_pb, i_inn; double a, adj, logbeta, g, h, pp, prev, qq, r, s, t, tx, w, y, yprev; double acu; volatile double xinbta; if (alpha <= 0. || beta < 0.) throw ("RandomTools::qBeta wih non positive parameters"); if (prob < 0. || prob > 1.) throw ("RandomTools::qBeta wih bad probability"); /* initialize */ logbeta = lnBeta(alpha, beta); /* change tail if necessary; afterwards 0 < a <= 1/2 */ if (prob <= 0.5) { a = prob; pp = alpha; qq = beta; swap_tail = 0; } else /* change tail, swap alpha <-> beta :*/ { a = 1 - prob; pp = beta; qq = alpha; swap_tail = 1; } /* calculate the initial approximation */ /* y := {fast approximation of} qnorm(1 - a) :*/ r = sqrt(-2 * log(a)); y = r - (const1 + const2 * r) / (1. + (const3 + const4 * r) * r); if (pp > 1 && qq > 1) { r = (y * y - 3.) / 6.; s = 1. / (pp + pp - 1.); t = 1. / (qq + qq - 1.); h = 2. / (s + t); w = y * sqrt(h + r) / h - (t - s) * (r + 5. / 6. - 2. / (3. * h)); xinbta = pp / (pp + qq * exp(w + w)); } else { r = qq + qq; t = 1. / (9. * qq); t = r * pow(1. - t + y * sqrt(t), 3.0); if (t <= 0.) xinbta = 1. - exp((log1p(-a) + log(qq) + logbeta) / qq); else { t = (4. * pp + r - 2.) / t; if (t <= 1.) xinbta = exp((log(a * pp) + logbeta) / pp); else xinbta = 1. - 2. / (t + 1.); } } /* solve for x by a modified newton-raphson method, */ /* using the function pbeta_raw */ r = 1 - pp; t = 1 - qq; yprev = 0.; adj = 1; /* Sometimes the approximation is negative! */ if (xinbta < lower) xinbta = 0.5; else if (xinbta > upper) xinbta = 0.5; /* Desired accuracy should depend on (a,p) * This is from Remark .. on AS 109, adapted. * However, it's not clear if this is "optimal" for IEEE double prec. * acu = fmax2(lower, pow(10., -25. - 5./(pp * pp) - 1./(a * a))); * NEW: 'acu' accuracy NOT for squared adjustment, but simple; * ---- i.e., "new acu" = sqrt(old acu) */ double po = pow(10., -13 - 2.5 / (pp * pp) - 0.5 / (a * a)); acu = (lower > po) ? lower : po; tx = prev = 0.; /* keep -Wall happy */ for (i_pb = 0; i_pb < 1000; i_pb++) { y = incompleteBeta(xinbta, pp, qq); // #ifdef IEEE_754 // if(!R_FINITE(y)) // #else // if (errno) // #endif // ML_ERR_return_NAN; y = (y - a) * exp(logbeta + r * log(xinbta) + t * log1p(-xinbta)); if (y * yprev <= 0.) prev = (fabs(adj) > lower) ? fabs(adj) : lower; g = 1; for (i_inn = 0; i_inn < 1000; i_inn++) { adj = g * y; if (fabs(adj) < prev) { tx = xinbta - adj; /* trial new x */ if (tx >= 0. && tx <= 1) { if ((prev <= acu) || (fabs(y) <= acu)) return swap_tail ? 1 - xinbta : xinbta; if (tx != 0. && tx != 1) break; } } g /= 3; } if (fabs(tx - xinbta) < 1e-15 * xinbta) return swap_tail ? 1 - xinbta : xinbta; xinbta = tx; yprev = y; } // throw Exception("Bad precision in RandomTools::qBeta"); return swap_tail ? 1 - xinbta : xinbta; } double RandomTools::incompleteBeta(double x, double alpha, double beta) { double t; double xc; double w; double y; int flag; double big; double biginv; double maxgam; double minlog; double maxlog; big = 4.503599627370496e15; biginv = 2.22044604925031308085e-16; maxgam = 171.624376956302725; minlog = log(NumConstants::VERY_TINY()); maxlog = log(NumConstants::VERY_BIG()); if ((alpha <= 0) || (beta <= 0)) throw Exception("RandomTools::incompleteBeta not valid with non-positive parameters"); if ((x < 0) || (x > 1)) throw Exception("RandomTools::incompleteBeta out of bounds limit"); if (x == 0) return 0; if (x == 1) return 1; flag = 0; if ((beta * x <= 1.0) && (x <= 0.95)) { return incompletebetaps(alpha, beta, x, maxgam); } w = 1.0 - x; if (x > alpha / (alpha + beta)) { flag = 1; t = alpha; alpha = beta; beta = t; xc = x; x = w; } else { xc = w; } if (flag == 1 && (beta * x <= 1.0) && (x <= 0.95) ) { t = incompletebetaps(alpha, beta, x, maxgam); if (t <= NumConstants::VERY_TINY()) return 1.0 - NumConstants::VERY_TINY(); else return 1.0 - t; } y = x * (alpha + beta - 2.0) - (alpha - 1.0); if (y < 0.0) { w = incompletebetafe(alpha, beta, x, big, biginv); } else { w = incompletebetafe2(alpha, beta, x, big, biginv) / xc; } y = alpha * log(x); t = beta * log(xc); if ( (alpha + beta < maxgam) && (fabs(y) < maxlog) && (fabs(t) < maxlog) ) { t = pow(xc, beta); t = t * pow(x, alpha); t = t / alpha; t = t * w; t = t * exp(lnGamma(alpha + beta) - (lnGamma(alpha) + lnGamma(beta))); if (flag == 1) { if (t < NumConstants::VERY_TINY()) return 1.0 - NumConstants::VERY_TINY(); else return 1.0 - t; } else return t; } y = y + t + lnGamma(alpha + beta) - lnGamma(alpha) - lnGamma(beta); y = y + log(w / alpha); if (y < minlog) { t = 0.0; } else { t = exp(y); } if (flag == 1) { if (t < NumConstants::VERY_TINY()) t = 1.0 - NumConstants::VERY_TINY(); else t = 1.0 - t; } return t; } /**********************************************/ double RandomTools::incompletebetafe(double a, double b, double x, double big, double biginv) { double result; double xk; double pk; double pkm1; double pkm2; double qk; double qkm1; double qkm2; double k1; double k2; double k3; double k4; double k5; double k6; double k7; double k8; double r; double t; double ans; double thresh; int n; k1 = a; k2 = a + b; k3 = a; k4 = a + 1.0; k5 = 1.0; k6 = b - 1.0; k7 = k4; k8 = a + 2.0; pkm2 = 0.0; qkm2 = 1.0; pkm1 = 1.0; qkm1 = 1.0; ans = 1.0; r = 1.0; n = 0; thresh = 3.0 * NumConstants::VERY_TINY(); do { xk = -x * k1 * k2 / (k3 * k4); pk = pkm1 + pkm2 * xk; qk = qkm1 + qkm2 * xk; pkm2 = pkm1; pkm1 = pk; qkm2 = qkm1; qkm1 = qk; xk = x * k5 * k6 / (k7 * k8); pk = pkm1 + pkm2 * xk; qk = qkm1 + qkm2 * xk; pkm2 = pkm1; pkm1 = pk; qkm2 = qkm1; qkm1 = qk; if (qk != 0) { r = pk / qk; } if (r != 0) { t = fabs((ans - r) / r); ans = r; } else { t = 1.0; } if (t < thresh) { break; } k1 = k1 + 1.0; k2 = k2 + 1.0; k3 = k3 + 2.0; k4 = k4 + 2.0; k5 = k5 + 1.0; k6 = k6 - 1.0; k7 = k7 + 2.0; k8 = k8 + 2.0; if (fabs(qk) + fabs(pk) > big) { pkm2 = pkm2 * biginv; pkm1 = pkm1 * biginv; qkm2 = qkm2 * biginv; qkm1 = qkm1 * biginv; } if ((fabs(qk) < biginv) || (fabs(pk) < biginv)) { pkm2 = pkm2 * big; pkm1 = pkm1 * big; qkm2 = qkm2 * big; qkm1 = qkm1 * big; } n = n + 1; } while (n != 300); result = ans; return result; } /************************************************************************* Continued fraction expansion #2 for incomplete beta integral Cephes Math Library, Release 2.8: June, 2000 Copyright 1984, 1995, 2000 by Stephen L. Moshier *************************************************************************/ double RandomTools::incompletebetafe2(double a, double b, double x, double big, double biginv) { double result; double xk; double pk; double pkm1; double pkm2; double qk; double qkm1; double qkm2; double k1; double k2; double k3; double k4; double k5; double k6; double k7; double k8; double r; double t; double ans; double z; double thresh; int n; k1 = a; k2 = b - 1.0; k3 = a; k4 = a + 1.0; k5 = 1.0; k6 = a + b; k7 = a + 1.0; k8 = a + 2.0; pkm2 = 0.0; qkm2 = 1.0; pkm1 = 1.0; qkm1 = 1.0; z = x / (1.0 - x); ans = 1.0; r = 1.0; n = 0; thresh = 3.0 * NumConstants::VERY_TINY(); do { xk = -z * k1 * k2 / (k3 * k4); pk = pkm1 + pkm2 * xk; qk = qkm1 + qkm2 * xk; pkm2 = pkm1; pkm1 = pk; qkm2 = qkm1; qkm1 = qk; xk = z * k5 * k6 / (k7 * k8); pk = pkm1 + pkm2 * xk; qk = qkm1 + qkm2 * xk; pkm2 = pkm1; pkm1 = pk; qkm2 = qkm1; qkm1 = qk; if (qk != 0) { r = pk / qk; } if (r != 0) { t = fabs((ans - r) / r); ans = r; } else { t = 1.0; } if (t < thresh) { break; } k1 = k1 + 1.0; k2 = k2 - 1.0; k3 = k3 + 2.0; k4 = k4 + 2.0; k5 = k5 + 1.0; k6 = k6 + 1.0; k7 = k7 + 2.0; k8 = k8 + 2.0; if (fabs(qk) + fabs(pk) > big) { pkm2 = pkm2 * biginv; pkm1 = pkm1 * biginv; qkm2 = qkm2 * biginv; qkm1 = qkm1 * biginv; } if ((fabs(qk) < biginv) || (fabs(pk) < biginv)) { pkm2 = pkm2 * big; pkm1 = pkm1 * big; qkm2 = qkm2 * big; qkm1 = qkm1 * big; } n = n + 1; } while (n != 300); result = ans; return result; } /************************************************************************* Power series for incomplete beta integral. Use when b*x is small and x not too close to 1. Cephes Math Library, Release 2.8: June, 2000 Copyright 1984, 1995, 2000 by Stephen L. Moshier *************************************************************************/ double RandomTools::incompletebetaps(double a, double b, double x, double maxgam) { double result; double s; double t; double u; double v; double n; double t1; double z; double ai; ai = 1.0 / a; u = (1.0 - b) * x; v = u / (a + 1.0); t1 = v; t = u; n = 2.0; s = 0.0; z = NumConstants::VERY_TINY() * ai; while (fabs(v) > z) { u = (n - b) * x / n; t = t * u; v = t / (a + n); s = s + v; n = n + 1.0; } s = s + t1; s = s + ai; u = a * log(x); if ((a + b < maxgam) && (fabs(u) < log(NumConstants::VERY_BIG()))) { t = exp(lnGamma(a + b) - (lnGamma(a) + lnGamma(b))); s = s * t * pow(x, a); } else { t = lnGamma(a + b) - lnGamma(a) - lnGamma(b) + u + log(s); if (t < log(NumConstants::VERY_TINY())) { s = 0.0; } else { s = exp(t); } } result = s; return result; } /**************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Random/ContingencyTableGenerator.h000664 001750 001750 00000006305 12370705300 026311 0ustar00jdutheiljdutheil000000 000000 // // File ContingencyTableGenerator.h // Author: Julien Dutheil // Created on: Fri Dec 10 2010 16:19 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _CONTINGENCYTABLEGENERATOR_H_ #define _CONTINGENCYTABLEGENERATOR_H_ #include "RandomFactory.h" #include "RandomTools.h" #include "../Matrix/Matrix.h" // From the STL: #include #include namespace bpp { /** * @brief Generate a random contingency matrix with given marginal counts. * * This procedure was adapted from the original fortran code described in: * Patefield, W. M. (1981) Algorithm AS159. An efficient method of * generating r x c tables with given row and column totals. * _Applied Statistics_ *30*, 91-97. * This algorithm is the one also used in R function chisq.test for instance. * * The code was adpated from file rcont.c, edited by Martin Maechler, Dec 2003, * available in the R software source distribution. * * @param nrowt Marginal counts. * @param ncolt Marginal counts. * @return A random matrix of counts with the same marginals as specified. */ class ContingencyTableGenerator { private: std::vector nrowt_; std::vector ncolt_; size_t nrow_; size_t ncol_; size_t nrowm_; size_t ncolm_; std::vector jwork_; //workspace size_t ntot_; //total number of observations std::vector fact_; //log factorial public: ContingencyTableGenerator(const std::vector& nrowt, const std::vector& ncolt); public: RowMatrix rcont2(const RandomFactory& generator = *RandomTools::DEFAULT_GENERATOR); }; } //end of namespace bpp. #endif //_CONTINGENCYTABLEGENERATOR_H_ bpp-core-2.2.0/src/Bpp/Numeric/Random/Uniform01WH.cpp000664 001750 001750 00000003674 12370705300 023572 0ustar00jdutheiljdutheil000000 000000 // // File Uniform01WH.cpp // Author : Sylvain Gaillard // Last modification : Friday September 24 2004 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "Uniform01WH.h" using namespace bpp; #include using namespace std; double Uniform01WH::drawNumber() const { double i; ix = (171 * ix) % 30269; iy = (172 * iy) % 30307; iz = (170 * iz) % 30323; return modf((double) ix / 30269. + (double) iy / 30307. + (double) iz / 30323, &i); } bpp-core-2.2.0/src/Bpp/Numeric/Random/RandomFactory.h000664 001750 001750 00000004350 12370705300 023760 0ustar00jdutheiljdutheil000000 000000 /* * File RandomFactory.h * Author : Sylvain Gaillard * Last modification : Friday September 24 2004 */ /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _RANDOMFACTORY_H_ #define _RANDOMFACTORY_H_ namespace bpp { /** * @brief This is the interface for the Random Number Generators. * * A Random Number Generator draw numbers between two end points. Each * number is taken from a given statistic distribution. */ class RandomFactory { public: RandomFactory() {} virtual ~RandomFactory() {} public: /** * @brief Set the generator's seed. */ virtual void setSeed(long seed) = 0; /** * @brief Return a random number. */ virtual double drawNumber() const = 0; }; } //end of namespace bpp. #endif // _RANDOMFACTORY_H_ bpp-core-2.2.0/src/Bpp/Numeric/Random/Uniform01WH.h000664 001750 001750 00000005635 12370705300 023236 0ustar00jdutheiljdutheil000000 000000 // // File Uniform01WH.h // Author : Sylvain Gaillard // Last modification : Friday September 24 2004 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _UNIFORM01WH_H_ #define _UNIFORM01WH_H_ #include "RandomFactory.h" namespace bpp { /** * @brief A uniform random number generator. * * This is a congruential uniform generator which draw double between 0 and 1 excluding * the end points. * This generator is based on a Fortan routine from Wichmann, B. A. and Hill, I. D. (1982). * "An efficient and portable pseudorandom number generator," Applied Statistics, 31, 188-190 */ class Uniform01WH : public virtual RandomFactory { public: // Constructors and destructor /** * @brief Create a Random Number Generator. * * @param seed The seed for the random numbers. */ Uniform01WH(long seed) : ix(seed), iy(seed), iz(seed) {} /** * @brief Destroy the generator. */ virtual ~Uniform01WH(); public: /** * @brief Set the seed for a new set of random numbers. */ void setSeed(long seed) { setSeeds(seed); } /** * @brief Set the three seeds. */ void setSeeds(long seed1, long seed2 = 20356, long seed3 = 35412) { ix = seed1; iy = seed2; iz = seed3; } /** * @brief Get a random number between 0.0 and 1.0 (exclusive of the end point values). */ double drawNumber() const; private: mutable long ix, iy, iz; }; } //end of namespace bpp. #endif // _UNIFORM01WH_H_ bpp-core-2.2.0/src/Bpp/Numeric/Random/ContingencyTableGenerator.cpp000664 001750 001750 00000013350 12370705300 026642 0ustar00jdutheiljdutheil000000 000000 // // File ContingencyTableGenerator.cpp // Author: Julien Dutheil // Created on: Fri Dec 10 2010 16:19 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "ContingencyTableGenerator.h" #include "../VectorTools.h" #include using namespace bpp; using namespace std; /**************************************************************************/ ContingencyTableGenerator::ContingencyTableGenerator( const std::vector& nrowt, const std::vector& ncolt): nrowt_(nrowt), ncolt_(ncolt), nrow_(nrowt.size()), ncol_(ncolt.size()), nrowm_(0), ncolm_(0), jwork_(ncolt.size()), ntot_(0), fact_(0) { if (nrow_ < 2 || ncol_ < 2) throw Exception("ContingencyTableGenerator. Input marginals must have size greater than 1."); ntot_ = VectorTools::sum(nrowt_); if (ntot_ != VectorTools::sum(ncolt_)) throw Exception("ContingencyTableGenerator. Marginal do not sum to the same value."); nrowm_ = nrow_ - 1; ncolm_ = ncol_ - 1; fact_.resize(ntot_ + 1); double x = 0.; fact_[0] = 0.; for (unsigned int i = 1; i <= ntot_; i++) { x = x + log(static_cast(i)); fact_[i] = x; } } /* Algorithm AS 159 Applied Statistics (1981), vol. 30, no. 1 original (C) Royal Statistical Society 1981 Generate random two-way table with given marginal totals. Heavily pretty edited by Martin Maechler, Dec 2003 use double precision for integer multiplication (against overflow); Taken from R source file rcont.c and adapted by Julien Dutheil, Dec 2010 */ RowMatrix ContingencyTableGenerator::rcont2(const RandomFactory& generator) { RowMatrix table(nrow_, ncol_); //Result size_t j, l, m, ia, ib, ic, jc, id, ie, ii, nll, nlm, nr_1, nc_1; long double x, y, dummy, sumprb; bool lsm, lsp; nr_1 = nrow_ - 1; nc_1 = ncol_ - 1; ib = 0; /* -Wall */ /* Construct random matrix */ for (j = 0; j < nc_1; ++j) jwork_[j] = ncolt_[j]; jc = ntot_; for (l = 0; l < nr_1; ++l) { /* ----- matrix[ l, * ] ----- */ ia = nrowt_[l]; ic = jc; jc -= ia;/* = n_tot - sum(nr[0:l]) */ for (m = 0; m < nc_1; ++m) { id = jwork_[m]; ie = ic; ic -= id; ib = ie - ia; ii = ib - id; if (ie == 0) { /* Row [l,] is full, fill rest with zero entries */ for (j = m; j < nc_1; ++j) table(l, j) = 0; ia = 0; break; } /* Generate pseudo-random number */ dummy = generator.drawNumber(); do {/* Outer Loop */ /* Compute conditional expected value of MATRIX(L, M) */ nlm = static_cast(ia * (static_cast(id) / static_cast(ie)) + 0.5); x = exp(fact_[ia] + fact_[ib] + fact_[ic] + fact_[id] - fact_[ie] - fact_[nlm] - fact_[id - nlm] - fact_[ia - nlm] - fact_[ii + nlm]); if (x >= dummy) break; sumprb = x; y = x; nll = nlm; do { /* Increment entry in row L, column M */ j = static_cast((id - nlm) * static_cast(ia - nlm)); lsp = (j == 0); if (!lsp) { ++nlm; x = x * j / (static_cast(nlm) * (ii + nlm)); sumprb += x; if (sumprb >= dummy) goto L160; } do { /* Decrement entry in row L, column M */ j = nll * (ii + nll); lsm = (j == 0); if (!lsm) { --nll; y = y * j / (static_cast(id - nll) * (ia - nll)); sumprb += y; if (sumprb >= dummy) { nlm = nll; goto L160; } /* else */ if (!lsp) break;/* to while (!lsp) */ } } while (!lsm); } while (!lsp); dummy = sumprb * generator.drawNumber(); } while (true); L160: table(l, m) = nlm; ia -= nlm; jwork_[m] -= nlm; } table(l, nc_1) = ia;/* last column in row l */ } /* Compute entries in last row of MATRIX */ for (m = 0; m < nc_1; ++m) table(nr_1, m) = jwork_[m]; table(nr_1, nc_1) = ib - table(nr_1, nc_1 - 1); return table; } /**************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/ParameterExceptions.h000664 001750 001750 00000011122 12370705300 023745 0ustar00jdutheiljdutheil000000 000000 // // File: ParameterExceptions.h // Created by: Julien Dutheil // Created on: Mon Nov 3 18:05:36 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _PARAMETEREXCEPTIONS_H_ #define _PARAMETEREXCEPTIONS_H_ // From Utils: #include "../Exceptions.h" // From the STL: #include namespace bpp { class Parameter; /** * @brief The parameter exception base class. * * @see Exception */ class ParameterException : public Exception { private: const Parameter* parameter_; public: // Class constructors and destructor: /** * @brief Build a new ParameterException object. * * @param text A message to be passed to the exception hierarchy. * @param param A const pointer toward the parameter that threw the exception. */ ParameterException(const std::string& text, const Parameter* param); ParameterException(const ParameterException& pe): Exception(pe), parameter_(pe.parameter_) {} //We explicitely do not want to make a hard copy of the pointer here. ParameterException& operator=(const ParameterException& pe) { Exception::operator=(pe); parameter_ = pe.parameter_; return *this; } virtual ~ParameterException() throw () {} public: /** * @brief Get the parameter that threw the exception. * * @return A const pointer toward the parameter. */ virtual const Parameter * getParameter() const; }; /** * @brief Exception thrown when a value do not match a given constraint. * * @see Constraint */ class ConstraintException : public ParameterException { private: double badValue_; public: // Class constructor and destructor: /** * @brief Build a new ConstraintException object. * * @param text A message to be passed to the exception hierarchy. * @param param A const pointer toward the parameter that threw the exception. * @param badValue The value that doesn't match the constraint. */ ConstraintException(const std::string& text, const Parameter* param, double badValue); virtual ~ConstraintException() throw () {} public: /** * @brief Get the value that doesn't match the constraint. * * @return The faulty value. */ virtual double getBadValue() const; }; /*******************************************************************************/ /** * @brief Exception thrown when a parameter is not found, * for instance in a ParameterList. */ class ParameterNotFoundException : public Exception { private: const std::string parameter_; public: // Class constructors and destructor: /** * @brief Build a new ParameterNotFoundException object. * * @param text A message to be passed to the exception hierarchy. * @param param The name of the parameter not found. */ ParameterNotFoundException(const std::string& text, const std::string& param = ""); virtual ~ParameterNotFoundException() throw () {} public: /** * @brief Get the name of the parameter not found. * * @return The parameter name. */ virtual std::string getParameter() const; }; } //end of namespace bpp. #endif //_PARAMETEREXCEPTIONS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Range.h000664 001750 001750 00000033042 12370705300 021024 0ustar00jdutheiljdutheil000000 000000 // // File: Range.h // Created by: Julien Dutheil // Created on: Mon Nov 21 15:52 2011 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _RANGE_H_ #define _RANGE_H_ #include "../Text/TextTools.h" #include "../Clonable.h" //From the STL: #include #include #include #include #include namespace bpp { /** * @brief The Range class, defining an interval. * * Methods are provided for extending the range, get union and intersection. */ template class Range: public virtual Clonable { private: T begin_; T end_; public: /** * @brief Creates a new interval. * * If a > b, then the positions are swapped. * If a == b, the interval is considered empty. * Coordinates are 0-based and of type [a, b[, * so that the length of the interval is computed as * b - a. * * @param a First position * @param b Second position */ Range(const T& a = 0, const T& b = 0): begin_(std::min(a, b)), end_(std::max(a, b)) {} Range(const Range& range): begin_(range.begin_), end_(range.end_) {} Range& operator=(const Range& range) { begin_ = range.begin_; end_ = range.end_; return *this; } Range* clone() const { return new Range(*this); } virtual ~Range() {} public: bool operator==(const Range& r) const { return begin_ == r.begin_ && end_ == r.end_; } bool operator!=(const Range& r) const { return begin_ != r.begin_ || end_ != r.end_; } bool operator<(const Range& r) const { return begin_ < r.begin_ || end_ < r.end_; } virtual Range& operator+=(const T& val) { begin_ += val; end_ += val; return *this; } virtual Range operator+(const T& val) { return Range(*this) += val; } virtual Range& operator-=(const T& val) { begin_ -= val; end_ -= val; return *this; } virtual Range operator-(const T& val) { return Range(*this) -= val; } T begin() const { return begin_; } T end() const { return end_; } T length() const { return end_ - begin_; } /** * @param r Range to compare with. * @return True if the two intervals overlap. */ bool overlap(const Range& r) const { return (r.begin_ < end_ && r.end_ > begin_); } /** * @param r Range to compare with. * @return True if the two intervals are contiguous (i.e. the two intervals * are adjacent and share one bound). */ bool isContiguous(const Range& r) const { return (r.begin_ == end_ || r.end_ == begin_); } /** * @param r Range to compare with. * @return True if the given interval is included in the instanciated one. */ bool contains(const Range& r) const { return (r.begin_ >= begin_ && r.end_ <= end_); } /** * @brief Expand the current interval with the given one. * * If the two intervals do not overlap, then the interval is not modified. * @param r input interval. */ void expandWith(const Range& r) { if (r.begin_ < begin_ && r.end_ >= begin_) begin_ = r.begin_; if (r.end_ > end_ && r.begin_ <= end_) end_ = r.end_; } /** * @brief Restrict the current interval to the intersection with the given one. * * If the two intervals do not overlap, then the interval is set to empty. * @param r input interval. */ void sliceWith(const Range& r) { if (!overlap(r)) { begin_ = 0; end_ = 0; } else { if (r.begin_ > begin_ && r.begin_ <= end_) begin_ = r.begin_; if (r.end_ < end_ && r.end_ >= begin_) end_ = r.end_; } } /** * @return True if then begining position equals the ending one. */ bool isEmpty() const { return begin_ == end_; } /** * @return A string describing the range. */ std::string toString() const { return ("[" + TextTools::toString(begin_) + "," + TextTools::toString(end_) + "["); } }; /** * @brief Interface discribing a collection of Range objects. */ template class RangeCollection { public: virtual ~RangeCollection() {} /** * @brief Add a new range to the collection. * * @param r The range to add to the collection. */ virtual void addRange(const Range& r) = 0; /** * @brief Get the intersection with a given range. * * The new multirange is the union of all ranges intersections with the given range. * * @param r Restriction range. */ virtual void restrictTo(const Range& r) = 0; /** * @brief Only keep the ranges that fall within the given range. * * @param r Restriction range. */ virtual void filterWithin(const Range& r) = 0; /** * @return A string representation of the set of intervals. */ virtual std::string toString() const = 0; /** * @return True if the set does not contain any range. */ virtual bool isEmpty() const = 0; /** * @return The number of ranges in the collection. */ virtual size_t size() const = 0; /** * @return The ith range in the collection. */ virtual const Range& getRange(size_t i) const = 0; /** * @brief Clear the collection. */ virtual void clear() = 0; }; /** * @brief A special class used inside RangeCollection. */ template class rangeComp_ { public: bool operator() (const Range* a, const Range* b) const { return ((*a) < (*b)); } }; /** * @brief This class implements a data structure describing a set of intervales. * * Intervales can be overlapping, but empty intervales will be ignored/removed. */ template class RangeSet: public RangeCollection { public: private: std::set< Range*, rangeComp_ > ranges_; public: RangeSet(): ranges_() {} RangeSet(const RangeSet& set): ranges_() { for (typename std::set< Range* >::iterator it = set.ranges_.begin(); it != set.ranges_.end(); ++it) { ranges_.insert(ranges_.end(), (**it).clone()); } } RangeSet& operator=(const RangeSet& set) { clear_(); for (typename std::set< Range* >::iterator it = set.ranges_.begin(); it != set.ranges_.end(); ++it) { ranges_.insert(ranges_.end(), (**it).clone()); } return *this; } virtual ~RangeSet() { clear_(); } public: void addRange(const Range& r) { if (!r.isEmpty()) ranges_.insert(r.clone()); } void restrictTo(const Range& r) { typename std::set< Range* >::iterator it = ranges_.begin(); while (it != ranges_.end()) { (**it).sliceWith(r); if ((**it).isEmpty()) { typename std::set< Range* >::iterator it2 = it; delete *it; ++it; ranges_.erase(it2); } else { ++it; } } } void filterWithin(const Range& r) { typename std::set< Range* >::iterator it = ranges_.begin(); while (it != ranges_.end()) { if (r.contains(**it)) { ++it; } else { typename std::set< Range* >::iterator it2 = it; delete *it; ++it; ranges_.erase(it2); } } } std::string toString() const { std::string s = "{ "; for (typename std::set< Range* >::const_iterator it = ranges_.begin(); it != ranges_.end(); ++it) { s += (**it).toString() + " "; } s += "}"; return s; } bool isEmpty() const { return ranges_.size() == 0; } size_t size() const { return ranges_.size(); } const Range& getRange(size_t i) const { typename std::set< Range* >::const_iterator it = ranges_.begin(); for (size_t c = 0; c < i; ++c) ++it; //it = it++; return **it; } const std::set< Range*, rangeComp_ >& getSet() const { return ranges_; } std::set< Range*, rangeComp_ >& getSet() { return ranges_; } void clear() { clear_(); } private: void clear_() { for (typename std::set< Range* >::const_iterator it = ranges_.begin(); it != ranges_.end(); ++it) { delete *it; } ranges_.clear(); } }; /** * @brief This class implements a data structure describing a set of non-overlapping intervales. */ template class MultiRange: public RangeCollection { private: std::vector*> ranges_; public: MultiRange(): ranges_() {} MultiRange(const MultiRange& mr): ranges_() { for (size_t i = 0; i < mr.ranges_.size(); ++i) ranges_.push_back(mr.ranges_[i]->clone()); } MultiRange& operator=(const MultiRange& mr) { clear_(); for (size_t i = 0; i < mr.ranges_.size(); ++i) ranges_.push_back(mr.ranges_[i]->clone()); return *this; } virtual ~MultiRange() { clear_(); } public: void addRange(const Range& r) { //this is a bit tricky, as many cases can happen. we have to check how many ranges overlap with the new one: std::vector overlappingPositions; for (size_t i = 0; i < ranges_.size(); ++i) { if (ranges_[i]->overlap(r)) overlappingPositions.push_back(i); } //check if not overlap: if (overlappingPositions.size() == 0) { //We simply add the new range to the list: ranges_.push_back(r.clone()); } else { //We extend the first overlapping element: ranges_[overlappingPositions[0]]->expandWith(r); //Now we merge all other overlapping ranges, if any: for (size_t i = overlappingPositions.size() - 1; i > 0; --i) { //Expand first range: ranges_[overlappingPositions[0]]->expandWith(*ranges_[overlappingPositions[i]]); //Then removes this range: delete ranges_[overlappingPositions[i]]; ranges_.erase(ranges_.begin() + static_cast(overlappingPositions[i])); } } clean_(); } void restrictTo(const Range& r) { for (size_t i = 0; i < ranges_.size(); ++i) ranges_[i]->sliceWith(r); clean_(); } void filterWithin(const Range& r) { typename std::vector< Range* >::iterator it = ranges_.begin(); while (it != ranges_.end()) { if (r.contains(**it)) { ++it; } else { delete *it; it = ranges_.erase(it); } } } /** * @return A string representation of the set of intervals. */ std::string toString() const { std::string s = "{ "; for (size_t i = 0; i < ranges_.size(); ++i) s += ranges_[i]->toString() + " "; s += "}"; return s; } /** * @return A vector with all interval bounds. */ std::vector getBounds() const { std::vector bounds; for (size_t i = 0; i < ranges_.size(); ++i) { bounds.push_back(ranges_[i]->begin()); bounds.push_back(ranges_[i]->end()); } return bounds; } /** * @return True if the set does not contain any range. */ bool isEmpty() const { return ranges_.size() == 0; } size_t size() const { return ranges_.size(); } const Range& getRange(size_t i) const { return *ranges_[i]; } void clear() { clear_(); } private: void clean_() { //Reorder rangeComp_ comp; std::sort(ranges_.begin(), ranges_.end(), comp); //Remove empty intervals: typename std::vector< Range* >::iterator it = ranges_.begin(); while (it != ranges_.end()) { if ((**it).isEmpty()) { delete *it; it = ranges_.erase(it); } else { ++it; } } } private: void clear_() { for (size_t i = 0; i < ranges_.size(); ++i) { delete ranges_[i]; } ranges_.clear(); } }; } //end of namespace bpp #endif //_RANGE_H_ bpp-core-2.2.0/src/Bpp/Numeric/AbstractParameterAliasable.cpp000664 001750 001750 00000027346 12370705300 025537 0ustar00jdutheiljdutheil000000 000000 // // File: AbstractParameterAliasable.cpp // Created by: Julien Dutheil // Created on: Sun Mar 29 09:10 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "AbstractParameterAliasable.h" #include "VectorTools.h" using namespace bpp; using namespace std; AbstractParameterAliasable::AbstractParameterAliasable(const AbstractParameterAliasable& ap) : AbstractParametrizable(ap), independentParameters_(ap.independentParameters_), aliasListenersRegister_() { // Actualize the register with adequate pointers: for (map::const_iterator it = ap.aliasListenersRegister_.begin(); it != ap.aliasListenersRegister_.end(); it++) { AliasParameterListener* listener = it->second->clone(); listener->setParameterList(&getParameters_()); aliasListenersRegister_[it->first] = listener; //Now correct parameters with appropriate pointers: for (unsigned int i = 0; i < getNumberOfParameters(); ++i) { if (getParameters_()[i].hasParameterListener(it->first)) { getParameters_()[i].removeParameterListener(it->first); getParameters_()[i].addParameterListener(listener, false); } } } } AbstractParameterAliasable& AbstractParameterAliasable::operator=(const AbstractParameterAliasable& ap) { independentParameters_ = ap.independentParameters_; // Actualize the register with adequate pointers: for (map::const_iterator it = ap.aliasListenersRegister_.begin(); it != ap.aliasListenersRegister_.end(); it++) { AliasParameterListener* listener = it->second->clone(); listener->setParameterList(&getParameters_()); aliasListenersRegister_[it->first] = listener; //Now correct parameters with appropriate pointers: for (unsigned int i = 0; i < getNumberOfParameters(); ++i) { if (getParameters_()[i].hasParameterListener(it->first)) { getParameters_()[i].removeParameterListener(it->first); getParameters_()[i].addParameterListener(listener, false); } } } return *this; } AbstractParameterAliasable::~AbstractParameterAliasable() { // Delete the registry content: for (map::iterator it = aliasListenersRegister_.begin(); it != aliasListenersRegister_.end(); it++) { delete it->second; } } void AbstractParameterAliasable::aliasParameters(const std::string& p1, const std::string& p2) throw (ParameterNotFoundException, Exception) { // In case this is the first time we call this method: if (getNumberOfParameters() > 0 && independentParameters_.size() == 0) independentParameters_ = getParameters(); if (!hasParameter(p1)) throw ParameterNotFoundException("AbstractParameterAliasable::aliasParameters", p1); if (!hasParameter(p2)) throw ParameterNotFoundException("AbstractParameterAliasable::aliasParameters", p2); if (!independentParameters_.hasParameter(getNamespace() + p2)) throw Exception("AbstractParameterAliasable::aliasParameters. Parameter " + p2 + " is already aliased to a parameter and can't be aliased twice."); string id = "__alias_" + p2 + "_to_" + p1; string idCheck = "__alias_" + p1 + "_to_" + p2; if (aliasListenersRegister_.find(idCheck) != aliasListenersRegister_.end()) throw Exception("AbstractParameterAliasable::aliasParameters. Trying to alias parameter " + p2 + " to " + p1 + ", but parameter " + p1 + " is already aliased to parameter " + p2 + "."); Parameter* param1 = &getParameter_(p1); Parameter* param2 = &getParameter_(p2); if (!param1->hasConstraint()) { if (param2->hasConstraint()) throw Exception("AbstractParameterAliasable::aliasParameters. Cannot alias parameter " + p2 + " to " + p1 + ", because the constraints attached to these two parameters are different."); } else // We use a small trick here, we test the constraints on the basis of their string description (C++ does not provide a default operator==() :( ). if (param2->hasConstraint() && (param1->getConstraint()->getDescription() != param2->getConstraint()->getDescription())) throw Exception("AbstractParameterAliasable::aliasParameters. Cannot alias parameter " + p2 + " to " + p1 + ", because the constraints attached to these two parameters are different."); // Every thing seems ok, let's create the listener and register it: AliasParameterListener* aliasListener = new AliasParameterListener(id, getParameters().whichParameterHasName(getNamespace() + p2), &getParameters_(), p1); ParameterList pl=getParameters_(); aliasListenersRegister_[id] = aliasListener; // Now we add it to the appropriate parameter, that is p1. // The parameter will not own the listener, the bookkeeping being achieved by the register: param1->addParameterListener(aliasListener, false); // Finally we remove p2 from the list of independent parameters: independentParameters_.deleteParameter(getNamespace() + p2); } void AbstractParameterAliasable::aliasParameters(map& unparsedParams, bool verbose) { ParameterList plpars, pl=getParameters(); for (size_t i=0; i< pl.size(); i++) { if (unparsedParams.find(pl[i].getName())==unparsedParams.end()) plpars.addParameter(*pl[i].clone()); } size_t unp_s=unparsedParams.size(); while (unp_s!=0) { map::iterator it; for (it=unparsedParams.begin(); it!=unparsedParams.end(); it++) { Parameter* pp=0; try { pp=&plpars.getParameter(it->second); } catch (ParameterNotFoundException& e){ if (!pl.hasParameter(it->second)) throw ParameterNotFoundException("Unknown aliasing parameter", it->second); continue; } auto_ptr p2(pp->clone()); p2->setName(it->first); plpars.addParameter(p2.release()); plpars.getParameter(it->first); aliasParameters(it->second, it->first); if (verbose) ApplicationTools::displayResult("Parameter alias found", it->first + " -> " + it->second + " = " + TextTools::toString(pp->getValue())); unparsedParams.erase(it); } if (unparsedParams.size()==unp_s) throw Exception("Error, there is a cycle in aliasing"); else unp_s=unparsedParams.size(); } matchParametersValues(plpars); } void AbstractParameterAliasable::unaliasParameters(const std::string& p1, const std::string& p2) throw (ParameterNotFoundException, Exception) { if (!hasParameter(p1)) throw ParameterNotFoundException("AbstractParameterAliasable::unaliasParameters", p1); if (!hasParameter(p2)) throw ParameterNotFoundException("AbstractParameterAliasable::unaliasParameters", p2); string id = "__alias_" + p2 + "_to_" + p1; map::iterator it = aliasListenersRegister_.find(id); if (it == aliasListenersRegister_.end()) throw Exception("AbstractParameterAliasable::unaliasParameters. Parameter " + p2 + " is not aliased to parameter " + p1 + "."); // Remove the listener: getParameter_(p1).removeParameterListener(id); delete it->second; aliasListenersRegister_.erase(it); // Finally we re-add p2 to the list of independent parameters: independentParameters_.addParameter(getParameter(p2)); } void AbstractParameterAliasable::setNamespace(const std::string& prefix) { string currentName; // First we correct the independent parameter list for (unsigned int i = 0; i < independentParameters_.size(); i++) { currentName = independentParameters_[i].getName(); if (TextTools::startsWith(currentName, getNamespace())) independentParameters_[i].setName(prefix + currentName.substr(getNamespace().size())); else independentParameters_[i].setName(prefix + currentName); } // Then we modify all the listeners for (map::iterator it = aliasListenersRegister_.begin(); it != aliasListenersRegister_.end(); it++) { currentName = it->second->getName(); if (TextTools::startsWith(currentName, getNamespace())) it->second->rename(prefix + currentName.substr(getNamespace().size())); else it->second->rename(prefix + currentName); } // Finally we notify the mother class: AbstractParametrizable::setNamespace(prefix); } vector AbstractParameterAliasable::getAlias(const string& name) const { vector aliases; for (map::const_iterator it = aliasListenersRegister_.begin(); it != aliasListenersRegister_.end(); it++) { if (it->second->getFrom() == name) { string alias = it->second->getAlias(); aliases.push_back(alias); if (alias!=name){ vector chainAliases = getAlias(alias); VectorTools::append(aliases, chainAliases); } } } return aliases; } ParameterList AbstractParameterAliasable::getAliasedParameters(const ParameterList& pl) const { ParameterList aliases; bool b=false; for (map::const_iterator it = aliasListenersRegister_.begin(); it != aliasListenersRegister_.end(); it++) { if ((pl.hasParameter(it->second->getFrom()) || aliases.hasParameter(it->second->getFrom())) && ! (aliases.hasParameter(it->second->getAlias()) || pl.hasParameter(it->second->getAlias()))) { b=true; aliases.addParameter(getParameter(it->second->getAlias())); } } while (b) { b=false; for (map::const_iterator it = aliasListenersRegister_.begin(); it != aliasListenersRegister_.end(); it++) { if (aliases.hasParameter(it->second->getFrom()) && ! (aliases.hasParameter(it->second->getAlias()) || pl.hasParameter(it->second->getAlias()))) { b=true; aliases.addParameter(getParameter(it->second->getAlias())); } } } return aliases; } string AbstractParameterAliasable::getFrom(const string& name) const { string from=""; for (map::const_iterator it = aliasListenersRegister_.begin(); it != aliasListenersRegister_.end(); it++) { if (it->second->getName() == name) { from = it->second->getFrom(); break; } } return from; } bpp-core-2.2.0/src/Bpp/Numeric/NumTools.cpp000664 001750 001750 00000006316 12370705300 022107 0ustar00jdutheiljdutheil000000 000000 // // File: NumTools.cpp // Created by: Julien Dutheil // Created on: Mon Nov 10 12:06:55 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This file is part of the Bio++ project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "NumTools.h" #include "Matrix/Matrix.h" using namespace bpp; using namespace std; /******************************************************************************/ double NumTools::uniRoot(Function& f, const std::string& param, double a, double b, double tolerance) throw (Exception) { ParameterList pl; pl.addParameter(Parameter(param, a)); double fa = f.f(pl); pl[0].setValue(b); double fb = f.f(pl); if(fa * fb > 0.) throw Exception("NumTools::uniRoot(). Initial interval values are not of opposite sign."); double c = (a + b) / 2.; double fc; while(abs(fb - fa) > tolerance) { c = (a + b) / 2.; //Better use golden section here... pl[0].setValue(c); fc = f.f(pl); if(fc * fa < 0.) { b = c; fb = fc; } else { a = c; fa = fc; } } return c; } /******************************************************************************/ RowMatrix* NumTools::computeHessianMatrix(DerivableSecondOrder& function, const ParameterList& parameters) { size_t n = parameters.size(); vector variables = parameters.getParameterNames(); RowMatrix* hessian = new RowMatrix(n, n); for(unsigned int i = 0; i < n; i++) for(unsigned int j = 0; j < n; j++) if(j == i) (*hessian)(i,j) = function.d2f(variables[i], parameters); else (*hessian)(i,j) = function.d2f(variables[i], variables[j], parameters); return hessian; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Matrix/Matrix.h000664 001750 001750 00000032445 12370705300 022506 0ustar00jdutheiljdutheil000000 000000 // // File: Matrix.h // Authors: Julien Dutheil // Sylvain Gaillard // Created on: Tue Apr 07 11:58 2004 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _MATRIX_H_ #define _MATRIX_H_ #include #include "../../Clonable.h" #include "../NumConstants.h" #include "../NumTools.h" #include "../VectorExceptions.h" #include namespace bpp { /** * @brief The matrix template interface. */ template class Matrix : public Clonable { public: Matrix() {} virtual ~Matrix() {} public: /** * @return \f$m_{i,j}\f$. * @param i row index. * @param j column index. */ virtual const Scalar& operator()(size_t i, size_t j) const = 0; /** * @return \f$m_{i,j}\f$. * @param i row index. * @param j column index. */ virtual Scalar& operator()(size_t i, size_t j) = 0; virtual bool equals(const Matrix& m, double threshold = NumConstants::TINY()) { if (m.getNumberOfRows() != getNumberOfRows() || m.getNumberOfColumns() != getNumberOfColumns()) return false; for (size_t i = 0; i < getNumberOfRows(); i++) { for (size_t j = 0; j < getNumberOfColumns(); j++) { if (NumTools::abs(static_cast(operator()(i, j)) - static_cast(m(i, j))) > threshold) return false; } } return true; } /** * @return The number of rows. */ virtual size_t getNumberOfRows() const = 0; /** * @return The number of columns. */ virtual size_t getNumberOfColumns() const = 0; /** * @return the row at position i as a vector. * @param i The index of the row. */ virtual std::vector row(size_t i) const = 0; /** * @return the column at position j as a vector. * @param j The index of the column. */ virtual std::vector col(size_t j) const = 0; /** * @brief Resize the matrix. * * @param nRows The new number of rows. * @param nCols The new number of columns. */ virtual void resize(size_t nRows, size_t nCols) = 0; }; /** * @brief Matrix storage by row. * * This matrix is a vector of vector of Scalar. * Row access is in \f$O(1)\f$ while column access is in \f$O(nRow)\f$. */ template class RowMatrix : public Matrix { private: std::vector< std::vector > m_; public: RowMatrix() : m_() {} RowMatrix(size_t nRow, size_t nCol) : m_(nRow) { for (size_t i = 0; i < nRow; i++) { m_[i].resize(nCol); } } RowMatrix(const Matrix& m) : m_(m.getNumberOfRows()) { size_t nr = m.getNumberOfRows(); size_t nc = m.getNumberOfColumns(); for (size_t i = 0; i < nr; i++) { m_[i].resize(nc); for (size_t j = 0; j < nc; j++) { m_[i][j] = m(i, j); } } } RowMatrix& operator=(const Matrix& m) { size_t nr = m.getNumberOfRows(); m_.resize(nr); size_t nc = m.getNumberOfColumns(); for (size_t i = 0; i < nr; i++) { m_[i].resize(nc); for (size_t j = 0; j < nc; j++) { m_[i][j] = m(i, j); } } return *this; } virtual ~RowMatrix() {} public: RowMatrix* clone() const { return new RowMatrix(*this); } const Scalar& operator()(size_t i, size_t j) const { return m_[i][j]; } Scalar& operator()(size_t i, size_t j) { return m_[i][j]; } size_t getNumberOfRows() const { return m_.size(); } size_t getNumberOfColumns() const { return m_.size() == 0 ? 0 : m_[0].size(); } std::vector row(size_t i) const { std::vector r(getNumberOfColumns()); for (size_t j = 0; j < getNumberOfColumns(); j++) { r[j] = operator()(i, j); } return r; } const std::vector& getRow(size_t i) const { return m_[i]; } std::vector col(size_t j) const { std::vector c(getNumberOfRows()); for (size_t i = 0; i < getNumberOfRows(); i++) { c[i] = operator()(i, j); } return c; } void resize(size_t nRows, size_t nCols) { m_.resize(nRows); for (size_t i = 0; i < nRows; i++) { m_[i].resize(nCols); } } void addRow(const std::vector& newRow) throw (DimensionException) { if (getNumberOfColumns()!=0 && newRow.size() != getNumberOfColumns()) throw DimensionException("RowMatrix::addRow: invalid row dimension", newRow.size(), getNumberOfColumns()); m_.push_back(newRow); } }; /** * @brief Matrix storage by column. * * This matrix is a vector of vector of Scalar. * Column access is in \f$O(1)\f$ while row access is in \f$O(nCol)\f$. */ template class ColMatrix : public Matrix { private: std::vector< std::vector > m_; public: ColMatrix() : m_() {} ColMatrix(size_t nRow, size_t nCol) : m_(nCol) { for (size_t i = 0; i < nCol; i++) { m_[i].resize(nRow); } } ColMatrix(const Matrix& m) : m_(m.getNumberOfColumns()) { size_t nr = m.getNumberOfRows(); size_t nc = m.getNumberOfColumns(); for (size_t i = 0; i < nc; i++) { m_[i].resize(nr); for (size_t j = 0; j < nr; j++) { m_[i][j] = m(j, i); } } } ColMatrix& operator=(const Matrix& m) { size_t nc = m.getNumberOfColumns(); m_.resize(nc); size_t nr = m.getNumberOfRows(); for (size_t i = 0; i < nc; i++) { m_[i].resize(nr); for (size_t j = 0; j < nr; j++) { m_[i][j] = m(j, i); } } return *this; } virtual ~ColMatrix() {} public: ColMatrix* clone() const { return new ColMatrix(*this); } const Scalar& operator()(size_t i, size_t j) const { return m_[j][i]; } Scalar& operator()(size_t i, size_t j) { return m_[j][i]; } size_t getNumberOfColumns() const { return m_.size(); } size_t getNumberOfRows() const { return m_.size() == 0 ? 0 : m_[0].size(); } std::vector row(size_t i) const { std::vector r(getNumberOfColumns()); for (size_t j = 0; j < getNumberOfColumns(); j++) { r[j] = operator()(i, j); } return r; } const std::vector& getCol(size_t i) const { return m_[i]; } std::vector col(size_t j) const { std::vector c(getNumberOfRows()); for (size_t i = 0; i < getNumberOfRows(); i++) { c[i] = operator()(i, j); } return c; } void resize(size_t nRows, size_t nCols) { m_.resize(nCols); for (size_t i = 0; i < nCols; i++) { m_[i].resize(nRows); } } void addCol(const std::vector& newCol) throw (DimensionException) { if (getNumberOfRows()!=0 && newCol.size() != getNumberOfRows()) throw DimensionException("ColMatrix::addCol: invalid column dimension", newCol.size(), getNumberOfRows()); m_.push_back(newCol); } }; /** * @brief Matrix storage in one vector. * * This Matrix is a simple vector of Scalar of size n x m. * Element access is in \f$O(1)\f$ but resizing the matrix while keeping the * old values is in \f$O(nm)\f$. * * Basic usage: * @code * LinearMatrix m(3, 2); // Create a 3x2 matrix of int * m(1, 2) = 5; // Set the value of element at row = 1, col = 2 to 5 * int x = m(0, 1); // Get the value of element at row = 0, col = 1; * @endcode * * @author Sylvain Gaillard */ template class LinearMatrix : public Matrix { private: std::vector m_; size_t rows_; size_t cols_; public: /** * @brief Build a 0 x 0 matrix. */ LinearMatrix() : m_(), rows_(0), cols_(0) { resize_(0, 0); } /** * @brief build a nRow x nCol matrix. */ LinearMatrix(size_t nRow, size_t nCol) : m_(), rows_(nRow), cols_(nCol) { resize_(nRow, nCol); } LinearMatrix(const Matrix& m) : m_(m.getNumberOfRows() * m.getNumberOfColumns()) { size_t nr = m.getNumberOfRows(); size_t nc = m.getNumberOfColumns(); for (size_t i = 0; i < nr; i++) { for (size_t j = 0; j < nc; j++) { m_[i * cols_ + j] = m(i, j); } } } LinearMatrix& operator=(const Matrix& m) { size_t nr = m.getNumberOfRows(); size_t nc = m.getNumberOfColumns(); m_.resize(nr * nc); for (size_t i = 0; i < nr; i++) { m_[i].resize(nc); for (size_t j = 0; j < nc; j++) { m_[i * cols_ + j] = m(i, j); } } return *this; } /** * @brief Destructor. */ virtual ~LinearMatrix() {} public: LinearMatrix* clone() const { return new LinearMatrix(*this); } const Scalar& operator()(size_t i, size_t j) const { return m_[i * cols_ + j]; } Scalar& operator()(size_t i, size_t j) { return m_[i * cols_ + j]; } size_t getNumberOfRows() const { return rows_; } size_t getNumberOfColumns() const { return cols_; } std::vector row(size_t i) const { std::vector r(getNumberOfColumns()); for (size_t j = 0; j < getNumberOfColumns(); j++) { r[j] = operator()(i, j); } return r; } std::vector col(size_t j) const { std::vector c(getNumberOfRows()); for (size_t i = 0; i < getNumberOfRows(); i++) { c[i] = operator()(i, j); } return c; } /** * @copydoc Matrix::resize * * This method resize the matrix keeping old data in place. * @see LinearMatrix::resize(size_t nRow, size_t nCol, bool keepValues) */ void resize(size_t nRows, size_t nCols) { resize(nRows, nCols, true); } /** * @brief Resize the matrix. * * This task may be memory consumming if keepValues is true because it use * a copy of the input matrix to keep trace of the values. * * @param nRows the new number of rows * @param nCols the new number of columns * @param keepValues if old values must be kept in the resized matrix. * If keepValues = false, old values are still in the matrix but not at * the same positions. For instance: * @code * LinearMatrix m(3, 2); * for (size_t i = 0 ; i < m.getNumberOfRows() ; i++) { * for (size_t j = 0 ; j < m.getNumberOfColumns() ; j++) { * m(i, j) = i * m.nCols() + j + 1; * } * } * MatrixTools::print(m); * // 3x2 * // [ * // [1, 2] * // [3, 4] * // [5, 6] * // ] * LinearMatrix m2 = m; * m2.resize(2, 4, false); // resize the matrix with keepValues = false * MatrixTools::print(m2); * // 2x4 * // [ * // [1, 2, 3, 4] * // [5, 6, 0, 0] * // ] * LinearMatrix m3 = m; * m3.resize(2, 4, true); // resize the matrix with keepValues = true * MatrixTools::print(m3); * // 2x4 * // [ * // [1, 2, 0, 0] * // [3, 4, 0, 0] * // ] * @endcode */ void resize(size_t nRows, size_t nCols, bool keepValues) { LinearMatrix tmpM; if (keepValues) tmpM = *this; resize_(nRows, nCols); if (keepValues) { for (size_t i = 0; i < nRows; i++) { for (size_t j = 0; j < nCols; j++) { if (i < tmpM.getNumberOfRows() && j < tmpM.getNumberOfColumns()) { operator()(i, j) = tmpM(i, j); } else { operator()(i, j) = 0; } } } } } private: /** * @brief Internal basic resize fonctionnalities. */ void resize_(size_t nRows, size_t nCols) { m_.resize(nRows * nCols); rows_ = nRows; cols_ = nCols; } }; template bool operator==(const Matrix& m1, const Matrix& m2) { if (m1.getNumberOfRows() != m2.getNumberOfRows() || m1.getNumberOfColumns() != m2.getNumberOfColumns()) return false; for (size_t i = 0; i < m1.getNumberOfRows(); i++) { for (size_t j = 0; j < m1.getNumberOfColumns(); j++) { if (m1(i, j) != m2(i, j)) return false; } } return true; } } // end of namespace bpp. #endif // _MATRIX_H_ bpp-core-2.2.0/src/Bpp/Numeric/Matrix/LUDecomposition.h000664 001750 001750 00000026456 12370705300 024324 0ustar00jdutheiljdutheil000000 000000 // // File: LU.h // Created by: Julien Dutheil // Created on: Tue Apr 7 16:24 2004 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _LU_H_ #define _LU_H_ #include "Matrix.h" #include "../NumTools.h" #include "../../Exceptions.h" // From the STL: #include #include // for min(), max() below namespace bpp { /** * @brief LU Decomposition. * * [This class and its documentation is adpated from the C++ port of the JAMA library.] * * For an m-by-n matrix A with m >= n, the LU decomposition is an m-by-n * unit lower triangular matrix L, an n-by-n upper triangular matrix U, * and a permutation vector piv of length m so that A(piv,:) = L*U. * If m < n, then L is m-by-m and U is m-by-n. * * The LU decompostion with pivoting always exists, even if the matrix is * singular, so the constructor will never fail. The primary use of the * LU decomposition is in the solution of square systems of simultaneous * linear equations. This will fail if isNonsingular() returns false. */ template class LUDecomposition { private: /* Array for internal storage of decomposition. */ RowMatrix LU; RowMatrix L_; RowMatrix U_; size_t m, n; int pivsign; std::vector piv; private: static void permuteCopy(const Matrix& A, const std::vector& piv, size_t j0, size_t j1, Matrix& X) { size_t piv_length = piv.size(); X.resize(piv_length, j1 - j0 + 1); for (size_t i = 0; i < piv_length; i++) { for (size_t j = j0; j <= j1; j++) { X(i, j - j0) = A(piv[i], j); } } } static void permuteCopy(const std::vector& A, const std::vector& piv, std::vector& X) { size_t piv_length = piv.size(); if (piv_length != A.size()) X.clean(); X.resize(piv_length); for (size_t i = 0; i < piv_length; i++) { X[i] = A[piv[i]]; } } public: /** * @brief LU Decomposition * * @param A Rectangular matrix * @return LU Decomposition object to access L, U and piv. */ // This is the constructor in JAMA C++ port. However, it seems to have some bug... // We use the original JAMA's 'experimental' port, which gives good results instead. /* LUDecomposition (const Matrix &A) : LU(A), m(A.getNumberOfRows()), n(A.getNumberOfColumns()), piv(A.getNumberOfRows()) { // Use a "left-looking", dot-product, Crout/Doolittle algorithm. for (size_t i = 0; i < m; i++) { piv[i] = i; } pivsign = 1; //Real *LUrowi = 0;; vector LUrowi; vector LUcolj; // Outer loop. for (size_t j = 0; j < n; j++) { // Make a copy of the j-th column to localize references. LUcolj = LU.col(j); //for (size_t i = 0; i < m; i++) { // LUcolj[i] = LU(i,j); //} // Apply previous transformations. for (size_t i = 0; i < m; i++) { //LUrowi = LU[i]; LUrowi = LU.row(i); // Most of the time is spent in the following dot product. size_t kmax = NumTools::min(i,j); double s = 0.0; for (size_t k = 0; k < kmax; k++) { s += LUrowi[k] * LUcolj[k]; } LUrowi[j] = LUcolj[i] -= s; } // Find pivot and exchange if necessary. size_t p = j; for (size_t i = j+1; i < m; i++) { if (NumTools::abs(LUcolj[i]) > NumTools::abs(LUcolj[p])) { p = i; } } if (p != j) { size_t k=0; for (k = 0; k < n; k++) { double t = LU(p,k); LU(p,k) = LU(j,k); LU(j,k) = t; } k = piv[p]; piv[p] = piv[j]; piv[j] = k; pivsign = -pivsign; } // Compute multipliers. if ((j < m) && (LU(j,j) != 0.0)) { for (size_t i = j+1; i < m; i++) { LU(i,j) /= LU(j,j); } } } } */ LUDecomposition (const Matrix& A) : LU(A), L_(A.getNumberOfRows(), A.getNumberOfColumns()), U_(A.getNumberOfColumns(), A.getNumberOfColumns()), m(A.getNumberOfRows()), n(A.getNumberOfColumns()), pivsign(1), piv(A.getNumberOfRows()) { for (size_t i = 0; i < m; i++) { piv[i] = i; } // Main loop. for (size_t k = 0; k < n; k++) { // Find pivot. size_t p = k; for (size_t i = k + 1; i < m; i++) { if (NumTools::abs(LU(i, k)) > NumTools::abs(LU(p, k))) { p = i; } } // Exchange if necessary. if (p != k) { for (size_t j = 0; j < n; j++) { double t = LU(p, j); LU(p, j) = LU(k, j); LU(k, j) = t; } size_t t = piv[p]; piv[p] = piv[k]; piv[k] = t; pivsign = -pivsign; } // Compute multipliers and eliminate k-th column. if (LU(k, k) != 0.0) { for (size_t i = k + 1; i < m; i++) { LU(i, k) /= LU(k, k); for (size_t j = k + 1; j < n; j++) { LU(i, j) -= LU(i, k) * LU(k, j); } } } } } /** * @brief Return lower triangular factor * * @return L */ const RowMatrix& getL() { for (size_t i = 0; i < m; i++) { for (size_t j = 0; j < n; j++) { if (i > j) { L_(i, j) = LU(i, j); } else if (i == j) { L_(i, j) = 1.0; } else { L_(i, j) = 0.0; } } } return L_; } /** * @brief Return upper triangular factor * * @return U portion of LU factorization. */ const RowMatrix& getU () { for (size_t i = 0; i < n; i++) { for (size_t j = 0; j < n; j++) { if (i <= j) { U_(i, j) = LU(i, j); } else { U_(i, j) = 0.0; } } } return U_; } /** * @brief Return pivot permutation vector * * @return piv */ std::vector getPivot () const { return piv; } /** * @brief Compute determinant using LU factors. * * @return determinant of A, or 0 if A is not square. */ Real det() const { if (m != n) { return Real(0); } Real d = Real(pivsign); for (size_t j = 0; j < n; j++) { d *= LU(j, j); } return d; } /** * @brief Solve A*X = B * * @param B [in] A Matrix with as many rows as A and any number of columns. * @param X [out] A RowMatrix that will be changed such that L*U*X = B(piv,:). * @return the lowest diagonal term (in absolute value), for further checkings * of non-singularity of LU. * * If B is nonconformant or LU is singular, an Exception is raised. * */ Real solve (const Matrix& B, Matrix& X) const throw (BadIntegerException, ZeroDivisionException) { /* Dimensions: A is mxn, X is nxk, B is mxk */ if (B.getNumberOfRows() != m) { throw BadIntegerException("Wrong dimension in LU::solve", static_cast(B.getNumberOfRows())); } Real minD = NumTools::abs(LU(0, 0)); for (size_t i = 1; i < m; i++) { Real currentValue = NumTools::abs(LU(i, i)); if (currentValue < minD) minD = currentValue; } if (minD < NumConstants::SMALL()) { throw ZeroDivisionException("Singular matrix in LU::solve."); } // Copy right hand side with pivoting size_t nx = B.getNumberOfColumns(); permuteCopy(B, piv, 0, nx - 1, X); // Solve L*Y = B(piv,:) for (size_t k = 0; k < n; k++) { for (size_t i = k + 1; i < n; i++) { for (size_t j = 0; j < nx; j++) { X(i, j) -= X(k, j) * LU(i, k); } } } // Solve U*X = Y; // !!! Do not use unsigned int with -- loop!!! // for (int k = n-1; k >= 0; k--) { size_t k = n; do { k--; for (size_t j = 0; j < nx; j++) { X(k, j) /= LU(k, k); } for (size_t i = 0; i < k; i++) { for (size_t j = 0; j < nx; j++) { X(i, j) -= X(k, j) * LU(i, k); } } } while (k > 0); return minD; } /** * @brief Solve A*x = b, where x and b are vectors of length equal to the number of rows in A. * * @param b [in] a vector (Array1D> of length equal to the first dimension of A. * @param x [out] a vector that will be changed so that so that L*U*x = b(piv). * @return the lowest diagonal term (in absolute value), for further checkings * of non-singularity of LU. * * If B is nonconformant or LU is singular, an Exception is raised. */ Real solve (const std::vector& b, std::vector& x) const throw (BadIntegerException, ZeroDivisionException) { /* Dimensions: A is mxn, X is nxk, B is mxk */ if (b.dim1() != m) { throw BadIntegerException("Wrong dimension in LU::solve", b.dim1()); } Real minD = NumTools::abs(LU(0, 0)); for (size_t i = 1; i < m; i++) { Real currentValue = NumTools::abs(LU(i, i)); if (currentValue < minD) minD = currentValue; } if (minD < NumConstants::SMALL()) { throw ZeroDivisionException("Singular matrix in LU::solve."); } permuteCopy(b, piv, x); // Solve L*Y = B(piv) for (size_t k = 0; k < n; k++) { for (size_t i = k + 1; i < n; i++) { x[i] -= x[k] * LU(i, k); } } // Solve U*X = Y; // for (size_t k = n-1; k >= 0; k--) { size_t k = n; do { k--; x[k] /= LU(k, k); for (size_t i = 0; i < k; i++) { x[i] -= x[k] * LU(i, k); } } while (k > 0); return minD; } }; /* class LU */ } // end of namespace bpp. #endif // _LU_H_ bpp-core-2.2.0/src/Bpp/Numeric/Matrix/MatrixTools.h000664 001750 001750 00000123061 12370705300 023522 0ustar00jdutheiljdutheil000000 000000 // // File: MatrixTools.h // Created by: Julien Dutheil // Created on: Mon Jan 19 16:42:25 2004 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This file is part of the Bio++ project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _MATRIXTOOLS_H_ #define _MATRIXTOOLS_H_ #include "../VectorTools.h" #include "Matrix.h" #include "LUDecomposition.h" #include "EigenValue.h" #include "../../Io/OutputStream.h" #include #include namespace bpp { /** * @brief Functions dealing with matrices. */ class MatrixTools { public: MatrixTools() {} ~MatrixTools() {} public: /** * @brief Copy operation. This function supplies the lack of inheritence of the assigment operator :D . * * @param A [in] Original matrix. * @param O [out] A copy of the given matrix. */ template static void copy(const MatrixA& A, MatrixO& O) { O.resize(A.getNumberOfRows(), A.getNumberOfColumns()); for (size_t i = 0; i < A.getNumberOfRows(); i++) { for (size_t j = 0; j < A.getNumberOfColumns(); j++) { O(i, j) = A(i, j); } } } /** * @brief Get a identity matrix of a given size. * * @param n the size of the matrix. * @param O [out] A identity matrix of size n. */ template static void getId(size_t n, Matrix& O) { O.resize(n, n); for (size_t i = 0; i < n; i++) { for (size_t j = 0; j < n; j++) { O(i, j) = (i == j) ? 1 : 0; } } } /** * @param D [in] A vector of diagonal elements. * @param O [out] A diagonal matrix with diagonal elements taken from a vector. */ template static void diag(const std::vector& D, Matrix& O) { size_t n = D.size(); O.resize(n, n); for (size_t i = 0; i < n; i++) { for (size_t j = 0; j < n; j++) { O(i, j) = (i == j) ? D[i] : 0;} } } /** * @param x [in] A scalar * @param n [in] the dimension of the output matrix * @param O [out] A diagonal matrix with diagonal elements equal to x */ template static void diag(const Scalar x, size_t n, Matrix& O) { O.resize(n, n); for (size_t i = 0; i < n; i++) { for (size_t j = 0; j < n; j++) { O(i, j) = (i == j) ? x : 0;} } } /** * @param M [in] The matrix. * @param O [out] The diagonal elements of a square matrix as a vector. * @throw DimensionException If M is not a square matrix. */ template static void diag(const Matrix& M, std::vector& O) throw (DimensionException) { size_t nc = M.getNumberOfColumns(); size_t nr = M.getNumberOfRows(); if (nc != nr) throw DimensionException("MatrixTools::diag(). M must be a square matrix.", nr, nc); O.resize(nc); for (size_t i = 0; i < nc; i++) { O[i] = M(i, i);} } /** * @brief Set all elements in M to value x. * @param M A matrix. * @param x The value to use. */ template static void fill(Matrix& M, Scalar x) { for (size_t i = 0; i < M.getNumberOfRows(); i++) { for (size_t j = 0; j < M.getNumberOfColumns(); j++) { M(i, j) = x; } } } /** * @brief Multiply all elements of a matrix by a given value, and add a constant. * * Performs \f$\forall i \forall j m_{i,j} = a.m_{i,j}+b\f$. * * @param A A matrix. * @param a Multiplicator. * @param b Constant. */ template static void scale(Matrix& A, Scalar a, Scalar b = 0) { for (size_t i = 0; i < A.getNumberOfRows(); i++) { for (size_t j = 0; j < A.getNumberOfColumns(); j++) { A(i, j) = a * A(i, j) + b; } } } /** * @param A [in] First matrix. * @param B [in] Second matrix. * @param O [out] The dot product of two matrices. */ template static void mult(const Matrix& A, const Matrix& B, Matrix& O) throw (DimensionException) { size_t ncA = A.getNumberOfColumns(); size_t nrA = A.getNumberOfRows(); size_t nrB = B.getNumberOfRows(); size_t ncB = B.getNumberOfColumns(); if (ncA != nrB) throw DimensionException("MatrixTools::mult(). nrows B != ncols A.", nrB, ncA); O.resize(nrA, ncB); for (size_t i = 0; i < nrA; i++) { for (size_t j = 0; j < ncB; j++) { O(i, j) = 0; for (size_t k = 0; k < ncA; k++) { O(i, j) += A(i, k) * B(k, j); } } } } /** * @brief Compute A . D . B where D is a diagonal matrix in O(n^3). * * Since D is a diagonal matrix, this function is more efficient than doing * mult(mult(A, diag(D)), B), which involves two 0(n^3) operations. * * @param A [in] The first matrix. * @param D [in] The diagonal matrix (only diagonal elements in a vector) * @param B [in] The second matrix. * @param O [out] The result matrix. * @throw DimensionException If matrices have not the appropriate size. */ template static void mult(const Matrix& A, const std::vector& D, const Matrix& B, Matrix& O) throw (DimensionException) { size_t ncA = A.getNumberOfColumns(); size_t nrA = A.getNumberOfRows(); size_t nrB = B.getNumberOfRows(); size_t ncB = B.getNumberOfColumns(); if (ncA != nrB) throw DimensionException("MatrixTools::mult(). nrows B != ncols A.", nrB, ncA); if (ncA != D.size()) throw DimensionException("MatrixTools::mult(). Vector size is not equal to matrix size.", D.size(), ncA); O.resize(nrA, ncB); for (size_t i = 0; i < nrA; i++) { for (size_t j = 0; j < ncB; j++) { O(i, j) = 0; for (size_t k = 0; k < ncA; k++) { O(i, j) += A(i, k) * B(k, j) * D[k]; } } } } /** * @brief Compute A . (U+D+L) . B where D is a diagonal matrix, U * (resp. L) is a matrix in which the only non-zero terms are on the * diagonal that is over (resp. under) the main diagonal, in O(n^3). * * Since D is a diagonal matrix, this function is more efficient than doing * mult(mult(A, diag(D)), B), which involves two 0(n^3) operations. * * @param A [in] The first matrix. * @param D [in] The diagonal matrix (only diagonal elements in a vector) * @param U [in] The upper diagonal matrix (only upper diagonal elements in a vector) * @param L [in] The lower diagonal matrix (only lower diagonal elements in a vector) * @param B [in] The second matrix. * @param O [out] The result matrix. * @throw DimensionException If matrices have not the appropriate size. */ template static void mult(const Matrix& A, const std::vector& D, const std::vector& U, const std::vector& L, const Matrix& B, Matrix& O) throw (DimensionException) { size_t ncA = A.getNumberOfColumns(); size_t nrA = A.getNumberOfRows(); size_t nrB = B.getNumberOfRows(); size_t ncB = B.getNumberOfColumns(); if (ncA != nrB) throw DimensionException("MatrixTools::mult(). nrows B != ncols A.", nrB, ncA); if (ncA != D.size()) throw DimensionException("MatrixTools::mult(). Vector size is not equal to matrix size.", D.size(), ncA); if (ncA != U.size()+1) throw DimensionException("MatrixTools::mult(). Vector size is not equal to matrix size-1.", U.size(), ncA); if (ncA != L.size()+1) throw DimensionException("MatrixTools::mult(). Vector size is not equal to matrix size-1.", L.size(), ncA); O.resize(nrA, ncB); for (size_t i = 0; i < nrA; i++) { for (size_t j = 0; j < ncB; j++) { O(i, j) = A(i, 0) * D[0] * B(0, j); if (nrB>1) O(i, j) += A(i,0) * U[0] * B(1,j); for (size_t k = 1; k < ncA-1; k++) { O(i, j) += A(i, k) * (L[k-1] * B(k-1, j) + D[k] * B(k, j) + U[k] * B(k+1,j)); } if (ncA>=2) O(i, j) += A(i, ncA-1) * L[ncA-2] * B(ncA-2, j); O(i,j) += A(i, ncA-1) * D[ncA-1] * B(ncA-1, j); } } } /** * @brief Add matrix B to matrix A. * * @param A [in] Matrix A * @param B [in] Matrix B * @throw DimensionException If A and B have note the same size. */ template static void add(MatrixA& A, const MatrixB& B) throw (DimensionException) { size_t ncA = A.getNumberOfColumns(); size_t nrA = A.getNumberOfRows(); size_t nrB = B.getNumberOfRows(); size_t ncB = B.getNumberOfColumns(); if (ncA != ncB) throw DimensionException("MatrixTools::operator+(). A and B must have the same number of colums.", ncB, ncA); if (nrA != nrB) throw DimensionException("MatrixTools::operator+(). A and B must have the same number of rows.", nrB, nrA); for (size_t i = 0; i < A.getNumberOfRows(); i++) { for (size_t j = 0; j < A.getNumberOfColumns(); j++) { A(i, j) += B(i, j); } } } /** * @brief Add matrix x.B to matrix A. * * @param A [in,out] Matrix A * @param x [in] Scalar x * @param B [in] Matrix B * @throw DimensionException If A and B have note the same size. */ template static void add(MatrixA& A, Scalar& x, const MatrixB& B) throw (DimensionException) { size_t ncA = A.getNumberOfColumns(); size_t nrA = A.getNumberOfRows(); size_t nrB = B.getNumberOfRows(); size_t ncB = B.getNumberOfColumns(); if (ncA != ncB) throw DimensionException("MatrixTools::operator+(). A and B must have the same number of colums.", ncB, ncA); if (nrA != nrB) throw DimensionException("MatrixTools::operator+(). A and B must have the same number of rows.", nrB, nrA); for (size_t i = 0; i < A.getNumberOfRows(); i++) { for (size_t j = 0; j < A.getNumberOfColumns(); j++) { A(i, j) += x*B(i, j); } } } /** * @brief Compute the power of a given matrix. * * @param A [in] The matrix. * @param p The number of multiplications. * @param O [out]\f$ A^p \f$ computed recursively: * \f$ A^{2n} = (A^n)^2 \f$ * \f$ A^{2n+1} = A*(A^n)^2 \f$ * If p = 0, sends the identity matrix. * @throw DimensionException If m is not a square matrix. */ template static void pow(const Matrix& A, size_t p, Matrix& O) throw (DimensionException) { size_t n = A.getNumberOfRows(); if (n != A.getNumberOfColumns()) throw DimensionException("MatrixTools::pow(). nrows != ncols.", A.getNumberOfColumns(), A.getNumberOfRows()); switch(p){ case 0: getId(n, O); break; case 1: copy(A,O); break; case 2: mult(A,A,O); break; default: Matrix tmp; if (p%2){ pow(A,p/2,tmp); pow(tmp,2,O); } else{ pow(A,(p-1)/2,tmp); pow(tmp,2,O); mult(A,O,tmp); copy(tmp,O); } } } /** * @brief Compute the power of a given matrix, using eigen value decomposition. * * @param A [in] The matrix. * @param p The power of the matrix. * @param O [out]\f$\prod_{i=1}^p m\f$. * If p = 0, sends the identity matrix. * @throw DimensionException If m is not a square matrix. */ template static void pow(const Matrix& A, double p, Matrix& O) throw (DimensionException) { size_t n = A.getNumberOfRows(); if (n != A.getNumberOfColumns()) throw DimensionException("MatrixTools::pow(). nrows != ncols.", A.getNumberOfColumns(), A.getNumberOfRows()); EigenValue eigen(A); RowMatrix rightEV, leftEV; rightEV = eigen.getV(); inv(rightEV, leftEV); mult(rightEV, VectorTools::pow(eigen.getRealEigenValues(), p), leftEV, O); } /** * @brief Perform matrix exponentiation using diagonalization. * * @warning This method currently relies only on diagonalization, so it won't work if your matrix is not diagonalizable. * The function may be extended later to deal with other cases. * * @param A [in] The matrix. * @param O [out]\f$\prod_{i=1}^p m\f$. * @throw DimensionException If m is not a square matrix. */ template static void exp(const Matrix& A, Matrix& O) throw (DimensionException) { size_t n = A.getNumberOfRows(); if (n != A.getNumberOfColumns()) throw DimensionException("MatrixTools::exp(). nrows != ncols.", A.getNumberOfColumns(), A.getNumberOfRows()); EigenValue eigen(A); RowMatrix rightEV, leftEV; rightEV = eigen.getV(); inv(rightEV, leftEV); mult(rightEV, VectorTools::exp(eigen.getRealEigenValues()), leftEV, O); } /** * @brief Compute a vector of the first powers of a given matrix. * * @param A [in] The matrix. * @param p The number of powers. * @param vO [out] the vector of the powers (from 0 to p) * * @throw DimensionException If m is not a square matrix. */ template static void Taylor(const Matrix& A, size_t p, std::vector< RowMatrix > & vO) throw (DimensionException) { size_t n = A.getNumberOfRows(); if (n != A.getNumberOfColumns()) throw DimensionException("MatrixTools::pow(). nrows != ncols.", A.getNumberOfColumns(), A.getNumberOfRows()); vO.resize(p+1); getId(n, vO[0]); copy(A,vO[1]); for (size_t i = 1; i < p; i++) { mult(vO[i], A, vO[i+1]); } } /** * @return The position of the maximum value in the matrix. * @param m The matrix. */ template static std::vector whichMax(const Matrix& m) { size_t nrows = m.getNumberOfRows(); size_t ncols = m.getNumberOfColumns(); std::vector pos(2); size_t imax = 0; size_t jmax = 0; double currentMax = log(0.); for (size_t i = 0; i < nrows; i++) { for (size_t j = 0; j < ncols; j++) { double currentValue = m(i, j); // cout << currentValue << "\t" << (currentValue > currentMax) << endl; if (currentValue > currentMax) { imax = i; jmax = j; currentMax = currentValue; } } } pos[0] = imax; pos[1] = jmax; return pos; } /** * @return The position of the minimum value in the matrix. * @param m The matrix. */ template static std::vector whichMin(const Matrix& m) { size_t nrows = m.getNumberOfRows(); size_t ncols = m.getNumberOfColumns(); std::vector pos(2); size_t imin = 0; size_t jmin = 0; double currentMin = -log(0.); for (size_t i = 0; i < nrows; i++) { for (size_t j = 0; j < ncols; j++) { double currentValue = m(i, j); if (currentValue < currentMin) { imin = i; jmin = j; currentMin = currentValue; } } } pos[0] = imin; pos[1] = jmin; return pos; } /** * @return The maximum value in the matrix. * @param m The matrix. */ template static Real max(const Matrix& m) { size_t nrows = m.getNumberOfRows(); size_t ncols = m.getNumberOfColumns(); Real currentMax = log(0.); for (size_t i = 0; i < nrows; i++) { for (size_t j = 0; j < ncols; j++) { Real currentValue = m(i, j); // cout << currentValue << "\t" << (currentValue > currentMax) << endl; if (currentValue > currentMax) { currentMax = currentValue; } } } return currentMax; } /** * @return The minimum value in the matrix. * @param m The matrix. */ template static Real min(const Matrix& m) { size_t nrows = m.getNumberOfRows(); size_t ncols = m.getNumberOfColumns(); Real currentMin = -log(0.); for (size_t i = 0; i < nrows; i++) { for (size_t j = 0; j < ncols; j++) { Real currentValue = m(i, j); if (currentValue < currentMin) { currentMin = currentValue; } } } return currentMin; } /** * @brief Print a matrix to a stream. * * @param m The matrix to print. * @param out The stream to use. */ template static void print(const Matrix& m, std::ostream& out = std::cout) { out << m.getNumberOfRows() << "x" << m.getNumberOfColumns() << std::endl; out << "[" << std::endl; for (size_t i = 0; i < m.getNumberOfRows(); i++) { out << "["; for (size_t j = 0; j < m.getNumberOfColumns() - 1; j++) { out << m(i, j) << ", "; } if (m.getNumberOfColumns() > 0) out << m(i, m.getNumberOfColumns() - 1) << "]" << std::endl; } out << "]" << std::endl; } /** * @brief Print a matrix to a stream. * * @param m The matrix to print. * @param out The stream to use. * @param pIn left delimiter (default: "(") * @param pOut right delimiter (default: ")") */ template static void print(const Matrix& m, bpp::OutputStream& out, char pIn = '(', char pOut = ')') { out << pIn; for (size_t i = 0; i < m.getNumberOfRows(); i++) { if (i!=0) out << ","; out << pIn; for (size_t j = 0; j < m.getNumberOfColumns() - 1; j++) { out << m(i, j) << ", "; } if (m.getNumberOfColumns() > 0) out << m(i, m.getNumberOfColumns() - 1) << pOut; } out << pOut; } /** * @brief Print a matrix to a stream, so that it is read by R. * * @param m The matrix to print. * @param variableName The name of the R variable handeling the matrix * @param out The stream to use. */ template static void printForR(const Matrix& m, const std::string& variableName = "x", std::ostream& out = std::cout) { out.precision(12); out << variableName << "<-matrix(c("; for (size_t i = 0; i < m.getNumberOfRows(); i++) { for (size_t j = 0; j < m.getNumberOfColumns(); j++) { if (i > 0 || j > 0) out << ", "; out << m(i, j); } } out << "), nrow=" << m.getNumberOfRows() << ", byrow=TRUE)" << std::endl; } /** * @brief Print a vector to a stream. * * @param v The vector to print. * @param out The stream to use. */ template static void print(const std::vector& v, std::ostream& out = std::cout) { out << v.size() << std::endl; out << "["; for (size_t i = 0; i < v.size() - 1; i++) { out << v[i] << ", "; } if (v.size() > 0) out << v[v.size() - 1]; out << "]" << std::endl; } /** * @return True if the matrix is a square matrix. * @param A A matrix. */ template static bool isSquare(const Matrix& A) { return A.getNumberOfRows() == A.getNumberOfColumns(); } /** * @param A [in] The matrix to inverse. * @param O [out] The inverse matrix of A. * @return x the minimum absolute value of the diagonal of the LU decomposition * @throw DimensionException If A is not a square matrix. */ template static Scalar inv(const Matrix& A, Matrix& O) throw (DimensionException, ZeroDivisionException) { if (!isSquare(A)) throw DimensionException("MatrixTools::inv(). Matrix A is not a square matrix.", A.getNumberOfRows(), A.getNumberOfColumns()); LUDecomposition lu(A); RowMatrix I; getId(A.getNumberOfRows(), I); return lu.solve(I, O); } /** * @brief Get determinant of a square matrix. * * This implementation is in @f$o(n^3)@f$ and uses the LU decomposition method. * * @param A [in] The input matrix. * @return The determinant of A. * @throw DimensionException If A is not a square matrix. */ template static double det(const Matrix& A) throw (DimensionException) { if (!isSquare(A)) throw DimensionException("MatrixTools::det(). Matrix A is not a square matrix.", A.getNumberOfRows(), A.getNumberOfColumns()); LUDecomposition lu(A); return lu.det(); } /** * @param A [in] The matrix to transpose. * @param O [out] The transposition of A. */ template static void transpose(const MatrixA& A, MatrixO& O) { O.resize(A.getNumberOfColumns(), A.getNumberOfRows()); for (size_t i = 0; i < A.getNumberOfColumns(); i++) { for (size_t j = 0; j < A.getNumberOfRows(); j++) { O(i, j) = A(j, i); } } } /** * @brief Compute the variance-covariance matrix of an input matrix. * * The input matrix represent a n-sample of a random vector of dimension r. * It is assumed to have r rows and n columns. * The variance matrix is then computed as @f[ V = A\cdot A^T - \mu\cdot\mu^T@f], * where @f$\mu@f$ is the mean vector of the sample. * the output matrix is a square matrix of size r. * * @param A [in] The intput matrix. * @param O [out] The resulting variance covariance matrix. */ template static void covar(const Matrix& A, Matrix& O) { size_t r = A.getNumberOfRows(); size_t n = A.getNumberOfColumns(); O.resize(r, r); RowMatrix tA; transpose(A, tA); mult(A, tA, O); scale(O, 1. / static_cast(n)); RowMatrix mean(r, 1); for (size_t i = 0; i < r; i++) { for (size_t j = 0; j < n; j++) { mean(i, 0) += A(i, j); } mean(i, 0) /= static_cast(n); } RowMatrix tMean; transpose(mean, tMean); RowMatrix meanMat; mult(mean, tMean, meanMat); scale(meanMat, -1.); add(O, meanMat); } /** * @brief Compute the Kronecker product of two row matrices. * * @param A [in] The first row matrix. * @param B [in] The second row matrix. * @param O [out] The product \f$A \otimes B\f$. */ template static void kroneckerMult(const Matrix& A, const Matrix& B, Matrix& O) { size_t ncA = A.getNumberOfColumns(); size_t nrA = A.getNumberOfRows(); size_t nrB = B.getNumberOfRows(); size_t ncB = B.getNumberOfColumns(); O.resize(nrA * nrB, ncA * ncB); for (size_t ia = 0; ia < nrA; ia++) { for (size_t ja = 0; ja < ncA; ja++) { Scalar aij = A(ia, ja); for (size_t ib = 0; ib < nrB; ib++) { for (size_t jb = 0; jb < ncB; jb++) { O(ia * nrB + ib, ja * ncB + jb) = aij * B(ib, jb); } } } } } /** * @brief Compute the Hadamard product of two row matrices with same dimensions. * * @param A [in] The first row matrix. * @param B [in] The second row matrix. * @param O [out] The Hadamard product. */ template static void hadamardMult(const Matrix& A, const Matrix& B, Matrix& O) { size_t ncA = A.getNumberOfColumns(); size_t nrA = A.getNumberOfRows(); size_t nrB = B.getNumberOfRows(); size_t ncB = B.getNumberOfColumns(); if (nrA != nrB) throw DimensionException("MatrixTools::hadamardMult(). nrows A != nrows B.", nrA, nrB); if (ncA != ncB) throw DimensionException("MatrixTools::hadamardMult(). ncols A != ncols B.", ncA, ncB); O.resize(nrA, ncA); for (size_t i = 0; i < nrA; i++) { for (size_t j = 0; j < ncA; j++) { O(i, j) = A(i, j) * B(i, j); } } } /** * @brief Compute the "Hadamard" product of a row matrix and a vector containing weights, according to rows or columns. * * @param A [in] The row matrix. * @param B [in] The vector of row or column weights. * @param O [out] The 'Hadamard' product. * @param row Boolean. If row is set to 'true', the vector contains weights for rows. Otherwise the vector contains weights for columns. */ template static void hadamardMult(const Matrix& A, const std::vector& B, Matrix& O, bool row = true) { size_t ncA = A.getNumberOfColumns(); size_t nrA = A.getNumberOfRows(); size_t sB = B.size(); if (row == true && nrA != sB) throw DimensionException("MatrixTools::hadamardMult(). nrows A != size of B.", nrA, sB); if (row == false && ncA != sB) throw DimensionException("MatrixTools::hadamardMult(). ncols A != size of B.", ncA, sB); O.resize(nrA, ncA); if (row) { for (size_t i = 0; i < nrA; i++) { for (size_t j = 0; j < ncA; j++) { O(i, j) = A(i, j) * B[i]; } } } else { for (size_t i = 0; i < nrA; i++) { for (size_t j = 0; j < ncA; j++) { O(i, j) = A(i, j) * B[j]; } } } } /** * @brief Compute the Kronecker sum of two row matrices. * * @param A [in] The first row matrix. * @param B [in] The second row matrix. * @param O [out] The product \f$A \oplus B\f$. */ template static void kroneckerSum(const Matrix& A, const Matrix& B, Matrix& O) { size_t ncA = A.getNumberOfColumns(); size_t nrA = A.getNumberOfRows(); size_t nrB = B.getNumberOfRows(); size_t ncB = B.getNumberOfColumns(); O.resize(nrA + nrB, ncA + ncB); for (size_t ia = 0; ia < nrA; ia++) { for (size_t ja = 0; ja < ncA; ja++) { O(ia, ja) = A(ia, ja); } } for (size_t ib = 0; ib < nrB; ib++) { for (size_t jb = 0; jb < nrB; jb++) { O(nrA + ib, ncA + jb) = B(ib, jb); } } } /** * @brief Compute the Kronecker sum of n row matrices. * * @param vA [in] A vector of row matrices of any size. * @param O [out] The product \f$\bigoplus_i A_i\f$. */ template static void kroneckerSum(const std::vector< Matrix*>& vA, Matrix& O) { size_t nr = 0; size_t nc = 0; for (size_t k = 0; k < vA.size(); k++) { nr += vA[k]->getNumberOfRows(); nc += vA[k]->getNumberOfColumns(); } O.resize(nr, nc); size_t rk = 0; // Row counter size_t ck = 0; // Col counter for (size_t k = 0; k < vA.size(); k++) { const Matrix* Ak = vA[k]; for (size_t i = 0; i < Ak->getNumberOfRows(); i++) { for (size_t j = 0; j < Ak->getNumberOfColumns(); j++) { O(rk + i, ck + j) = (*Ak)(i, j); } } rk += Ak->getNumberOfRows(); ck += Ak->getNumberOfColumns(); } } /** * @brief Convert to a vector of vector. * * @param M [in] A matrix object. * @param vO [out] The output vector of vector (will be resized accordingly). */ template static void toVVdouble(const Matrix& M, std::vector< std::vector >& vO) { size_t n = M.getNumberOfRows(); size_t m = M.getNumberOfColumns(); vO.resize(n); for (size_t i = 0; i < n; i++) { vO[i].resize(m); for (size_t j = 0; j < m; j++) { vO[i][j] = M(i, j); } } } /** * @brief Sum all elements in M. * @param M A matrix. * @return The sum of all elements. */ template static Scalar sumElements(const Matrix& M) { Scalar sum = 0; for (size_t i = 0; i < M.getNumberOfRows(); i++) { for (size_t j = 0; j < M.getNumberOfColumns(); j++) { sum += M(i, j); } } return sum; } /** * @brief Linear Assignment Problem * * The algorithm coded here is described in * * A Shortest Augmenting Path Algorithm for Dense and Sparse Linear Assignment Problems, Computing 38, 325-340, 1987 * by R. Jonker and A. Volgenant, University of Amsterdam. * * @param assignCost [input/output] Cost matrix * @param rowSol [output] Column assigned to row in solution * @param colSol [output] Row assigned to column in solution * @param u [output] Dual variables, row reduction numbers * @param v [output] Dual variables, column reduction numbers * @return The optimal cost. */ template static Scalar lap(Matrix& assignCost, std::vector &rowSol, std::vector &colSol, std::vector &u, std::vector &v) throw (Exception) { size_t dim = assignCost.getNumberOfRows(); if (assignCost.getNumberOfColumns() != dim) throw Exception("MatrixTools::lap. Cost matrix should be scare."); bool unassignedFound; size_t i, iMin; size_t numFree = 0, previousNumFree, f, k, freeRow; int i0; std::vector free(dim); // list of unassigned rows. std::vector pred(dim); // row-predecessor of column in augmenting/alternating path. size_t j, j1, j2, endOfPath, last, low, up; std::vector colList(dim); // list of columns to be scanned in various ways. std::vector matches(dim, 0); // counts how many times a row could be assigned. Scalar min; Scalar h; size_t uMin, uSubMin; Scalar v2; std::vector d(dim); // 'cost-distance' in augmenting path calculation. // Column reduction for (j = dim; j > 0; j--) // reverse order gives better results. { // find minimum cost over rows. min = assignCost(0, j - 1); iMin = 0; for (i = 1; i < dim; ++i) { if (assignCost(i, j - 1) < min) { min = assignCost(i, j - 1); iMin = i; } } v[j - 1] = min; if (++matches[iMin] == 1) { // init assignment if minimum row assigned for first time. rowSol[iMin] = static_cast(j - 1); colSol[j - 1] = static_cast(iMin); } else colSol[j - 1] = -1; // row already assigned, column not assigned. } // Reduction tranfer for (i = 0; i < dim; i++) { if (matches[i] == 0) // fill list of unassigned 'free' rows. free[numFree++] = i; else { if (matches[i] == 1) // transfer reduction from rows that are assigned once. { j1 = static_cast(rowSol[i]); //rowSol[i] is >= 0 here min = -log(0); for (j = 0; j < dim; j++) if (j != j1) if (assignCost(i, j - 1) - v[j] < min) min = assignCost(i, j - 1) - v[j - 1]; v[j1] = v[j1] - min; } } } // Augmenting row reduction short loopcnt = 0; // do-loop to be done twice. do { loopcnt++; // scan all free rows. // in some cases, a free row may be replaced with another one to be scanned next. k = 0; previousNumFree = numFree; numFree = 0; // start list of rows still free after augmenting row reduction. while (k < previousNumFree) { i = free[k]; k++; // find minimum and second minimum reduced cost over columns. uMin = assignCost(i, 0) - v[0]; j1 = 0; uSubMin = static_cast(-log(0)); for (j = 1; j < dim; j++) { h = assignCost(i, j) - v[j]; if (h < uSubMin) { if (h >= uMin) { uSubMin = h; j2 = j; } else { uSubMin = uMin; uMin = h; j2 = j1; j1 = j; } } } i0 = colSol[j1]; if (uMin < uSubMin) { // change the reduction of the minimum column to increase the minimum // reduced cost in the row to the subminimum. v[j1] = v[j1] - (uSubMin - uMin); } else { // minimum and subminimum equal. if (i0 >= 0) // minimum column j1 is assigned. { // swap columns j1 and j2, as j2 may be unassigned. j1 = j2; i0 = colSol[j2]; } } // (re-)assign i to j1, possibly de-assigning an i0. rowSol[i] = static_cast(j1); colSol[j1] = static_cast(i); if (i0 >= 0) { // minimum column j1 assigned earlier. if (uMin < uSubMin) { // put in current k, and go back to that k. // continue augmenting path i - j1 with i0. free[--k] = static_cast(i0); } else { // no further augmenting reduction possible. // store i0 in list of free rows for next phase. free[numFree++] = static_cast(i0); } } } } while (loopcnt < 2); // repeat once. // Augment solution for each free row. for (f = 0; f < numFree; f++) { freeRow = free[f]; // start row of augmenting path. // Dijkstra shortest path algorithm. // runs until unassigned column added to shortest path tree. for (j = 0; j < dim; j++) { d[j] = assignCost(freeRow, j) - v[j]; pred[j] = freeRow; colList[j] = j; // init column list. } low = 0; // columns in 0..low-1 are ready, now none. up = 0; // columns in low..up-1 are to be scanned for current minimum, now none. // columns in up..dim-1 are to be considered later to find new minimum, // at this stage the list simply contains all columns unassignedFound = false; do { if (up == low) // no more columns to be scanned for current minimum. { last = low - 1; // scan columns for up..dim-1 to find all indices for which new minimum occurs. // store these indices between low..up-1 (increasing up). min = d[colList[up++]]; for (k = up; k < dim; k++) { j = colList[k]; h = d[j]; if (h <= min) { if (h < min) // new minimum. { up = low; // restart list at index low. min = h; } // new index with same minimum, put on undex up, and extend list. colList[k] = colList[up]; colList[up++] = j; } } // check if any of the minimum columns happens to be unassigned. // if so, we have an augmenting path right away. for (k = low; k < up; k++) { if (colSol[colList[k]] < 0) { endOfPath = colList[k]; unassignedFound = true; break; } } } if (!unassignedFound) { // update 'distances' between freerow and all unscanned columns, via next scanned column. j1 = colList[low]; low++; i = static_cast(colSol[j1]); h = assignCost(i, j1) - v[j1] - min; for (k = up; k < dim; k++) { j = colList[k]; v2 = assignCost(i, j) - v[j] - h; if (v2 < d[j]) { pred[j] = i; if (v2 == min) { // new column found at same minimum value if (colSol[j] < 0) { // if unassigned, shortest augmenting path is complete. endOfPath = j; unassignedFound = true; break; } // else add to list to be scanned right away. else { colList[k] = colList[up]; colList[up++] = j; } } d[j] = v2; } } } } while (!unassignedFound); // update column prices. for (k = 0; k <= last; k++) { j1 = colList[k]; v[j1] = v[j1] + d[j1] - min; } // reset row and column assignments along the alternating path. do { i = pred[endOfPath]; colSol[endOfPath] = static_cast(i); j1 = endOfPath; endOfPath = static_cast(rowSol[i]); rowSol[i] = static_cast(j1); } while (i != freeRow); } // calculate optimal cost. Scalar lapCost = 0; for (i = 0; i < dim; i++) { j = static_cast(rowSol[i]); u[i] = assignCost(i, j) - v[j]; lapCost = lapCost + assignCost(i, j); } return lapCost; } }; /* DEPRECATED namespace MatrixOperators { MatrixB operator*(const MatrixA & A, const MatrixB & B) throw (DimensionException) { return MatrixTools::mult(A, B); } template MatrixA operator+(const MatrixA & A, const MatrixB & B) throw (DimensionException) { MatrixA C = A; MatrixTools::add(C, B); return C; } template MatrixA operator+=(MatrixA & A, const MatrixB & B) throw (DimensionException) { MatrixTools::add(A, B); return A; } template Matrix operator-(const Matrix A) { Matrix B(A.getNumberOfRows(), A.getNumberOfColumns()); for(size_t i = 0; i < B.getNumberOfRows(); i++) { for(size_t j = 0; j < B.getNumberOfColumns(); j++) { B(i, j) = -A(i, j); } } return B; } template MatrixA operator-(const MatrixA & A, const MatrixB & B) throw (DimensionException) { // size_t ncA = A.getNumberOfColumns(); // size_t nrA = A.getNumberOfRows(); // size_t nrB = B.getNumberOfRows(); // size_t ncB = B.getNumberOfColumns(); // if(ncA != ncB) throw DimensionException("MatrixTools::operator-(). A and B must have the same number of colums.", ncB, ncA); // if(nrA != nrB) throw DimensionException("MatrixTools::operator-(). A and B must have the same number of rows.", nrB, nrA); // MatrixB C(A.getNumberOfRows(), A.getNumberOfColumns()); // for(size_t i = 0; i < A.getNumberOfRows(); i++) { // for(size_t j = 0; j < A.getNumberOfColumns(); j++) { // C(i, j) = A(i, j) - B(i, j); // } // } // return C; MatrixA C = A; MatrixTools::add(C, -B); return C; } template MatrixA operator-=(MatrixA & A, const MatrixB & B) throw (DimensionException) { MatrixTools::add(A, -B); return A; } }; */ } // end of namespace bpp. #endif // _MATRIXTOOLS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Matrix/EigenValue.h000664 001750 001750 00000100233 12370705300 023255 0ustar00jdutheiljdutheil000000 000000 // // File: EigenValue.h // Created by: Julien Dutheil // Created on: Tue Apr 7 16:24 2004 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This file is part of the Bio++ project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _EIGENVALUE_H_ #define _EIGENVALUE_H_ #define TOST(i) static_cast(i) #include // for min(), max() below #include // for abs() below #include #include "Matrix.h" #include "../NumTools.h" namespace bpp { /** * @brief Computes eigenvalues and eigenvectors of a real (non-complex) matrix. * * [This class and its documentation is adpated from the C++ port of the JAMA library.] * * If A is symmetric, then A = V*D*V' where the eigenvalue matrix D is * diagonal and the eigenvector matrix V is orthogonal. That is, * the diagonal values of D are the eigenvalues, and * V*V' = I, where I is the identity matrix. The columns of V * represent the eigenvectors in the sense that A*V = V*D. * * If A is not symmetric, then the eigenvalue matrix D is block diagonal * with the real eigenvalues in 1-by-1 blocks and any complex eigenvalues, * a + i*b, in 2-by-2 blocks, [a, b; -b, a]. That is, if the complex * eigenvalues look like * 
 * 
 *         u + iv     .        .          .      .    .
 *           .      u - iv     .          .      .    .
 *           .        .      a + ib       .      .    .
 *           .        .        .        a - ib   .    .
 *           .        .        .          .      x    .
 *           .        .        .          .      .    y
 *
* then D looks like * 
 * 
 *           u        v        .          .      .    .
 *          -v        u        .          .      .    . 
 *           .        .        a          b      .    .
 *           .        .       -b          a      .    .
 *           .        .        .          .      x    .
 *           .        .        .          .      .    y
 *
* This keeps V a real matrix in both symmetric and non-symmetric * cases, and A*V = V*D. * * * The matrix V may be badly * conditioned, or even singular, so the validity of the equation * A = V*D*inverse(V) depends upon the condition number of V. * * (Adapted from JAMA, a Java Matrix Library, developed by jointly * by the Mathworks and NIST; see http://math.nist.gov/javanumerics/jama). */ template class EigenValue { private: /** * @brief Row and column dimension (square matrix). */ size_t n_; /** * @brief Tell if the matrix is symmetric. */ bool issymmetric_; /** * @name Arrays for internal storage of eigenvalues. * * @{ */ std::vector d_; /* real part */ std::vector e_; /* img part */ /** @} */ /** * @brief Array for internal storage of eigenvectors. */ RowMatrix V_; /** * @brief Matrix for internal storage of nonsymmetric Hessenberg form. * * Internal storage of nonsymmetric Hessenberg form. */ RowMatrix H_; /** * @brief Matrix for internal storage of eigen values in a matrix form. * * Internal storage of eigen values in a matrix form. */ mutable RowMatrix D_; /** * @brief Working storage for nonsymmetric algorithm. * * Working storage for nonsymmetric algorithm. */ std::vector ort_; /** * @brief Symmetric Householder reduction to tridiagonal form. * * This is derived from the Algol procedures tred2 by * Bowdler, Martin, Reinsch, and Wilkinson, Handbook for * Auto. Comp., Vol.ii-Linear Algebra, and the corresponding * Fortran subroutine in EISPACK. */ void tred2() { for (size_t j = 0; j < n_; j++) { d_[j] = V_(n_-1,j); } // Householder reduction to tridiagonal form. for (size_t i = n_-1; i > 0; i--) { // Scale to avoid under/overflow. Real scale = 0.0; Real h = 0.0; for (size_t k = 0; k < i; ++k) { scale = scale + NumTools::abs(d_[k]); } if (scale == 0.0) { e_[i] = d_[i-1]; for (size_t j = 0; j < i; ++j) { d_[j] = V_(i - 1, j); V_(i, j) = 0.0; V_(j, i) = 0.0; } } else { // Generate Householder vector. for (size_t k = 0; k < i; ++k) { d_[k] /= scale; h += d_[k] * d_[k]; } Real f = d_[i - 1]; Real g = sqrt(h); if (f > 0) { g = -g; } e_[i] = scale * g; h = h - f * g; d_[i-1] = f - g; for (size_t j = 0; j < i; ++j) { e_[j] = 0.0; } // Apply similarity transformation to remaining columns. for (size_t j = 0; j < i; ++j) { f = d_[j]; V_(j,i) = f; g = e_[j] + V_(j,j) * f; for (size_t k = j + 1; k <= i - 1; k++) { g += V_(k,j) * d_[k]; e_[k] += V_(k,j) * f; } e_[j] = g; } f = 0.0; for (size_t j = 0; j < i; ++j) { e_[j] /= h; f += e_[j] * d_[j]; } Real hh = f / (h + h); for (size_t j = 0; j < i; ++j) { e_[j] -= hh * d_[j]; } for (size_t j = 0; j < i; ++j) { f = d_[j]; g = e_[j]; for (size_t k = j; k <= i-1; ++k) { V_(k,j) -= (f * e_[k] + g * d_[k]); } d_[j] = V_(i-1,j); V_(i,j) = 0.0; } } d_[i] = h; } // Accumulate transformations. for (size_t i = 0; i < n_-1; i++) { V_(n_-1,i) = V_(i,i); V_(i,i) = 1.0; Real h = d_[i+1]; if (h != 0.0) { for (size_t k = 0; k <= i; k++) { d_[k] = V_(k,i+1) / h; } for (size_t j = 0; j <= i; j++) { Real g = 0.0; for (size_t k = 0; k <= i; k++) { g += V_(k,i+1) * V_(k,j); } for (size_t k = 0; k <= i; k++) { V_(k,j) -= g * d_[k]; } } } for (size_t k = 0; k <= i; k++) { V_(k,i+1) = 0.0; } } for (size_t j = 0; j < n_; j++) { d_[j] = V_(n_-1,j); V_(n_-1,j) = 0.0; } V_(n_-1,n_-1) = 1.0; e_[0] = 0.0; } /** * @brief Symmetric tridiagonal QL algorithm. * * This is derived from the Algol procedures tql2, by * Bowdler, Martin, Reinsch, and Wilkinson, Handbook for * Auto. Comp., Vol.ii-Linear Algebra, and the corresponding * Fortran subroutine in EISPACK. */ void tql2 () { for (size_t i = 1; i < n_; i++) { e_[i - 1] = e_[i]; } e_[n_ - 1] = 0.0; Real f = 0.0; Real tst1 = 0.0; Real eps = pow(2.0,-52.0); for (size_t l = 0; l < n_; ++l) { // Find small subdiagonal element tst1 = std::max(tst1, NumTools::abs(d_[l]) + NumTools::abs(e_[l])); size_t m = l; // Original while-loop from Java code while (m < n_) { if (NumTools::abs(e_[m]) <= eps*tst1) { break; } m++; } // If m == l, d_[l] is an eigenvalue, // otherwise, iterate. if (m > l) { int iter = 0; do { iter = iter + 1; // (Could check iteration count here.) // Compute implicit shift Real g = d_[l]; Real p = (d_[l + 1] - g) / (2.0 * e_[l]); Real r = hypot(p,1.0); if (p < 0) { r = -r; } d_[l] = e_[l] / (p + r); d_[l + 1] = e_[l] * (p + r); Real dl1 = d_[l + 1]; Real h = g - d_[l]; for (size_t i = l + 2; i < n_; ++i) { d_[i] -= h; } f = f + h; // Implicit QL transformation. p = d_[m]; Real c = 1.0; Real c2 = c; Real c3 = c; Real el1 = e_[l + 1]; Real s = 0.0; Real s2 = 0.0; //for (size_t i = m - 1; i >= l; --i) for (size_t ii = m; ii > l; --ii) { size_t i = ii - 1; //to avoid infinite loop! c3 = c2; c2 = c; s2 = s; g = c * e_[i]; h = c * p; r = hypot(p, e_[i]); e_[i + 1] = s * r; s = e_[i] / r; c = p / r; p = c * d_[i] - s * g; d_[i + 1] = h + s * (c * g + s * d_[i]); // Accumulate transformation. for (size_t k = 0; k < n_; k++) { h = V_(k, i + 1); V_(k, i + 1) = s * V_(k, i) + c * h; V_(k, i) = c * V_(k, i) - s * h; } } p = -s * s2 * c3 * el1 * e_[l] / dl1; e_[l] = s * p; d_[l] = c * p; // Check for convergence. } while (NumTools::abs(e_[l]) > eps * tst1); } d_[l] = d_[l] + f; e_[l] = 0.0; } // Sort eigenvalues and corresponding vectors. for (size_t i = 0; n_ > 0 && i < n_-1; i++) { size_t k = i; Real p = d_[i]; for (size_t j = i+1; j < n_; j++) { if (d_[j] < p) { k = j; p = d_[j]; } } if (k != i) { d_[k] = d_[i]; d_[i] = p; for (size_t j = 0; j < n_; j++) { p = V_(j, i); V_(j,i) = V_(j, k); V_(j,k) = p; } } } } /** * @brief Nonsymmetric reduction to Hessenberg form. * * This is derived from the Algol procedures orthes and ortran, * by Martin and Wilkinson, Handbook for Auto. Comp., * Vol.ii-Linear Algebra, and the corresponding * Fortran subroutines in EISPACK. */ void orthes() { if (n_ == 0) return; size_t low = 0; size_t high = n_-1; for (size_t m = low + 1; m <= high - 1; ++m) { // Scale column. Real scale = 0.0; for (size_t i = m; i <= high; ++i) { scale = scale + NumTools::abs(H_(i, m - 1)); } if (scale != 0.0) { // Compute Householder transformation. Real h = 0.0; for (size_t i = high; i >= m; --i) { ort_[i] = H_(i, m - 1)/scale; h += ort_[i] * ort_[i]; } Real g = sqrt(h); if (ort_[m] > 0) { g = -g; } h = h - ort_[m] * g; ort_[m] = ort_[m] - g; // Apply Householder similarity transformation // H = (I-u*u'/h)*H*(I-u*u')/h) for (size_t j = m; j < n_; ++j) { Real f = 0.0; for (size_t i = high; i >= m; --i) { f += ort_[i] * H_(i, j); } f = f/h; for (size_t i = m; i <= high; ++i) { H_(i,j) -= f*ort_[i]; } } for (size_t i = 0; i <= high; ++i) { Real f = 0.0; for (size_t j = high; j >= m; --j) { f += ort_[j] * H_(i, j); } f = f/h; for (size_t j = m; j <= high; ++j) { H_(i,j) -= f * ort_[j]; } } ort_[m] = scale * ort_[m]; H_(m, m - 1) = scale * g; } } // Accumulate transformations (Algol's ortran). for (size_t i = 0; i < n_; i++) { for (size_t j = 0; j < n_; j++) { V_(i,j) = (i == j ? 1.0 : 0.0); } } for (size_t m = high - 1; m >= low + 1; --m) { if (H_(m, m - 1) != 0.0) { for (size_t i = m + 1; i <= high; ++i) { ort_[i] = H_(i, m - 1); } for (size_t j = m; j <= high; ++j) { Real g = 0.0; for (size_t i = m; i <= high; i++) { g += ort_[i] * V_(i, j); } // Double division avoids possible underflow g = (g / ort_[m]) / H_(m, m - 1); for (size_t i = m; i <= high; ++i) { V_(i, j) += g * ort_[i]; } } } } } // Complex scalar division. Real cdivr, cdivi; void cdiv(Real xr, Real xi, Real yr, Real yi) { Real r,d; if (NumTools::abs(yr) > NumTools::abs(yi)) { r = yi/yr; d = yr + r*yi; cdivr = (xr + r*xi)/d; cdivi = (xi - r*xr)/d; } else { r = yr/yi; d = yi + r*yr; cdivr = (r*xr + xi)/d; cdivi = (r*xi - xr)/d; } } // Nonsymmetric reduction from Hessenberg to real Schur form. void hqr2 () { // This is derived from the Algol procedure hqr2, // by Martin and Wilkinson, Handbook for Auto. Comp., // Vol.ii-Linear Algebra, and the corresponding // Fortran subroutine in EISPACK. // Initialize int nn = static_cast(this->n_); int n = nn-1; int low = 0; int high = nn-1; Real eps = pow(2.0,-52.0); Real exshift = 0.0; Real p=0,q=0,r=0,s=0,z=0,t,w,x,y; // Store roots isolated by balanc and compute matrix norm Real norm = 0.0; for (int i = 0; i < nn; i++) { if ((i < low) || (i > high)) { d_[TOST(i)] = H_(TOST(i),TOST(i)); e_[TOST(i)] = 0.0; } for (int j = std::max(i-1,0); j < nn; j++) { norm = norm + NumTools::abs(H_(TOST(i),TOST(j))); } } // Outer loop over eigenvalue index int iter = 0; while (n >= low) { // Look for single small sub-diagonal element int l = n; while (l > low) { s = NumTools::abs(H_(TOST(l-1),TOST(l-1))) + NumTools::abs(H_(TOST(l),TOST(l))); if (s == 0.0) { s = norm; } if (NumTools::abs(H_(TOST(l),TOST(l-1))) < eps * s) { break; } l--; } // Check for convergence // One root found if (l == n) { H_(TOST(n),TOST(n)) = H_(TOST(n),TOST(n)) + exshift; d_[TOST(n)] = H_(TOST(n),TOST(n)); e_[TOST(n)] = 0.0; n--; iter = 0; // Two roots found } else if (l == n-1) { w = H_(TOST(n),TOST(n-1)) * H_(TOST(n-1),TOST(n)); p = (H_(TOST(n-1),TOST(n-1)) - H_(TOST(n),TOST(n))) / 2.0; q = p * p + w; z = sqrt(NumTools::abs(q)); H_(TOST(n),TOST(n)) = H_(TOST(n),TOST(n)) + exshift; H_(TOST(n-1),TOST(n-1)) = H_(TOST(n-1),TOST(n-1)) + exshift; x = H_(TOST(n),TOST(n)); // Real pair if (q >= 0) { if (p >= 0) { z = p + z; } else { z = p - z; } d_[TOST(n - 1)] = x + z; d_[TOST(n)] = d_[TOST(n - 1)]; if (z != 0.0) { d_[TOST(n)] = x - w / z; } e_[TOST(n - 1)] = 0.0; e_[TOST(n)] = 0.0; x = H_(TOST(n),TOST(n-1)); s = NumTools::abs(x) + NumTools::abs(z); p = x / s; q = z / s; r = sqrt(p * p+q * q); p = p / r; q = q / r; // Row modification for (int j = n-1; j < nn; j++) { z = H_(TOST(n-1),TOST(j)); H_(TOST(n-1),TOST(j)) = q * z + p * H_(TOST(n),TOST(j)); H_(TOST(n),TOST(j)) = q * H_(TOST(n),TOST(j)) - p * z; } // Column modification for (int i = 0; i <= n; i++) { z = H_(TOST(i),TOST(n-1)); H_(TOST(i),TOST(n-1)) = q * z + p * H_(TOST(i),TOST(n)); H_(TOST(i),TOST(n)) = q * H_(TOST(i),TOST(n)) - p * z; } // Accumulate transformations for (int i = low; i <= high; i++) { z = V_(TOST(i),TOST(n-1)); V_(TOST(i),TOST(n-1)) = q * z + p * V_(TOST(i),TOST(n)); V_(TOST(i),TOST(n)) = q * V_(TOST(i),TOST(n)) - p * z; } // Complex pair } else { d_[TOST(n - 1)] = x + p; d_[TOST(n)] = x + p; e_[TOST(n-1)] = z; e_[TOST(n)] = -z; } n = n - 2; iter = 0; // No convergence yet } else { // Form shift x = H_(TOST(n),TOST(n)); y = 0.0; w = 0.0; if (l < n) { y = H_(TOST(n-1),TOST(n-1)); w = H_(TOST(n),TOST(n-1)) * H_(TOST(n-1),TOST(n)); } // Wilkinson's original ad hoc shift if (iter == 10) { exshift += x; for (int i = low; i <= n; i++) { H_(TOST(i),TOST(i)) -= x; } s = NumTools::abs(H_(TOST(n),TOST(n-1))) + NumTools::abs(H_(TOST(n-1),TOST(n-2))); x = y = 0.75 * s; w = -0.4375 * s * s; } // MATLAB's new ad hoc shift if (iter == 30) { s = (y - x) / 2.0; s = s * s + w; if (s > 0) { s = sqrt(s); if (y < x) { s = -s; } s = x - w / ((y - x) / 2.0 + s); for (int i = low; i <= n; i++) { H_(TOST(i),TOST(i)) -= s; } exshift += s; x = y = w = 0.964; } } iter = iter + 1; // (Could check iteration count here.) // Look for two consecutive small sub-diagonal elements int m = n-2; while (m >= l) { z = H_(TOST(m),TOST(m)); r = x - z; s = y - z; p = (r * s - w) / H_(TOST(m+1),TOST(m)) + H_(TOST(m),TOST(m+1)); q = H_(TOST(m+1),TOST(m+1)) - z - r - s; r = H_(TOST(m+2),TOST(m+1)); s = NumTools::abs(p) + NumTools::abs(q) + NumTools::abs(r); p = p / s; q = q / s; r = r / s; if (m == l) { break; } if (NumTools::abs(H_(TOST(m),TOST(m-1))) * (NumTools::abs(q) + NumTools::abs(r)) < eps * (NumTools::abs(p) * (NumTools::abs(H_(TOST(m-1),TOST(m-1))) + NumTools::abs(z) + NumTools::abs(H_(TOST(m+1),TOST(m+1)))))) { break; } m--; } for (int i = m+2; i <= n; i++) { H_(TOST(i),TOST(i-2)) = 0.0; if (i > m+2) { H_(TOST(i),TOST(i-3)) = 0.0; } } // Double QR step involving rows l:n and columns m:n for (int k = m; k <= n-1; k++) { int notlast = (k != n-1); if (k != m) { p = H_(TOST(k),TOST(k-1)); q = H_(TOST(k+1),TOST(k-1)); r = (notlast ? H_(TOST(k+2),TOST(k-1)) : 0.0); x = NumTools::abs(p) + NumTools::abs(q) + NumTools::abs(r); if (x != 0.0) { p = p / x; q = q / x; r = r / x; } } if (x == 0.0) { break; } s = sqrt(p * p + q * q + r * r); if (p < 0) { s = -s; } if (s != 0) { if (k != m) { H_(TOST(k),TOST(k-1)) = -s * x; } else if (l != m) { H_(TOST(k),TOST(k-1)) = -H_(TOST(k),TOST(k-1)); } p = p + s; x = p / s; y = q / s; z = r / s; q = q / p; r = r / p; // Row modification for (int j = k; j < nn; j++) { p = H_(TOST(k),TOST(j)) + q * H_(TOST(k+1),TOST(j)); if (notlast) { p = p + r * H_(TOST(k+2),TOST(j)); H_(TOST(k+2),TOST(j)) = H_(TOST(k+2),TOST(j)) - p * z; } H_(TOST(k),TOST(j)) = H_(TOST(k),TOST(j)) - p * x; H_(TOST(k+1),TOST(j)) = H_(TOST(k+1),TOST(j)) - p * y; } // Column modification for (int i = 0; i <= std::min(n,k+3); i++) { p = x * H_(TOST(i),TOST(k)) + y * H_(TOST(i),TOST(k+1)); if (notlast) { p = p + z * H_(TOST(i),TOST(k+2)); H_(TOST(i),TOST(k+2)) = H_(TOST(i),TOST(k+2)) - p * r; } H_(TOST(i),TOST(k)) = H_(TOST(i),TOST(k)) - p; H_(TOST(i),TOST(k+1)) = H_(TOST(i),TOST(k+1)) - p * q; } // Accumulate transformations for (int i = low; i <= high; i++) { p = x * V_(TOST(i),TOST(k)) + y * V_(TOST(i),TOST(k+1)); if (notlast) { p = p + z * V_(TOST(i),TOST(k+2)); V_(TOST(i),TOST(k+2)) = V_(TOST(i),TOST(k+2)) - p * r; } V_(TOST(i),TOST(k)) = V_(TOST(i),TOST(k)) - p; V_(TOST(i),TOST(k+1)) = V_(TOST(i),TOST(k+1)) - p * q; } } // (s != 0) } // k loop } // check convergence } // while (n >= low) // Backsubstitute to find vectors of upper triangular form if (norm == 0.0) { return; } for (n = nn-1; n >= 0; n--) { p = d_[TOST(n)]; q = e_[TOST(n)]; // Real vector if (q == 0) { int l = n; H_(TOST(n),TOST(n)) = 1.0; for (int i = n-1; i >= 0; i--) { w = H_(TOST(i),TOST(i)) - p; r = 0.0; for (int j = l; j <= n; j++) { r = r + H_(TOST(i),TOST(j)) * H_(TOST(j),TOST(n)); } if (e_[TOST(i)] < 0.0) { z = w; s = r; } else { l = i; if (e_[TOST(i)] == 0.0) { if (w != 0.0) { H_(TOST(i),TOST(n)) = -r / w; } else { H_(TOST(i),TOST(n)) = -r / (eps * norm); } // Solve real equations } else { x = H_(TOST(i),TOST(i+1)); y = H_(TOST(i+1),TOST(i)); q = (d_[TOST(i)] - p) * (d_[TOST(i)] - p) + e_[TOST(i)] * e_[TOST(i)]; t = (x * s - z * r) / q; H_(TOST(i),TOST(n)) = t; if (NumTools::abs(x) > NumTools::abs(z)) { H_(TOST(i+1),TOST(n)) = (-r - w * t) / x; } else { H_(TOST(i+1),TOST(n)) = (-s - y * t) / z; } } // Overflow control t = NumTools::abs(H_(TOST(i),TOST(n))); if ((eps * t) * t > 1) { for (int j = i; j <= n; j++) { H_(TOST(j),TOST(n)) = H_(TOST(j),TOST(n)) / t; } } } } // Complex vector } else if (q < 0) { int l = n-1; // Last vector component imaginary so matrix is triangular if (NumTools::abs(H_(TOST(n),TOST(n-1))) > NumTools::abs(H_(TOST(n-1),TOST(n)))) { H_(TOST(n-1),TOST(n-1)) = q / H_(TOST(n),TOST(n-1)); H_(TOST(n-1),TOST(n)) = -(H_(TOST(n),TOST(n)) - p) / H_(TOST(n),TOST(n-1)); } else { cdiv(0.0,-H_(TOST(n-1),TOST(n)),H_(TOST(n-1),TOST(n-1))-p,q); H_(TOST(n-1),TOST(n-1)) = cdivr; H_(TOST(n-1),TOST(n)) = cdivi; } H_(TOST(n),TOST(n-1)) = 0.0; H_(TOST(n),TOST(n)) = 1.0; for (int i = n-2; i >= 0; i--) { Real ra,sa,vr,vi; ra = 0.0; sa = 0.0; for (int j = l; j <= n; j++) { ra = ra + H_(TOST(i),TOST(j)) * H_(TOST(j),TOST(n-1)); sa = sa + H_(TOST(i),TOST(j)) * H_(TOST(j),TOST(n)); } w = H_(TOST(i),TOST(i)) - p; if (e_[TOST(i)] < 0.0) { z = w; r = ra; s = sa; } else { l = i; if (e_[TOST(i)] == 0) { cdiv(-ra,-sa,w,q); H_(TOST(i),TOST(n-1)) = cdivr; H_(TOST(i),TOST(n)) = cdivi; } else { // Solve complex equations x = H_(TOST(i),TOST(i+1)); y = H_(TOST(i+1),TOST(i)); vr = (d_[TOST(i)] - p) * (d_[TOST(i)] - p) + e_[TOST(i)] * e_[TOST(i)] - q * q; vi = (d_[TOST(i)] - p) * 2.0 * q; if ((vr == 0.0) && (vi == 0.0)) { vr = eps * norm * (NumTools::abs(w) + NumTools::abs(q) + NumTools::abs(x) + NumTools::abs(y) + NumTools::abs(z)); } cdiv(x*r-z*ra+q*sa,x*s-z*sa-q*ra,vr,vi); H_(TOST(i),TOST(n-1)) = cdivr; H_(TOST(i),TOST(n)) = cdivi; if (NumTools::abs(x) > (NumTools::abs(z) + NumTools::abs(q))) { H_(TOST(i+1),TOST(n-1)) = (-ra - w * H_(TOST(i),TOST(n-1)) + q * H_(TOST(i),TOST(n))) / x; H_(TOST(i+1),TOST(n)) = (-sa - w * H_(TOST(i),TOST(n)) - q * H_(TOST(i),TOST(n-1))) / x; } else { cdiv(-r-y*H_(TOST(i),TOST(n-1)),-s-y*H_(TOST(i),TOST(n)),z,q); H_(TOST(i+1),TOST(n-1)) = cdivr; H_(TOST(i+1),TOST(n)) = cdivi; } } // Overflow control t = std::max(NumTools::abs(H_(TOST(i),TOST(n-1))),NumTools::abs(H_(TOST(i),TOST(n)))); if ((eps * t) * t > 1) { for (int j = i; j <= n; j++) { H_(TOST(j),TOST(n-1)) = H_(TOST(j),TOST(n-1)) / t; H_(TOST(j),TOST(n)) = H_(TOST(j),TOST(n)) / t; } } } } } } // Vectors of isolated roots for (int i = 0; i < nn; i++) { if (i < low || i > high) { for (int j = i; j < nn; j++) { V_(TOST(i),TOST(j)) = H_(TOST(i),TOST(j)); } } } // Back transformation to get eigenvectors of original matrix for (int j = nn-1; j >= low; j--) { for (int i = low; i <= high; i++) { z = 0.0; for (int k = low; k <= std::min(j,high); k++) { z = z + V_(TOST(i),TOST(k)) * H_(TOST(k),TOST(j)); } V_(TOST(i),TOST(j)) = z; } } } public: bool isSymmetric() const { return issymmetric_; } /** * @brief Check for symmetry, then construct the eigenvalue decomposition * * @param A Square real (non-complex) matrix */ EigenValue(const Matrix& A) : n_(A.getNumberOfColumns()), issymmetric_(true), d_(n_), e_(n_), V_(n_,n_), H_(), D_(n_, n_), ort_(), cdivr(), cdivi() { if (n_ > INT_MAX) throw Exception("EigenValue: can only be computed for matrices <= " + TextTools::toString(INT_MAX)); for (size_t j = 0; (j < n_) && issymmetric_; j++) { for (size_t i = 0; (i < n_) && issymmetric_; i++) { issymmetric_ = (A(i,j) == A(j,i)); } } if (issymmetric_) { for (size_t i = 0; i < n_; i++) { for (size_t j = 0; j < n_; j++) { V_(i,j) = A(i,j); } } // Tridiagonalize. tred2(); // Diagonalize. tql2(); } else { H_.resize(n_,n_); ort_.resize(n_); for (size_t j = 0; j < n_; j++) { for (size_t i = 0; i < n_; i++) { H_(i,j) = A(i,j); } } // Reduce to Hessenberg form. orthes(); // Reduce Hessenberg to real Schur form. hqr2(); } } /** * @brief Return the eigenvector matrix * * @return V */ const RowMatrix& getV() const { return V_; } /** * @brief Return the real parts of the eigenvalues * * @return real(diag(D)) */ const std::vector& getRealEigenValues() const { return d_; } /** * @brief Return the imaginary parts of the eigenvalues in parameter e. * * @return e: new matrix with imaginary parts of the eigenvalues. */ const std::vector& getImagEigenValues() const { return e_; } /** * @brief Computes the block diagonal eigenvalue matrix. * * If the original matrix A is not symmetric, then the eigenvalue * matrix D is block diagonal with the real eigenvalues in 1-by-1 * blocks and any complex eigenvalues, * a + i*b, in 2-by-2 blocks, [a, b; -b, a]. That is, if the complex * eigenvalues look like * 
     *
     *       u + iv     .        .          .      .    .
     *         .      u - iv     .          .      .    .
     *         .        .      a + ib       .      .    .
     *         .        .        .        a - ib   .    .
     *         .        .        .          .      x    .
     *         .        .        .          .      .    y
     *
* then D looks like * 
     *
     *         u        v        .          .      .    .
     *        -v        u        .          .      .    . 
     *         .        .        a          b      .    .
     *         .        .       -b          a      .    .
     *         .        .        .          .      x    .
     *         .        .        .          .      .    y
     *
* This keeps V a real matrix in both symmetric and non-symmetric * cases, and A*V = V*D. * * @return D: upon return, the matrix is filled with the block diagonal * eigenvalue matrix. */ const RowMatrix& getD() const { for (size_t i = 0; i < n_; i++) { for (size_t j = 0; j < n_; j++) { D_(i,j) = 0.0; } D_(i,i) = d_[i]; if (e_[i] > 0) { D_(i,i+1) = e_[i]; } else if (e_[i] < 0) { D_(i,i-1) = e_[i]; } } return D_; } }; } //end of namespace bpp. #endif //_EIGENVALUE_H_ bpp-core-2.2.0/src/Bpp/Numeric/AbstractParametrizable.h000664 001750 001750 00000016374 12370705300 024427 0ustar00jdutheiljdutheil000000 000000 // // File: AbstractParametrizable.h // Created by: Julien Dutheil // Created on: Sun Mar 29 09:10 2009 // Created from file Parametrizable.h // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _ABSTRACTPARAMETRIZABLE_H_ #define _ABSTRACTPARAMETRIZABLE_H_ #include "Parametrizable.h" //From the STL: #include namespace bpp { /** * @brief A partial implementation of the Parametrizable interface. * * Parameters are stored in a protected ParameterList object. * * The abstract fireParameterChanged() method is provided so that the derived class * know when a parameter has changed, and can be updated. * All methods call the corresponding method in ParameterList and then call the * fireParameterChanged() method. */ class AbstractParametrizable: public virtual Parametrizable { private: ParameterList parameters_; std::string prefix_; public: AbstractParametrizable(const std::string& prefix) : parameters_(), prefix_(prefix) {} virtual ~AbstractParametrizable() {} public: bool hasParameter(const std::string& name) const { return parameters_.hasParameter(prefix_ + name); } const ParameterList& getParameters() const { return parameters_; } const Parameter& getParameter(const std::string& name) const throw (ParameterNotFoundException) { return parameters_.getParameter(prefix_ + name); } double getParameterValue(const std::string& name) const throw (ParameterNotFoundException) { return getParameter(name).getValue(); } void setAllParametersValues(const ParameterList & parameters) throw (ParameterNotFoundException, ConstraintException) { parameters_.setAllParametersValues(parameters); fireParameterChanged(parameters); } void setParameterValue(const std::string& name, double value) throw (ParameterNotFoundException, ConstraintException) { parameters_.setParameterValue(prefix_ + name, value); fireParameterChanged(parameters_.subList(prefix_ + name)); } void setParametersValues(const ParameterList& parameters) throw (ParameterNotFoundException, ConstraintException) { parameters_.setParametersValues(parameters); fireParameterChanged(parameters); } bool matchParametersValues(const ParameterList& parameters) throw (ConstraintException) { std::auto_ptr< std::vector >updatedParameters(new std::vector()); bool test = parameters_.matchParametersValues(parameters, updatedParameters.get()); if (test) fireParameterChanged(parameters.subList(*updatedParameters)); return test; } size_t getNumberOfParameters() const { return parameters_.size(); } void setNamespace(const std::string& prefix); std::string getNamespace() const { return prefix_; } std::string getParameterNameWithoutNamespace(const std::string& name) const; /** * @brief Notify the class when one or several parameters have changed. * * @param parameters A ParameterList object with parameters that changed. */ virtual void fireParameterChanged(const ParameterList& parameters) = 0; protected: void addParameter_(Parameter* parameter) { if (parameter) parameters_.addParameter(parameter); } void addParameters_(const ParameterList& parameters) { parameters_.addParameters(parameters); } void deleteParameter_(size_t index) throw (IndexOutOfBoundsException) { if (index >= parameters_.size()) throw IndexOutOfBoundsException("AbstractParametrizable::deleteParameter_.", index, 0, parameters_.size() - 1); parameters_.deleteParameter(index); } void deleteParameter_(std::string& name) { parameters_.deleteParameter(name); } void deleteParameters_(const std::vector& names) { parameters_.deleteParameters(names); } void resetParameters_() { parameters_.reset(); } /** * @param name The name of the parameter. * @return A reference toward the corresponding parameter. * @throw ParameterNotFoundException If no parameter with that name is found in the list. */ Parameter& getParameter_(const std::string& name) throw (ParameterNotFoundException) { return parameters_.getParameter(prefix_ + name); } /** * @param name The name of the parameter, including its namespace. * @return A reference toward the corresponding parameter. * @throw ParameterNotFoundException If no parameter with that name is found in the list. */ Parameter& getParameterWithNamespace_(const std::string& name) throw (ParameterNotFoundException) { return getParameter_(name); } /** * @param name The name of the parameter, including its namespace. * @return A reference toward the corresponding parameter. * @throw ParameterNotFoundException If no parameter with that name is found in the list. */ const Parameter& getParameterWithNamespace_(const std::string& name) const throw (ParameterNotFoundException) { return getParameter(name); } Parameter& getParameter_(size_t index) throw (IndexOutOfBoundsException) { if (index >= parameters_.size()) throw IndexOutOfBoundsException("AbstractParametrizable::getParameter_.", index, 0, parameters_.size() - 1); return parameters_[index]; } const Parameter& getParameter_(size_t index) const throw (IndexOutOfBoundsException) { if(index >= parameters_.size()) throw IndexOutOfBoundsException("AbstractParametrizable::getParameter_.", index, 0, parameters_.size() - 1); return parameters_[index]; } ParameterList& getParameters_() { return parameters_; } }; } //end of namespace bpp. #endif //_ABSTRACTPARAMETRIZABLE_H_ bpp-core-2.2.0/src/Bpp/Numeric/AutoParameter.cpp000664 001750 001750 00000010322 12370705300 023070 0ustar00jdutheiljdutheil000000 000000 // // File: AutoParameter.cpp // Created by: Julien Dutheil // Created on: Tue Nov 11 22:15:16 2003 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "AutoParameter.h" #include "NumConstants.h" #include using namespace std; // Utils: #include "../Text/TextTools.h" #include "../App/ApplicationTools.h" using namespace bpp; /******************************************************************************/ string AutoParameter::CONSTRAINTS_AUTO = "auto"; string AutoParameter::CONSTRAINTS_IGNORE = "ignore"; string AutoParameter::CONSTRAINTS_KEEP = "keep"; /** Constructors: *************************************************************/ AutoParameter::AutoParameter(const std::string& name, double value, Constraint* constraint, bool attachConstraint) throw (ConstraintException): Parameter(name, value, constraint, attachConstraint), messageHandler_(ApplicationTools::message) {} AutoParameter::AutoParameter(const Parameter& p): Parameter(p), messageHandler_(ApplicationTools::message) {} AutoParameter::AutoParameter(const AutoParameter& p): Parameter(p), messageHandler_(p.messageHandler_) {} AutoParameter& AutoParameter::operator=(const AutoParameter& p) { Parameter::operator=(p); messageHandler_ = p.messageHandler_; return *this; } /******************************************************************************/ void AutoParameter::setValue(double value) throw (ConstraintException) { try { // First we try to assign this value: Parameter::setValue(value); } catch (ConstraintException& ce) { // Aie, there's a pb here... if (messageHandler_) { (*messageHandler_) << "Constraint match at parameter "; (*messageHandler_) << name_; (*messageHandler_) << ", badValue = "; (*messageHandler_) << ce.getBadValue(); (*messageHandler_) << " "; (*messageHandler_ << constraint_->getDescription()).endLine(); } double limit = constraint_->getAcceptedLimit(value); try { // We try to assign the limit then. Parameter::setValue(limit); } catch(ConstraintException& ce2) { // Aie, the limit is not reachable, so we perform a smaller step... //Parameter::setValue((getValue() + limit) / 2); try { // Try on the right: Parameter::setValue(limit + NumConstants::TINY()); } catch(ConstraintException& ce3) { // Try on the left: Parameter::setValue(limit - NumConstants::TINY()); } } } } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Parameter.h000664 001750 001750 00000025473 12370705300 021721 0ustar00jdutheiljdutheil000000 000000 // // File: Parameter.h // Created by: Julien Dutheil // Created on: Wed Oct 15 15:40:47 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _PARAMETER_H_ #define _PARAMETER_H_ #include "ParameterExceptions.h" #include "Constraints.h" #include "../Clonable.h" // From the STL: #include #include #include namespace bpp { class Parameter; class ParameterEvent: public virtual Clonable { protected: Parameter* parameter_; public: ParameterEvent(Parameter* parameter); ParameterEvent(const ParameterEvent& pe): parameter_(pe.parameter_) {} ParameterEvent& operator=(const ParameterEvent& pe) { parameter_ = pe.parameter_; return *this; } #ifndef NO_VIRTUAL_COV ParameterEvent* #else Clonable* #endif clone() const { return new ParameterEvent(*this); } public: const Parameter* getParameter() const { return parameter_; } Parameter* getParameter() { return parameter_; } }; /** * @brief The parameter listener interface. * * Imlementing this interface allows to catch events associated to parameters modifications. * Listeners must have an identifier that will be used to pinpoint it when attached to a list. * This identifier needs not be unique though, but listeners with identical id will be undistinguishable. */ class ParameterListener: public virtual Clonable { public: #ifndef NO_VIRTUAL_COV ParameterListener* #else Clonable* #endif clone() const = 0; public: /** * @return The identifier of this listener. */ virtual const std::string& getId() const = 0; /** * @brief Notify a renaming action. * * @param event Event associated to the acion. */ virtual void parameterNameChanged(ParameterEvent& event) = 0; /** * @brief Notify a value change. * * @param event Event associated to the acion. */ virtual void parameterValueChanged(ParameterEvent& event) = 0; }; /** * @brief This class is designed to facilitate the manipulation of parameters. * * A parameter object contains a value stored as a double. * It also contains a name and optionaly a constraint. * Constraint objects allows to apply restriction on the value of the parameter, * for instance positive number, or a particular interval and so on. * * @see ParameterList, Parametrizable, Constraint. */ class Parameter: public virtual Clonable { protected: std::string name_; //Parameter name double value_; //Parameter value double precision_; // Precision needed for Parameter value Constraint* constraint_; //A constraint on the value bool attach_; // Tells if the constraint is attached to the Parameter std::vector listeners_; std::vector listenerAttach_; public: // Class constructors and destructors: /** * @brief Default contructor. Creates a parameter with no name, no constraint, and a value of 0. */ Parameter(): name_(""), value_(0), precision_(0), constraint_(0), attach_(true), listeners_(), listenerAttach_() {} /** * @brief Build a new parameter. * * @param name The parameter name. * @param value The parameter value. * @param constraint A pointer toward a constraint Object. * @param attachConstraint Tell if the constraint must be attached to this parameter, or shared * @param precision An optional parameter precision (default 0) * between different objects (the default behavior, for backward compatibility). * If the first case, the constraint object will be destroyed when the parameter is destroyed, * and duplicated when the parameter is copied. * @throw ConstraintException If the parameter value does not match the contraint. */ Parameter(const std::string& name, double value, Constraint* constraint, bool attachConstraint, double precision=0) throw (ConstraintException); /** * @brief Build a new parameter. * * @param name The parameter name. * @param value The parameter value. * @param constraint An optional pointer toward a constraint Object. The constraint will be copied and attached to this instance. * @param precision An optional parameter precision (default 0) * @throw ConstraintException If the parameter value does not match the contraint. */ Parameter(const std::string& name, double value, const Constraint* constraint = 0, double precision=0) throw (ConstraintException); /** * @brief Copy constructor. */ Parameter(const Parameter& param); /** * @brief Assignment operator. */ Parameter& operator=(const Parameter& param); virtual ~Parameter(); #ifndef NO_VIRTUAL_COV Parameter* #else Clonable* #endif clone() const { return new Parameter(*this); } public: /** * @brief Set the name of this parameter. * * @param name the new parameter name. */ virtual void setName(const std::string & name) { name_ = name; ParameterEvent event(this); fireParameterNameChanged(event); } /** * @brief Set the value of this parameter. * * @param value the new parameter value. */ virtual void setValue(double value) throw (ConstraintException); /** * @brief Set the precision of this parameter. * * @param precision the new parameter precision. */ void setPrecision(double precision); /** * @brief Get the name of this parameter. * * @return The parameter name. */ virtual const std::string& getName() const { return name_; } /** * @brief Get the value of this parameter. * * @return The parameter value. */ virtual double getValue() const { return value_; } /** * @brief Get the precision of this parameter. * * @return The precision value. */ virtual double getPrecision() const { return precision_; } /** * @brief Return the constraint associated to this parameter if there is one. * * @return A pointer toward the constraint, or NULL if there is no constraint. */ virtual const Constraint* getConstraint() const { return constraint_; } /** * @brief Return the constraint associated to this parameter if there is one. * * @return A pointer toward the constraint, or NULL if there is no constraint. */ virtual Constraint* getConstraint() { return constraint_; } /** * @brief Tells if this parameter has a constraint. * * @return True if this parameter has a contraint. */ virtual bool hasConstraint() const { return constraint_ != 0; } /** * @brief Remove the constraint associated to this parameter. * * Warning! The contraint objet is not deleted. * * @return A pointer toward the formerly used contraint. */ virtual const Constraint* removeConstraint(); /** * @brief Set a constraint to this parameter. * * @param constraint a pointer to the constraint (may be null) * @param attach says if the constraint is attached to the Parameter (default: false). */ virtual void setConstraint(Constraint* constraint, bool attach = false); /** * @brief Add a new listener to this parameter. * * @param listener The listener to add. * @param attachListener Tell if the parameter will own this listener. * If so, deep copies will be made when cloning the parameter, and the listener will be destroyed upon * destruction of the parameter or upon removal. Alternatively, only superficial copies will be made, * and the listener will persist if the parameter is destroyed. */ virtual void addParameterListener(ParameterListener* listener, bool attachListener = true) { listeners_.push_back(listener); listenerAttach_.push_back(attachListener); } /** * @brief Remove all listeners with a given id from this parameter. * * @param listenerId The id of listener to remove. */ virtual void removeParameterListener(const std::string& listenerId); /** * @brief Tell is there is a listener with a given id from this parameter. * * @param listenerId The id of listener to remove. * @return True if at list one listener with the given id was found. */ virtual bool hasParameterListener(const std::string& listenerId); protected: void fireParameterNameChanged(ParameterEvent& event) { for(std::vector::iterator it = listeners_.begin(); it != listeners_.end(); it++) (*it)->parameterNameChanged(event); } void fireParameterValueChanged(ParameterEvent& event) { for(std::vector::iterator it = listeners_.begin(); it != listeners_.end(); it++) (*it)->parameterValueChanged(event); } public: static const IntervalConstraint R_PLUS; static const IntervalConstraint R_PLUS_STAR; static const IntervalConstraint R_MINUS; static const IntervalConstraint R_MINUS_STAR; static const IntervalConstraint PROP_CONSTRAINT_IN; static const IntervalConstraint PROP_CONSTRAINT_EX; }; } //end of namespace bpp. #endif //_PARAMETER_H_ bpp-core-2.2.0/src/Bpp/Numeric/VectorExceptions.h000664 001750 001750 00000010630 12370705300 023272 0ustar00jdutheiljdutheil000000 000000 // // File: VectorExceptions.h // Created by: Julien Dutheil // Created on: 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _VECTOREXCEPTIONS_H_ #define _VECTOREXCEPTIONS_H_ #include "../Exceptions.h" #include "../Text/TextTools.h" //From the STL/ #include #include namespace bpp { /** * @brief General Exception dealing with vectors. */ template class VectorException : public Exception { protected: const std::vector * vect_; public: VectorException(const std::string& text, const std::vector* vect = 0) : Exception("VectorException: " + text), vect_(vect) {}; VectorException(const VectorException& ve): Exception(ve), vect_(ve.vect_) {} VectorException& operator=(const VectorException& ve) { Exception::operator=(ve); vect_ = ve.vect_; return *this; } virtual ~VectorException() throw () {}; public: virtual const std::vector* getVector() const { return vect_; } }; /** * @brief Exception thrown when an empty vector was found. */ template class EmptyVectorException : public VectorException { public: EmptyVectorException(const std::string& text, const std::vector* vect = 0) : VectorException("EmptyVectorException: " + text, vect) {}; virtual ~EmptyVectorException() throw () {} }; /** * @brief Exception thrown when a dimension problem occured. */ class DimensionException : public Exception { private: size_t dimension_; size_t correctDimension_; public: DimensionException(const std::string& text, size_t dimension, size_t correctDimension) : Exception("DimensionException (found " + TextTools::toString(dimension) + ", should be " + TextTools::toString(correctDimension) + ") " + text), dimension_(dimension), correctDimension_(correctDimension) {}; virtual ~DimensionException() throw () {} public: virtual size_t getDimension() const { return dimension_; } virtual size_t getCorrectDimension() const { return correctDimension_; } }; /** * @brief Exception thrown when a given element was not found in the vector. */ template class ElementNotFoundException : public VectorException { private: const T* element_; public: ElementNotFoundException(const std::string& text, const std::vector* vect = 0, const T* element = 0) : VectorException("ElementNotFoundException: " + text, vect), element_(element) {}; ElementNotFoundException(const ElementNotFoundException& enfe): VectorException(enfe), element_(enfe.element_) {} ElementNotFoundException& operator=(const ElementNotFoundException& enfe) { VectorException::operator=(enfe); element_ = enfe.element_; return *this; } virtual ~ElementNotFoundException() throw () {}; public: virtual const T* getElement() const { return element_; } }; } //end of namespace bpp. #endif //_VECTOREXCEPTIONS_H_ bpp-core-2.2.0/src/Bpp/Numeric/AbstractParametrizable.cpp000664 001750 001750 00000004711 12370705300 024752 0ustar00jdutheiljdutheil000000 000000 // // File: AbstractParametrizable.cpp // Created by: Julien Dutheil // Created on: Sun Mar 29 09:10 2009 // /* Copyright or © or Copr. CNRS, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "AbstractParametrizable.h" using namespace bpp; using namespace std; void AbstractParametrizable::setNamespace(const std::string& prefix) { //We need to update all parameter names! //First correct the global parameter list string currentName; for(unsigned int i = 0; i < parameters_.size(); i++) { currentName = parameters_[i].getName(); if (TextTools::startsWith(currentName, prefix_)) parameters_[i].setName(prefix + currentName.substr(prefix_.size())); else parameters_[i].setName(prefix + currentName); } //Then we store the new namespace: prefix_ = prefix; } std::string AbstractParametrizable::getParameterNameWithoutNamespace(const std::string& name) const { if(TextTools::startsWith(name, prefix_)) return name.substr(prefix_.size()); else return name; } bpp-core-2.2.0/src/Bpp/Numeric/ParameterList.cpp000664 001750 001750 00000042721 12370705300 023103 0ustar00jdutheiljdutheil000000 000000 // // File: ParameterList.cpp // Created by: Julien Dutheil // Created on: Wed Oct 15 18:17:29 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "ParameterList.h" #include "../Text/StringTokenizer.h" using namespace bpp; #include #include using namespace std; /** Copy constructor: *********************************************************/ ParameterList::ParameterList(const ParameterList& pl) : parameters_(pl.size()) { // Now copy all parameters: for (unsigned int i = 0; i < size(); i++) { parameters_[i] = dynamic_cast(pl.parameters_[i]->clone()); } } /** Assignation operator: *****************************************************/ ParameterList& ParameterList::operator=(const ParameterList& pl) { // First delete all parameters: reset(); // Then resize the vector: parameters_.resize(pl.size()); // Now copy all parameters: for (unsigned int i = 0; i < pl.size(); i++) { parameters_[i] = dynamic_cast(pl.parameters_[i]->clone()); } return *this; } /** Destructor: ***************************************************************/ ParameterList::~ParameterList() { // Delete all parameter objects. reset(); } /******************************************************************************/ const Parameter& ParameterList::getParameter(const std::string& name) const throw (ParameterNotFoundException) { for (unsigned int i = 0; i < size(); i++) { const Parameter* p = parameters_[i]; if (p->getName() == name) return *p; } throw ParameterNotFoundException("ParameterList::getParameter('name').", name); } /******************************************************************************/ double ParameterList::getParameterValue(const std::string& name) const throw (ParameterNotFoundException) { for (unsigned int i = 0; i < size(); i++) { const Parameter* p = parameters_[i]; if (p->getName() == name) return p->getValue(); } throw ParameterNotFoundException("ParameterList::getParameterValue('name').", name); } /******************************************************************************/ Parameter& ParameterList::getParameter(const std::string& name) throw (ParameterNotFoundException) { for (unsigned int i = 0; i < size(); i++) { Parameter* p = parameters_[i]; if (p->getName() == name) return *p; } throw ParameterNotFoundException("ParameterList::getParameter('name').", name); } /******************************************************************************/ ParameterList ParameterList::subList(const std::vector& names) const throw (ParameterNotFoundException) { ParameterList pl; for (unsigned int i = 0; i < names.size(); i++) { Parameter param = getParameter(names[i]); pl.addParameter(param); } return pl; } /******************************************************************************/ ParameterList ParameterList::subList(const std::string& name) const throw (ParameterNotFoundException) { ParameterList pl; Parameter param = getParameter(name); pl.addParameter(param); return pl; } /******************************************************************************/ ParameterList ParameterList::subList(const std::vector& parameters) const { ParameterList pl; for (unsigned int i = 0; i < parameters.size(); i++) { if (parameters[i] < size()) pl.parameters_.push_back(dynamic_cast(parameters_[parameters[i]]->clone())); } return pl; } /******************************************************************************/ ParameterList ParameterList::subList(size_t parameter) const { ParameterList pl; if (parameter < size()) pl.parameters_.push_back(dynamic_cast(parameters_[parameter]->clone())); return pl; } /******************************************************************************/ ParameterList ParameterList::getCommonParametersWith(const ParameterList& params) const { ParameterList pl; for (unsigned int i = 0; i < params.size(); i++) { const Parameter& p = params[i]; if (hasParameter(p.getName())) pl.parameters_.push_back(dynamic_cast(p.clone())); // We use push_back instead of addParameter because we are sure the name is not duplicated. } return pl; } /******************************************************************************/ std::vector ParameterList::getParameterNames() const { vector pNames(size()); for (unsigned int i = 0; i < size(); i++) { pNames[i] = parameters_[i]->getName(); } return pNames; } /****************************************************************************/ vector ParameterList::getMatchingParameterNames(const string& pattern) const { vector pNames; for (unsigned int i = 0; i < size(); i++) { string name = parameters_[i]->getName(); StringTokenizer stj(pattern, "*", true, false); size_t pos1, pos2; bool flag(true); string g=stj.nextToken(); pos1=name.find(g); if (pos1!=0) flag=false; pos1+=g.length(); while (flag && stj.hasMoreToken()){ g=stj.nextToken(); pos2=name.find(g,pos1); if (pos2 == string::npos){ flag=false; break; } pos1=pos2+g.length(); } if (flag && ((g.length()==0) || (pos1==name.length()) || (name.rfind(g)==name.length()-g.length()))) pNames.push_back(name); } return pNames; } /******************************************************************************/ void ParameterList::addParameter(const Parameter& param) throw (ParameterException) { if (hasParameter(param.getName())) throw ParameterException("ParameterList::addParameter. Parameter with name '" + param.getName() + "' already exists.", ¶m); parameters_.push_back(dynamic_cast(param.clone())); } /******************************************************************************/ void ParameterList::addParameter(Parameter* param) throw (ParameterException) { if (hasParameter(param->getName())) throw ParameterException("ParameterList::addParameter. Parameter with name '" + param->getName() + "' already exists.", param); parameters_.push_back(param); } /******************************************************************************/ void ParameterList::setParameter(size_t index, const Parameter& param) throw (IndexOutOfBoundsException) { if (index >= size()) throw IndexOutOfBoundsException("ParameterList::setParameter.", index, 0, size()); delete parameters_[index]; parameters_[index] = dynamic_cast(param.clone()); } /******************************************************************************/ void ParameterList::includeParameters(const ParameterList& params) { for (unsigned int i = 0; i < params.size(); i++) { if (hasParameter(params[i].getName())) setParameterValue(params[i].getName(), params[i].getValue()); else parameters_.push_back(dynamic_cast(params[i].clone())); } } /******************************************************************************/ void ParameterList::addParameters(const ParameterList& params) throw (ParameterException) { for (unsigned int i = 0; i < params.size(); i++) { addParameter(params[i]); } } /******************************************************************************/ void ParameterList::setParameterValue(const string& name, double value) throw (ParameterNotFoundException, ConstraintException) { Parameter* p = &getParameter(name); p->setValue(value); } /******************************************************************************/ void ParameterList::setAllParametersValues(const ParameterList& params) throw (ParameterNotFoundException, ConstraintException) { // First we check if all values are correct: for (vector::iterator it = parameters_.begin(); it < parameters_.end(); it++) { const Parameter* p = ¶ms.getParameter((*it)->getName()); if ((*it)->hasConstraint() && !(*it)->getConstraint()->isCorrect(p->getValue())) throw ConstraintException("ParameterList::setParametersValues()", *it, p->getValue()); } // If all values are ok, we set them: for (vector::iterator it = parameters_.begin(); it < parameters_.end(); it++) { const Parameter* p = ¶ms.getParameter((*it)->getName()); (*it)->setValue(p->getValue()); } } /******************************************************************************/ void ParameterList::setParametersValues(const ParameterList& params) { // First we check if all values are correct: for (vector::const_iterator it = params.parameters_.begin(); it < params.parameters_.end(); it++) { if (hasParameter((*it)->getName())) { Parameter* p = &getParameter((*it)->getName()); if (p->hasConstraint() && !p->getConstraint()->isCorrect((*it)->getValue())) throw ConstraintException("ParameterList::setParametersValues()", p, (*it)->getValue()); } } // If all values are ok, we set them: { for (vector::const_iterator it = params.parameters_.begin(); it < params.parameters_.end(); it++) { if (hasParameter((*it)->getName())) { Parameter* p = &getParameter((*it)->getName()); p->setValue((*it)->getValue()); } } } } /******************************************************************************/ bool ParameterList::testParametersValues(const ParameterList& params) const { // First we check if all values are correct: for (vector::const_iterator it = params.parameters_.begin(); it < params.parameters_.end(); it++) { if (hasParameter((*it)->getName())) { const Parameter* p = &getParameter((*it)->getName()); if (p->hasConstraint() && !p->getConstraint()->isCorrect((*it)->getValue())) throw ConstraintException("ParameterList::matchParametersValues()", p, (*it)->getValue()); } } // If all values are ok, we test them: bool ch = 0; for (vector::const_iterator it = params.parameters_.begin(); it < params.parameters_.end(); it++) { if (hasParameter((*it)->getName())) { const Parameter* p = &getParameter((*it)->getName()); if (p->getValue() != (*it)->getValue()) ch |= 1; } } return ch; } /******************************************************************************/ bool ParameterList::matchParametersValues(const ParameterList& params, vector* updatedParameters) throw (ConstraintException) { // First we check if all values are correct: for (vector::const_iterator it = params.parameters_.begin(); it < params.parameters_.end(); it++) { if (hasParameter((*it)->getName())) { Parameter* p = &getParameter((*it)->getName()); if (p->hasConstraint() && !p->getConstraint()->isCorrect((*it)->getValue())) throw ConstraintException("ParameterList::matchParametersValues()", p, (*it)->getValue()); } } // If all values are ok, we set them: bool ch = 0; size_t pos = 0; for (vector::const_iterator it = params.parameters_.begin(); it < params.parameters_.end(); it++) { if (hasParameter((*it)->getName())) { Parameter* p = &getParameter((*it)->getName()); if (p->getValue() != (*it)->getValue()) { ch |= 1; p->setValue((*it)->getValue()); if (updatedParameters) updatedParameters->push_back(pos); } } pos++; } return ch; } /******************************************************************************/ void ParameterList::setAllParameters(const ParameterList& params) throw (ParameterNotFoundException) { for (vector::iterator it = parameters_.begin(); it < parameters_.end(); it++) { const Parameter* p = ¶ms.getParameter((*it)->getName()); **it = *p; } } /******************************************************************************/ void ParameterList::setParameters(const ParameterList& params) throw (ParameterNotFoundException) { for (vector::const_iterator it = params.parameters_.begin(); it < params.parameters_.end(); it++) { Parameter* p = &getParameter((*it)->getName()); *p = **it; } } /******************************************************************************/ bool ParameterList::hasParameter(const std::string& name) const { for (unsigned int i = 0; i < size(); i++) { const Parameter* p = parameters_[i]; if (p->getName() == name) return true; } return false; } /******************************************************************************/ void ParameterList::matchParameters(const ParameterList& params) { for (vector::const_iterator it = params.parameters_.begin(); it < params.parameters_.end(); it++) { if (hasParameter((*it)->getName())) { Parameter* p = &getParameter((*it)->getName()); *p = **it; } } } /******************************************************************************/ void ParameterList::deleteParameter(const std::string& name) throw (ParameterNotFoundException) { for (unsigned int i = 0; i < size(); i++) { Parameter* p = parameters_[i]; if (p->getName() == name) { delete p; parameters_.erase(parameters_.begin() + i); return; } } throw ParameterNotFoundException("ParameterList::deleteParameter", name); } /******************************************************************************/ void ParameterList::deleteParameters(const std::vector& names, bool mustExist) throw (ParameterNotFoundException) { for (unsigned int i = 0; i < names.size(); i++) { try { deleteParameter(names[i]); } catch (ParameterNotFoundException& e) { if (mustExist) throw ParameterNotFoundException(e); else continue; } } } /******************************************************************************/ void ParameterList::deleteParameter(size_t index) throw (IndexOutOfBoundsException) { if (index >= size()) throw IndexOutOfBoundsException("ParameterList::deleteParameter.", index, 0, size()); Parameter* p = parameters_[index]; delete p; parameters_.erase(parameters_.begin() + static_cast(index)); } /******************************************************************************/ void ParameterList::deleteParameters(const std::vector& indices) throw (IndexOutOfBoundsException) { vector tmp(indices); sort(tmp.begin(), tmp.end()); for (vector::reverse_iterator i = tmp.rbegin(); i != tmp.rend(); i++) { size_t index = *i; if (index >= size()) throw IndexOutOfBoundsException("ParameterList::deleteParameter.", index, 0, size()); Parameter* p = parameters_[index]; delete p; parameters_.erase(parameters_.begin() + static_cast(index)); } } /******************************************************************************/ size_t ParameterList::whichParameterHasName(const std::string& name) const throw (ParameterNotFoundException) { for (size_t i = 0; i < size(); i++) { if (parameters_[i]->getName() == name) return i; } throw ParameterNotFoundException("ParameterList::whichParameterHasName.", name); } /******************************************************************************/ void ParameterList::printParameters(OutputStream& out) const { (out << "Name:\tValue:\tConstraint:").endLine(); (out << "_________________________________________________").endLine(); for (unsigned int i = 0; i < size(); i++) { out << parameters_[i]->getName(); out << "\t" << parameters_[i]->getValue(); out << (parameters_[i]->hasConstraint() ? "\t" + parameters_[i]->getConstraint()->getDescription() : string("")); out.endLine(); } } /******************************************************************************/ void ParameterList::reset() { for (unsigned int i = 0; i < size(); i++) { delete parameters_[i]; } parameters_.resize(0); } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/NumTools.h000664 001750 001750 00000015563 12370705300 021560 0ustar00jdutheiljdutheil000000 000000 // // File: NumTools.h // Created by: Julien Dutheil // Created on: Mon Nov 10 12:06:55 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This file is part of the Bio++ project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _NUMTOOLS_H_ #define _NUMTOOLS_H_ #include "Function/Functions.h" namespace bpp { //Forward declaration: template class RowMatrix; /** * @brief Some utilitary function for numerical calculus. */ class NumTools { public: /** * @brief Get the magnitude of a value. * * This template function may work with any type for which the operators * < and - are defined. * * @param a The value for which the magnitude must be returned. * @return The magnitude of the value a. */ template static T abs(T a) { return a < 0 ? -a : a; } /** * @brief Get the sign of a value. * * This template function may work with any type for which the operators * < and == are defined. * * @param a The value for which the sign must be returned. * @return -1 if a < 0, 0 if a = 0, 1 else. */ template static T sign(T a) { return a < 0 ? -1 : (a == 0 ? 0 : 1); } /** * @brief Get the max between 2 values. * * This template function may work with any type for which the operator * > is defined. * * @param a, b The two values to compare. * @return a if a > b, b else. */ template static T max(T a, T b) { return a > b ? a : b; } /** * @brief Get the min between 2 values. * * This template function may work with any type for which the operator * < is defined. * * @param a, b The two values to compare. * @return a if a < b, b else. */ template static T min(T a, T b) { return a < b ? a : b; } /** * @brief Get the magnitude of a times the sign of b. * * @param a The value whose magnitude must be used. * @param b The value whose sign must be used. * @return abs(a) * sign(b). */ template static T sign(T a, T b) { return abs(a) * sign(b); } /** * @brief Get the square of a number. * * @param a The value. * @return @f$ a^2 @f$. */ template static T sqr(T a) { return a * a; } /** * @brief Compute the logarithm of a sum from the sum of logarithms. * * The following formula is used: * @f[ * \ln(x) + \ln\left(1+ \exp\left(\ln(y) - \ln(x)\right)\right) = \ln(x + y) * @f] * see http://bozeman.genome.washington.edu/compbio/mbt599_2006/hmm_scaling_revised.pdf * * @param lnx The value. * @param lny The power * @return @f$ ln(x+y) @f$. */ template static T logsum(T lnx, T lny) { return (lny < lnx) ? lnx + log(1. + exp(lny - lnx)) : lny + log(1. + exp(lnx - lny)); } /**************************************************************************/ template static void swap(T & a, T & b) { T swap = a; a = b; b = swap; } template static void shift(T & a, T & b, T c) { a = b; b = c; } template static void shift(T & a, T & b, T & c, T d) { a = b; b = c; c = d; } /**************************************************************************/ template static T fact(T n) { return (n == 0) ? 1 : n * fact(n - 1); } /**************************************************************************/ template static T logFact(T n) { return (n == 0) ? 0 : (log(n) + logFact(n - 1)); } /**************************************************************************/ /** * @brief Find one root of the given function. * * @param f The function to analyse. * @param param The name of the parameter to solve. * @param a Lower bound of initial interval. * @param b Upper bound of initial interval. * @param tolerance The final precision requested. * @return The value of the parameter for which the function is zero. * @throw Exception If something bad happened or if the initial interval do not contains a root. */ static double uniRoot(Function & f, const std::string & param, double a, double b, double tolerance) throw (Exception); /**************************************************************************/ /** * @brief Compute the Hessian matrix for a function at a given point. * * @f[ * H(f(\theta)) = \begin{pmatrix} * \frac{\partial^2 f(\theta)}{\partial \theta_1^2} & \frac{\partial^2 f(\theta)}{\partial \theta_1 \partial \theta_2} & \cdots & \frac{\partial^2 f(\theta)}{\partial \theta_1 \partial \theta_n}\\ * \frac{\partial^2 f(\theta)}{\partial \theta_2 \partial \theta_1} & \frac{\partial^2 f(\theta)}{\partial \theta_2^2} & \cdots & \frac{\partial^2 f(\theta)}{\partial \theta_2 \partial \theta_n}\\ * \vdots & \vdots & \ddots & \vdots \\ * \frac{\partial^2 f(\theta)}{\partial \theta_n \partial \theta_1} & \frac{\partial^2 f(\theta)}{\partial \theta_n \partial \theta_2} & \cdots & \frac{\partial^2 f(\theta)}{\partial \theta_n^2} * \end{pmatrix} * @f] * * @param function A function with second order derivatives. * @param parameters The set of parameters for which to compute the hessian matrix. * @return A matrix with size equal to the number of parameters. */ static RowMatrix* computeHessianMatrix(DerivableSecondOrder& function, const ParameterList & parameters); /**************************************************************************/ }; } //end of namespace bpp. #endif //_NUMTOOLS_H_ bpp-core-2.2.0/src/Bpp/Numeric/AutoParameter.h000664 001750 001750 00000010703 12370705300 022540 0ustar00jdutheiljdutheil000000 000000 // // File: AutoParameter.h // Created by: Julien Dutheil // Created on: Tue Nov 11 22:15:16 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _AUTOPARAMETER_H_ #define _AUTOPARAMETER_H_ #include "Parameter.h" //From Utils: #include "../Io/OutputStream.h" namespace bpp { /** * @brief The AutoParameter class. * * This class overides the setValue() method of class Parameter so that no * Exception is thrown. This allows to perform optimization under constraint. */ class AutoParameter: public Parameter { private: OutputStream* messageHandler_; public: /** * @brief Build a new AutoParameter. * * @param name The parameter name. * @param value The parameter value. * @param constraint An optional pointer toward a Constraint object. * @param attachConstraint Tell if the constraint must be attached to this parameter, or shared * between different objects. See Parameter. * @throw ConstraintException If the parameter value does not match the contraint. */ AutoParameter(const std::string& name = "", double value = 0, Constraint* constraint = 0, bool attachConstraint = false) throw (ConstraintException); /** * @brief Copy constructor. * * @param param The parameter to copy. */ AutoParameter(const Parameter& param); /** * @brief Copy constructor. * * @param param The parameter to copy. */ AutoParameter(const AutoParameter& param); /** * @brief Assignment operator. * * @param param The parameter to copy. */ AutoParameter& operator=(const AutoParameter& param); virtual ~AutoParameter() {} AutoParameter* clone() const { return new AutoParameter(* this); } public: /** * @brief Set the value of this parameter. * * This method is redefined so that no constraintException is thrown! * When a Constraint is match, we automatically apply a correct value instead. * This correct value is the nearest limit reached by the value, or a value next to * the limit if the limit is not reachable. * * This allow to perform optimization under constraint whith algorithms that are not * initially built for this. * * @param value the new parameter value. * @throw ConstraintException Never thrown! */ virtual void setValue(double value) throw (ConstraintException); public: //Specific method: /** * @brief Set the message handler for this AutoParameter. * * The message handler keeps all messages that the parameter may send. * The default handler is set to standard output, but you can pass any * ostream object (cerr, ofstream, etc.). * * A NULL pointer disable message output. * * @param mh The message handler to use. */ virtual void setMessageHandler(OutputStream* mh) { messageHandler_ = mh; } public: static std::string CONSTRAINTS_AUTO; static std::string CONSTRAINTS_IGNORE; static std::string CONSTRAINTS_KEEP; }; } //end of namespace bpp. #endif //_AUTOPARAMETER_H_ bpp-core-2.2.0/src/Bpp/Numeric/AdaptiveKernelDensityEstimation.h000664 001750 001750 00000011107 12370705300 026261 0ustar00jdutheiljdutheil000000 000000 // // File: AdaptiveKernelDensityEstimation.h // Created by: Julien Dutheil // Created on: Thu Nov 05 13:25:07 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This file is part of the Bio++ project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _ADAPTIVEKERNELDENSITYESTIMATION_H_ #define _ADAPTIVEKERNELDENSITYESTIMATION_H_ #include "Matrix/Matrix.h" namespace bpp { /** * @brief Density estimation using the adaptive kernel method. * * For now this implementation is quite restricted, more options may be implemented later... * * The source for this method can be found is the appendix of the following paper: * Ivan Kojadinovic, _Computational Statistics and Data Analaysis_ (2004), 46:269-294 * * @author Julien Dutheil */ class AdaptiveKernelDensityEstimation { private: RowMatrix x_; //The original sample size_t n_; size_t r_; RowMatrix covar_; //The covariance matrix, used for the linear transformation RowMatrix invSqrtCovar_; //The inverse of the square root of the covariance matrix, used for the linear transformation std::vector xMean_; double gamma_; //Tune the effect of the pilot density. double c1_; std::vector c2_; double h_; //The bandwidth. std::vector lambda_; //The local tuning coefficient of the bandwidth. std::vector pilot_; //The pilot density public: /** * @brief Build a new AdaptiveKernelDensityEstimation object. * @param x A mtrix contianing the sample point, one point per column. * The row of the matrix are the dimension of the sampled vectors, wich can be 1. * @param gamma Controls the influence of the pilot density. A value of 0 * maximizes the impact of the pilot density, and hence corresponds to the standard * Kernel Density Estimation method. A value in ]0,1] allows a local adjustement of * the bandwith. The 0.5 value is commonly used. */ AdaptiveKernelDensityEstimation(const Matrix& x, double gamma = 0.5): x_(x), n_(x.getNumberOfColumns()), r_(x.getNumberOfRows()), covar_(), invSqrtCovar_(), xMean_(), gamma_(gamma), c1_(0), c2_(x.getNumberOfColumns()), h_(0), lambda_(x.getNumberOfColumns()), pilot_(x.getNumberOfColumns()) { init_(); } virtual ~AdaptiveKernelDensityEstimation() {} public: /** * @return The value of the estimated density for point x. * @param x The point where to estimate the density. */ double kDensity(const std::vector& x); private: void init_(); void sampleMean_(const Matrix& x, std::vector& mean); /** * @brief The kernel function. * * For now a standard normal density is used, further options may be added later, * including the possibility to use your own function. * * @param x The point for which to compute the density, as a matrix with 1 column and r_ rows. * @return The value of the kernel function at the corresponding point. */ double kernel_(const Matrix& x); }; } //End of namespace bpp. #endif //_ADAPTIVEKERNELDENSITYESTIMATION_H_ bpp-core-2.2.0/src/Bpp/Numeric/ParameterExceptions.cpp000664 001750 001750 00000006201 12370705300 024302 0ustar00jdutheiljdutheil000000 000000 // // File: ParameterExceptions.cpp // Created by: Julien Dutheil // Created on: Mon Nov 3 18:05:36 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "ParameterExceptions.h" #include "Parameter.h" // From Utils: #include "../Text/TextTools.h" using namespace bpp; using namespace std; /******************************************************************************/ ParameterException::ParameterException(const std::string& text, const Parameter* param) : Exception("ParameterException: " + text + (param != 0 ? "(" + param -> getName() + ")" : string(""))), parameter_(param) {}; const Parameter* ParameterException::getParameter() const { return parameter_; } /******************************************************************************/ ConstraintException::ConstraintException(const std::string& text, const Parameter* param, double badValue) : ParameterException("ConstraintException: " + text + "(" + TextTools::toString(badValue) + ")" + (param->hasConstraint() ? param->getConstraint()->getDescription() : "no constraint"), param), badValue_(badValue) {}; double ConstraintException::getBadValue() const { return badValue_; } /******************************************************************************/ ParameterNotFoundException::ParameterNotFoundException(const string& text, const string& param) : Exception("ParameterNotFoundException: " + text + (!TextTools::isEmpty(param) ? "(" + param + ")" : string(""))), parameter_(param) {}; std::string ParameterNotFoundException::getParameter() const { return parameter_; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/AdaptiveKernelDensityEstimation.cpp000664 001750 001750 00000011534 12370705300 026620 0ustar00jdutheiljdutheil000000 000000 // // File: AdaptiveKernelDensityEstimation.cpp // Created by: Julien Dutheil // Created on: Thu Nov 05 13:25:07 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This file is part of the Bio++ project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "AdaptiveKernelDensityEstimation.h" #include "Matrix/MatrixTools.h" #include "NumConstants.h" using namespace bpp; using namespace std; void AdaptiveKernelDensityEstimation::init_() { //Compute the covariance matrix of the sample: MatrixTools::covar(x_, covar_); //Compute the mean vector sampleMean_(x_, xMean_); //Compute the inverse of the square root of the covariance matrix: MatrixTools::pow(covar_, -0.5, invSqrtCovar_); //Compute the bandwidth: h_ = std::pow(4. / ((2 * static_cast(r_) + 1.) * static_cast(n_)), 1. / (static_cast(r_) + 4.)); //Compute as much as we can in advance to simplify the density calculation: c1_ = 1. / (std::sqrt(MatrixTools::det(covar_)) * static_cast(n_) * std::pow(h_, static_cast(r_))); //Now compute the local tuning of the bandwidth. //First estimate the pilot density: vector xi(r_); LinearMatrix diff_xi(r_, 1); LinearMatrix std_xi(r_, 1); for (unsigned int i = 0; i < n_; i++) { //Get the current xi point to evaluate: for(unsigned int k = 0; k < r_; k++) xi[k] = x_(k, i); //Sum loop, over all xi's: double sum = 0; for (unsigned int j = 0; j < n_; j++) { for (unsigned int k = 0; k < r_; k++) diff_xi(k, 0) = xi[k] - x_(k, j); MatrixTools::mult(invSqrtCovar_, diff_xi, std_xi); MatrixTools::scale(std_xi, 1. / h_); sum += kernel_(std_xi); } pilot_[i] = c1_ * sum; } //Compute the tuning parameters: double g = 0; for (unsigned int i = 0; i < n_; i++) g += std::log(pilot_[i]); g = std::exp(g / static_cast(n_)); for (unsigned int i = 0; i < n_; i++) lambda_[i] = std::pow(g / pilot_[i], gamma_); //Compute as much as we can in advance to simplify the density calculation: for (unsigned int i = 0; i < n_; i++) c2_[i] = std::pow(lambda_[i], - static_cast(r_)); } void AdaptiveKernelDensityEstimation::sampleMean_(const Matrix& x, std::vector& mean) { size_t nc = x.getNumberOfColumns(); size_t nr = x.getNumberOfRows(); mean.resize(nr); for (size_t i = 0; i < nr; i++) { mean[i] = 0; for (size_t j = 0; j < nc; j++) mean[i] += x(i, j); mean[i] /= static_cast(nc); } } double AdaptiveKernelDensityEstimation::kernel_(const Matrix& x) { //x is supposed to have only one column and r_ rows. //We compute the scalar product of the column with itself: double scalar = 0; for (size_t i = 0; i < r_; i++) scalar += std::pow(x(i, 0), 2.); return std::pow(2. * NumConstants::PI(), -static_cast(r_) / 2.) * std::exp(-0.5 * scalar); } double AdaptiveKernelDensityEstimation::kDensity(const std::vector& x) { LinearMatrix diff_xi(r_, 1); LinearMatrix std_xi(r_, 1); //Sum loop, over all xi's: double sum = 0; for(unsigned int j = 0; j < n_; j++) { for(unsigned int k = 0; k < r_; k++) diff_xi(k, 0) = x[k] - x_(k, j); MatrixTools::mult(invSqrtCovar_, diff_xi, std_xi); MatrixTools::scale(std_xi, 1. / (h_ * lambda_[j])); sum += kernel_(std_xi) * c2_[j]; } return c1_ * sum; } bpp-core-2.2.0/src/Bpp/Numeric/Prob/BetaDiscreteDistribution.h000664 001750 001750 00000007307 12370705300 025635 0ustar00jdutheiljdutheil000000 000000 // // File: BetaDiscreteDistribution.h // Created by: Laurent Guéguen // Created on: jeudi 27 mai 2010, à 23h 34 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _BETADISCRETEDISTRIBUTION_H_ #define _BETADISCRETEDISTRIBUTION_H_ #include "AbstractDiscreteDistribution.h" #include "../Random/RandomTools.h" namespace bpp { /** * @brief Discretized Beta distribution with parameters alpha and * beta, on a given interval. On default, the interval is @f$ [0;1] * @f$, but it can be restricted. * * The minimum (resp maximum) value of this distribution is set to * 1e-12 (resp 1-1e-12) if alpha>1 (resp beta>1), otherwise it is 0 * (resp 1). * * The Parameters are: alpha and beta @f$ \in [0.0001;\infty[ @f$. * @author Laurent Guéguen */ class BetaDiscreteDistribution: public AbstractDiscreteDistribution { private: double alpha_, beta_; /* for computation economy */ double diffln_; public: /** * @brief Build a new discretized beta distribution. * * @param n the number of categories to use. * @param alpha The alpha parameter. * @param beta The beta parameter. * */ BetaDiscreteDistribution(size_t n, double alpha = 1, double beta = 1); BetaDiscreteDistribution(const BetaDiscreteDistribution&); BetaDiscreteDistribution& operator=(const BetaDiscreteDistribution&); BetaDiscreteDistribution* clone() const { return new BetaDiscreteDistribution(*this); } public: std::string getName() const { return "Beta";} void fireParameterChanged(const ParameterList & parameters); double randC() const throw (Exception) { double x= RandomTools::randBeta(getParameterValue("alpha"), getParameterValue("beta")); while (!intMinMax_.isCorrect(x)) x= RandomTools::randBeta(getParameterValue("alpha"), getParameterValue("beta")); return x; } double qProb(double x) const; double pProb(double x) const; double Expectation(double a) const; }; } //end of namespace bpp. #endif //_BETADISCRETEDISTRIBUTION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Prob/ConstantDistribution.cpp000664 001750 001750 00000007065 12370705300 025424 0ustar00jdutheiljdutheil000000 000000 // // File: ConstantDistribution.cpp // Created by: jdutheil // Created on: Fri Oct 24 08:48:03 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "ConstantDistribution.h" using namespace bpp; #include using namespace std; /******************************************************************************/ ConstantDistribution::ConstantDistribution(double value): AbstractParameterAliasable("Constant."), AbstractDiscreteDistribution(1, "Constant."), value_(value) { addParameter_(new Parameter("Constant.value", value)); distribution_[value_] = 1; //One single class with probability 1. } ConstantDistribution::ConstantDistribution(const ConstantDistribution& cd) : AbstractParameterAliasable(cd), AbstractDiscreteDistribution(cd), value_(cd.value_) {} ConstantDistribution& ConstantDistribution::operator=(const ConstantDistribution& cd) { AbstractParameterAliasable::operator=(cd); AbstractDiscreteDistribution::operator=(cd); value_=cd.value_; return *this; } /******************************************************************************/ void ConstantDistribution::fireParameterChanged(const ParameterList& parameters) { AbstractDiscreteDistribution::fireParameterChanged(parameters); value_=getParameterValue("value"); distribution_.clear(); distribution_[value_] = 1; //One single class of rate 1 with probability 1. } /******************************************************************************/ void ConstantDistribution::restrictToConstraint(const Constraint& c) { if (getNumberOfParameters()==0) return; const IntervalConstraint* pi=dynamic_cast(&c); if (!pi) throw Exception("ConstantDistribution::restrictToConstraint: Non-interval exception"); if (! pi->isCorrect(getParameterValue("value"))) throw ConstraintException("Impossible to restrict to Constraint", &getParameter_("value"), getParameterValue("value")); AbstractDiscreteDistribution::restrictToConstraint(c); Parameter& p=getParameter_("value"); p.setConstraint(intMinMax_.clone(),true); } bpp-core-2.2.0/src/Bpp/Numeric/Prob/Simplex.h000664 001750 001750 00000012740 12370705300 022315 0ustar00jdutheiljdutheil000000 000000 // // File: Simplex.h // Created by: Laurent Guéguen // Created on: mardi 31 mai 2011, à 11h 02 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _SIMPLEX_H_ #define _SIMPLEX_H_ // From the STL: #include #include "../AbstractParameterAliasable.h" namespace bpp { /** * @brief A Simplex object, used to define sets of probabilities that * sum 1. * * The probabilities are denoted @f$p_i@f$ for @f$i \in <1,n>@f$. * * If they are parametrized, the parameters are called \c "theta1", * ..., \c "theta(n-1)". * * Two ways of parametrization are available: * * Global ratio: * * @f$\forall i@f$. * * @f$p_{i+1}=\theta'_{i_c}....\theta'_{i_1} @f$ * */ class Simplex : public AbstractParameterAliasable { private: /** * @brief The dimension+1 of the space simplex (ie the number of probabilities). * */ size_t dim_; /** * @brief the method of parametrization. * * 0: No parametrization * 1: Global ratio * 2: Local ratio * 3: Binary */ unsigned short method_; std::vector vProb_; /** * @brief just used with local ratio (method 2) */ std::vector valpha_; public: /** * @brief Builds a new Simplex object from a number of * probabilities. They are initialized equal. * * @param dim The number of probabilities. * @param method tells the method of parametrization (default 0) * 0: No parametrization * 1: Global ratio * 2: Local ratio * 3: Binary * @param allowNull if null probabilites are allowed (default: false) * @param name The name passed to AbstractParameterAliasable constructor. * */ Simplex(size_t dim, unsigned short method = 0, bool allowNull = false, const std::string& name = "Simplex."); /** * @brief Builds a new Simplex object from a vector of probabilities * * @param probas The vector of probabilities. * @param method tells the method of parametrization (default 0) * 0: No parametrization * 1: Global ratio * 2: Local ratio * 3: Binary * @param allowNull if null probabilites are allowed (default: false) * @param name The name passed to AbstractParameterAliasable constructor. * */ Simplex(const std::vector& probas, unsigned short method = 0, bool allowNull = false, const std::string& name = "Simplex."); virtual ~Simplex() {} Simplex* clone() const { return new Simplex(*this); } public: void fireParameterChanged(const ParameterList& parameters); size_t dimension() const { return dim_; } void setFrequencies(const std::vector&); const std::vector& getFrequencies() const { return vProb_;} std::vector& getFrequencies() { return vProb_;} double prob(size_t i) const { return vProb_[i]; } unsigned short getMethod() const { return method_; } }; } // end of namespace bpp. #endif // _SIMPLEDISCRETEDISTRIBUTION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Prob/AbstractDiscreteDistribution.h000664 001750 001750 00000015120 12370705300 026515 0ustar00jdutheiljdutheil000000 000000 // // File: AbstractDiscreteDistribution.h // Created by: Julien Dutheil // Created on: ? // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _ABSTRACTDISCRETEDISTRIBUTION_H_ #define _ABSTRACTDISCRETEDISTRIBUTION_H_ #include "DiscreteDistribution.h" #include "../Constraints.h" #include "../AbstractParameterAliasable.h" #include namespace bpp { /** * @brief Partial implementation of the DiscreteDistribution interface. * * This class uses a map to store the cateogry values as keys and probabilities as values. * It uses its own comparator class to deal with double precision. * By default, category values that differ less than 10E-9 will be considered identical. */ class AbstractDiscreteDistribution : public virtual DiscreteDistribution, public virtual AbstractParameterAliasable { public: /** * @brief Comparator class for AbstractDiscreteDistribution. */ class Order { private: double precision_; public: Order(double prec=NumConstants::TINY()): precision_(prec) {} Order(const Order& ord) : precision_(ord.precision_) {} Order& operator=(const Order& ord) { precision_=ord.precision_; return *this; } double precision() const { return precision_; } void setPrecision(double prec) { precision_=prec; } bool operator() (double l1, double l2) const { return (l1 < l2 - precision_); } }; protected: /* * The number of categories */ size_t numberOfCategories_; /** * These fields must be initialized in the constructor of the derived classes. */ std::map distribution_; std::vector bounds_; /** * @brief the interval where the distribution is defined/restricted. * */ IntervalConstraint intMinMax_; /** * Tells if the values in the classes is associated to the median or not (default: false) * */ bool median_; public: AbstractDiscreteDistribution(size_t nbClasses, const std::string& prefix = ""); /** * With additional precision value to discriminate categories (default 1e-12) * */ AbstractDiscreteDistribution(size_t nbClasses, double precision, const std::string& prefix = ""); AbstractDiscreteDistribution(const AbstractDiscreteDistribution& adde); AbstractDiscreteDistribution& operator=(const AbstractDiscreteDistribution& adde); virtual ~AbstractDiscreteDistribution() {} public: /** * @name The DiscreteDistribution interface. * * @{ */ size_t getNumberOfCategories() const; void setNumberOfCategories(size_t nbClasses); double getCategory(size_t categoryIndex) const; double getProbability(size_t categoryIndex) const; double getProbability(double category) const; Vdouble getCategories() const; Vdouble getProbabilities() const; double getValueCategory(double value) const; void set(double category, double probability); void add(double category, double probability); double getInfCumulativeProbability(double category) const; double getIInfCumulativeProbability(double category) const; double getSupCumulativeProbability(double category) const; double getSSupCumulativeProbability(double category) const; double rand() const; double randC() const throw (Exception) { throw Exception("AbstractDiscreteDistribution::randC. No continuous version available for this distribution."); } /* *@return value of the internal bound * */ double getBound(size_t i) const throw (IndexOutOfBoundsException) { if (i >= numberOfCategories_ - 1) throw IndexOutOfBoundsException("AbstractDiscreteDistribution::getBound(i)", i , 0, numberOfCategories_-1); return bounds_[i]; } /* *@brief Information about the range of the distribution * */ double getLowerBound() const { return intMinMax_.getLowerBound(); } double getUpperBound() const { return intMinMax_.getUpperBound(); } bool strictLowerBound() const { return intMinMax_.strictLowerBound(); } bool strictUpperBound() const { return intMinMax_.strictUpperBound(); } Vdouble getBounds() const; void print(OutputStream& out) const; double precision() const { return distribution_.key_comp().precision();} void setMedian(bool median) { if (median_ != median) { median_ = median; discretize(); } } virtual void discretize(); /** @} */ /** * @brief Restricts the distribution to the domain where the * constraint is respected, in addition of other predefined * constraints. * * @param c The Constraint to respect. * */ virtual void restrictToConstraint(const Constraint& c); }; } //end of namespace bpp. #endif //_ABSTRACTDISCRETEDISTRIBUTION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Prob/UniformDiscreteDistribution.cpp000664 001750 001750 00000005654 12370705300 026737 0ustar00jdutheiljdutheil000000 000000 // // File: UniformDiscreteDistribution.cpp // Created by: Laurent Guéguen // Created on: April 2010 // /* Copyright or © or Copr. CNRS, (2010) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "UniformDiscreteDistribution.h" #include "../Random/RandomTools.h" #include "../../Utils/MapTools.h" using namespace bpp; // From the STL: #include using namespace std; /** Constructor: **************************************************************/ UniformDiscreteDistribution::UniformDiscreteDistribution(unsigned int n, double min, double max) : AbstractParameterAliasable("Uniform."), AbstractDiscreteDistribution(n,"Uniform."), min_((min=tp_) return 1.; else return (1. - exp(-lambda_ * x))/cond_; } double qProb(double x) const { if (x==1) return tp_; else return -log(1. - cond_*x) / lambda_; } double Expectation(double a) const { if (agetNamespace()) { // We first change the namespace of the nested distribution: dist_->setNamespace("Invariant." + nestedPrefix_); addParameters_(dist_->getIndependentParameters()); addParameter_(new Parameter("Invariant.p", p, &Parameter::PROP_CONSTRAINT_IN)); updateDistribution(); } /******************************************************************************/ void InvariantMixedDiscreteDistribution::fireParameterChanged(const ParameterList& parameters) { AbstractDiscreteDistribution::fireParameterChanged(parameters); p_ = getParameterValue("p"); dist_->matchParametersValues(parameters); updateDistribution(); } /******************************************************************************/ void InvariantMixedDiscreteDistribution::updateDistribution() { distribution_.clear(); bounds_.clear(); size_t distNCat = dist_->getNumberOfCategories(); vector probs = dist_->getProbabilities(); vector cats = dist_->getCategories(); distribution_[invariant_] = p_; for (size_t i = 0; i < distNCat; i++) { if (cats[i] == invariant_) distribution_[invariant_] += (1. - p_) * probs[i]; else distribution_[cats[i]] = (1. - p_) * probs[i]; } intMinMax_.setLowerBound(dist_->getLowerBound(), !dist_->strictLowerBound()); intMinMax_.setUpperBound(dist_->getUpperBound(), !dist_->strictUpperBound()); if (invariant_ <= intMinMax_.getLowerBound()) intMinMax_.setLowerBound(invariant_, true); if (invariant_ >= intMinMax_.getUpperBound()) intMinMax_.setUpperBound(invariant_, true); numberOfCategories_ = distribution_.size(); // bounds_ // if invariant_ is between 2 values of dist_, bounds_ are set in the // middle of the 3 values bool nv = true; double a = dist_->getCategory(0), b; if (nv && (invariant_ < a)) { bounds_.push_back((a + invariant_) / 2); nv = false; } for (size_t i = 1; i < distNCat; i++) { b = dist_->getCategory(i); if (nv && (invariant_ < b)) { bounds_.push_back((a + invariant_) / 2); bounds_.push_back((invariant_ + b) / 2); nv = false; } else bounds_.push_back(dist_->getBound(i - 1)); a = b; } if (nv) bounds_.push_back((a + invariant_) / 2); } /******************************************************************************/ void InvariantMixedDiscreteDistribution::setNamespace(const string& prefix) { AbstractDiscreteDistribution::setNamespace(prefix); // We also need to update the namespace of the nested distribution: dist_->setNamespace(prefix + nestedPrefix_); } /******************************************************************************/ void InvariantMixedDiscreteDistribution::restrictToConstraint(const Constraint& c) { if (!c.isCorrect(invariant_)) throw ConstraintException("Impossible to restrict to Constraint", &getParameter_("p"), invariant_); dist_->restrictToConstraint(c); updateDistribution(); } bpp-core-2.2.0/src/Bpp/Numeric/Prob/GaussianDiscreteDistribution.cpp000664 001750 001750 00000007172 12370705300 027067 0ustar00jdutheiljdutheil000000 000000 // // File: GaussianDiscreteDistribution.cpp // Created by: Laurent Guéguen // Created on: April 2010 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "GaussianDiscreteDistribution.h" #include "../Random/RandomTools.h" #include "../NumConstants.h" #include "../../Utils/MapTools.h" using namespace bpp; // From the STL: #include using namespace std; /** Constructor: **************************************************************/ GaussianDiscreteDistribution::GaussianDiscreteDistribution(size_t n, double mu, double sigma) : AbstractParameterAliasable("Gaussian."), AbstractDiscreteDistribution(n,"Gaussian."), mu_(mu), sigma_(sigma) { addParameter_(new Parameter("Gaussian.mu", mu)); addParameter_(new Parameter("Gaussian.sigma", sigma, &Parameter::R_PLUS_STAR)); discretize(); } GaussianDiscreteDistribution::GaussianDiscreteDistribution(const GaussianDiscreteDistribution& gdd) : AbstractParameterAliasable(gdd), AbstractDiscreteDistribution(gdd), mu_(gdd.mu_), sigma_(gdd.sigma_) { } GaussianDiscreteDistribution& GaussianDiscreteDistribution::operator=(const GaussianDiscreteDistribution& gdd) { AbstractParameterAliasable::operator=(gdd); AbstractDiscreteDistribution::operator=(gdd); mu_=gdd.mu_; sigma_=gdd.sigma_; return *this; } GaussianDiscreteDistribution::~GaussianDiscreteDistribution() {} /******************************************************************************/ void GaussianDiscreteDistribution::fireParameterChanged(const ParameterList& parameters) { AbstractDiscreteDistribution::fireParameterChanged(parameters); mu_ = getParameterValue("mu"); sigma_ = getParameterValue("sigma"); discretize(); } /******************************************************************************/ double GaussianDiscreteDistribution::qProb(double x) const { return RandomTools::qNorm(x, mu_, sigma_); } double GaussianDiscreteDistribution::pProb(double x) const { return RandomTools::pNorm(x, mu_, sigma_); } double GaussianDiscreteDistribution::Expectation(double a) const { return -sigma_/sqrt(2*M_PI)*exp(-pow((a-mu_)/sigma_,2)/2) +mu_*RandomTools::pNorm(a,mu_,sigma_); } bpp-core-2.2.0/src/Bpp/Numeric/Prob/MixtureOfDiscreteDistributions.h000664 001750 001750 00000012236 12370705300 027064 0ustar00jdutheiljdutheil000000 000000 // // File: MixtureOfDiscreteDistributions.h // Created by: Laurent Guéguen // Created on: mercredi 9 juin 2010, à 22h 44 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _MIXTUREOFDISCRETEDISTRIBUTIONS_H_ #define _MIXTUREOFDISCRETEDISTRIBUTIONS_H_ #include "AbstractDiscreteDistribution.h" namespace bpp { /** * @brief A Discrete distribution object defined by a vector of * Discrete Distributions and a set of probabilities for these * Discrete Distributions. * * The non-null values of the MixtureOfDiscreteDistributions are all * the non-null values of the Discrete Distributions, with * probabilities equal to their probabilities in each Discrete * Distribution multiplied by the specific probability of this * Distribution. * * Parameters: * * For the probabilities: they are called \c "theta1",... and defined * as @f$ \theta_{i \in 1..\textrm{size-1}} @f$ such that probability * of value @f$i @f$ is @f$ (1-\theta_1).(1-\theta_2)...\theta_{i} @f$ * * For the values: they are the parameters of the Discrete * Distributions, prefixed by the index in the vector of the Discrete * Distributions. * */ class MixtureOfDiscreteDistributions : public AbstractDiscreteDistribution { protected: std::vector vdd_; std::vector probas_; std::vector vNestedPrefix_; public: /** * @brief Builds a new MixtureOfDiscreteDistributions object from a * vector of Discrete Distributions and a vector of probabilities. * The Discrete Distributions are cloned in the constructor to * become attributes. * * @param distributions The vector of pointers to Discrete * Distributions. * @param probas The vector of probabilities. * */ MixtureOfDiscreteDistributions(const std::vector& distributions, const std::vector& probas); ~MixtureOfDiscreteDistributions(); MixtureOfDiscreteDistributions(const MixtureOfDiscreteDistributions& mdd); MixtureOfDiscreteDistributions& operator=(const MixtureOfDiscreteDistributions& mdd); #if defined(NO_VIRTUAL_COV) Clonable* clone() const { return new MixtureOfDiscreteDistributions(*this); } #else MixtureOfDiscreteDistributions* clone() const { return new MixtureOfDiscreteDistributions(*this); } #endif public: std::string getName() const {return "Mixture"; } /** * @brief Returns the number of discrete distributions in the * mixture. * */ size_t getNumberOfDistributions() const {return vdd_.size(); } /** * @brief Returns a pointer to the n-th discrete distribution in the mixture. * * @param n tne number of the distribution in the mixture; */ const DiscreteDistribution* getNDistribution(size_t n) const { return vdd_[n]; } /** * @brief Returns the probability of the n-th discrete distribution in the mixture. * * @param n the number of the distribution in the mixture; */ double getNProbability(size_t n) const { return probas_[n]; } /** * @brief sets the number of categories of EACH submodel to * nbClasses, so the number of categories of the mixture is the sum * of all these numbers. * */ void setNumberOfCategories(size_t nbClasses); void fireParameterChanged(const ParameterList& parameters); double qProb(double x) const; double pProb(double x) const; double Expectation(double a) const; void setMedian(bool median); void restrictToConstraint(const Constraint& c); void discretize(); void setNamespace(const std::string& prefix); protected: void updateDistribution(); }; } // end of namespace bpp. #endif // _MIXTUREOFDISCRETEDISTRIBUTIONS_H__ bpp-core-2.2.0/src/Bpp/Numeric/Prob/MixtureOfDiscreteDistributions.cpp000664 001750 001750 00000021003 12370705300 027407 0ustar00jdutheiljdutheil000000 000000 // // File: MixtureOfDiscreteDistributions // Created by: Laurent Guéguen // Created on: mercredi 9 juin 2010, à 23h 09 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "MixtureOfDiscreteDistributions.h" #include "../NumConstants.h" #include "../../Utils/MapTools.h" #include "../../Text/TextTools.h" using namespace bpp; using namespace std; MixtureOfDiscreteDistributions::MixtureOfDiscreteDistributions(const vector& distributions, const vector& probas ) : AbstractParameterAliasable("Mixture."), AbstractDiscreteDistribution(1, "Mixture."), vdd_(), probas_(), vNestedPrefix_() { if (distributions.size() != probas.size()) { throw Exception("MixtureOfDiscreteDistributions. Distributions and probabilities vectors must have the same size (" + TextTools::toString(distributions.size()) + " != " + TextTools::toString(probas.size()) + ")."); } size_t size = distributions.size(); for (size_t i = 0; i < size; i++) { if (distributions[i] == 0) throw Exception("MixtureOfDiscreteDistributions. Null DiscreteDistribution* in argument vector at index " + TextTools::toString(i)); } for (size_t i = 0; i < size; i++) { probas_.push_back(probas[i]); } double sum = VectorTools::sum(probas); if (fabs(1. - sum) > precision()) throw Exception("MixtureOfDiscreteDistributions. Probabilities must equal 1 (sum =" + TextTools::toString(sum) + ")."); double y = 1; for (size_t i = 0; i < size - 1; i++) { addParameter_(new Parameter("Mixture.theta" + TextTools::toString(i + 1), probas[i] / y, &Parameter::PROP_CONSTRAINT_IN)); y -= probas[i]; } for (size_t i = 0; i < size; i++) { vdd_.push_back(distributions[i]->clone()); } // Parameters for (size_t i = 0; i < size; i++) { vNestedPrefix_.push_back(TextTools::toString(i + 1) + "_" + distributions[i]->getNamespace()); } for (size_t i = 0; i < size; i++) { vdd_[i]->setNamespace("Mixture." + vNestedPrefix_[i]); } for (size_t i = 0; i < size; i++) { addParameters_(vdd_[i]->getParameters()); } updateDistribution(); } MixtureOfDiscreteDistributions::MixtureOfDiscreteDistributions(const MixtureOfDiscreteDistributions& mdd) : AbstractParameterAliasable(mdd), AbstractDiscreteDistribution(mdd), vdd_(), probas_(), vNestedPrefix_() { for (size_t i = 0; i < mdd.vdd_.size(); i++) { probas_.push_back(mdd.probas_[i]); vdd_.push_back(mdd.vdd_[i]->clone()); vNestedPrefix_.push_back(mdd.vNestedPrefix_[i]); } } MixtureOfDiscreteDistributions& MixtureOfDiscreteDistributions::operator=(const MixtureOfDiscreteDistributions& mdd) { AbstractParameterAliasable::operator=(mdd); AbstractDiscreteDistribution::operator=(mdd); vdd_.clear(); probas_.clear(); vNestedPrefix_.clear(); for (size_t i = 0; i < mdd.vdd_.size(); i++) { probas_.push_back(mdd.probas_[i]); vdd_.push_back(mdd.vdd_[i]->clone()); vNestedPrefix_.push_back(mdd.vNestedPrefix_[i]); } return *this; } MixtureOfDiscreteDistributions::~MixtureOfDiscreteDistributions() { for (size_t i = 0; i < vdd_.size(); i++) { delete vdd_[i]; } vdd_.clear(); } void MixtureOfDiscreteDistributions::setNumberOfCategories(size_t nbClasses) { for (size_t i = 0; i < vdd_.size(); i++) { vdd_[i]->setNumberOfCategories(nbClasses); } updateDistribution(); } void MixtureOfDiscreteDistributions::fireParameterChanged(const ParameterList& parameters) { AbstractDiscreteDistribution::fireParameterChanged(parameters); size_t size = vdd_.size(); double x = 1.0; for (size_t i = 0; i < size - 1; i++) { probas_[i] = getParameterValue("theta" + TextTools::toString(i + 1)) * x; x *= 1 - getParameterValue("theta" + TextTools::toString(i + 1)); } probas_[size - 1] = x; for (size_t i = 0; i < size; i++) { vdd_[i]->matchParametersValues(parameters); } updateDistribution(); } void MixtureOfDiscreteDistributions::updateDistribution() { size_t size = vdd_.size(); distribution_.clear(); // calculation of distribution for (size_t i = 0; i < size; i++) { vector values = vdd_[i]->getCategories(); for (size_t j = 0; j < values.size(); j++) { distribution_[values[j]] = 0; } } for (size_t i = 0; i < size; i++) { vector values = vdd_[i]->getCategories(); vector probas2 = vdd_[i]->getProbabilities(); for (size_t j = 0; j < values.size(); j++) { distribution_[values[j]] += probas2[j] * probas_[i]; } } numberOfCategories_ = distribution_.size(); // intMinMax_ double uB, lB; uB = -NumConstants::VERY_BIG(); lB = NumConstants::VERY_BIG(); bool suB = true, slB = true; for (size_t i = 0; i < size; i++) { if (vdd_[i]->getLowerBound() <= lB) { lB = vdd_[i]->getLowerBound(); slB = vdd_[i]->strictLowerBound(); } if (vdd_[i]->getUpperBound() >= uB) { uB = vdd_[i]->getUpperBound(); suB = vdd_[i]->strictUpperBound(); } } intMinMax_.setLowerBound(lB, slB); intMinMax_.setUpperBound(uB, suB); // Compute midpoint bounds_: vector values = MapTools::getKeys(distribution_); bounds_.resize(numberOfCategories_ - 1); // Fill from 0 to numberOfCategories_-1 with midpoints: for (size_t i = 0; i < numberOfCategories_ - 1; i++) { bounds_[i] = (values[i] + values[i + 1]) / 2.; } } void MixtureOfDiscreteDistributions::setMedian(bool median) { if (median_ != median) { median_ = median; for (size_t i = 0; i < vdd_.size(); i++) { vdd_[i]->setMedian(median); } updateDistribution(); } } void MixtureOfDiscreteDistributions::discretize() { for (size_t i = 0; i < vdd_.size(); i++) { vdd_[i]->discretize(); } updateDistribution(); } double MixtureOfDiscreteDistributions::pProb(double x) const { double s = 0; for (size_t i = 0; i < vdd_.size(); i++) { s += probas_[i] * vdd_[i]->pProb(x); } return s; } double MixtureOfDiscreteDistributions::qProb(double x) const { throw Exception("MixtureOfDiscreteDistributions::qProb to difficult to compute: not implemented"); return 0; } double MixtureOfDiscreteDistributions::Expectation(double a) const { double s = 0; for (size_t i = 0; i < vdd_.size(); i++) { s += probas_[i] * vdd_[i]->Expectation(a); } return s; } void MixtureOfDiscreteDistributions::restrictToConstraint(const Constraint& c) { for (size_t i = 0; i < vdd_.size(); i++) { vdd_[i]->restrictToConstraint(c); } updateDistribution(); } /******************************************************************************/ void MixtureOfDiscreteDistributions::setNamespace(const string& prefix) { AbstractDiscreteDistribution::setNamespace(prefix); // We also need to update the namespace of the nested distributions: for (size_t i = 0; i < vdd_.size(); i++) { vdd_[i]->setNamespace(prefix + vNestedPrefix_[i]); } } bpp-core-2.2.0/src/Bpp/Numeric/Prob/UniformDiscreteDistribution.h000664 001750 001750 00000007030 12370705300 026372 0ustar00jdutheiljdutheil000000 000000 // // File: UniformDiscreteDistribution.h // Created by: Laurent Guéguen // Created on: April 2010 // /* Copyright or © or Copr. CNRS, (2010) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _UNIFORMDISCRETEDISTRIBUTION_H_ #define _UNIFORMDISCRETEDISTRIBUTION_H_ #include "AbstractDiscreteDistribution.h" #include "../Constraints.h" #include "../Random/RandomTools.h" namespace bpp { /** * @brief Discretized Uniform distribution. * All categories are equidistributed all along a given interval. * * @author Laurent Gueguen */ class UniformDiscreteDistribution: public AbstractDiscreteDistribution { private: double min_; double max_; public: /** * @brief Build a new discretized uniform distribution. * @param n the number of categories to use. * @param min The minimun value (default 0) * @param max The maximum value (default 1) */ UniformDiscreteDistribution(unsigned int n, double min = 0., double max = 1.); UniformDiscreteDistribution(const UniformDiscreteDistribution&); UniformDiscreteDistribution& operator=(const UniformDiscreteDistribution&); virtual ~UniformDiscreteDistribution(); UniformDiscreteDistribution* clone() const { return new UniformDiscreteDistribution(*this); } public: std::string getName() const {return("Uniform");} void fireParameterChanged(const ParameterList & parameters); double randC() const throw (Exception) { double x= RandomTools::giveRandomNumberBetweenZeroAndEntry(max_-min_)+min_; while (!intMinMax_.isCorrect(x)) x= RandomTools::giveRandomNumberBetweenZeroAndEntry(max_-min_)+min_; return x; } double qProb(double x) const { return min_+x*(max_-min_); } double pProb(double x) const { return (x<=min_)?0:(x-min_)/(max_-min_); } double Expectation(double a) const { return (a<=min_)?0:((a>=max_)?(max_+min_)/2:(a*a-min_*min_)/(max_-min_)/2); } }; } //end of namespace bpp. #endif //_UNIFORMDISCRETEDISTRIBUTION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Prob/ConstantDistribution.h000664 001750 001750 00000006303 12370705300 025063 0ustar00jdutheiljdutheil000000 000000 // // File: ConstantDistribution.h // Created by: jdutheil // Created on: Fri Oct 24 08:48:03 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _CONSTANTDISTRIBUTION_H_ #define _CONSTANTDISTRIBUTION_H_ #include "AbstractDiscreteDistribution.h" namespace bpp { /** * @brief Constant discrete distribution. * * Only one category with probability 1.0. */ class ConstantDistribution : public AbstractDiscreteDistribution { private: double value_; public: /** * @brief Builds a new ConstantDistribution object from a * value * * @param value The value of the distribution. * */ ConstantDistribution(double value); ConstantDistribution(const ConstantDistribution&); ConstantDistribution& operator=(const ConstantDistribution&); virtual ~ConstantDistribution() {} ConstantDistribution* clone() const { return new ConstantDistribution(*this); } public: void fireParameterChanged(const ParameterList& parameters); double randC() const throw (Exception) { return value_; } std::string getName() const { return("Constant"); } double getLowerBound() const { return value_; } double getUpperBound() const { return value_; } double qProb(double x) const { return (x >= 1) ? value_ : -NumConstants::VERY_BIG(); } double pProb(double x) const { return x < value_ ? 0 : 1; } double Expectation(double a) const { return a < value_ ? 0 : 1; } void restrictToConstraint(const Constraint& c); void discretize() {} }; } //end of namespace bpp. #endif //_CONSTANTDISTRIBUTION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Prob/DiscreteDistribution.h000664 001750 001750 00000022666 12370705300 025046 0ustar00jdutheiljdutheil000000 000000 // // File: DiscreteDistribution.h // Created by: Julien Dutheil // Created on: ? // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _DISCRETEDISTRIBUTION_H_ #define _DISCRETEDISTRIBUTION_H_ #include "../VectorTools.h" #include "../ParameterAliasable.h" #include "../NumConstants.h" #include "../../Exceptions.h" #include "../../Io/OutputStream.h" namespace bpp { /** * @brief Interface for discrete distribution objects. * * A discrete distribution usually contains a finite set of * categories and a probability associated to each. * * Each category (or class) is defined by two bounds, and sometimes by * a mean or a median value. * * A discrete distribution may contain one or several parameters. * The probabilities associated to each class usually depends on * the parameter values. * In some cases, the number and/or bounds of the classes may also * depend on the parameters values, depending on the kind of * discretization used. */ class DiscreteDistribution: public virtual ParameterAliasable { public: DiscreteDistribution() {} virtual ~DiscreteDistribution() {} #ifndef NO_VIRTUAL_COV DiscreteDistribution* clone() const = 0; #endif public: /** * @brief Get the name of the distribution. * * @return The name of this distribution. */ virtual std::string getName() const = 0; /** * @return The number of categories. */ virtual size_t getNumberOfCategories() const = 0; /** * @brief sets the number of categories and discretizes if there * is a change in this number. */ virtual void setNumberOfCategories(size_t nbClasses) = 0; /** * @param value * @return The value of the category the value is in. Throws a * OutOfRangeException if the value is off the domain of the * DiscreteDistribution. */ virtual double getValueCategory(double value) const = 0 ; /** * @param categoryIndex Class index. * @return The value associated to a given class. */ virtual double getCategory(size_t categoryIndex) const = 0; /** * @param categoryIndex Class index. * @return The probability associated to a given class. */ virtual double getProbability(size_t categoryIndex) const = 0; /** * @param category The value associated to the class. * @return The probability associated to a given class. */ virtual double getProbability(double category) const = 0; /** * @return A vector with all classes values. */ virtual Vdouble getCategories() const = 0; /** * @return A vector with all probabilities. */ virtual Vdouble getProbabilities() const = 0; /** * @brief Set the probability associated to a class. * * If the category does not exist, a new category is created * with the corresponding probability. * If the category already exist, its probability is set to 'probability'. * The sum of all probabilities is not checked. * * @param category The class value. * @param probability The class probability. */ virtual void set(double category, double probability) = 0; /** * @brief Modify the probability associated to a class. * * If the category does not exist, a new category is created * with the corresponding probability. * if the category exists, add 'probability' to the existing probability. * The sum of all probabilities is not checked. * * @param category The class value. * @param probability The class probability. */ virtual void add(double category, double probability) = 0; /** * @return \f$Pr(x < \mbox{category})\f$. * @param category The class value. */ virtual double getInfCumulativeProbability(double category) const = 0; /** * @return \f$Pr(x \leq \mbox{category})\f$. * @param category The class value. */ virtual double getIInfCumulativeProbability(double category) const = 0; /** * @return \f$Pr(x > \mbox{category})\f$. * @param category The class value. */ virtual double getSupCumulativeProbability(double category) const = 0; /** * @return \f$Pr(x \geq \mbox{category})\f$. * @param category The class value. */ virtual double getSSupCumulativeProbability(double category) const = 0; /** * @brief Draw a random number from this distribution. * * This number will be one of the class values, drawn according * to the class probabilities. * * @return A random number according to this distribution. */ virtual double rand() const = 0; /** * @brief Draw a random number from the continuous version of this distribution, if it exists. * * Uses the continuous version of this distribution to draw a random number. * * @return A random number according to this distribution. * @throw Exception If there is no continuous version of this distribution. */ virtual double randC() const throw (Exception) = 0; /** * @brief Return the quantile of the continuous version of the * distribution, ie y such that @f$ Prob(X namespace bpp { /** * @brief A Discrete distribution object, where some specific * probabilities are assigned to a finite set of values. * * Optional parameters: * * For the probabilities: they are called \c "theta1",... and defined * as @f$ \theta_{i \in 1..\textrm{size-1}} @f$ such that probability of value @f$i @f$ is @f$ (1-\theta_1).(1-\theta_2)...\theta_{i} @f$ * * For the values: they are called \c "V1", \c "V2" ... * */ class SimpleDiscreteDistribution: public AbstractDiscreteDistribution { private: std::map > givenRanges_; public: /** * @brief Builds a new SimpleDiscreteDistribution object from a * map object. With this constructor, the * probabilities are fixed (ie no parameters). * * Keys are taken to be interval values, and map values to be the corresponding probabilities. * * @param distribution The map object to use. * @param precision to discriminate the categories * @param fixed tells if there are parameters (default false means there are parameters). */ SimpleDiscreteDistribution(const std::map& distribution, double precision=NumConstants::TINY(), bool fixed=false); /** * @brief Builds a new SimpleDiscreteDistribution object from a * vector of values and a vector of probabilities * * @param values The vector of values. * @param probas The vector of probabilities. * @param prec precision used to discriminate the categories * @param fixed tells if there are parameters (default false means there are parameters). * */ SimpleDiscreteDistribution(const std::vector& values, const std::vector& probas, double prec=NumConstants::TINY(), bool fixed=false); /** * @brief Builds a new SimpleDiscreteDistribution object from a * vector of values, a map of ranges and a vector of probabilities * * @param values The vector of values. * @param ranges The map of ranges. Each key is the index of the * parameter in the given vector of values, and the * associated value is a vector of two doubles, for the min * and the max of the range. * @param probas The vector of probabilities. * @param prec precision to discriminate the categories * @param fixed tells if there are parameters (default false means there are parameters). * */ SimpleDiscreteDistribution(const std::vector& values, const std::map >& ranges, const std::vector& probas, double prec=NumConstants::TINY(), bool fixed=false); virtual ~SimpleDiscreteDistribution() {} SimpleDiscreteDistribution(const SimpleDiscreteDistribution&); SimpleDiscreteDistribution& operator=(const SimpleDiscreteDistribution&); SimpleDiscreteDistribution * clone() const { return new SimpleDiscreteDistribution(*this); } public: /* *@brief Returns the map of the given ranges for the values. * */ const std::map > getRanges() const { return givenRanges_;} std::string getName() const {return("Simple");} void discretize(); void fireParameterChanged(const ParameterList & parameters); double getLowerBound() const { return distribution_.begin()->first; } double getUpperBound() const { return distribution_.rbegin()->first; } double qProb(double x) const ; double pProb(double x) const ; double Expectation(double a) const; void restrictToConstraint(const Constraint& c); }; } //end of namespace bpp. #endif //_SIMPLEDISCRETEDISTRIBUTION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Prob/GammaDiscreteDistribution.h000664 001750 001750 00000007654 12370705300 026011 0ustar00jdutheiljdutheil000000 000000 // // File: GammaDiscreteDistribution.h // Created by: Julien Dutheil // Created on: Sun Oct 26 20:36:12 2003 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _GAMMADISCRETEDISTRIBUTION_H_ #define _GAMMADISCRETEDISTRIBUTION_H_ #include "AbstractDiscreteDistribution.h" #include "../Constraints.h" #include "../Random/RandomTools.h" namespace bpp { /** * @brief Discretized Gamma distribution. * * @author Julien Dutheil, Laurent Guéguen, with original code from Tal Pupko and Ziheng Yang. */ class GammaDiscreteDistribution: public AbstractDiscreteDistribution { private: double alpha_, beta_; // To prevent useless computations double ga1_; public: std::string getName() const {return("Gamma");} /** * @brief Build a new discretized gamma distribution. * @param n the number of categories to use. * @param alpha The alpha parameter (shape) * @param beta The beta parameter (rate) * @param minimumAlpha The minimum allowed value for parameter alpha. * @param minimumBeta The minimum allowed value for parameter beta. * * The Parameters are: alpha and beta @f$ \in [minimumBound;\infty[ @f$. * Small values of alpha and/or beta can lead to discretization issues. * * If @f$ alpha > 1 @f$, the minimum value of the distribution is * set to 1e-12, otherwise it is 0. */ GammaDiscreteDistribution(size_t n, double alpha = 1., double beta = 1., double minimumAlpha = 0.05, double minimumBeta = 0.05); GammaDiscreteDistribution(const GammaDiscreteDistribution&); GammaDiscreteDistribution& operator=(const GammaDiscreteDistribution&); virtual ~GammaDiscreteDistribution(); GammaDiscreteDistribution* clone() const { return new GammaDiscreteDistribution(*this); } void fireParameterChanged(const ParameterList & parameters); double randC() const throw (Exception) { double x= RandomTools::randGamma(getParameterValue("alpha"), getParameterValue("beta")); while (!intMinMax_.isCorrect(x)) x= RandomTools::randGamma(getParameterValue("alpha"), getParameterValue("beta")); return x; } double qProb(double x) const; double pProb(double x) const; double Expectation(double a) const; }; } //end of namespace bpp. #endif //_GAMMADISCRETEDISTRIBUTION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Prob/GammaDiscreteDistribution.cpp000664 001750 001750 00000010577 12370705300 026342 0ustar00jdutheiljdutheil000000 000000 // // File: GammaDiscreteDistribution.cpp // Created by: Julien Dutheil // Created on: Sun Oct 26 20:36:12 2003 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "GammaDiscreteDistribution.h" #include "../Random/RandomTools.h" #include "../NumConstants.h" #include "../../Utils/MapTools.h" using namespace bpp; // From the STL: #include using namespace std; /** Constructor: **************************************************************/ GammaDiscreteDistribution::GammaDiscreteDistribution(size_t n, double alpha, double beta, double minimumAlpha, double minimumBeta) : AbstractParameterAliasable("Gamma."), AbstractDiscreteDistribution(n, "Gamma."), alpha_(alpha), beta_(beta), ga1_(1) { // We use a lower bound of 0.0001 for alpha and beta to prohibe errors due to computer // floating precision: if alpha is quite low (gamma -> constant), some classes // may have the same category value, leading to a classe number lower than expected. // NB: if this is the case, then a warning is shown. This may happen in optimization // algorithms. addParameter_(new Parameter("Gamma.alpha", alpha, new IntervalConstraint(1, minimumAlpha, true), true)); addParameter_(new Parameter("Gamma.beta", beta, new IntervalConstraint(1, minimumBeta, true), true)); ga1_ = exp(RandomTools::lnGamma(alpha_ + 1) - RandomTools::lnGamma(alpha_)); intMinMax_.setLowerBound(0, true); discretize(); } GammaDiscreteDistribution::GammaDiscreteDistribution(const GammaDiscreteDistribution& gdd) : AbstractParameterAliasable(gdd), AbstractDiscreteDistribution(gdd), alpha_(gdd.alpha_), beta_(gdd.beta_), ga1_(gdd.ga1_) { } GammaDiscreteDistribution& GammaDiscreteDistribution::operator=(const GammaDiscreteDistribution& gdd) { AbstractParameterAliasable::operator=(gdd); AbstractDiscreteDistribution::operator=(gdd); alpha_=gdd.alpha_; beta_=gdd.beta_; ga1_=gdd.ga1_; return *this; } GammaDiscreteDistribution::~GammaDiscreteDistribution() {} /******************************************************************************/ void GammaDiscreteDistribution::fireParameterChanged(const ParameterList& parameters) { AbstractDiscreteDistribution::fireParameterChanged(parameters); alpha_ = getParameterValue("alpha"); beta_ = getParameterValue("beta"); ga1_ = exp(RandomTools::lnGamma(alpha_ + 1) - RandomTools::lnGamma(alpha_)); discretize(); } /******************************************************************************/ // Adapted from function DiscreteGamma of Yang double GammaDiscreteDistribution::qProb(double x) const { return RandomTools::qGamma(x, alpha_, beta_); } double GammaDiscreteDistribution::pProb(double x) const { return RandomTools::pGamma(x, alpha_, beta_); } double GammaDiscreteDistribution::Expectation(double a) const { return RandomTools::pGamma(a, alpha_ + 1, beta_) / beta_ * ga1_; } bpp-core-2.2.0/src/Bpp/Numeric/Prob/DirichletDiscreteDistribution.h000664 001750 001750 00000013540 12370705300 026665 0ustar00jdutheiljdutheil000000 000000 // // File: DirichletDiscreteDistribution.h // Created by: Laurent Guéguen // Created on: jeudi 2 septembre 2010, à 17h 03 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _DIRICHLETDISCRETEDISTRIBUTION_H_ #define _DIRICHLETDISCRETEDISTRIBUTION_H_ #include "MultipleDiscreteDistribution.h" #include "BetaDiscreteDistribution.h" #include "../VectorTools.h" #include "../ParameterAliasable.h" #include "../../Exceptions.h" #include "../../Io/OutputStream.h" namespace bpp { /** * @brief Discretized Dirichlet distribution. If the distribution is * in n dimensions, the domain is the n-1 simplex. * * The discretization is made in the order of these dimensions. Then * the order of the dimensions is not neutral on the resulting * categories. * * Here is an example of the discretization process: if the * distribution is in 3 dimensions, and the number of categories is * 4 in the first dimension, 3 in the second and 5 in the third, the * first interval is split in 4 equi-probable intervals, and each * interval is split on the second dimension in 3 equi-probable * intervals, and each of the 12 resulting 2D intervals is split in * 5 equi-probable 3D-intervals. Eventually, there are 60 * equi-probable categories. * * In the same example, if the distribution is followed by the * random vector @f$ (X_1,X_2,X_3) @f$, the 1D distribution used for * @f$ X_1 @f$ is the marginal distribution, which discretized * values are say, @f$ v_1^1, v_1^2, v_1^3, v_1^4 @f$, then the four * 1D distributions used for @f$ X_2 @f$ are the conditional * marginal distributions @f$ (X_2|X_1=v_1^1), (X_2|X_1=v_1^2), * (X_2|X_1=v_1^3), (X_2|X_1=v_1^4) @f$. And in a similar way for * @f$ X_3 @f$, with the 12 resulting conditions on @f$ X_1 @f$ and * @f$ X_2 @f$. * * * It uses the AbstractDiscreteDistribution comparator class to deal * with double precision. By default, category values that differ * less than 10E-9 will be considered identical. * * * The successive discretization process is done using the * distributions, if the parameters are @f$ (\alpha_1, ..., * \alpha_n)@f$: * * @f$ X_1 @f$ follows Beta(@f$ \alpha_1, \sum_{i=2}^n \alpha_i @f$). * * @f$ X_j @f$ follows @f$ (1-\sum_{i=1}^{j-1} X_i) @f$ * * Beta(@f$ \alpha_j, \sum_{i=j+1}^n \alpha_i @f$). * * @f$ X_n = 1 - \sum_{i=1}^{n-1} X_i @f$. * * * The parameters are: alpha_1, ... alpha_n @f$ \in [0.0001;\infty[ * @f$. */ class DirichletDiscreteDistribution : public MultipleDiscreteDistribution, public AbstractParameterAliasable { private: std::vector vpBDD_; public: /** * @brief Build a new discretized Dirichlet distribution * * @param vn the vector of the dim-1 numbers of categories to use. * @param valpha the vector of the dim alpha parameters. */ DirichletDiscreteDistribution(std::vector vn, Vdouble valpha); ~DirichletDiscreteDistribution(); DirichletDiscreteDistribution* clone() const { return new DirichletDiscreteDistribution(*this); } protected: void applyParameters(); public: std::string getName() const {return("Dirichlet");} void fireParameterChanged(const ParameterList& parameters); /** * @return The number of categories */ size_t getNumberOfCategories() const; /** * @param Vvalue * @return The vector of categoryIndex of the classes the value is * in. Throws a ConstraintException if the value is off the domain * of the DirichletDiscreteDistribution. */ Vdouble getValueCategory(Vdouble& Vvalue) const; VVdouble getCategories() const; /** * @param category The vector of values associated to the class. * @return The probability associated to a given class. */ virtual double getProbability(Vdouble& category) const; /** * @brief Draw a random vector from this distribution. * * This vector will be one of the class values, drawn according * to the class probabilities. * * @return A random number according to this distribution. */ Vdouble rand() const; /** * @brief Draw a random vector from the continuous version of this * distribution. * * @return A random vector according to this distribution. */ Vdouble randC() const; protected: void discretize(Vdouble& valpha); }; } // end of namespace bpp. #endif // _DIRICHLETDISCRETEDISTRIBUTION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Prob/AbstractDiscreteDistribution.cpp000664 001750 001750 00000032557 12370705300 027065 0ustar00jdutheiljdutheil000000 000000 // // File: AbstractDiscreteDistribution.cpp // Created by: Julien Dutheil // Created on: ? // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "AbstractDiscreteDistribution.h" #include "../Random/RandomTools.h" #include "../VectorTools.h" using namespace bpp; using namespace std; AbstractDiscreteDistribution::AbstractDiscreteDistribution(size_t nbClasses, const std::string& prefix) : AbstractParameterAliasable(prefix), numberOfCategories_(nbClasses), distribution_(), bounds_(nbClasses-1), intMinMax_(-NumConstants::VERY_BIG(), NumConstants::VERY_BIG(), true, true), median_(false) {} AbstractDiscreteDistribution::AbstractDiscreteDistribution(size_t nbClasses, double delta, const std::string& prefix) : AbstractParameterAliasable(prefix), numberOfCategories_(nbClasses), distribution_(Order(delta)), bounds_(nbClasses-1), intMinMax_(-NumConstants::VERY_BIG(), NumConstants::VERY_BIG(),true, true), median_(false) {} AbstractDiscreteDistribution::AbstractDiscreteDistribution(const AbstractDiscreteDistribution& adde) : AbstractParameterAliasable(adde), numberOfCategories_(adde.numberOfCategories_), distribution_(adde.distribution_), bounds_(adde.bounds_), intMinMax_(adde.intMinMax_), median_(adde.median_) { } AbstractDiscreteDistribution& AbstractDiscreteDistribution::operator=(const AbstractDiscreteDistribution& adde) { AbstractParameterAliasable::operator=(adde); numberOfCategories_=adde.numberOfCategories_; distribution_=adde.distribution_; bounds_=adde.bounds_; intMinMax_=adde.intMinMax_; median_=adde.median_; return *this; } /******************************************************************************/ size_t AbstractDiscreteDistribution::getNumberOfCategories() const { return numberOfCategories_; } void AbstractDiscreteDistribution::setNumberOfCategories(size_t nbClasses) { if (nbClasses <= 0) cerr << "DEBUG: ERROR!!! Number of categories is <= 0 in AbstractDiscreteDistribution::setNumberOfCategories()." << endl; if (numberOfCategories_ != nbClasses) { numberOfCategories_ = nbClasses; discretize(); } } /******************************************************************************/ double AbstractDiscreteDistribution::getCategory(size_t categoryIndex) const { map::const_iterator it = distribution_.begin(); for (unsigned int i = 0; i < categoryIndex; i++) { it++; } return it->first; } /******************************************************************************/ double AbstractDiscreteDistribution::getProbability(size_t categoryIndex) const { map::const_iterator it = distribution_.begin(); for (unsigned int i = 0; i < categoryIndex; i++) { it++; } return it->second; } /******************************************************************************/ double AbstractDiscreteDistribution::getProbability(double category) const { return distribution_.find(category)->second; } /******************************************************************************/ Vdouble AbstractDiscreteDistribution::getCategories() const { Vdouble result(distribution_.size()); unsigned int i = 0; for (map::const_iterator it = distribution_.begin(); it != distribution_.end(); it++) { result[i] = it->first; i++; } return result; } /******************************************************************************/ Vdouble AbstractDiscreteDistribution::getProbabilities() const { Vdouble result(distribution_.size()); size_t i = 0; for (map::const_iterator it = distribution_.begin(); it != distribution_.end(); it++) { result[i] = it->second; i++; } return result; } /******************************************************************************/ void AbstractDiscreteDistribution::set(double category, double probability) { distribution_[category] = probability; } /******************************************************************************/ void AbstractDiscreteDistribution::add(double category, double probability) { if (distribution_.find(category) == distribution_.end()) { // new category distribution_[category] = probability; } else { // existing category distribution_[category] += probability; } } /******************************************************************************/ double AbstractDiscreteDistribution::rand() const { double r = RandomTools::giveRandomNumberBetweenZeroAndEntry(1); double cumprob = 0; for (map::const_iterator i = distribution_.begin(); i != distribution_.end(); i++) { cumprob += i->second; if (r <= cumprob) return i->first; } // This line can't be reached: return -1.; } /******************************************************************************/ double AbstractDiscreteDistribution::getInfCumulativeProbability(double category) const { double prob = 0; map::const_iterator it = distribution_.find(category); for (map::const_iterator i = distribution_.begin(); i != it; i++) { prob += i->second; } return prob; } /******************************************************************************/ double AbstractDiscreteDistribution::getIInfCumulativeProbability(double category) const { double prob = 0; map::const_iterator it = distribution_.find(category); if (it == distribution_.end()) return 0; for (map::const_iterator i = ++it; i != distribution_.end(); i++) { prob += i->second; } return 1. - prob; } /******************************************************************************/ double AbstractDiscreteDistribution::getSupCumulativeProbability(double category) const { double prob = 0; map::const_iterator it = distribution_.find(category); if (it == distribution_.end()) return 0; for (map::const_iterator i = ++it; i != distribution_.end(); i++) { prob += i->second; } return prob; } /******************************************************************************/ double AbstractDiscreteDistribution::getSSupCumulativeProbability(double category) const { double prob = 0; map::const_iterator it = distribution_.find(category); for (map::const_iterator i = distribution_.begin(); i != it; i++) { prob += i->second; } return 1. - prob; } /******************************************************************************/ void AbstractDiscreteDistribution::print(OutputStream& out) const { for (map::const_iterator i = distribution_.begin(); i != distribution_.end(); i++) { (out << "Pr(" << (i->first) << ") = " << (i->second)).endLine(); } } /******************************************************************************/ double AbstractDiscreteDistribution::getValueCategory(double value) const { if (!(intMinMax_.isCorrect(value))) throw Exception("AbstractDiscreteDistribution::getValueCategory out of bounds:" + TextTools::toString(value)); map::const_iterator it = distribution_.begin(); for (unsigned int i=1;ifirst; } /***********************************************************************/ void AbstractDiscreteDistribution::discretize() { /* discretization of distribution with equal proportions in each category */ distribution_.clear(); bounds_.resize(numberOfCategories_ - 1); double minX = pProb(intMinMax_.getLowerBound()); double maxX = pProb(intMinMax_.getUpperBound()); double ec; size_t i; vector values(numberOfCategories_); if (maxX != minX) { // divide the domain into equiprobable intervals ec = (maxX - minX) / static_cast(numberOfCategories_); for (i = 1; i < numberOfCategories_; i++) { bounds_[i-1] = qProb(minX + static_cast(i) * ec); } // for each category, sets the value v as the median, adjusted // such that the sum of the values = 1 if (median_) { double t=0; for (i = 0; i < numberOfCategories_; i++) values[i] = qProb(minX + (static_cast(i) + 0.5) * ec); for (i = 0, t = 0; i < numberOfCategories_; i++) t += values[i]; double mean = Expectation(intMinMax_.getUpperBound()) - Expectation(intMinMax_.getLowerBound()); for (i = 0; i < numberOfCategories_; i++) values[i] *= mean / t / ec; } else // for each category, sets the value v such that // v * length_of_the_interval = the surface of the category { double a = Expectation(intMinMax_.getLowerBound()), b; for (i = 0; i < numberOfCategories_-1; i++) { b = Expectation(bounds_[i]); values[i] = (b - a) / ec; a = b; } values[numberOfCategories_-1] = (Expectation(intMinMax_.getUpperBound())-a) / ec; } } else // if maxX==minX, uniform discretization of the range { ec = (intMinMax_.getUpperBound() - intMinMax_.getLowerBound()) / static_cast(numberOfCategories_); for (i = 1; i < numberOfCategories_; i++) bounds_[i-1] = intMinMax_.getLowerBound() + static_cast(i) * ec; values[0] = (intMinMax_.getLowerBound() + bounds_[0]) / 2; for (i = 1; i < numberOfCategories_-1; i++) values[i] = (bounds_[i-1] + bounds_[i]) / 2; values[numberOfCategories_-1] = (intMinMax_.getUpperBound()+bounds_[numberOfCategories_ - 1]) / 2; } // adjustments near the boundaries of the domain, according to the precision chosen if (intMinMax_.strictLowerBound()) { for (i = 0; i < numberOfCategories_; i++) { if (values[i] < intMinMax_.getLowerBound() + precision()) values[i] = intMinMax_.getLowerBound() + precision(); else break; } } else { for (i = 0; i < numberOfCategories_; i++) { if (values[i] < intMinMax_.getLowerBound()) values[i] = intMinMax_.getLowerBound() + precision(); else break; } } if (intMinMax_.strictUpperBound()) { for (i = numberOfCategories_; i > 0; i--) { if (values[i-1] > intMinMax_.getUpperBound() - precision()) values[i-1] = intMinMax_.getUpperBound() - precision(); else break; } } else { for (i = numberOfCategories_; i > 0; i--) { if (values[i-1] > intMinMax_.getUpperBound()) values[i-1] = intMinMax_.getUpperBound() - precision(); else break; } } // now the distribution_ map, taking care that all values are different double p = 1. / static_cast(numberOfCategories_); for (i = 0; i < numberOfCategories_; i++) { if (distribution_.find(values[i]) != distribution_.end()) { int j = 1; int f = ((values[i] + NumConstants::TINY()) >= intMinMax_.getUpperBound()) ? -1 : 1; while (distribution_.find(values[i] + f * j * precision()) != distribution_.end()) { j++; f = ((values[i] + f * j * precision()) >= intMinMax_.getUpperBound()) ? -1 : 1; } distribution_[values[i] + f * j * precision()] = p; } else distribution_[values[i]] = p; } return; } Vdouble AbstractDiscreteDistribution::getBounds() const { Vdouble vb(numberOfCategories_ + 1); vb[0] = getLowerBound(); for (unsigned int i = 0; i < numberOfCategories_ - 1; i++) vb[i + 1] = getBound(i); vb[numberOfCategories_] = getUpperBound(); return vb; } void AbstractDiscreteDistribution::restrictToConstraint(const Constraint& c) { const IntervalConstraint* pi = dynamic_cast(&c); if (!pi) throw Exception("AbstractDiscreteDistribution::restrictToConstraint: the constraint is not an interval"); if (!(intMinMax_ <= (*pi))) { intMinMax_ &= c; discretize(); } } bpp-core-2.2.0/src/Bpp/Numeric/Prob/TruncatedExponentialDiscreteDistribution.cpp000664 001750 001750 00000006455 12370705300 031460 0ustar00jdutheiljdutheil000000 000000 // // File: TruncatedExponentialDiscreteDistribution.cpp // Created by: Julien Dutheil // Created on: Fri Jan 25 15:24 2008 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "TruncatedExponentialDiscreteDistribution.h" #include "../Random/RandomTools.h" #include "../../Utils/MapTools.h" using namespace bpp; // From the STL: #include using namespace std; /** Constructor: **************************************************************/ TruncatedExponentialDiscreteDistribution::TruncatedExponentialDiscreteDistribution(size_t n, double lambda, double truncationPoint) : AbstractParameterAliasable("TruncExponential."), AbstractDiscreteDistribution(n, "TruncExponential."), lambda_(lambda), tp_(truncationPoint), cond_(1-exp(-lambda_*tp_)) { addParameter_(new Parameter("TruncExponential.tp", truncationPoint, &Parameter::R_PLUS)); addParameter_(new Parameter("TruncExponential.lambda", lambda, &Parameter::R_PLUS)); intMinMax_.setLowerBound(0, true); intMinMax_.setUpperBound(tp_, false); discretize(); } /******************************************************************************/ void TruncatedExponentialDiscreteDistribution::fireParameterChanged(const ParameterList& parameters) { AbstractDiscreteDistribution::fireParameterChanged(parameters); lambda_ = getParameterValue("lambda"); tp_ = getParameterValue("tp"); intMinMax_.setUpperBound(tp_, false); cond_=1-exp(-lambda_*tp_); discretize(); } /******************************************************************************/ void TruncatedExponentialDiscreteDistribution::restrictToConstraint(const Constraint& c) { AbstractDiscreteDistribution::restrictToConstraint(c); getParameter_("tp").setConstraint(intMinMax_.clone(), true); } bpp-core-2.2.0/src/Bpp/Numeric/Prob/InvariantMixedDiscreteDistribution.h000664 001750 001750 00000012544 12370705300 027703 0ustar00jdutheiljdutheil000000 000000 // // File: InvariantMixedDiscreteDistribution.h // Created by: Julien Dutheil // Created on: Mon Dec 24 12:02 2007 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _INVARIANTMIXEDDISCRETEDISTRIBUTION_H_ #define _INVARIANTMIXEDDISCRETEDISTRIBUTION_H_ #include "AbstractDiscreteDistribution.h" namespace bpp { /** * @brief Discrete mixed distribution, with a one-category fixed value (called "invariant") and a user-specified multi-categories distribution. * * The term "invariant" comes from the use of such distributions in phylogenetics: * the fixed category corresponds to a value of 0 and describes invariant positions in an alignment. */ class InvariantMixedDiscreteDistribution : public AbstractDiscreteDistribution { private: DiscreteDistribution* dist_; double invariant_, p_; std::string nestedPrefix_; public: /** * @brief Build a new InvariantMixedDiscreteDistribution object. * * @param dist The distribution to use. The mixed distribution will "own" this distribution object. * This means that the distribution will be cloned in case of copy of this instance, and will be * deleted with this instance. * @param p The probability of being in the invariant category. * @param invariant The value of the invariant category (typically 0, but other values may be specified). */ InvariantMixedDiscreteDistribution(DiscreteDistribution* dist, double p, double invariant = 0.); virtual ~InvariantMixedDiscreteDistribution() { delete dist_; } InvariantMixedDiscreteDistribution(const InvariantMixedDiscreteDistribution& imdd) : AbstractParameterAliasable(imdd), AbstractDiscreteDistribution(imdd), dist_(dynamic_cast(imdd.dist_->clone())), invariant_(imdd.invariant_), p_(imdd.p_), nestedPrefix_(imdd.nestedPrefix_) {} InvariantMixedDiscreteDistribution& operator=(const InvariantMixedDiscreteDistribution& imdd) { AbstractParameterAliasable::operator=(imdd); AbstractDiscreteDistribution::operator=(imdd); dist_ = dynamic_cast(imdd.dist_->clone()); invariant_ = imdd.invariant_; p_ = imdd.p_; nestedPrefix_ = imdd.nestedPrefix_; return *this; } InvariantMixedDiscreteDistribution* clone() const { return new InvariantMixedDiscreteDistribution(*this); } public: std::string getName() const {return "Invariant"; } void fireParameterChanged(const ParameterList& parameters); void setNamespace(const std::string& prefix); /** * @ brief Sets the number of categories of the embedded * distribution. The number of categories of this class equals this * plus one if the invariant_ is not in the embedded distribution * values. */ void setNumberOfCategories(size_t nbClasses) { dist_->setNumberOfCategories(nbClasses); updateDistribution(); } /** * @return The nested, conditional, sub-distribution. */ const DiscreteDistribution* getVariableSubDistribution() const { return dist_; } double qProb(double x) const { return (x >= p_ + (1 - p_) * dist_->pProb(invariant_)) ? dist_->qProb((x - p_) / (1 - p_)) : dist_->qProb(x / (1 - p_)); } double pProb(double x) const { return (1 - p_) * dist_->pProb(x) + (x < invariant_ ? 0 : p_); } double Expectation(double a) const { return (1 - p_) * dist_->Expectation(a) + (a < invariant_ ? 0 : p_); } void setMedian(bool median) { if (median_ != median) { median_ = median; dist_->setMedian(median); updateDistribution(); } } void discretize() { dist_->discretize(); updateDistribution(); } void restrictToConstraint(const Constraint& c); protected: void updateDistribution(); }; } // end of namespace bpp. #endif // _INVARIANTMIXEDDISCRETEDISTRIBUTION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Prob/MultipleDiscreteDistribution.h000664 001750 001750 00000012145 12370705300 026551 0ustar00jdutheiljdutheil000000 000000 // // File: MultipleDiscreteDistribution.h // Created by: Laurent Guéguen // Created on: mardi 20 juillet 2010, à 14h 52 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _MULTIPLEDISCRETEDISTRIBUTION_H_ #define _MULTIPLEDISCRETEDISTRIBUTION_H_ #include "../VectorTools.h" #include "../ParameterAliasable.h" #include "../../Exceptions.h" #include "../../Io/OutputStream.h" namespace bpp { /** * @brief Interface for multiple discrete distribution objects. * * A multiple discrete distribution usually contains a vector of * finite set of categories and a probability associated to each. * The size of the vector is the dimension of the distribution. * * Each category (or class) is defined by two bounds, and sometimes * by a mean or a median value. * * A multiple discrete distribution may contain one or several * parameters. The probabilities associated to each class usually * depends on the parameter values. In some cases, the number and/or * bounds of the classes may also depend on the parameters values, * depending on the kind of discretization used. */ class MultipleDiscreteDistribution: public virtual ParameterAliasable { public: MultipleDiscreteDistribution() {} virtual ~MultipleDiscreteDistribution() {} #ifndef NO_VIRTUAL_COV MultipleDiscreteDistribution * clone() const = 0; #endif public: /** * @return The number of categories */ virtual size_t getNumberOfCategories() const = 0; /** * @param Vvalue The vector of values to check. * @return The vector of categories of the classes the value is * in. Throws a ConstraintException if the value is off the domain * of the MultipleDiscreteDistribution. */ virtual Vdouble getValueCategory(Vdouble& Vvalue) const = 0; /** * @param category The vector of values associated to the class. * @return The probability associated to a given class. */ virtual double getProbability(Vdouble& category) const = 0; public: /** * @brief Draw a random vector from this distribution. * * This vector will be one of the class values, drawn according * to the class probabilities. * * @return A random number according to this distribution. */ virtual Vdouble rand() const = 0; /** * @brief Draw a random vector from the continuous version of this distribution, if it exists. * * Uses the continuous version of this distribution to draw a random vector. * * @return A random vector according to this distribution. * @throw Exception If there is no continuous version of this distribution. */ virtual Vdouble randC() const = 0; /** * @brief Checks if the Parameters can respect the given * Constraints (one per dimension) and optionnaly tries to modify * their own Constraints. * * @param vc The vector of Constraint to respect. * @param f boolean flag to say if the Constraints must be changed * (if possible) (default: true) * * @return true if the Parameters Constraints are adapted to the * given Constraints, false otherwise. */ //virtual bool adaptToConstraint(const std::vector& vc, bool f=true) = 0; /** * @brief Print the distribution (categories and corresponding probabilities) to a stream. * * @param out The outstream where to print the distribution. */ // virtual void print(OutputStream& out) const = 0; }; } //end of namespace bpp. #endif //_MULTIPLEDISCRETEDISTRIBUTION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Prob/BetaDiscreteDistribution.cpp000664 001750 001750 00000010154 12370705300 026162 0ustar00jdutheiljdutheil000000 000000 // // File: BetaDiscreteDistribution.cpp // Created by: Laurent Guéguen // Created on: lundi 31 mai 2010, à 11h 15 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "BetaDiscreteDistribution.h" #include "../Random/RandomTools.h" #include "../NumConstants.h" #include "../../Utils/MapTools.h" using namespace bpp; // From the STL: #include using namespace std; /** Constructor: **************************************************************/ BetaDiscreteDistribution::BetaDiscreteDistribution(size_t n, double alpha, double beta) : AbstractParameterAliasable("Beta."), AbstractDiscreteDistribution(n,NumConstants::VERY_TINY(),"Beta."), alpha_(alpha), beta_(beta), diffln_(0) { addParameter_(new Parameter("Beta.alpha", alpha, new IntervalConstraint(1, 0.0001, true), true)); // For precision issues, beta cannot be too low addParameter_(new Parameter("Beta.beta", beta, new IntervalConstraint(1, 0.1, true), true)); intMinMax_.setLowerBound(0, true); intMinMax_.setUpperBound(1, true); diffln_ = exp(RandomTools::lnBeta(alpha_ + 1, beta_) - RandomTools::lnBeta(alpha_, beta_)); discretize(); } BetaDiscreteDistribution::BetaDiscreteDistribution(const BetaDiscreteDistribution& bdd) : AbstractParameterAliasable(bdd), AbstractDiscreteDistribution(bdd), alpha_(bdd.alpha_), beta_(bdd.beta_), diffln_(bdd.diffln_) { } BetaDiscreteDistribution& BetaDiscreteDistribution::operator=(const BetaDiscreteDistribution& bdd) { AbstractParameterAliasable::operator=(bdd); AbstractDiscreteDistribution::operator=(bdd); alpha_=bdd.alpha_; beta_=bdd.beta_; diffln_=bdd.diffln_; return *this; } /******************************************************************************/ void BetaDiscreteDistribution::fireParameterChanged(const ParameterList& parameters) { AbstractDiscreteDistribution::fireParameterChanged(parameters); alpha_=getParameterValue("alpha"); beta_=getParameterValue("beta"); if (alpha_<=1 && intMinMax_.getLowerBound()==0) intMinMax_.setLowerBound(precision(),false); if (beta_<=1 && intMinMax_.getUpperBound()==1) intMinMax_.setUpperBound(1-precision(),false); diffln_=exp(RandomTools::lnBeta(alpha_+1,beta_)-RandomTools::lnBeta(alpha_,beta_)); discretize(); } /******************************************************************************/ double BetaDiscreteDistribution::qProb(double x) const { return RandomTools::qBeta(x, alpha_, beta_); } double BetaDiscreteDistribution::pProb(double x) const { return RandomTools::pBeta(x, alpha_, beta_); } double BetaDiscreteDistribution::Expectation(double a) const { return RandomTools::pBeta(a,alpha_+1,beta_)*diffln_; } bpp-core-2.2.0/src/Bpp/Numeric/Prob/ExponentialDiscreteDistribution.cpp000664 001750 001750 00000005234 12370705300 027600 0ustar00jdutheiljdutheil000000 000000 // // File: ExponentialDiscreteDistribution.cpp // Created by: Julien Dutheil // Created on: Tue Nov 13 12:37 2007 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "ExponentialDiscreteDistribution.h" #include "../Random/RandomTools.h" #include "../NumConstants.h" #include "../../Utils/MapTools.h" using namespace bpp; // From the STL: #include using namespace std; /****************************************************************/ ExponentialDiscreteDistribution::ExponentialDiscreteDistribution(size_t n, double lambda) : AbstractParameterAliasable("Exponential."), AbstractDiscreteDistribution(n, "Exponential."), lambda_(lambda) { addParameter_(new Parameter("Exponential.lambda", lambda, &Parameter::R_PLUS)); intMinMax_.setLowerBound(0, true); discretize(); } /******************************************************************************/ void ExponentialDiscreteDistribution::fireParameterChanged(const ParameterList& parameters) { AbstractDiscreteDistribution::fireParameterChanged(parameters); lambda_ = getParameterValue("lambda"); discretize(); } bpp-core-2.2.0/src/Bpp/Numeric/Prob/ExponentialDiscreteDistribution.h000664 001750 001750 00000007312 12370705300 027244 0ustar00jdutheiljdutheil000000 000000 // // File: ExponentialDiscreteDistribution.h // Created by: Julien Dutheil // Created on: Tue Nov 13 12:37 2007 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _EXPONENTIALDISCRETEDISTRIBUTION_H_ #define _EXPONENTIALDISCRETEDISTRIBUTION_H_ #include "AbstractDiscreteDistribution.h" #include "../Constraints.h" #include "../Random/RandomTools.h" namespace bpp { /** * @brief Discretized Exponential distribution. * * @author Julien Dutheil */ class ExponentialDiscreteDistribution : public AbstractDiscreteDistribution { protected: double lambda_; public: /** * @brief Build a new discretized exponential distribution. * @param n the number of categories to use. * @param lambda The lambda parameter. * * The Parameter is: lambda @f$ \in [0;\infty[ @f$. * */ ExponentialDiscreteDistribution(size_t n, double lambda = 1.); ExponentialDiscreteDistribution(const ExponentialDiscreteDistribution& dist) : AbstractParameterAliasable(dist), AbstractDiscreteDistribution(dist), lambda_(dist.lambda_) {} ExponentialDiscreteDistribution& operator=(const ExponentialDiscreteDistribution& dist) { AbstractParameterAliasable::operator=(dist); AbstractDiscreteDistribution::operator=(dist); lambda_ = dist.lambda_; return *this; } ~ExponentialDiscreteDistribution(){}; ExponentialDiscreteDistribution* clone() const { return new ExponentialDiscreteDistribution(*this); } public: std::string getName() const {return("Exponential");} void fireParameterChanged(const ParameterList& parameters); double randC() const throw (Exception) { double x = RandomTools::randExponential(1. / getParameterValue("lambda")); while (!intMinMax_.isCorrect(x)) x = RandomTools::randExponential(1. / getParameterValue("lambda")); return x; } double pProb(double x) const { return 1. - exp(-lambda_ * x); } double qProb(double x) const { return -log(1. - x) / lambda_; } double Expectation(double a) const { return 1. / lambda_ - exp(-a * lambda_) * (a + 1. / lambda_); } }; } //end of namespace bpp. #endif //_EXPONENTIALDISCRETEDISTRIBUTION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Prob/Simplex.cpp000664 001750 001750 00000017265 12370705300 022657 0ustar00jdutheiljdutheil000000 000000 // // File: Simplex.cpp // Created by: Laurent Guéguen // Created on: mardi 31 mai 2011, à 13h 16 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "Simplex.h" #include "../NumConstants.h" #include "../VectorTools.h" using namespace bpp; using namespace std; Simplex::Simplex(const std::vector& probas, unsigned short method, bool allowNull, const std::string& name) : AbstractParameterAliasable(name), dim_(probas.size()), method_(method), vProb_(), valpha_() { if (dim_==0) return; double sum = VectorTools::sum(probas); if (fabs(1. - sum) > NumConstants::SMALL()) throw Exception("Simplex. Probabilities must equal 1 (sum =" + TextTools::toString(sum) + ")."); const Constraint* pc = (allowNull ? &Parameter::PROP_CONSTRAINT_IN : &Parameter::PROP_CONSTRAINT_EX); for (unsigned int i = 0; i < dim_; i++) { vProb_.push_back(probas[i]); } double y = 1; switch (method_) { case 1: for (unsigned int i = 0; i < dim_ - 1; i++) { addParameter_(new Parameter(name + "theta" + TextTools::toString(i + 1), vProb_[i] / y, pc)); y -= vProb_[i]; } break; case 2: for (unsigned int i = 0; i < dim_ - 1; i++) { addParameter_(new Parameter(name + "theta" + TextTools::toString(i + 1), vProb_[i] / (vProb_[i] + vProb_[i + 1]), pc)); } for (unsigned int i = 0; i < dim_ - 1; i++) { valpha_.push_back(vProb_[i + 1] / vProb_[i]); } break; case 3: for (size_t i = 1; i < dim_; i++) { size_t o = i; size_t li2 = 0; // rank of the strongest bit while (o) { li2++; o = o >> 1; } double i1 = 0, i0 = 0; size_t j = 0; size_t pi = i & ~(1 << (li2 - 1)); while (j < dim_) { size_t t = (j << li2) + pi; if (t >= dim_) break; else i0 += vProb_[t]; t += (1 << (li2 - 1)); if (t < dim_) i1 += vProb_[t]; j++; } addParameter_(new Parameter(name + "theta" + TextTools::toString(i), i1 / (i0 + i1), pc)); } break; } } Simplex::Simplex(size_t dim, unsigned short method, bool allowNull, const std::string& name) : AbstractParameterAliasable(name), dim_(dim), method_(method), vProb_(), valpha_() { if (dim_==0) return; for (size_t i = 0; i < dim_; i++) { vProb_.push_back(1. / static_cast(dim_)); } const Constraint* pc = (allowNull ? &Parameter::PROP_CONSTRAINT_IN : &Parameter::PROP_CONSTRAINT_EX); double y = 1; switch (method_) { case 1: for (unsigned int i = 0; i < dim_ - 1; i++) { addParameter_(new Parameter(name + "theta" + TextTools::toString(i + 1), vProb_[i] / y, pc)); y -= vProb_[i]; } break; case 2: for (unsigned int i = 0; i < dim_ - 1; i++) { addParameter_(new Parameter(name + "theta" + TextTools::toString(i + 1), 0.5, pc)); } for (unsigned int i = 0; i < dim_ - 1; i++) { valpha_.push_back(1.); } break; case 3: for (unsigned int i = 0; i < dim_ - 1; i++) { addParameter_(new Parameter(name + "theta" + TextTools::toString(i + 1), 0.5, pc)); } setFrequencies(vProb_); break; } } void Simplex::fireParameterChanged(const ParameterList& parameters) { if (dim_==0) return; AbstractParameterAliasable::fireParameterChanged(parameters); double x = 1.0; switch (method_) { case 1: double th; for (unsigned int i = 0; i < dim_ - 1; i++) { th = getParameterValue("theta" + TextTools::toString(i + 1)); vProb_[i] = th * x; x *= 1 - th; } vProb_[dim_ - 1] = x; break; case 2: for (unsigned int i = 0; i < dim_ - 1; i++) { th = getParameterValue("theta" + TextTools::toString(i + 1)); valpha_[i] = (1 - th) / th; } th = 1; vProb_[0] = 1; x = 1.0; for (unsigned int i = 0; i < dim_ - 1; i++) { th *= valpha_[i]; vProb_[i + 1] = th; x += vProb_[i + 1]; } for (unsigned int i = 0; i < dim_; i++) { vProb_[i] /= x; } break; case 3: size_t o = dim_; size_t ld2 = 0; // rank of the strongest bit while (o) { ld2++; o = o >> 1; } for (size_t i = 0; i < dim_; i++) { x = 1; size_t ld = ld2; size_t k = i; while (ld) { if (k >> (ld - 1)) x *= getParameterValue("theta" + TextTools::toString(k)); else { if ((k + (1 << (ld - 1))) < dim_) x *= 1 - getParameterValue("theta" + TextTools::toString(k + (1 << (ld - 1)))); } k &= ~(1 << (--ld)); } vProb_[i] = x; } break; } } void Simplex::setFrequencies(const std::vector& probas) { if (dim_==0) return; double sum = VectorTools::sum(probas); if (fabs(1. - sum) > NumConstants::SMALL()) throw Exception("Simplex::setFrequencies. Probabilities must equal 1 (sum =" + TextTools::toString(sum) + ")."); double y = 1; ParameterList pl; switch (method_) { case 1: for (unsigned int i = 0; i < dim_ - 1; i++) { pl.addParameter(Parameter(getNamespace() + "theta" + TextTools::toString(i + 1), probas[i] / y)); y -= probas[i]; } break; case 2: for (unsigned int i = 0; i < dim_ - 1; i++) { pl.addParameter(Parameter(getNamespace() + "theta" + TextTools::toString(i + 1), probas[i] / (probas[i] + probas[i + 1]))); valpha_[i] = probas[i + 1] / probas[i]; } break; case 3: for (size_t i = 1; i < dim_; i++) { size_t o = i; size_t li2 = 0; // rank of the strongest bit while (o) { li2++; o = o >> 1; } double i1 = 0, i0 = 0; size_t j = 0; size_t pi = i & ~(1 << (li2 - 1)); while (j < dim_) { size_t t = (j << li2) + pi; if (t >= dim_) break; else i0 += vProb_[t]; t += (1 << (li2 - 1)); if (t < dim_) i1 += vProb_[t]; j++; } pl.addParameter(Parameter(getNamespace() + "theta" + TextTools::toString(i), i1 / (i0 + i1))); } break; } matchParametersValues(pl); } bpp-core-2.2.0/src/Bpp/Numeric/Prob/SimpleDiscreteDistribution.cpp000664 001750 001750 00000030360 12370705300 026541 0ustar00jdutheiljdutheil000000 000000 // // File: SimpleDiscreteDistribution.cpp // Created by: Julien Dutheil // Created on: ? // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "SimpleDiscreteDistribution.h" #include "../NumConstants.h" #include "../../Utils/MapTools.h" #include "../../Text/TextTools.h" using namespace bpp; using namespace std; SimpleDiscreteDistribution::SimpleDiscreteDistribution(const map& distribution, double prec, bool fixed) : AbstractParameterAliasable("Simple."), AbstractDiscreteDistribution(distribution.size(), prec, "Simple."), givenRanges_() { double sum = 0; for (map::const_iterator i = distribution.begin(); i != distribution.end(); i++) { distribution_[i->first] = i->second; sum += i->second; } if (fabs(1. - sum) > precision()) throw Exception("SimpleDiscreteDistribution. Probabilities must equal 1 (sum =" + TextTools::toString(sum) + ")."); if (!fixed) { unsigned int n = 1; double x, y = 1; for (map::const_iterator i = distribution.begin(); i != distribution.end(); i++) { addParameter_(new Parameter("Simple.V" + TextTools::toString(n), i->first)); if (n != numberOfCategories_) { x = i->second; addParameter_(new Parameter("Simple.theta" + TextTools::toString(n), x / y, &Parameter::PROP_CONSTRAINT_IN)); y -= x; } n++; } } discretize(); } SimpleDiscreteDistribution::SimpleDiscreteDistribution(const vector& values, const vector& probas, double prec, bool fixed ) : AbstractParameterAliasable("Simple."), AbstractDiscreteDistribution(values.size(), prec, "Simple."), givenRanges_() { if (values.size() != probas.size()) { throw Exception("SimpleDiscreteDistribution. Values and probabilities vectors must have the same size (" + TextTools::toString(values.size()) + " != " + TextTools::toString(probas.size()) + ")."); } size_t size = values.size(); for (size_t i = 0; i < size; i++) { if (distribution_.find(values[i]) != distribution_.end()) throw Exception("SimpleDiscreteDistribution: two given values are equal"); else distribution_[values[i]] = probas[i]; } double sum = VectorTools::sum(probas); if (fabs(1. - sum) > precision()) throw Exception("SimpleDiscreteDistribution. Probabilities must equal 1 (sum =" + TextTools::toString(sum) + ")."); if (!fixed) { double y = 1; for (unsigned int i = 0; i < size - 1; i++) { addParameter_(new Parameter("Simple.V" + TextTools::toString(i + 1), values[i])); addParameter_(new Parameter("Simple.theta" + TextTools::toString(i + 1), probas[i] / y, &Parameter::PROP_CONSTRAINT_IN)); y -= probas[i]; } addParameter_(new Parameter("Simple.V" + TextTools::toString(size), values[size - 1])); } discretize(); } SimpleDiscreteDistribution::SimpleDiscreteDistribution(const std::vector& values, const std::map >& ranges, const std::vector& probas, double prec, bool fixed) : AbstractParameterAliasable("Simple."), AbstractDiscreteDistribution(values.size(), prec, "Simple."), givenRanges_() { if (values.size() != probas.size()) { throw Exception("SimpleDiscreteDistribution. Values and probabilities vectors must have the same size (" + TextTools::toString(values.size()) + " != " + TextTools::toString(probas.size()) + ")."); } size_t size = values.size(); for (size_t i = 0; i < size; i++) { if (distribution_.find(values[i]) != distribution_.end()) throw Exception("SimpleDiscreteDistribution: two given values are equal"); else distribution_[values[i]] = probas[i]; } double sum = VectorTools::sum(probas); if (fabs(1. - sum) > precision()) throw Exception("SimpleDiscreteDistribution. Probabilities must equal 1 (sum =" + TextTools::toString(sum) + ")."); if (!fixed) { double y = 1; for (size_t i = 0; i < size - 1; i++) { map >::const_iterator it = ranges.find(i + 1); if (it == ranges.end()) addParameter_(new Parameter("Simple.V" + TextTools::toString(i + 1), values[i])); else { if (values[i] >= it->second[0] && values[i] <= it->second[1]) { addParameter_(new Parameter("Simple.V" + TextTools::toString(i + 1), values[i], new IntervalConstraint(it->second[0], it->second[1], true, true), true)); givenRanges_[i + 1] = it->second; } else throw Exception("SimpleDiscreteDistribution. Value and given range of parameter V" + TextTools::toString(i + 1) + " do not match: " + TextTools::toString(values[i]) + " vs [" + TextTools::toString(it->second[0]) + ";" + TextTools::toString(it->second[1]) + "]"); } addParameter_(new Parameter("Simple.theta" + TextTools::toString(i + 1), probas[i] / y, &Parameter::PROP_CONSTRAINT_IN)); y -= probas[i]; } map >::const_iterator it = ranges.find(size); if (it == ranges.end()) addParameter_(new Parameter("Simple.V" + TextTools::toString(size), values[size - 1])); else { if (values[size - 1] >= it->second[0] && values[size - 1] <= it->second[1]) { addParameter_(new Parameter("Simple.V" + TextTools::toString(size), values[size - 1], new IntervalConstraint(it->second[0], it->second[1], true, true), true)); givenRanges_[size] = it->second; } else throw Exception("SimpleDiscreteDistribution. Value and given range of parameter V" + TextTools::toString(size) + " do not match: " + TextTools::toString(values[size - 1]) + " vs [" + TextTools::toString(it->second[0]) + ";" + TextTools::toString(it->second[1]) + "]"); } } discretize(); } SimpleDiscreteDistribution::SimpleDiscreteDistribution(const SimpleDiscreteDistribution& sdd) : AbstractParameterAliasable(sdd), AbstractDiscreteDistribution(sdd), givenRanges_(sdd.givenRanges_) {} SimpleDiscreteDistribution& SimpleDiscreteDistribution::operator=(const SimpleDiscreteDistribution& sdd) { AbstractParameterAliasable::operator=(sdd); AbstractDiscreteDistribution::operator=(sdd); givenRanges_ = sdd.givenRanges_; return *this; } void SimpleDiscreteDistribution::fireParameterChanged(const ParameterList& parameters) { if (getNumberOfParameters() != 0) { AbstractDiscreteDistribution::fireParameterChanged(parameters); size_t size = distribution_.size(); distribution_.clear(); double x = 1.0; double v; for (size_t i = 0; i < size - 1; i++) { v = getParameterValue("V" + TextTools::toString(i + 1)); if (distribution_.find(v) != distribution_.end()) { int j = 1; int f = ((v + precision()) >= intMinMax_.getUpperBound()) ? -1 : 1; while (distribution_.find(v + f * j * precision()) != distribution_.end()) { j++; f = ((v + f * j * precision()) >= intMinMax_.getUpperBound()) ? -1 : 1; } v += f * j * precision(); // approximation to avoid useless computings: // setParameterValue("V"+TextTools::toString(i+1),v); } distribution_[v] = getParameterValue("theta" + TextTools::toString(i + 1)) * x; x *= 1 - getParameterValue("theta" + TextTools::toString(i + 1)); } v = getParameterValue("V" + TextTools::toString(size)); if (distribution_.find(v) != distribution_.end()) { int j = 1; int f = ((v + precision()) >= intMinMax_.getUpperBound()) ? -1 : 1; while (distribution_.find(v + f * j * precision()) != distribution_.end()) { j++; f = ((v + f * j * precision()) >= intMinMax_.getUpperBound()) ? -1 : 1; } v += f * j * precision(); // approximation to avoid useless computings: // setParameterValue("V"+TextTools::toString(size),v); } distribution_[v] = x; } discretize(); } double SimpleDiscreteDistribution::qProb(double x) const { double s = -NumConstants::VERY_BIG(); double x2 = x; for (map::const_iterator it = distribution_.begin(); it != distribution_.end(); it++) { x2 -= it->second; if (x2 < 0) return s; else s = it->second; } return s; } double SimpleDiscreteDistribution::pProb(double x) const { double s = 0; for (map::const_iterator it = distribution_.begin(); it != distribution_.end(); it++) { if (it->first >= x) s += it->second; else break; } return s; } double SimpleDiscreteDistribution::Expectation(double a) const { double s = 0; for (map::const_iterator it = distribution_.begin(); it != distribution_.end(); it++) { if (it->first >= a) s += it->second; else break; } return s; } void SimpleDiscreteDistribution::discretize() { // Compute a new arbitray bounderi: vector values = MapTools::getKeys(distribution_); // Fill from 0 to numberOfCategories_-2 with midpoints: for (unsigned int i = 0; i < numberOfCategories_ - 1; i++) { bounds_[i] = (values[i] + values[i + 1]) / 2.; } } void SimpleDiscreteDistribution::restrictToConstraint(const Constraint& c) { if (getNumberOfParameters() == 0) return; const IntervalConstraint* pi = dynamic_cast(&c); if (!pi) throw Exception("SimpleDiscreteDistribution::restrictToConstraint: Non-interval exception"); map::const_iterator it; for (it = distribution_.begin(); it != distribution_.end(); it++) { if (!pi->isCorrect(it->first)) throw Exception("Impossible to restrict to Constraint value " + TextTools::toString(it->first)); } AbstractDiscreteDistribution::restrictToConstraint(c); size_t size = distribution_.size(); for (size_t i = 0; i < size; i++) { map >::const_iterator itr = givenRanges_.find(i + 1); if (itr == givenRanges_.end()) getParameter_("V" + TextTools::toString(i + 1)).setConstraint(intMinMax_.clone(), true); else { const Constraint* pc = getParameter_("V" + TextTools::toString(i + 1)).removeConstraint(); getParameter_("V" + TextTools::toString(i + 1)).setConstraint(*pc & *intMinMax_.clone(), true); delete pc; } } } bpp-core-2.2.0/src/Bpp/Numeric/Prob/GaussianDiscreteDistribution.h000664 001750 001750 00000006223 12370705300 026530 0ustar00jdutheiljdutheil000000 000000 // // File: GaussianDiscreteDistribution.h // Created by: Laurent Guéguen // Created on: April 2010 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _GAUSSIANDISCRETEDISTRIBUTION_H_ #define _GAUSSIANDISCRETEDISTRIBUTION_H_ #include "AbstractDiscreteDistribution.h" #include "../Constraints.h" #include "../Random/RandomTools.h" namespace bpp { /** * @brief Discretized Gaussian distribution. * * @author Laurent Guéguen */ class GaussianDiscreteDistribution: public AbstractDiscreteDistribution { private: double mu_, sigma_; public: /** * @brief Build a new discretized normal distribution. * @param n the number of categories to use. * @param mu The mean parameter. * @param sigma The standard deviation parameter. * * The Parameters are: mu @f$ \in ]-\infty;\infty[ @f$ and sigma * @f$ \in ]0;\infty[ @f$. * */ GaussianDiscreteDistribution(size_t n, double mu=0., double sigma = 1.); GaussianDiscreteDistribution(const GaussianDiscreteDistribution&); GaussianDiscreteDistribution& operator=(const GaussianDiscreteDistribution&); virtual ~GaussianDiscreteDistribution(); GaussianDiscreteDistribution* clone() const { return new GaussianDiscreteDistribution(*this); } public: std::string getName() const {return("Gaussian");} void fireParameterChanged(const ParameterList & parameters); double randC() const throw (Exception) { return RandomTools::randGaussian(mu_,sigma_); } double qProb(double x) const; double pProb(double x) const; double Expectation(double a) const; }; } //end of namespace bpp. #endif //_GAUSSIANDISCRETEDISTRIBUTION_H_ bpp-core-2.2.0/src/Bpp/Numeric/Prob/DirichletDiscreteDistribution.cpp000664 001750 001750 00000017032 12370705300 027220 0ustar00jdutheiljdutheil000000 000000 // // File: BetaDiscreteDistribution.cpp // Created by: Laurent Guéguen // Created on: jeudi 2 septembre 2010, à 17h 03 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "DirichletDiscreteDistribution.h" #include "BetaDiscreteDistribution.h" #include "../Random/RandomTools.h" #include "../NumConstants.h" #include "../../Text/TextTools.h" using namespace bpp; // From the STL: #include using namespace std; /** Constructor: **************************************************************/ DirichletDiscreteDistribution::DirichletDiscreteDistribution(vector vn, Vdouble valpha) : AbstractParameterAliasable("Dirichlet."), vpBDD_() { if (vn.size() <= 0 || vn.size() != valpha.size() - 1) throw Exception("Wrong number of categories for Dirichlet distribution: " + TextTools::toString(vn.size())); for (size_t j = 0; j < valpha.size(); j++) { addParameter_(new Parameter("Dirichlet.alpha_" + TextTools::toString(j + 1), valpha[j], new IntervalConstraint(1, 0.0001, true), true)); } for (size_t j = 0; j < vn.size(); j++) { if (vn[j] <= 0) throw Exception("Wrong number of categories in Dirichlet distribution constructor: " + TextTools::toString(vn[j])); } for (size_t j = 0; j < vn.size(); j++) { vpBDD_.push_back(new BetaDiscreteDistribution(vn[j], 1, 1)); } discretize(valpha); } DirichletDiscreteDistribution::~DirichletDiscreteDistribution() { for (unsigned int i = 0; i < vpBDD_.size(); i++) { delete vpBDD_[i]; } } /******************************************************************************/ void DirichletDiscreteDistribution::fireParameterChanged(const ParameterList& parameters) { AbstractParameterAliasable::fireParameterChanged(parameters); applyParameters(); } /******************************************************************************/ void DirichletDiscreteDistribution::applyParameters() { Vdouble valpha; for (unsigned int j = 0; j < vpBDD_.size() + 1; j++) { valpha.push_back(getParameterValue("alpha_" + TextTools::toString(j + 1))); } discretize(valpha); } /******************************************************************************/ void DirichletDiscreteDistribution::discretize(Vdouble& valpha) { /* discretization of Dirichlet distribution with equal proportions in each category */ double x; ParameterList pL; pL.addParameter(Parameter("Beta.alpha", 1)); pL.addParameter(Parameter("Beta.beta", 1)); for (unsigned int j = 0; j < vpBDD_.size(); j++) { x = 0; for (unsigned int i = j + 1; i < valpha.size(); i++) { x += valpha[i]; } pL.setParameterValue("Beta.alpha", valpha[j]); pL.setParameterValue("Beta.beta", x); vpBDD_[j]->matchParametersValues(pL); } } /******************************************************************************/ size_t DirichletDiscreteDistribution::getNumberOfCategories() const { size_t n = 1; for (size_t j = 0; j < vpBDD_.size(); j++) { n *= vpBDD_[j]->getNumberOfCategories(); } return n; } /******************************************************************************/ Vdouble DirichletDiscreteDistribution::getValueCategory(Vdouble& value) const { if (value.size() != vpBDD_.size() + 1) throw Exception("Bad Vdouble parameter in DirichletDiscreteDistribution::getValueCategory"); Vdouble vd; double y, sumc = 0; for (size_t j = 0; j < vpBDD_.size(); j++) { if (1 - sumc < NumConstants::VERY_TINY()) y = vpBDD_[j]->getValueCategory(NumConstants::VERY_TINY()); else y = vpBDD_[j]->getValueCategory(value[j] / (1 - sumc)) * (1 - sumc); sumc += y; vd.push_back(y); } vd.push_back(1 - sumc); return vd; } /******************************************************************************/ double DirichletDiscreteDistribution::getProbability(Vdouble& category) const { if (category.size() != vpBDD_.size() + 1) throw Exception("Bad Vdouble parameter in DirichletDiscreteDistribution::getProbability"); double sumc = 0; double p = 1; for (unsigned int j = 0; j < vpBDD_.size(); j++) { p *= vpBDD_[j]->getProbability(category[j] / (1 - sumc)); sumc += category[j]; } return p; } /******************************************************************************/ VVdouble DirichletDiscreteDistribution::getCategories() const { VVdouble vvd1, vvd2; Vdouble vdj, vd; double sumc = 0; vdj = vpBDD_[0]->getCategories(); for (unsigned int k = 0; k < vdj.size(); k++) { vd.push_back(vdj[k]); vvd1.push_back(vd); vd.pop_back(); } for (unsigned int j = 1; j < vpBDD_.size(); j++) { vdj = vpBDD_[j]->getCategories(); vvd2.clear(); for (unsigned int i = 0; i < vvd1.size(); i++) { vd = vvd1[i]; sumc = 0; for (unsigned int k = 0; k < vd.size(); k++) { sumc += vd[k]; } for (unsigned int k = 0; k < vdj.size(); k++) { vd.push_back(vdj[k] * (1 - sumc)); vvd2.push_back(vd); vd.pop_back(); } } vvd1 = vvd2; } vvd2.clear(); for (unsigned int i = 0; i < vvd1.size(); i++) { vd = vvd1[i]; sumc = 0; for (unsigned int k = 0; k < vd.size(); k++) { sumc += vd[k]; } vd.push_back(1 - sumc); vvd2.push_back(vd); } return vvd2; } /******************************************************************************/ Vdouble DirichletDiscreteDistribution::rand() const { Vdouble vd; double x, sumc = 0; for (unsigned int j = 0; j < vpBDD_.size(); j++) { x = vpBDD_[j]->rand() * (1 - sumc); sumc += x; vd.push_back(x); } vd.push_back(1 - sumc); return vd; } /******************************************************************************/ Vdouble DirichletDiscreteDistribution::randC() const { Vdouble vd; double x, sumc = 0; for (unsigned int j = 0; j < vpBDD_.size(); j++) { x = vpBDD_[j]->randC() * (1 - sumc); sumc += x; vd.push_back(x); } vd.push_back(1 - sumc); return vd; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Parametrizable.h000664 001750 001750 00000020014 12370705300 022725 0ustar00jdutheiljdutheil000000 000000 // // File: Parametrizable.h // Created by: Julien Dutheil // Created on: Sun Oct 19 23:06:42 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _PARAMETRIZABLE_H_ #define _PARAMETRIZABLE_H_ // From Utils: #include "../Clonable.h" // From the STL: #include #include "ParameterList.h" namespace bpp { /** * @brief This is the interface for all objects that imply parameters. * * @see Parameter, ParameterList */ class Parametrizable: public virtual Clonable { public: Parametrizable() {} virtual ~Parametrizable() {} public: /** * @brief Tell if there is a parameter with specified name. * * @param name The name of the parameter to look for. * @return y/n. */ virtual bool hasParameter(const std::string& name) const = 0; /** * @brief Get all parameters available. * * @see getIndependentParameters if some parameters are aliased. * @return A list with all parameters available. */ virtual const ParameterList& getParameters() const = 0; /** * @brief Get the parameter with specified name. * * @param name The name of the parameter to look for. * @return The parameter with given name. * @throw ParameterNotFoundException if no parameter with this name is found. */ virtual const Parameter& getParameter(const std::string& name) const throw (ParameterNotFoundException) = 0; /** * @brief Get the value for parameter of name 'name'. * * @param name The name of the parameter. * @return the value of parameter name. */ virtual double getParameterValue(const std::string& name) const throw (ParameterNotFoundException) = 0; /** * @brief Set the parameters values to be equals to those of parameters. * * The list must contain exactly the same parameters (ie same names) * than the parameters available. * * @param parameters A list with all parameters. * @throw ParameterNotFoundException If a some parameter in the list is not in params. * @throw ConstraintException If a value in parameters does not match the constraint in the * corresponding parameter in the list. */ virtual void setAllParametersValues(const ParameterList& parameters) throw (ParameterNotFoundException, ConstraintException) = 0; /** * @brief Set the value of parameter with name name to be equal to value. * * @param name the name of the parameter to set. * @param value The value of the parameter. * @throw ParameterNotFoundException If no parameter in the list has the name name. * @throw ConstraintException If value does not match the constraint associated to * parameter name. */ virtual void setParameterValue(const std::string& name, double value) throw (ParameterNotFoundException, ConstraintException) = 0; /** * @brief Update the parameters from parameters. * * parameters must be a subset of all parameters available. * * @param parameters A list containing all parameters to update. * @throw ParameterNotFoundException If a some parameter in params is not in the list. * @throw ConstraintException If a value in parameters does not match the constraint in the * corresponding parameter in the list. */ virtual void setParametersValues(const ParameterList& parameters) throw (ParameterNotFoundException, ConstraintException) = 0; /** * @brief Update the parameters from parameters. * * Only common parameters with parameters will be updated. * * @param parameters A list of parameters. * @return True if at least one parameter value has been changed. * @throw ConstraintException If a value in parameters does not match the constraint in the * corresponding parameter in the list. */ virtual bool matchParametersValues(const ParameterList& parameters) throw (ConstraintException) = 0; /** * @brief Get the number of parameters. * * @see getNumberOfIndependentParameters If some parameters are aliased. * @return The number of parameters. */ virtual size_t getNumberOfParameters() const = 0; /** * @brief Set the namespace for the parameter names. * * @param prefix The 'namespace', that is a prefix to add to all parameter names. * If parameter names are already prefixed, the new prefix will be used instead. */ virtual void setNamespace(const std::string& prefix) = 0; /** * @return The current namespace used. This is an empty string if no namespace is currently defined. */ virtual std::string getNamespace() const = 0; /** * @brief Resolves a parameter name according to the current namespace. * * @return The parameter name without the namespace prefix, if any. */ virtual std::string getParameterNameWithoutNamespace(const std::string& name) const = 0; }; /** * @brief A low-level implementation of the Parametrizable interface with void functions. * * @see Parameter, ParameterList, Parametrizable */ class ParametrizableAdapter: public virtual Parametrizable { protected: ParameterList parameters_; Parameter parameter_; public: ParametrizableAdapter(): parameters_(), parameter_() {} virtual ~ParametrizableAdapter() {} public: /** * @name The Parametrizable interface. * * @{ */ bool hasParameter(const std::string & name) const { return parameters_.hasParameter(name); } const ParameterList & getParameters() const { return parameters_; } const Parameter & getParameter(const std::string & name) const throw (ParameterNotFoundException) { return parameter_; } double getParameterValue(const std::string & name) const throw (ParameterNotFoundException) { return 0; }; void setAllParametersValues(const ParameterList & parameters) throw (ParameterNotFoundException, ConstraintException) {} void setParameterValue(const std::string & name, double value) throw (ParameterNotFoundException, ConstraintException) {} void setParametersValues(const ParameterList & parameters) throw (ParameterNotFoundException, ConstraintException) {} bool matchParametersValues(const ParameterList & parameters) throw (ConstraintException) { return false ;} size_t getNumberOfParameters() const{ return 0; } void setNamespace(const std::string& prefix) {} std::string getNamespace() const { return ""; } std::string getParameterNameWithoutNamespace(const std::string& name) const { return name; } /** @} */ }; } //end of namespace bpp. #endif //_PARAMETRIZABLE_H_ bpp-core-2.2.0/src/Bpp/Numeric/VectorTools.h000664 001750 001750 00000156752 12370705300 022271 0ustar00jdutheiljdutheil000000 000000 // // File: VectorTools.h // Created by: Julien Dutheil // Created on: Fri Mar 14 14:16:32 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _VECTORTOOLS_H_ #define _VECTORTOOLS_H_ #include "VectorExceptions.h" #include "NumTools.h" #include "AdaptiveKernelDensityEstimation.h" #include "Matrix/Matrix.h" #include "../Io/OutputStream.h" #include "../App/ApplicationTools.h" // From the STL: #include #include #include #include #include namespace bpp { typedef std::vector > Vcomplex; typedef std::vector VVcomplex; typedef std::vector VVVcomplex; typedef std::vector > Vlcomplex; typedef std::vector VVlcomplex; typedef std::vector VVVlcomplex; typedef std::vector Vdouble; typedef std::vector VVdouble; typedef std::vector VVVdouble; typedef std::vector VVVVdouble; typedef std::vector Vldouble; typedef std::vector VVldouble; typedef std::vector VVVldouble; typedef std::vector VVVVldouble; typedef std::vector Vint; typedef std::vector VVint; typedef std::vector VVVint; typedef std::vector VVVVint; /** * @name Element-wise operations. * @{ */ template std::vector operator+(const std::vector& v1, const std::vector& v2) throw (DimensionException) { size_t size; if (v1.size() != v2.size()) { throw DimensionException("VectorTools::operator+", v1.size(), v2.size()); } else { size = v1.size(); } std::vector result(size); for (size_t i = 0; i < size; i++) { result[i] = v1[i] + v2[i]; } return result; } template std::vector operator-(const std::vector& v1, const std::vector& v2) throw (DimensionException) { size_t size; if (v1.size() != v2.size()) { throw DimensionException("VectorTools::operator-", v1.size(), v2.size()); } else { size = v1.size(); } std::vector result(size); for (size_t i = 0; i < size; i++) { result[i] = v1[i] - v2[i]; } return result; } template std::vector operator*(const std::vector& v1, const std::vector& v2) throw (DimensionException) { size_t size; if (v1.size() != v2.size()) { throw DimensionException("VectorTools::operator*", v1.size(), v2.size()); } else { size = v1.size(); } std::vector result(size); for (size_t i = 0; i < size; i++) { result[i] = v1[i] * v2[i]; } return result; } template std::vector operator/(const std::vector& v1, const std::vector& v2) throw (DimensionException) { size_t size; if (v1.size() != v2.size()) { throw DimensionException("VectorTools::operator/", v1.size(), v2.size()); } else { size = v1.size(); } std::vector result(size); for (size_t i = 0; i < size; i++) { result[i] = v1[i] / v2[i]; } return result; } template std::vector operator+(const std::vector& v1, const C& c) { std::vector result(v1.size()); for (size_t i = 0; i < result.size(); i++) { result[i] = v1[i] + c; } return result; } template std::vector operator+(const C& c, const std::vector& v1) { std::vector result(v1.size()); for (size_t i = 0; i < result.size(); i++) { result[i] = c + v1[i]; } return result; } template std::vector operator-(const std::vector& v1, const C& c) { std::vector result(v1.size()); for (size_t i = 0; i < result.size(); i++) { result[i] = v1[i] - c; } return result; } template std::vector operator-(const C& c, const std::vector& v1) { std::vector result(v1.size()); for (size_t i = 0; i < result.size(); i++) { result[i] = c - v1[i]; } return result; } template std::vector operator*(const std::vector& v1, const C& c) { std::vector result(v1.size()); for (size_t i = 0; i < result.size(); i++) { result[i] = v1[i] * c; } return result; } template std::vector operator*(const C& c, const std::vector& v1) { std::vector result(v1.size()); for (size_t i = 0; i < result.size(); i++) { result[i] = c * v1[i]; } return result; } template std::vector operator/(const std::vector& v1, const C& c) { std::vector result(v1.size()); for (size_t i = 0; i < result.size(); i++) { result[i] = v1[i] / c; } return result; } template std::vector operator/(const C& c, const std::vector& v1) { std::vector result(v1.size()); for (size_t i = 0; i < result.size(); i++) { result[i] = c / v1[i]; } return result; } template void operator+=(std::vector& v1, const std::vector& v2) throw (DimensionException) { for (size_t i = 0; i < v1.size(); i++) { v1[i] += v2[i]; } } template void operator-=(std::vector& v1, const std::vector& v2) throw (DimensionException) { for (size_t i = 0; i < v1.size(); i++) { v1[i] -= v2[i]; } } template void operator*=(std::vector& v1, const std::vector& v2) throw (DimensionException) { for (size_t i = 0; i < v1.size(); i++) { v1[i] *= v2[i]; } } template void operator/=(std::vector& v1, const std::vector& v2) throw (DimensionException) { for (size_t i = 0; i < v1.size(); i++) { v1[i] /= v2[i]; } } template void operator+=(std::vector& v1, const C& c) { for (size_t i = 0; i < v1.size(); i++) { v1[i] += c; } } template void operator-=(std::vector& v1, const C& c) { for (size_t i = 0; i < v1.size(); i++) { v1[i] -= c; } } template void operator*=(std::vector& v1, const C& c) { for (size_t i = 0; i < v1.size(); i++) { v1[i] *= c; } } template void operator/=(std::vector& v1, const C& c) { for (size_t i = 0; i < v1.size(); i++) { v1[i] /= c; } } /** @} */ /******************************************************************************/ class VectorTools { public: VectorTools() {} virtual ~VectorTools() {} public: /** * @name Matrix-like functions to resize arrays. * * @{ */ template static void resize2(VVdouble& vv, size_t n1, size_t n2) { vv.resize(n1); for (size_t i = 0; i < n1; i++) { vv[i].resize(n2); } } template static void resize3(VVVdouble& vvv, size_t n1, size_t n2, size_t n3) { vvv.resize(n1); for (size_t i = 0; i < n1; i++) { vvv[i].resize(n2); for (size_t j = 0; j < n2; j++) { vvv[i][j].resize(n3); } } } static void resize4(VVVVdouble& vvvv, size_t n1, size_t n2, size_t n3, size_t n4) { vvvv.resize(n1); for (size_t i = 0; i < n1; i++) { vvvv[i].resize(n2); for (size_t j = 0; j < n2; j++) { vvvv[i][j].resize(n3); for (size_t k = 0; k < n3; k++) { vvvv[i][j][k].resize(n4); } } } } /** @} */ template static void fill(std::vector& v, T value) { for (typename std::vector::iterator it = v.begin(); it < v.end(); it++) { *it = value; } } /** * @brief Build a sequence std::vector. * * Build a std::vector from a value to another with a specified step. * This works for numerical values for which additions, subtractions and division * makes sens. * * @param from The begining. * @param to The end. * @param by The step. * @return A std::vector containing the sequence. */ template static std::vector seq(T from, T to, T by) { std::vector v; if (from < to) { // for (T i = from ; i <= to ; i += by) { // Not good for double, 'to' for (T i = from; i <= to + (by / 100); i += by) { // must be a little bit larger v.push_back(i); } } else { for (T i = from; i >= to - (by / 100); i -= by) { v.push_back(i); } } return v; } /** * @brief Send the position of the first occurence of 'which'. * * Comparisons are performed using the == operator. * Maximum complexity: O(v.size()). * * @param v The std::vector to search. * @param which The element to search. * @return The position of which in v. */ template static size_t which(const std::vector& v, const T& which) throw (ElementNotFoundException ) { for (size_t i = 0; i < v.size(); i++) { if (v[i] == which) return i; } throw ElementNotFoundException("VectorTools::which.", &v, &which); } /** * @brief Send the positions of all occurences of 'which'. * * Comparisons are performed using the == operator. * Complexity: O(v.size()). * * @param v The std::vector to search. * @param which The element to search. * @return A std::vector containing the positions of which in v. */ template static std::vector whichAll(const std::vector& v, const T& which) throw (ElementNotFoundException ) { std::vector w; for (size_t i = 0; i < v.size(); i++) { if (v[i] == which) w.push_back(i); } if (w.size()) return w; throw ElementNotFoundException("VectorTools::whichAll.", &v, &which); } /** * @brief Send a new std::vector with unique elements. * * The input std::vector is copied, and the copy is sorted using QuickSort algorithm. * A one-pass loop then look for duplicates and copy unique element to a result std::vector. * The output std::vector is hence sorted. * * If v is empty, it is passed 'as is' in return (after being copied). * * @param v the std::vector to parse. */ template static std::vector unique(const std::vector& v) { if (v.size() == 0) return v; std::vector sortedV(v.begin(), v.end()); sort(sortedV.begin(), sortedV.end()); std::vector uniq; uniq.push_back(sortedV[0]); for (size_t i = 1; i < sortedV.size(); i++) { if (sortedV[i] != sortedV[i - 1]) uniq.push_back(sortedV[i]); } return uniq; } /** * @brief Tell if the std::vector as unique elements. * * The input std::vector is copied, and the copy is sorted using QuickSort algorithm. * A one-pass loop then look for duplicates. * * If v is empty, the method returns 'true'. * * @param v the std::vector to parse. */ template static bool isUnique(const std::vector& v) { if (v.size() == 0) return true; std::vector sortedV(v.begin(), v.end()); sort(sortedV.begin(), sortedV.end()); for (size_t i = 1; i < sortedV.size(); i++) { if (sortedV[i] == sortedV[i - 1]) return false; } return true; } /** * @author Laurent Gueguen * @param v1 the std::vector of elements, * @param v2 the std::vector of the selected positions * @return the std::vector of the selected elements, in the order of the * required positions */ template static std::vector extract(const std::vector& v1, const std::vector& v2) { std::vector v(v2.size()); for (size_t i = 0; i < v2.size(); i++) { v[i] = v1[v2[i]]; } return v; } /** * @brief Count each element of a std::vector. * * @return A map with keys = unique std::vector values and values = count for each std::vector value. * @param v the std::vector to parse. */ template static std::map countValues(const std::vector& v) { std::map c; for (size_t i = 0; i < v.size(); i++) { c[v[i]]++; } return c; } /** * @brief Get the break points for a given number of classes. * * Given a std::vector of values, return the values that cut the range of values * in a given number of classes. * * @param v The std::vector to parse. * @param n The expected number of classes. * @return a std::vector of size = n + 1 containing the breaking points. */ static std::vector breaks(const std::vector& v, unsigned int n); /** * @brief Get the optimal class number following Scott's method. * * Use Scott's (1979) method to compute the optimal class number for histogram. * * Scott, D.W. (1979) On optimal and data-based histograms. Biometrika, 66, 605¿610. * * @param v The std::vector to parse. * @return The number of classes. */ template static size_t nclassScott(const std::vector& v) { std::vector r1 = VectorTools::range(v); T r = r1[1] - r1[0]; double n = v.size(); double h = 3.5 * VectorTools::sd(v) * std::pow(n, -1. / 3); return (size_t) ceil(r / h); } /** * @return The product of all elements in a std::vector. * @param v1 A std::vector. */ template static T prod(const std::vector& v1) { T p = 1; for (size_t i = 0; i < v1.size(); i++) { p *= v1[i]; } return p; } /** * @return The cumulative product of all elements in a std::vector. * @param v1 A std::vector. * @author Julien Dutheil */ template static std::vector cumProd(const std::vector& v1) { std::vector p(v1.size()); if (v1.size() == 0) return p; p[0] = v1[0]; for (size_t i = 1; i < v1.size(); i++) { p[i] = v1[i] * p[i - 1]; } return p; } /** * @return The sum of all elements in a std::vector. * @param v1 A std::vector. */ template static T sum(const std::vector& v1) { T s = 0; for (size_t i = 0; i < v1.size(); i++) { s += v1[i]; } return s; } /** * @return The cumulative sum of all elements in a std::vector. * @param v1 A std::vector. * @author Julien Dutheil */ template static std::vector cumSum(const std::vector& v1) { std::vector s(v1.size()); if (v1.size() == 0) return s; s[0] = v1[0]; for (size_t i = 1; i < v1.size(); i++) { s[i] = v1[i] + s[i - 1]; } return s; } /** * @author Laurent Gueguen * @return Log-normalize std::vector v1, ie add a constant to the elements of v * such that @f$\sum_i(\exp(v_i)) = 1@f$. * @param v std::vector. */ template static void logNorm(std::vector& v) { T M = max(v); T x = std::exp(v[0] - M); for (size_t i = 1; i < v.size(); i++) { x += std::exp(v[i] - M); } v -= M + std::log(x); } /** * @author Laurent Gueguen * @return From std::vector v1, return @f$\log(\sum_i(\exp(v1_i)))@f$. * @param v1 a std::vector. */ template static T logSumExp(const std::vector& v1) { T M = max(v1); T x = std::exp(v1[0] - M); for (size_t i = 1; i < v1.size(); i++) { x += std::exp(v1[i] - M); } return std::log(x) + M; } /** * @author Laurent Gueguen * @return From std::vector v1, return @f$\log(\sum_i(v2_i * \exp(v1_i)))@f$. * @param v1 a std::vector. * @param v2 another std::vector. */ template static T logSumExp(const std::vector& v1, const std::vector& v2) { size_t size; if (v1.size() != v2.size()) throw DimensionException("VectorTools::logsumexp", v1.size(), v2.size()); else size = v1.size(); T M = max(v1); T x = v2[0] * std::exp(v1[0] - M); for (size_t i = 1; i < size; i++) { x += v2[i] * std::exp(v1[i] - M); } return std::log(x) + M; } /** * @author Laurent Gueguen * @return From std::vector v1, return @f$\log(\textrm{mean}_i(\exp(v1_i)))@f$. * @param v1 a std::vector. */ template static T logMeanExp(const std::vector& v1) { T M = max(v1); T x = std::exp(v1[0] - M); for (size_t i = 1; i < v1.size(); i++) { x += std::exp(v1[i] - M); } return std::log(x) + M - std::log(v1.size()); } /** * @author Laurent Gueguen * @return From std::vector v1, return @f$\sum_i(\exp(v1_i))@f$. * @param v1 a std::vector. */ template static T sumExp(const std::vector& v1) { T M = max(v1); T x = std::exp(v1[0] - M); for (size_t i = 1; i < v1.size(); i++) { x += std::exp(v1[i] - M); } return x * std::exp(M); } /** * @author Laurent Gueguen * @return From std::vector v1, return @f$\sum_i(v2_i * \exp(v1_i))@f$. * @param v1 a std::vector. * @param v2 another std::vector. */ template static T sumExp(const std::vector& v1, const std::vector& v2) { size_t size; if (v1.size() != v2.size()) throw DimensionException("VectorTools::logsumexp", v1.size(), v2.size()); else size = v1.size(); T M = max(v1); T x = v2[0] * std::exp(v1[0] - M); for (size_t i = 1; i < size; i++) { x += v2[i] * std::exp(v1[i] - M); } return x * std::exp(M); } /** * @name These methods apply the corresponding function to each element * and return the result in a new std::vector. * * @{ */ template static std::vector log(const std::vector& v1) { std::vector v2(v1.size()); for (size_t i = 0; i < v2.size(); i++) { v2[i] = std::log(v1[i]); } return v2; } template static std::vector log(const std::vector& v1, double base) { std::vector v2(v1.size()); for (size_t i = 0; i < v2.size(); i++) { v2[i] = std::log(v1[i]) / std::log(base); } return v2; } template static std::vector exp(const std::vector& v1) { std::vector v2(v1.size()); for (size_t i = 0; i < v2.size(); i++) { v2[i] = std::exp(v1[i]); } return v2; } template static std::vector cos(const std::vector& v1) { std::vector v2(v1.size()); for (size_t i = 0; i < v2.size(); i++) { v2[i] = std::cos(v1[i]); } return v2; } template static std::vector sin(const std::vector& v1) { std::vector v2(v1.size()); for (size_t i = 0; i < v2.size(); i++) { v2[i] = std::sin(v1[i]); } return v2; } template static std::vector log10(const std::vector& v1) { std::vector v2(v1.size()); for (size_t i = 0; i < v1.size(); i++) { v2[i] = std::log10(v1[i]); } return v2; } template static std::vector fact(const std::vector& v1) { std::vector v2(v1.size()); for (size_t i = 0; i < v1.size(); i++) { v2[i] = NumTools::fact(v1[i]); } return v2; } template static std::vector sqr(const std::vector& v1) { std::vector v2(v1.size()); for (size_t i = 0; i < v1.size(); i++) { v2[i] = NumTools::sqr(v1[i]); } return v2; } template static std::vector pow(const std::vector& v1, T& b) { std::vector v2(v1.size()); for (size_t i = 0; i < v1.size(); i++) { v2[i] = std::pow(v1[i], b); } return v2; } /** @} */ /** * @brief Concatenate a std::vector after converting to string. * * @param v The std::vector to concatenate. * @param delim A string which is used to separate the values (default is " "). */ template static std::string paste(const std::vector& v, const std::string& delim = " ") { std::ostringstream out; out.precision(12); for (size_t i = 0; i < v.size(); i++) { out << v[i]; if (i < v.size() - 1) out << delim; } return out.str(); } /** * @brief Print a std::vector to a stream. * @param v1 A std::vector. * @param out A stream. * @param delim A string which is used to separate the values (default is " "). */ template static void print(const std::vector& v1, OutputStream& out = * ApplicationTools::message, const std::string& delim = " ") { for (size_t i = 0; i < v1.size(); i++) { out << v1[i]; if (i < v1.size() - 1) out << delim; } out.endLine(); } /** * @brief Print a std::vector to a stream in R format * @param v1 A std::vector. * @param variableName the variable name (default "x"). * @param out A stream (default cout). */ template static void printForR(const std::vector& v1, std::string variableName = "x", std::ostream& out = std::cout) { out.precision(12); out << variableName << "<-c("; for (size_t i = 0; i < v1.size(); i++) { out << v1[i]; if (i < v1.size() - 1) out << ", "; } out << ")" << std::endl; } /** * @return The scalar product of two std::vectors. * @param v1 First std::vector. * @param v2 Second std::vector. * @throw DimensionException If the two std::vector do not have the same length. */ template static OutputType scalar(const std::vector& v1, const std::vector& v2) throw (DimensionException) { if (v1.size() != v2.size()) { throw DimensionException("VectorFunctions::scalar", v1.size(), v2.size()); } OutputType result = 0; for (size_t i = 0; i < v1.size(); i++) { result += v1[i] * v2[i]; } return result; } /** * This dt product correspond to the dot product in the space defined by * @f[ * M = * \begin{pmatrix} * w_1 & \ldots & \\ * \vdots & w_2 & \ldots\\ * & \vdots & \ddots\\ * \end{pmatrix} * @f] * @return The "weighted" scalar product of two std::vectors. * @param v1 First std::vector. * @param v2 Second std::vector. * @param w A std::vector of weights. * @throw DimensionException If the two std::vector do not have the same length or do not match the length of the weights. */ template static OutputType scalar(const std::vector& v1, const std::vector& v2, const std::vector& w) throw (DimensionException) { if (v1.size() != w.size()) { throw DimensionException("VectorFunctions::scalar", v1.size(), w.size()); } if (v2.size() != w.size()) { throw DimensionException("VectorFunctions::scalar", v2.size(), w.size()); } OutputType result = 0; for (size_t i = 0; i < v1.size(); i++) { result += v1[i] * v2[i] * w[i]; } return result; } /** * @return The scalar Kronecker product of two std::vectors. * @param v1 First std::vector. * @param v2 Second std::vector. * @throw DimensionException If the two std::vector do not have the same length. */ template static std::vector kroneckerMult(const std::vector& v1, const std::vector& v2) throw (DimensionException) { size_t n1 = v1.size(); size_t n2 = v2.size(); std::vector v3(n1 * n2); for (size_t i = 0; i < n1; i++) { T v1i = v1[i]; for (size_t j = 0; j < n2; j++) { v3[i * n2 + j] = v1i * v2[j]; } } return v3; } /** * @return The norm of a std::vector (@f$\sqrt{\sum_i^n x_i^2}@f$). * @param v1 A std::vector. */ template static OutputType norm(const std::vector& v1) { OutputType result = 0; for (size_t i = 0; i < v1.size(); i++) { result += v1[i] * v1[i]; } return sqrt(result); } /** * @return The "weighted" norm of a std::vector (@f$\sqrt{\sum_i^n x_i^2}@f$). * @param v1 A std::vector. * @param w A std::vector of weights. * @throw DimensionException If v1 and w do not have the same length. * @see scalar. */ template static OutputType norm(const std::vector& v1, const std::vector& w) throw (DimensionException) { if (v1.size() != w.size()) { throw DimensionException("VectorFunctions::norm", v1.size(), w.size()); } OutputType result = 0; for (size_t i = 0; i < v1.size(); i++) { result += v1[i] * v1[i] * w[i]; } return sqrt(result); } /** * @return The cosinus of the angle of two std::vectors. * @param v1 First std::vector. * @param v2 Second std::vector. * @throw DimensionException If the two std::vector do not have the same length. */ template static OutputType cos(const std::vector& v1, const std::vector& v2) throw (DimensionException) { return scalar(v1, v2) / (norm(v1) * norm(v2)); } /** * @return The weighted cosinus of the angle of two std::vectors. * @param v1 First std::vector. * @param v2 Second std::vector. * @param w A std::vector of weights. * @throw DimensionException If the two std::vector do not have the same length. */ template static OutputType cos(const std::vector& v1, const std::vector& v2, const std::vector& w) throw (DimensionException) { return scalar(v1, v2, w) / (norm(v1, w) * norm(v2, w)); } /** * @name Extrema. * * @{ */ /** * @brief Template function to get the minimum value of a std::vector. * * The < operator must be defined for the specified class. * * @param v The input std::vector. * @return The minimum value in the std::vector. * @throw EmptyVectorException If the input std::vector is empty. */ template static T min(const std::vector& v) throw (EmptyVectorException ) { if (v.size() == 0) throw EmptyVectorException("VectorFunctions::min()", &v); T mini = v[0]; for (size_t i = 1; i < v.size(); i++) { if (v[i] < mini) mini = v[i]; } return mini; } /** * @brief Template function to get the maximum value of a std::vector. * * The > operator must be defined for the specified class. * * @param v The input std::vector. * @return The maximum value in the std::vector. * @throw EmptyVectorException If the input std::vector is empty. */ template static T max(const std::vector& v) throw (EmptyVectorException ) { if (v.size() == 0) throw EmptyVectorException("VectorFuntions::max()", &v); T maxi = v[0]; for (size_t i = 1; i < v.size(); i++) { if (v[i] > maxi) maxi = v[i]; } return maxi; } /** * @brief Template function to get the index of the maximum value of a std::vector. * * The > operator must be defined for the specified class. * The position sent is the first one matching the maximum value. * * @param v The input std::vector. * @return The position of the maximum value in the std::vector. * @throw EmptyVectorException If the input std::vector is empty. */ template static size_t whichMax(const std::vector& v) throw (EmptyVectorException ) { if (v.size() == 0) throw EmptyVectorException("VectorFuntions::whichMax()", &v); T maxi = v[0]; size_t pos = 0; for (size_t i = 1; i < v.size(); i++) { if (v[i] > maxi) { maxi = v[i]; pos = i; } } return pos; } /** * @brief Template function to get the index of the minimum value of a std::vector. * * The < operator must be defined for the specified class. * The position sent is the first one matching the maximum value. * * @param v The input std::vector. * @return The position of the minimum value in the std::vector. * @throw EmptyVectorException If the input std::vector is empty. */ template static size_t whichMin(const std::vector& v) throw (EmptyVectorException ) { if (v.size() == 0) throw EmptyVectorException("VectorFunctions::whichMin()", &v); T mini = v[0]; size_t pos = 0; for (size_t i = 1; i < v.size(); i++) { if (v[i] < mini) { mini = v[i]; pos = i; } } return pos; } /** * @brief Template function to get the indices of the maximum value of a std::vector. * * The > and == operator must be defined for the specified class. * All positions matching the maximum value are returned. * * @param v The input std::vector. * @return A vector of positions matching the maximum value in the std::vector. * @throw EmptyVectorException If the input std::vector is empty. */ template static std::vector whichMaxAll(const std::vector& v) throw (EmptyVectorException ) { if (v.size() == 0) throw EmptyVectorException("VectorFuntions::whichMaxAll()", &v); T maxi = max(v); std::vector pos; for (size_t i = 0; i < v.size(); i++) { if (v[i] == maxi) { pos.push_back(i); } } return pos; } /** * @brief Template function to get the indices of the minimum value of a std::vector. * * The < and == operator must be defined for the specified class. * All positions matching the maximum value are returned. * * @param v The input std::vector. * @return A vector of positions matching the minimum value in the std::vector. * @throw EmptyVectorException If the input std::vector is empty. */ template static std::vector whichMinAll(const std::vector& v) throw (EmptyVectorException ) { if (v.size() == 0) throw EmptyVectorException("VectorFuntions::whichMinAll()", &v); T mini = min(v); std::vector pos; for (size_t i = 0; i < v.size(); i++) { if (v[i] == mini) { pos.push_back(i); } } return pos; } /** * @brief Template function to get both extrema of a std::vector. * * Both < and > operators must be defined for the specified class. * * @param v The input std::vector. * @return A std::vector of size 2 which values are min(v) and max(v). * throw EmptyVectorException If the input std::vector is empty. */ template static std::vector range(const std::vector& v) throw (EmptyVectorException ) { if (v.size() == 0) throw EmptyVectorException("VectorTools::range()", &v); std::vector r(2); r[0] = r[1] = v[0]; for (size_t i = 1; i < v.size(); i++) { if (v[i] < r[0]) r[0] = v[i]; if (v[i] > r[1]) r[1] = v[i]; } return r; } private: template class order_Cmp_ { const std::vector& values_; public: order_Cmp_(const std::vector& v) : values_(v) {} bool operator()(size_t a, size_t b) { return values_[a] < values_[b]; } }; public: /** * @brief Template function to get the order of elements in the input vector. * * This function is equivalent to the R 'order' function. It will sort elements by increasing size, so that [0] in the resulting outptu vector is the indice of the minimum element in the input vector, [1] is the second minimum, etc. * * @param v The input std::vector. * @return Vector with sorted positions, according to input vector. * throw EmptyVectorException If the input std::vector is empty. */ template static std::vector order(const std::vector& v) throw (EmptyVectorException ) { if (v.size() == 0) throw EmptyVectorException("VectorTools::sort()", &v); // Private inner class: std::vector index(v.size()); for (size_t i = 0; i < index.size(); ++i) { index[i] = i; } sort(index.begin(), index.end(), order_Cmp_(v)); return index; } /** @} */ /** * @brief Template function to get the absolute value of all elements of a std::vector. * * * @param v The input std::vector. * @return A vector with all absolute values. */ template static std::vector abs(const std::vector& v) throw (EmptyVectorException ) { std::vector vabs(v.size()); for (size_t i = 1; i < v.size(); i++) { vabs[i] = std::abs(v[i]); } return vabs; } /** * @return The mean value of the std::vector. * @param v1 A std::vector. */ template static OutputType mean(const std::vector& v1) { return (OutputType)sum(v1) / (OutputType)v1.size(); } /** * @return The weighted mean value of the std::vector. * @param v1 A std::vector. * @param w A std::vector of weights. * @param normalizeWeights Tell if weights should be normalized so that they sum to 1. */ template static OutputType mean(const std::vector& v1, const std::vector& w, bool normalizeWeights = true) { if (normalizeWeights) { std::vector wn = w / sum(w); return scalar(v1, wn); } else { return scalar(v1, w); } } /** * @return The median value of the std::vector. * @param v1 A std::vector. */ template static InputType median(std::vector& v1) { InputType med = 0; if (v1.size() == 0) return med; if (v1.size() == 1) return v1[0]; sort(v1.begin(), v1.end()); size_t i = v1.size() / 2; if (v1.size() % 2 == 0) { // Vector size is pair med = double((v1[i - 1] + v1[i]) / 2); } else { // Vector size is impair med = v1[i]; } return med; } /** * @brief Set the mean of a std::vector to be 0. * * @return A std::vector with mean 0. * @param v1 A std::vector. */ template static std::vector center(const std::vector& v1) { OutputType m = mean(v1); std::vector v(v1.size()); for (size_t i = 0; i < v1.size(); i++) { v[i] = (OutputType)v1[i] - m; } return v; } /** * @brief Set the weighted mean of a std::vector to be 0. * * @return A std::vector with mean 0. * @param v1 A std::vector. * @param w A std::vector of weights. * @param normalizeWeights Tell if weights should be normalized so that they sum to 1. */ template static std::vector center(const std::vector& v1, const std::vector& w, bool normalizeWeights = true) { OutputType m = mean(v1, w, normalizeWeights); std::vector v(v1.size()); for (size_t i = 0; i < v1.size(); i++) { v[i] = (OutputType)v1[i] - m; } return v; } /** * @return The covariance of two std::vectors. * @param v1 First std::vector. * @param v2 Second std::vector. * @param unbiased Tell if an unbiased estimate must be computed. * @throw DimensionException If the two std::vector do not have the same length. */ template static OutputType cov(const std::vector& v1, const std::vector& v2, bool unbiased = true) throw (DimensionException) { OutputType n = (OutputType)v1.size(); OutputType x = scalar( center(v1), center(v2) ) / n; if (unbiased) x = x * n / (n - 1); return x; } /** * @return The weighted covariance of two std::vectors. * To have a population estimate you have to multiply by \f$\frac{n}{n-1}\f$. * @param v1 First std::vector. * @param v2 Second std::vector. * @param w A std::vector of weights. * @param unbiased Tell if an unbiased estimate must be computed. * @param normalizeWeights Tell if weights should be normalized so that they sum to 1. * @throw DimensionException If the two std::vector do not have the same length. */ template static OutputType cov(const std::vector& v1, const std::vector& v2, const std::vector& w, bool unbiased = true, bool normalizeWeights = true) throw (DimensionException) { if (normalizeWeights) { std::vector wn = w / sum(w); OutputType x = scalar( center(v1, wn, false), center(v2, wn, false), wn ); if (unbiased) { x = x / (1 - sum(sqr(wn))); } return x; } else { OutputType x = scalar( center(v1, w, false), center(v2, w, false), w ); if (unbiased) { x = x / (1 - sum(sqr(w))); } return x; } } /** * @return The variance of the std::vector. * @param v1 The sample std::vector. * @param unbiased Tell if an unbiased estimate must be computed. */ template static OutputType var(const std::vector& v1, bool unbiased = true) { return cov(v1, v1, unbiased); } /** * @return The weighted variance of the std::vector. * @param v1 The sample std::vector. * @param w A std::vector of weights. * @param unbiased Tell if an unbiased estimate must be computed. * @param normalizeWeights Tell if weights should be normalized so that they sum to 1. * @throw DimensionException If v1 and w do not have the same length. */ template static OutputType var(const std::vector& v1, const std::vector& w, bool unbiased = true, bool normalizeWeights = true) throw (DimensionException) { return cov(v1, v1, w, unbiased, normalizeWeights); } /** * @return The standard deviation of the std::vector. * @param v1 The sample std::vector. * @param unbiased Tell if an unbiased estimate must be computed. */ template static OutputType sd(const std::vector& v1, bool unbiased = true) { return sqrt(var(v1, unbiased)); } /** * @return The weighted standard deviation of the std::vector. * @param v1 The sample std::vector. * @param w A std::vector of weights. * @param unbiased Tell if an unbiased estimate must be computed. * @param normalizeWeights Tell if weights should be normalized so that they sum to 1. * @throw DimensionException If v1 and w do not have the same length. */ template static OutputType sd(const std::vector& v1, const std::vector& w, bool unbiased = true, bool normalizeWeights = true) throw (DimensionException) { return sqrt(var(v1, w, unbiased, normalizeWeights)); } /** * @return The Pearson correlation coefficient of two std::vectors. * @param v1 First std::vector. * @param v2 Second std::vector. * @throw DimensionException If the two std::vector do not have the same length. */ template static OutputType cor(const std::vector& v1, const std::vector& v2) throw (DimensionException) { return cov(v1, v2) / ( sd(v1) * sd(v2) ); } /** * @return The weighted Pearson correlation coefficient of two std::vectors. * @param v1 First std::vector. * @param v2 Second std::vector. * @param w A std::vector of weights. * @param normalizeWeights Tell if weights should be normalized so that they sum to 1. * @throw DimensionException If the two std::vector do not have the same length. */ template static OutputType cor(const std::vector& v1, const std::vector& v2, const std::vector& w, bool normalizeWeights = true) throw (DimensionException) { if (normalizeWeights) { std::vector wn = w / sum(w); return cov(v1, v2, wn, false, false) / ( sd(v1, wn, false, false) * sd(v2, wn, false, false) ); } else { return cov(v1, v2, w, false, false) / ( sd(v1, w, false, false) * sd(v2, w, false, false) ); } } /** * @return Compute the Shannon entropy indice of a vector of frequencies. * * The elements of the vector should contain frequencies * of each modality of the variable and sum to one. This verification is left to the user * though. * * @author Julien Dutheil * @see shannonDiscrete for computing the shannon indice of a sample, discrete version. * @see shannonContinuous for computing the shannon indice of a sample, continuous version. * * @param v The input std::vector. * @param base The base of the logarithm to use. */ template static OutputType shannon(const std::vector& v, double base = 2.7182818) { OutputType s = 0; for (size_t i = 0; i < v.size(); i++) { if (v[i] > 0) s += static_cast(v[i] * std::log(v[i]) / std::log(base)); } return -s; } /** * @return Compute the Shannon entropy indice of a vector. * * This is the discrete version. The vector is supposed to be a finite sample from * a discrete distribution. The counts of each observed state are computed and used * to compute the discrete entropy. * * @author Julien Dutheil * @see shannonContinuous for the continuous version. * @see shannon for direct computation from frequencies. * * @param v The input std::vector. * @param base The base of the logarithm to use. */ template static OutputType shannonDiscrete(const std::vector& v, double base = 2.7182818) { std::map counts; for (size_t i = 0; i < v.size(); i++) { counts[v[i]]++; } OutputType s = 0; double n = static_cast(v.size()); for (typename std::map::iterator it = counts.begin(); it != counts.end(); it++) { s += static_cast((it->second / n) * std::log(it->second / n) / std::log(base)); } return -s; } /** * @return Compute mutual information index from two samples from discrete variables. * * This is the discrete version. Each vector is supposed to be a finite sample from * a discrete distribution. The counts of each (joint) observed state are computed * and used to compute the discrete mutual information. * * @author Julien Dutheil * @see miContinuous. * * @param v1 The first input vector. * @param v2 The second input vector. * @param base The base of the logarithm to use. * @throw DimensionException if the two vectors do not have the same lengths. */ template static OutputType miDiscrete(const std::vector& v1, const std::vector& v2, double base = 2.7182818) throw (DimensionException) { if (v1.size() != v2.size()) throw DimensionException("VectorTools::miDiscrete. The two samples must have the same length.", v2.size(), v1.size()); std::map counts1; std::map counts2; std::map > counts12; for (size_t i = 0; i < v1.size(); i++) { counts1[v1[i]]++; counts2[v2[i]]++; counts12[v1[i]][v2[i]]++; } OutputType s = 0; double n = static_cast(v1.size()); for (typename std::map >::iterator it1 = counts12.begin(); it1 != counts12.end(); it1++) { for (typename std::map::iterator it2 = it1->second.begin(); it2 != it1->second.end(); it2++) { s += static_cast((it2->second / n) * std::log(it2->second * n / (counts1[it1->first] * counts2[it2->first])) / std::log(base)); } } return s; } /** * @return Compute the Shannon entropy indice of a sample from a continuous variable. * * This is the continuous version. The vector is supposed to be a finite sample from * a continuous distribution. The density is of the distribution is estimated using * a kernel method, and is used to compute the continuous entropy. * * Reference: Ivan Kojadinovic (2004) _Computational Statistics & Data Analysis_, 46:269-294 * * @author Julien Dutheil * @see shannon For the discrete version. * * @param v The input std::vector. * @param base The base of the logarithm to use. */ template static OutputType shannonContinuous(const std::vector& v, double base = 2.7182818) { LinearMatrix m(1, v.size()); for (size_t i = 0; i < v.size(); i++) { m(0, i) = v[i]; } AdaptiveKernelDensityEstimation kd(m); OutputType s = 0; std::vector x(1); for (size_t i = 0; i < v.size(); i++) { x[0] = static_cast(v[i]); s += static_cast(std::log(kd.kDensity(x)) / std::log(base)); } return -s / static_cast(v.size()); } /** * @return Compute mutual information index from two samples from continuous variables. * * This is the continuous version. Each vector is supposed to be a finite sample from * a continuous distribution. The density is of the distribution is estimated using * a kernel method, as well as the joint density, and are used to compute the continuous * mutual information. * * Reference: Ivan Kojadinovic (2004) _Computational Statistics & Data Analysis_, 46:269-294 * * @author Julien Dutheil * @see miDiscrete For the discrete version. * @warning This function is experimental. Notably, bad kernel density estimates may lead to negative MI :( * * @param v1 The first input vector. * @param v2 The second input vector. * @param base The base of the logarithm to use. * @throw DimensionException if the two vectors do not have the same lengths. */ template static OutputType miContinuous(const std::vector& v1, const std::vector& v2, double base = 2.7182818) throw (DimensionException) { if (v1.size() != v2.size()) throw DimensionException("VectorTools::miContinuous. The two samples must have the same length.", v2.size(), v1.size()); LinearMatrix m1(1, v1.size()); LinearMatrix m2(1, v2.size()); LinearMatrix m12(2, v1.size()); for (size_t i = 0; i < v1.size(); i++) { m1(0, i) = m12(0, i) = v1[i]; m2(0, i) = m12(1, i) = v2[i]; } AdaptiveKernelDensityEstimation kd1(m1); AdaptiveKernelDensityEstimation kd2(m2); AdaptiveKernelDensityEstimation kd12(m12); OutputType s = 0; std::vector x1(1); std::vector x2(1); std::vector x12(2); for (size_t i = 0; i < v1.size(); i++) { x1[0] = x12[0] = static_cast(v1[i]); x2[0] = x12[1] = static_cast(v2[i]); s += static_cast(std::log(kd12.kDensity(x12) / (kd1.kDensity(x1) * kd2.kDensity(x2))) / std::log(base)); } return s / static_cast(v1.size()); } /** * @return 'true' if the two std::vectors contains the same elements, whatever their order in the container. * @param v1 First std::vector. * @param v2 Second std::vector. */ template static bool haveSameElements(const std::vector& v1, const std::vector& v2) { std::vector u1(v1); std::vector u2(v2); if (u1.size() != u2.size()) return false; std::sort(u1.begin(), u1.end()); std::sort(u2.begin(), u2.end()); return u1 == u2; } /** * @return 'true' if the two std::vectors contains the same elements, in the same frequency, whatever their order in the container. * * @warning The two input std::vectors will be sorted. * * @param v1 First std::vector. * @param v2 Second std::vector. */ template static bool haveSameElements(std::vector& v1, std::vector& v2) { if (v1.size() != v2.size()) return false; std::sort(v1.begin(), v1.end()); std::sort(v2.begin(), v2.end()); return v1 == v2; } /** * @return 'true' if a the input std::vector contains the given element. * @param vec The std::vector to check. * @param el The element to look for. */ template static bool contains(const std::vector& vec, T el) { for (size_t i = 0; i < vec.size(); i++) { if (vec[i] == el) return true; } return false; } /** * @return 'true' if a the first std::vector contains all elements of the second std::vector. * * @warning The two input std::vectors will be sorted. * * @param v1 The first std::vector to check. * @param v2 The second std::vector to check. */ template static bool containsAll(std::vector& v1, std::vector& v2) { std::sort(v1.begin(), v1.end()); std::sort(v2.begin(), v2.end()); size_t j = 0; for (size_t i = 0; i < v2.size(); i++) { if (i > 0 && v2[i] == v2[i - 1]) continue; while (j < v1.size() - 1 && v1[j] < v2[i]) j++; if (v1[j] != v2[i]) return false; } return true; } /** * @return A std::vector which is the union of two std::vectors passed as input. * Duplicate element will be removed. * @param vec1 Vector 1. * @param vec2 Vector 2. */ template static std::vector vectorUnion(const std::vector& vec1, const std::vector& vec2) { std::vector unionEl = vec1; for (size_t j = 0; j < vec2.size(); j++) { if (!contains(unionEl, vec2[j])) unionEl.push_back(vec2[j]); } return unionEl; } /** * @return A std::vector which is the union of all std::vectors passed as input. * Duplicate element will be removed. * @param vecElementL A std::vector of std::vectors. */ template static std::vector vectorUnion(const std::vector< std::vector >& vecElementL) { std::vector unionEl; for (size_t i = 0; i < vecElementL.size(); i++) { for (size_t j = 0; j < vecElementL[i].size(); j++) { if (!contains(unionEl, vecElementL[i][j])) unionEl.push_back(vecElementL[i][j]); } } return unionEl; } /** * @return A std::vector which is the intersection of two std::vectors passed as input. * @param vec1 Vector 1. * @param vec2 Vector 2. */ template static std::vector vectorIntersection(const std::vector& vec1, const std::vector& vec2) { std::vector interEl; for (size_t i = 0; i < vec1.size(); i++) { if (contains(vec2, vec1[i])) interEl.push_back(vec1[i]); } return interEl; } /** * @return A std::vector which is the intersection of all std::vectors passed as input. * @param vecElementL A std::vector of std::vectors. */ template static std::vector vectorIntersection(const std::vector< std::vector >& vecElementL) { if (vecElementL.size() == 1) return vecElementL[0]; std::vector interEl; if (vecElementL.size() == 0) return interEl; for (size_t i = 0; i < vecElementL[0].size(); i++) { bool test = true; for (size_t j = 1; test && j < vecElementL.size(); j++) { if (!contains(vecElementL[j], vecElementL[0][i])) test = false; } if (test) interEl.push_back(vecElementL[0][i]); } return interEl; } /** * @brief Append the content of a std::vector to another one. * @param vec1 Vector 1. * @param vec2 Vector 2. */ template static void append(std::vector& vec1, const std::vector& vec2) { vec1.insert(vec1.end(), vec2.begin(), vec2.end()); // for(size_t i = 0; i < vec2.size(); i++) // { // vec1.push_back(vec2[i]); // } } /** * @brief Prepend the content of a std::vector to another one. * @param vec1 Vector 1. * @param vec2 Vector 2. */ template static void prepend(std::vector& vec1, const std::vector& vec2) { vec1.insert(vec1.begin(), vec2.begin(), vec2.end()); } /** * @return A single std::vector made of the concatenation of the std::vectors passed as input. * @param vecElementL A std::vector of std::vectors. */ template static std::vector append(const std::vector< std::vector >& vecElementL) { if (vecElementL.size() == 1) return vecElementL[0]; std::vector v; if (vecElementL.size() == 0) return v; for (size_t i = 0; i < vecElementL[0].size(); i++) { v.push_back(vecElementL[0][i]); } return v; } /** * @brief Extend the content of a std::vector with another one. Only the elements not present in the first vector will be added. * @param vec1 Vector 1. * @param vec2 Vector 2. */ template static void extend(std::vector& vec1, const std::vector& vec2) { for (size_t i = 0; i < vec2.size(); i++) { if (!contains(vec1, vec2[i])) vec1.push_back(vec2[i]); } } /** * @return A single std::vector made of the repetion of the std::vectors passed as input. * @param vec A std::vector. * @param n the number of repetitions */ template static std::vector rep(const std::vector& vec, size_t n) { if (n == 1) return vec; std::vector v; if (n == 0) return v; v.resize(vec.size() * n); for (size_t i = 0; i < v.size(); i++) { v[i] = vec[i % vec.size()]; } return v; } /** * @brief This function returns the difference of two std::vectors. * * @warning The two input std::vectors will be sorted. As a consequence, the output std::vector will be also sorted. * * @param v1 First std::vector. * @param v2 Second std::vector. * @param v3 A std::vector to be populated with all elements in v1 that are not found in v2. */ template static void diff(std::vector& v1, std::vector& v2, std::vector& v3) { if (v2.size() == 0) append(v3, v1); std::sort(v1.begin(), v1.end()); std::sort(v2.begin(), v2.end()); size_t j = 0; for (size_t i = 0; i < v1.size(); i++) { if (i > 0 && v1[i] == v1[i - 1]) continue; while (j < v2.size() - 1 && v2[j] < v1[i]) j++; if (v2[j] != v1[i]) v3.push_back(v1[i]); } } /** * @brief Test function. * @return true if all tests are passed. */ static bool test(); }; } // end of namespace bpp. #endif // _VECTORTOOLS_H_ bpp-core-2.2.0/src/Bpp/Numeric/DataTable.h000664 001750 001750 00000042322 12370705300 021612 0ustar00jdutheiljdutheil000000 000000 // // File: DataTable.h // Created by: Julien Dutheil // Created on: Aug 2005 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _DataTable_H_ #define _DataTable_H_ #include "VectorTools.h" #include "DataTableExceptions.h" #include "../Exceptions.h" #include "../Text/TextTools.h" #include "../Clonable.h" // From the STL: #include #include #include namespace bpp { /** * @brief This class corresponds to a 'dataset', i.e. a table with data by rows * and variable by columns. * * Data are stored as string objects, by column. * A DataTable object is hence similar to a ColMatrix.object. * (NB: actually, ColMatrix does not exist yet...) */ class DataTable : public Clonable { protected: size_t nRow_, nCol_; std::vector< std::vector > data_; std::vector* rowNames_; std::vector* colNames_; public: /** * @brief Build a new void DataTable object with nRow rows and nCol columns. * * @param nRow The number of rows of the DataTable. * @param nCol The number of columns of the DataTable. */ DataTable(size_t nRow, size_t nCol); /** * @brief Build a new void DataTable object with nCol columns. * * @param nCol The number of columns of the DataTable. */ DataTable(size_t nCol); /** * @brief Build a new void DataTable object with named columns. * * @param colNames The names of the columns of the DataTable. * @throw DuplicatedTableColumnNameException If colnames contains identical names. */ DataTable(const std::vector& colNames) throw (DuplicatedTableColumnNameException); DataTable(const DataTable& table); DataTable& operator=(const DataTable& table); DataTable* clone() const { return new DataTable(*this); } virtual ~DataTable(); public: /** * @return The element at a given position. * @param rowIndex Row number. * @param colIndex Column number. * @throw IndexOutOfBoundsException If one of the index is greater or equal to the corresponding number of columns/rows. */ std::string& operator()(size_t rowIndex, size_t colIndex) throw (IndexOutOfBoundsException); /** * @return The element at a given position. * @param rowIndex Row number. * @param colIndex Column number. * @throw IndexOutOfBoundsException If one of the index is greater or equal to the corresponding number of columns/rows. */ const std::string& operator()(size_t rowIndex, size_t colIndex) const throw (IndexOutOfBoundsException); /** * @return The element at a given position. * @param rowName Row name. * @param colName Column name. * @throw NoTableRowNamesException If the table does not have names associated to rows. * @throw NoTableColumnNamesException If the table does not have names associated to columns. * @throw TableNameNotFoundException If one of rowName or colName do not match existing names. */ std::string& operator()(const std::string& rowName, const std::string& colName) throw (NoTableRowNamesException, NoTableColumnNamesException, TableNameNotFoundException); /** * @return The element at a given position. * @param rowName Row name. * @param colName Column name. * @throw NoTableRowNamesException If the table does not have names associated to rows. * @throw NoTableColumnNamesException If the table does not have names associated to columns. * @throw TableNameNotFoundException If one of rowName or colName do not match existing names. */ const std::string& operator()(const std::string& rowName, const std::string& colName) const throw (NoTableRowNamesException, NoTableColumnNamesException, TableNameNotFoundException); /** * @return The element at a given position. * @param rowName Row name. * @param colIndex Column number. * @throw NoTableRowNamesException If the table does not have names associated to rows. * @throw IndexOutOfBoundsException If the index is greater or equal to the number of columns. * @throw TableNameNotFoundException If rowName do not match existing names. */ std::string& operator()(const std::string& rowName, size_t colIndex) throw (NoTableRowNamesException, TableNameNotFoundException, IndexOutOfBoundsException); /** * @return The element at a given position. * @param rowName Row name. * @param colIndex Column number. * @throw NoTableRowNamesException If the table does not have names associated to rows. * @throw IndexOutOfBoundsException If the index is greater or equal to the number of columns. * @throw TableNameNotFoundException If rowName do not match existing names. */ const std::string& operator()(const std::string& rowName, size_t colIndex) const throw (NoTableRowNamesException, TableNameNotFoundException, IndexOutOfBoundsException); /** * @return The element at a given position. * @param rowIndex Row number. * @param colName Column name. * @throw IndexOutOfBoundsException If the index is greater or equal to the number of rows. * @throw NoTableColumnNamesException If the table does not have names associated to columns. * @throw TableNameNotFoundException If colName do not match existing names. */ std::string& operator()(size_t rowIndex, const std::string& colName) throw (IndexOutOfBoundsException, NoTableColumnNamesException, TableNameNotFoundException); /** * @return The element at a given position. * @param rowIndex Row number. * @param colName Column name. * @throw IndexOutOfBoundsException If the index is greater or equal to the number of rows. * @throw NoTableColumnNamesException If the table does not have names associated to columns. * @throw TableNameNotFoundException If colName do not match existing names. */ const std::string& operator()(size_t rowIndex, const std::string& colName) const throw (IndexOutOfBoundsException, NoTableColumnNamesException, TableNameNotFoundException); /** * @name Work on columns. * * @{ */ /** * @return The number of columns in this table. */ size_t getNumberOfColumns() const { return nCol_; } /** * @brief Set the column names of this table. * * @param colNames The row names. * @throw DimensionException If the number of names do not match the number of columns in the table. * @throw DuplicatedTableColumnNameException If names are not unique. */ void setColumnNames(const std::vector& colNames) throw (DimensionException, DuplicatedTableColumnNameException); /** * @brief Get the column names of this table. * * @return The column names of this table. * @throw NoTableColumnNamesException If no column names are associated to this table. */ std::vector getColumnNames() const throw (NoTableColumnNamesException); /** * @brief Get a given column name. * * @param index The index of the column. * @return The column name associated to the given column. * @throw NoTableColumnNamesException If no column names are associated to this table. * @throw IndexOutOfBoundsException If index is >= number of columns. */ std::string getColumnName(size_t index) const throw (NoTableColumnNamesException, IndexOutOfBoundsException); /** * @return true If column names are associated to this table. */ bool hasColumnNames() const { return colNames_ != 0; } /** * @return The values in the given column. * @param index The index of the column. * @throw IndexOutOfBoundsException If index is >= number of columns. */ std::vector& getColumn(size_t index) throw (IndexOutOfBoundsException); /** * @return The values in the given column. * @param index The index of the column. * @throw IndexOutOfBoundsException If index is >= number of columns. */ const std::vector& getColumn(size_t index) const throw (IndexOutOfBoundsException); /** * @return The values in the given column. * @param colName The name of the column. * @throw NoTableColumnNamesException If no column names are associated to this table. * @throw TableColumnNameNotFoundException If colName do not match existing column names. */ std::vector& getColumn(const std::string& colName) throw (NoTableColumnNamesException, TableColumnNameNotFoundException); /** * @return The values in the given column. * @param colName The name of the column. * @throw NoTableColumnNamesException If no column names are associated to this table. * @throw TableColumnNameNotFoundException If colName do not match existing column names. */ const std::vector& getColumn(const std::string& colName) const throw (NoTableColumnNamesException, TableColumnNameNotFoundException); /** * @brief Tell is a given column exists. * * @param colName The name of the column to look for. * @return true if the column was found, false if not or if there are no column names. */ bool hasColumn(const std::string& colName) const; /** * @brief Delete the given column. * * @param index The index of the column. * @throw IndexOutOfBoundsException If index is >= number of columns. */ void deleteColumn(size_t index) throw (IndexOutOfBoundsException); /** * @brief Delete the given column. * * @param colName The name of the column. * @throw NoTableColumnNamesException If no column names are associated to this table. * @throw TableColumnNameNotFoundException If colName do not match existing column names. */ void deleteColumn(const std::string& colName) throw (NoTableColumnNamesException, TableColumnNameNotFoundException); /** * @brief Add a new column. * * @param newColumn The new column values. * @throw DimensionException If the number of values does not match the number of rows. * @throw TableColumnNamesException If the table has row names. */ void addColumn(const std::vector& newColumn) throw (DimensionException, TableColumnNamesException); /** * @brief Add a new column. * * @param colName The name of the column. * @param newColumn The new column values. * @throw DimensionException If the number of values does not match the number of rows. * @throw NoTableColumnNamesException If the table does not have row names. * @throw DuplicatedTableColumnNameException If colName is already used. */ void addColumn(const std::string& colName, const std::vector& newColumn) throw (DimensionException, NoTableColumnNamesException, DuplicatedTableColumnNameException); /** @} */ /** * @name Work on rows. * * @{ */ /** * @return The number of rows in this table. */ size_t getNumberOfRows() const { return nRow_; } /** * @brief Set the row names of this table. * * @param rowNames The row names. * @throw DimensionException If the number of names do not match the number of rows in the table. * @throw DuplicatedTableRowNameException If names are not unique. */ void setRowNames(const std::vector& rowNames) throw (DimensionException, DuplicatedTableRowNameException); /** * @brief Get the row names of this table. * * @return The row names of this table. * @throw NoTableRowNamesException If no row names are associated to this table. */ std::vector getRowNames() const throw (NoTableRowNamesException); /** * @brief Tell is a given row exists. * * @param rowName The name of the row to look for. * @return true if the row was found, false if not or if there are no row names. */ bool hasRow(const std::string& rowName) const; /** * @brief Get a given row name. * * @param index The index of the row. * @return The row name associated to the given row. * @throw NoTableRowNamesException If no row names are associated to this table. * @throw IndexOutOfBoundsException If index is >= number of rows. */ std::string getRowName(size_t index) const throw (NoTableRowNamesException, IndexOutOfBoundsException); /** * @return true If row names are associated to this table. */ bool hasRowNames() const { return rowNames_ != 0; } /** * @return A vector which contains a copy in the given row. * @param index The index of the row. * @throw IndexOutOfBoundsException If index is >= number of rows. */ std::vector getRow(size_t index) const throw (IndexOutOfBoundsException); /** * @return A vector which contains a copy in the given row. * @param rowName The name of the row. * @throw NoTableRowNamesException If no row names are associated to this table. * @throw TableRowNameNotFoundException If rowName do not match existing row names. */ std::vector getRow(const std::string& rowName) const throw (NoTableRowNamesException, TableRowNameNotFoundException); /** * @brief Delete the given row. * * @param index The index of the row. * @throw IndexOutOfBoundsException If index is >= number of row. */ void deleteRow(size_t index) throw (IndexOutOfBoundsException); /** * @brief Delete the given row. * * @param rowName The name of the row. * @throw NoTableRowNamesException If no row names are associated to this table. * @throw TableRowNameNotFoundException If rowName do not match existing column names. */ void deleteRow(const std::string& rowName) throw (NoTableRowNamesException, TableRowNameNotFoundException); /** * @brief Add a new row. * * @param newRow The new row values. * @throw DimensionException If the number of values does not match the number of columns. * @throw TableRowNamesException If the table has column names. */ void addRow(const std::vector& newRow) throw (DimensionException, TableRowNamesException); /** * @brief Add a new row. * * @param rowName The name of the row. * @param newRow The new row values. * @throw DimensionException If the number of values does not match the number of columns. * @throw NoTableRowNamesException If the table does not have column names. * @throw DuplicatedTableRowNameException If rowName is already used. */ void addRow(const std::string& rowName, const std::vector& newRow) throw (DimensionException, NoTableRowNamesException, DuplicatedTableRowNameException); /** @} */ public: /** * @brief Read a table form a stream in CSV-like format. * * The number of rows is given by the second line in the file. * By default, if the first line as one column less than the second one, * the first line is taken as column names, and the first column as row names. * Otherwise, no column names and no row names are specified, unless * explicitely precised by the user. * * @param in The input stream. * @param sep The column delimiter. * @param header Tell if the first line must be used as column names, otherwise use default. * @param rowNames Use a column as rowNames. If positive, use the specified column to compute rownames, otherwise use default; * @return A pointer toward a new DataTable object. */ static DataTable* read(std::istream& in, const std::string& sep = "\t", bool header = true, int rowNames = -1) throw (DimensionException, IndexOutOfBoundsException, DuplicatedTableRowNameException); /** * @brief Write a DataTable object to stream in CVS-like format. * * @param data The table to write. * @param out The output stream. * @param sep The column delimiter. * @param alignHeaders If true, add a delimiter before the first column header if there is row names. */ static void write(const DataTable& data, std::ostream& out, const std::string& sep = "\t", bool alignHeaders = false); static void write(const DataTable& data, bpp::OutputStream& out, const std::string& sep = "\t", bool alignHeaders = false); }; } // end of namespace bpp. #endif // _DataTable_H_ bpp-core-2.2.0/src/Bpp/Numeric/TransformedParameter.h000664 001750 001750 00000025377 12406010523 024125 0ustar00jdutheiljdutheil000000 000000 // // File: TransformedParameter.h // Created by: Julien Dutheil // Created on: Fri Jan 30 09:42 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 19, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _TRANSFORMEDPARAMETER_H_ #define _TRANSFORMEDPARAMETER_H_ #include "Parameter.h" #include "NumConstants.h" #include namespace bpp { /** * @brief The TransformedParameter abstract class. * * This class extends the Parameter class. * A transformed parameter does not have a constraint attached to it, and is supposed to range from -inf to +inf. * It uses a transformation in order to do this, typically using a bijection. * The exact function used to achieve the transformation depends on the implementation of the interface. */ class TransformedParameter: public Parameter { public: TransformedParameter(const std::string& name, double value): Parameter(name, value) {} TransformedParameter* clone() const = 0; public: /** * @brief Set the value of the parameter using the orignal coordinate system. * * @param value Parameter value in original coordinates. * @throw ConstraintException if the value is not correct. */ virtual void setOriginalValue(double value) throw (ConstraintException) = 0; /** * @return The current value of the parameter in orignal coordinates. */ virtual double getOriginalValue() const = 0; /** * @return The first order derivative of the transformation at the original point. * @throw NotImplementedException if the transformation does not support derivation * or if the derivation was not implemented. */ virtual double getFirstOrderDerivative() const throw (NotImplementedException) = 0; /** * @return The second order derivative of the transformation at the original point. * @throw NotImplementedException if the transformation does not support derivation * or if the derivation was not implemented. */ virtual double getSecondOrderDerivative() const throw (NotImplementedException) = 0; }; /** * @brief Parameter transformation from ] b, +inf [ or ] -inf, b [ to ]-inf, + inf [. * * The equation of the tranformation is * @f[ * x' = \begin{cases} * \log(a\cdot(x-b)) & \text{if $x < b+1$},\\ * a(x-1-b) & \text{if $a \geq b+1$}. * \end{cases} * @f] * for a transformation from ] b, +inf [ to ]-inf, + inf [. * The 'b' parameter is the lower bound and 'a' is a scaling factor set to 1 by default. * For a transformation from ] -inf, b [, the transformation is then * @f[ * x' = \begin{cases} * -\log(-a\cdot(x-b)) & \text{if $x < b-1$},\\ * -a(x-1-b) & \text{if $a \geq b-1$}. * \end{cases} * @f] */ class RTransformedParameter: public TransformedParameter { private: double scale_; double bound_; bool positive_; public: /** * @brief Build a new RTransformedParameter, with given bound and scale. * * @param name the name of the parameter. * @param value the value of th eparameter, in orginal coordinates. * @param bound the inerval bound to use. * @param positive tell if the original interval is positive or negative. * @param scale the scaling factor. */ RTransformedParameter(const std::string& name, double value, double bound = 0, bool positive = true, double scale = 1): TransformedParameter(name, 1.), scale_(scale), bound_(bound), positive_(positive) { setOriginalValue(value); } RTransformedParameter* clone() const { return new RTransformedParameter(*this); } public: void setOriginalValue(double value) throw (ConstraintException) { if (positive_ ? value <= bound_ : value >= bound_) throw ConstraintException("RTransformedParameter::setValue", this, value); if (positive_ & (value < 1 + bound_)) setValue(log(scale_ * (value - bound_))); if (positive_ & (value >= 1 + bound_)) setValue(scale_ * (value - 1. - bound_)); if (!positive_ & (value > -1 + bound_)) setValue(log(-scale_ * (value - bound_))); if (!positive_ & (value <= -1 + bound_)) setValue(-scale_ * (value - 1. - bound_)); } double getOriginalValue() const { double x = getValue(); if (positive_) if(x < 0) return exp(x) / scale_ + bound_; else return x / scale_ + 1. + bound_; else if(x < 0) return - exp(-x) / scale_ + bound_; else return - x / scale_ - 1. + bound_; } double getFirstOrderDerivative() const throw (NotImplementedException) { double x = getValue(); if (positive_) if(x < 0) return exp(x) / scale_; else return 1. / scale_; else if(x < 0) return exp(-x) / scale_; else return - 1. / scale_; } double getSecondOrderDerivative() const throw (NotImplementedException) { double x = getValue(); if (positive_) if(x < 0) return exp(x) / scale_; else return 0; else if(x < 0) return - exp(-x) / scale_; else return 0; } }; /** * @brief Parameter transformation from ] a, b [ to ]-inf, + inf [. * * The equation of the tranformation is * @f[ * x' = s\tan\left(\pi\frac{x-a}{b-a} - \frac{\pi}{2}\right) * @f] * The 'a' and 'b' parameters are the lower and upper bounds and 's' is a scaling factor set to 1 by default. * If the hyperbolic option is set to true (the default), then the following transformation is used instead: * @f[ * x' = s\,\text{atanh}\left(2\frac{x-a}{b-a} - 1\right) * @f] * */ class IntervalTransformedParameter: public TransformedParameter { private: double scale_; double lowerBound_; double upperBound_; bool hyper_; double tiny_; public: /** * @brief Build a new IntervalTransformedParameter, with given bounds and scale. * * @param name the name of the parameter. * @param value the value of th eparameter, in orginal coordinates. * @param lowerBound the inerval lower bound to use. * @param upperBound the inerval lower bound to use. * @param scale the scaling factor. * @param hyper tell if the hyberbolic function should be used (true by default). */ IntervalTransformedParameter(const std::string& name, double value, double lowerBound = 0, double upperBound = 1, double scale = 1, bool hyper = true): TransformedParameter(name, hyper ? scale * atanh(2. * (value - lowerBound) / (upperBound - lowerBound) - 1.) : scale * tan(NumConstants::PI() * (value - lowerBound)/(upperBound - lowerBound) - NumConstants::PI() / 2.)), scale_(scale), lowerBound_(lowerBound), upperBound_(upperBound), hyper_(hyper), tiny_(NumConstants::TINY()) {} IntervalTransformedParameter* clone() const { return new IntervalTransformedParameter(*this); } public: void setOriginalValue(double value) throw (ConstraintException) { if (value <= lowerBound_ || value >= upperBound_) throw ConstraintException("IntervalTransformedParameter::setValue", this, value); setValue(hyper_ ? scale_ * atanh(2. * (value - lowerBound_) / (upperBound_ - lowerBound_) - 1.) : scale_ * std::tan(NumConstants::PI() * (value - lowerBound_)/(upperBound_ - lowerBound_) - NumConstants::PI() / 2.)); } double getOriginalValue() const { double x = getValue(); double x2 = hyper_ ? (tanh(x / scale_) + 1.) * (upperBound_ - lowerBound_) / 2. + lowerBound_ : (atan(x / scale_) + NumConstants::PI() / 2.) * (upperBound_ - lowerBound_) / NumConstants::PI() + lowerBound_; return x2; } double getFirstOrderDerivative() const throw (NotImplementedException) { double x = getValue(); double x2 = hyper_ ? 1. / (pow(cosh(x / scale_), 2)) * (upperBound_ - lowerBound_) / (2. * scale_) : (upperBound_ - lowerBound_) / (NumConstants::PI() * scale_ * (pow(x / scale_, 2) + 1.)); return x2; } double getSecondOrderDerivative() const throw (NotImplementedException) { double x = getValue(); double x2 = hyper_ ? - 1. / (pow(cosh(x / scale_), 2)) * tanh(x / scale_) * (upperBound_ - lowerBound_) / (scale_ * scale_) : -2. * x * (upperBound_ - lowerBound_) / (NumConstants::PI() * pow(scale_, 3) * pow((pow(x / scale_, 2) + 1.), 2)); return x2; } }; /** * @brief 'Placebo' parameter transformation from ] b, +inf [ or ] -inf, b [ to ]-inf, + inf [. * * The class create a Transformed parameter which is exactly the same as a standard parameter. * It only implements the setOriginalValue and getOriginalValue methods, and remove the constraint. */ class PlaceboTransformedParameter: public TransformedParameter { public: PlaceboTransformedParameter(const std::string& name, double value): TransformedParameter(name, value) {} PlaceboTransformedParameter* clone() const { return new PlaceboTransformedParameter(*this); } public: void setOriginalValue(double value) throw (ConstraintException) { setValue(value); } double getOriginalValue() const { return getValue(); } double getFirstOrderDerivative() const throw (NotImplementedException) { return 1.; } double getSecondOrderDerivative() const throw (NotImplementedException) { return 0.; } }; } //end of namespace bpp. #endif //_TRANSFORMEDPARAMETER_H_ bpp-core-2.2.0/src/Bpp/Numeric/ParametrizableCollection.h000664 001750 001750 00000024366 12370705300 024757 0ustar00jdutheiljdutheil000000 000000 // // File: ParametrizableCollection.h // Created by: Laurent Guéguen // Created on: mercredi 12 juin 2013, à 14h 24 // /* Copyright or (c) or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _PARAMETRIZABLECOLLECTION_H_ #define _PARAMETRIZABLECOLLECTION_H_ #include "Parametrizable.h" #include "AbstractParameterAliasable.h" // From the STL: #include #include namespace bpp { /** * @brief Plain collection of parametrizable objects * * The collection is a map from unsigned integers to Parametrizables. * * The access to the parameters of the objects will be done through * this collection. * */ template class ParametrizableCollection : public AbstractParameterAliasable { protected: /** * @brief Contains all objects used. */ std::map objectsSet_; /** * @brief A vector of the numbers of objects that have changed * during the last fireParameterChanged. * */ std::vector vChanged_; public: /** * @brief Create an empty object set. * */ ParametrizableCollection(): AbstractParameterAliasable(""), objectsSet_(), vChanged_() { } ParametrizableCollection(const ParametrizableCollection& set) : AbstractParameterAliasable(set), objectsSet_(), vChanged_(set.vChanged_) { // Duplicate all objects: typename std::map::const_iterator it; for (it=set.objectsSet_.begin(); it!=set.objectsSet_.end(); it++) objectsSet_[it->first]=it->second->clone(); } ParametrizableCollection& operator=(const ParametrizableCollection& set) { clear(); AbstractParameterAliasable::operator=(set); vChanged_ = set.vChanged_; // Duplicate all objects: typename std::map::const_iterator it; for (it=set.objectsSet_.begin(); it!=set.objectsSet_.end(); it++) objectsSet_[it->first]=it->second->clone(); return *this; } /** * @brief Resets all the information contained in this object. * */ void clear() { resetParameters_(); typename std::map::const_iterator it; for (it=objectsSet_.begin(); it!=objectsSet_.end(); it++) delete it->second; objectsSet_.clear(); vChanged_.empty(); } ~ParametrizableCollection() { clear(); } ParametrizableCollection* clone() const { return new ParametrizableCollection(*this); } public: /** * To be called when a parameter has changed. * Depending on parameters, this will actualize the corresponding objects in the set. * @param parameters The modified parameters. */ void fireParameterChanged(const ParameterList& parameters) { vChanged_.clear(); std::vector vCh; std::map mNumPl; for (size_t i=0; i::iterator it; // Then we update all objects in the set: for (it=mNumPl.begin(); it!=mNumPl.end(); it++){ if (hasObject(it->first) && objectsSet_[it->first]->matchParametersValues(it->second)) vChanged_.push_back(it->first); } } std::vector hasChanged() const { return vChanged_; } void clearChanged() { vChanged_.clear(); } /** * @return The current number of distinct discrete objects in this set. */ size_t getNumberOfObjects() const { return objectsSet_.size(); } /** * @brief Says if there is a object with a given index. * * @param objectIndex Index of the object in the set. * @return true or false. */ const bool hasObject(size_t objectIndex) const { return (objectsSet_.find(objectIndex)!=objectsSet_.end()); } /** * @brief Returns the keys of the set. * */ const std::vector keys() const { std::vector vkeys; typename std::map::const_iterator it; for (it=objectsSet_.begin(); it!=objectsSet_.end(); it++) vkeys.push_back(it->first); return vkeys; } /** * @brief Get one object from the set knowing its index. * * @param objectIndex Index of the object in the set. * @return A pointer toward the corresponding object. */ const N* operator[](size_t objectIndex) const { typename std::map::const_iterator it=objectsSet_.find(objectIndex); if (it==objectsSet_.end()) throw BadIntegerException("ParametrizableCollection::getObject().", (int)objectIndex); return dynamic_cast(it->second); } N* operator[](size_t objectIndex) { typename std::map::iterator it=objectsSet_.find(objectIndex); if (it==objectsSet_.end()) throw BadIntegerException("ParametrizableCollection::getObject().", (int)objectIndex); return it->second; } /** * @brief Add a new object to the set with a given number. * * @throw Exception if the number is already used. See replace function instead. * * @param object A pointer toward an object, that will added to the set. * * WARNING! The set will now be the owner of the pointer, and will destroy it if needed! * Copy the object first if you don't want it to be lost! * * @param objectIndex The number of the object in the Collection * */ void addObject(N* object, size_t objectIndex) { typename std::map::iterator it=objectsSet_.find(objectIndex); if (it!=objectsSet_.end()) throw BadIntegerException("ParametrizableCollection::addObject. Object objectIndex already used", (int)objectIndex); objectsSet_[objectIndex]=object; // Associate parameters: std::string pname; std::vector nplm; nplm=object->getParameters().getParameterNames(); for (size_t i = 0; i < nplm.size(); i++) { pname = nplm[i]; Parameter* p = new Parameter(object->getParameters().getParameter(pname)); p->setName(pname + "_" + TextTools::toString(objectIndex)); addParameter_(p); } if (dynamic_cast(object)){ ParameterAliasable* ppa=dynamic_cast(object); for (size_t i = 0; i < nplm.size(); i++) { std::vector va=ppa->getAlias(nplm[i]); for (size_t j=0;j::removeObject. None Object at this objectIndex", (int)objectIndex); N* pm=objectsSet_[objectIndex]; objectsSet_.erase(objectIndex); // Erase all parameter references to this object and translate other indices... ParameterList pl=getParameters(); for (size_t i = pl.size(); i>0; i--) { std::string pn=pl[i-1].getName(); size_t pu=pn.rfind("_"); int nm=atoi(pn.substr(pu+1).c_str()); if (nm==(int)objectIndex){ std::vector alpn=getAlias(pn); for (unsigned j=0; j //From Utils: #include "../Text/TextTools.h" using namespace bpp; #include using namespace std; /******************************************************************************/ ParameterEvent::ParameterEvent(Parameter* parameter): parameter_(parameter) {} /** Constructors: *************************************************************/ Parameter::Parameter(const std::string& name, double value, Constraint* constraint, bool attachConstraint, double precision) throw (ConstraintException) : name_(name), value_(0), precision_(0), constraint_(constraint), attach_(attachConstraint), listeners_(), listenerAttach_() { // This may throw a ConstraintException: setValue(value); setPrecision(precision); } Parameter::Parameter(const std::string& name, double value, const Constraint* constraint, double precision) throw (ConstraintException) : name_(name), value_(0), precision_(0), constraint_(constraint ? constraint->clone() : 0), attach_(true), listeners_(), listenerAttach_() { // This may throw a ConstraintException: setValue(value); setPrecision(precision); } Parameter::Parameter(const Parameter& p) : name_(p.name_), value_(p.value_), precision_(p.precision_), constraint_(0), attach_(p.attach_), listeners_(p.listeners_), listenerAttach_(p.listenerAttach_) { if (p.attach_ && p.constraint_) constraint_ = p.constraint_->clone(); else constraint_ = p.constraint_; for (size_t i = 0; i < listeners_.size(); i++) if (listenerAttach_[i]) listeners_[i] = dynamic_cast(p.listeners_[i]->clone()); } Parameter& Parameter::operator=(const Parameter& p) { name_ = p.name_; value_ = p.value_; precision_ = p.precision_; attach_ = p.attach_; if (p.attach_ && p.constraint_) constraint_ = p.constraint_->clone(); else constraint_ = p.constraint_; listeners_ = p.listeners_; listenerAttach_ = p.listenerAttach_; for (size_t i = 0; i < listeners_.size(); i++) if (listenerAttach_[i]) listeners_[i] = dynamic_cast(p.listeners_[i]->clone()); return *this; } /** Destructor: ***************************************************************/ Parameter::~Parameter() { if (attach_ && constraint_) delete constraint_; for (size_t i = 0; i < listeners_.size(); i++) if (listenerAttach_[i]) delete listeners_[i]; } /** Value: ********************************************************************/ void Parameter::setValue(double value) throw (ConstraintException) { if (std::abs(value-value_)>precision_/2){ if (constraint_ && !constraint_->isCorrect(value)) throw ConstraintException("Parameter::setValue", this, value); value_ = value; ParameterEvent event(this); fireParameterValueChanged(event); } } /** Precision: ********************************************************************/ void Parameter::setPrecision(double precision) { precision_=(precision<0)?0:precision; } /** Constraint: ***************************************************************/ void Parameter::setConstraint(Constraint* constraint, bool attach) { if (!constraint){ if (constraint_ && attach_) delete constraint_; constraint_=0; attach_=false; } else { if (constraint->isCorrect(value_)) { if (constraint_ && attach_) delete constraint_; constraint_ = constraint; attach_= attach; } else throw ConstraintException("Parameter::setConstraint", this, value_); } } const Constraint* Parameter::removeConstraint() { const Constraint * c = constraint_; constraint_ = 0; return c; } /******************************************************************************/ void Parameter::removeParameterListener(const std::string& listenerId) { for (unsigned int i = 0; i < listeners_.size(); i++) { if (listeners_[i]->getId() == listenerId) { if (listenerAttach_[i]) delete listeners_[i]; listeners_.erase(listeners_.begin() + i); listenerAttach_.erase(listenerAttach_.begin() + i); } } } /******************************************************************************/ bool Parameter::hasParameterListener(const std::string& listenerId) { for (unsigned int i = 0; i < listeners_.size(); i++) if (listeners_[i]->getId() == listenerId) return true; return false; } /******************************************************************************/ const IntervalConstraint Parameter::R_PLUS(true, 0, true); const IntervalConstraint Parameter::R_PLUS_STAR(true, 0, false); const IntervalConstraint Parameter::R_MINUS(false, 0, true); const IntervalConstraint Parameter::R_MINUS_STAR(false, 0, false); const IntervalConstraint Parameter::PROP_CONSTRAINT_IN(0, 1, true, true); const IntervalConstraint Parameter::PROP_CONSTRAINT_EX(0, 1, false, false); /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Hmm/HmmLikelihood.h000664 001750 001750 00000015125 12370705300 023240 0ustar00jdutheiljdutheil000000 000000 // // File: HmmLikelihood.h // Created by: Julien Dutheil // Created on: Fri Oct 26 11:20 2007 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _HMMLIKELIHOOD_H_ #define _HMMLIKELIHOOD_H_ // From NumCalc: #include "../Function/Functions.h" #include "../VectorTools.h" #include "HmmStateAlphabet.h" #include "HmmTransitionMatrix.h" #include "HmmEmissionProbabilities.h" namespace bpp { /** * @brief Basal interface for Hidden Markov Models likelihood computation. * * HmmLikelihood classes compute the probability of data according to parameters (likelihood), * using the so-called forward recursion: * * - Initialisation: @f[ f_0({\cal A}_0), \ldots, f_0({\cal A}_n) @f] The initial frequencies, set to the equilibrium frequencies of the chain. * - Recursion (for i=1 to l, the length of the sequence data): @f[ f_i({\cal A}_y) = e_y(D_i) \sum_{x=1}^n f_{i-1}({\cal A}_x) \cdot p_{x,y} @f] * - Termination: @f[ \Pr(D) = \sum_{x=1}^n f_l({\cal A}_x) @f] * where @f$ {\cal A}_{1..n} @f$ denotes the hidden states of the alphabet, @f$ e_y(D_i) @f$ the * probability of the data at position i conditioned on hidden state y (emission probabilities) * and @f$ p_{x,y} @f$ is the probability of havving hidden state y at state i+1 knowing there * is hidden state x at position i (transition probabilities). These essential elements are given * respectively by the HmmEmissionProbabilities and HmmTransitionMatrix object associated to this * class. Both objects have to share the same HmmStateAlphabet instance, which describes all * allowed hidden states. * * The HmmLikelihood interface provides essentially two major methods: * - A method to retrieve the likelihood value (parameter estimation) * - Two methods to retrieve the posterio probabilities of each state using the forward and backward conditionnal likelihoods (posterior decoding). */ class HmmLikelihood: public virtual DerivableSecondOrder { public: #ifndef NO_VIRTUAL_COV virtual HmmLikelihood* clone() const = 0; #endif virtual const HmmStateAlphabet& getHmmStateAlphabet() const = 0; virtual HmmStateAlphabet& getHmmStateAlphabet() = 0; virtual const HmmTransitionMatrix& getHmmTransitionMatrix() const = 0; virtual HmmTransitionMatrix& getHmmTransitionMatrix() = 0; virtual const HmmEmissionProbabilities& getHmmEmissionProbabilities() const = 0; virtual HmmEmissionProbabilities& getHmmEmissionProbabilities() = 0; virtual void getHiddenStatesPosteriorProbabilities(std::vector< std::vector >& probs, bool append) const throw (Exception) = 0; virtual Vdouble getHiddenStatesPosteriorProbabilitiesForASite(size_t site) const = 0; virtual double getLogLikelihood() const = 0; virtual double getDLogLikelihood() const = 0; virtual double getD2LogLikelihood() const = 0; /** * @brief Get the likelihood for a site. * * @param site The site index to analyse. * @return The likelihood for site site. */ virtual double getLikelihoodForASite(size_t site) const = 0; /** * @brief Get the likelihood for each site. * * @return A vector with all likelihoods for each site. */ virtual Vdouble getLikelihoodForEachSite() const = 0; virtual const std::vector& getBreakPoints() const = 0; virtual void setBreakPoints(const std::vector& breakPoints) = 0; protected: virtual void computeDLikelihood_() const = 0; virtual void computeD2Likelihood_() const = 0; }; /* * @brief partial impmementation of Hmm Likelihoods. * */ class AbstractHmmLikelihood: public virtual HmmLikelihood { protected: mutable double dLogLik_; mutable std::string dVariable_; mutable double d2LogLik_; mutable std::string d2Variable_; public: AbstractHmmLikelihood(); AbstractHmmLikelihood(const AbstractHmmLikelihood& adhlik); AbstractHmmLikelihood& operator=(const AbstractHmmLikelihood& adhlik); /* @{ * * @brief From FirstOrder: * */ void enableFirstOrderDerivatives(bool yn) {}; bool enableFirstOrderDerivatives() const { return true;} double getFirstOrderDerivative(const std::string& variable) const throw (Exception); double getDLogLikelihood() const { return dLogLik_; } /* * @} * */ /* @{ * * @brief From SecondOrder: * */ void enableSecondOrderDerivatives(bool yn) {}; bool enableSecondOrderDerivatives() const {return true;} double getSecondOrderDerivative(const std::string& variable) const throw (Exception); double getD2LogLikelihood() const { return d2LogLik_; } double getSecondOrderDerivative(const std::string& variable1, const std::string& variable2) const throw (Exception) { throw (NotImplementedException("AbstractHmmLikelihood::getSecondOrderDerivative is not defined for 2 variables.")); } /* * @} * */ }; } //end of namespace bpp. #endif //_HMMLIKELIHOOD_H_ bpp-core-2.2.0/src/Bpp/Numeric/Hmm/HmmEmissionProbabilities.h000664 001750 001750 00000011662 12370705300 025456 0ustar00jdutheiljdutheil000000 000000 // // File: HmmEmissionProbabilities.h // Created by: Julien Dutheil // Created on: Fri Sep 04 13:14 2009 from file HmmLikelihood. // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _HMMEMISSIONPROBABILITIES_H_ #define _HMMEMISSIONPROBABILITIES_H_ #include "HmmStateAlphabet.h" #include "HmmExceptions.h" #include "../Parametrizable.h" //From the STL: #include namespace bpp { /** * @brief Interface for computing emission probabilities in a Hidden Markov Model. * * This class is part of the HMM framework. It compute the probabilities of the data * conditionned on each hidden state. The emission probabilities class also has in charge * the data, its putative compression, and the number of position in the sequence of * observed states. * * @see HmmStateAlphabet * @see HmmTransitionMatrix */ class HmmEmissionProbabilities: public virtual Parametrizable { public: virtual HmmEmissionProbabilities* clone() const = 0; virtual const HmmStateAlphabet* getHmmStateAlphabet() const = 0; /** * @brief Set the new hidden state alphabet. * @param stateAlphabet The new state alphabet. * @throw UnvalidStateAlphabetException if the new alphabet is uncorrect (for instance is NULL pointer). */ virtual void setHmmStateAlphabet(const HmmStateAlphabet* stateAlphabet) throw (HmmUnvalidAlphabetException) = 0; /** * @brief Operator access to the emission probabilities. * * This is the fastest way to get the values, but no checking is performed on the indices. * For debugging purpose, the getEmissionProbability would be a safer use. * * @param pos The position of the sequential data to consider. * @param state The index of the hidden state to consider, as defined by the HmmStateAlphabet object associated to this class. */ virtual double operator()(size_t pos, size_t state) const = 0; virtual void computeDEmissionProbabilities(std::string& variable) const { throw (NotImplementedException("HmmEmissionProbabilities::computeDEmissionProbabilities is not overdefined.")); } virtual void computeD2EmissionProbabilities(std::string& variable) const { throw (NotImplementedException("HmmEmissionProbabilities::computeD2EmissionProbabilities is not overdefined.")); } virtual const std::vector& getDEmissionProbabilities(size_t pos) const { throw (NotImplementedException("HmmEmissionProbabilities::getDEmissionProbability is not overdefined.")); } virtual const std::vector& getD2EmissionProbabilities(size_t pos) const { throw (NotImplementedException("HmmEmissionProbabilities::getD2EmissionProbability is not overdefined.")); } /** * @brief Operator access to the emission probabilities. * * This is the fastest way to get the values, but no checking is performed on the indices. * For debugging purpose, the getEmissionProbability would be a safer use. * * @param pos The position of the sequential data to consider. * @return A vector of probabilities, whose size is the number of hidden states. */ virtual const std::vector& operator()(size_t pos) const = 0; /** * @return The number of positions in the data. */ virtual size_t getNumberOfPositions() const = 0; }; } //end of namespace bpp. #endif //_HMMEMISSIONPROBABILITIES_H_ bpp-core-2.2.0/src/Bpp/Numeric/Hmm/RescaledHmmLikelihood.h000664 001750 001750 00000021676 12370705300 024713 0ustar00jdutheiljdutheil000000 000000 // // File: RescaledHmmLikelihood.h // Created by: Julien Dutheil // Created on: Fri Oct 26 11:57 2007 // /* Copyright or © or Copr. CNRS, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _RESCALEDHMMLIKELIHOOD_H_ #define _RESCALEDHMMLIKELIHOOD_H_ #include "HmmLikelihood.h" #include "../AbstractParametrizable.h" #include "../Matrix/Matrix.h" //From the STL: #include #include namespace bpp { /** * @brief A simple implementation of hidden Markov models recursion. * * This implementation uses the rescaling method described in Durbin et al "Biological sequence analysis", Cambridge University Press. * It also offer the possibility to specify "breakpoints", where the chain will be reset to the equilibrium frequencies. */ class RescaledHmmLikelihood: public virtual AbstractHmmLikelihood, public AbstractParametrizable { private: /** * @brief The alphabet describing the hidden states. */ std::auto_ptr hiddenAlphabet_; std::auto_ptr transitionMatrix_; std::auto_ptr emissionProbabilities_; /** * @brief The likelihood arrays. * */ /** * @brief forward likelihood * * likelihood_[i * nbStates_ + j] corresponds to Pr(x_1...x_i, y_i=j)/Pr(x_1...x_i), * where the x are the observed states, and y the hidden states. */ std::vector likelihood_; /** * @brief derivatec of forward likelihood * * dlikelihood_[i][j] corresponds to d(Pr(x_1...x_i, y_i=j))/Pr(x_1...x_i)), * where the x are the observed states, and y the hidden states. */ mutable std::vector > dLikelihood_; mutable std::vector > d2Likelihood_; /** * @brief backward likelihood * * backLikelihood_[i][j] corresponds to Pr(x_i+1...x_n | yi=j), * where the x are the observed states, and y the hidden states. */ mutable std::vector > backLikelihood_; mutable bool backLikelihoodUpToDate_; /** * @brief scales for likelihood computing * * scales_[i * nbStates_ + j] corresponds to Pr(x_1...x_i)/Pr(x_1...x_{i-1}) * where the x are the observed states. */ std::vector scales_; mutable std::vector dScales_; mutable std::vector d2Scales_; double logLik_; std::vector breakPoints_; size_t nbStates_, nbSites_; public: /** * @brief Build a new RescaledHmmLikelihood object. * * @warning the HmmTransitionMatrix and HmmEmissionProbabilities object passed as argument must be non-null * and point toward the same HmmStateAlphabet instance. The three object will be copied if needed, and * deleted when the hmm likelihood objet is deleted. You should secure a copy before if you don't want them to * be destroyed with this object. */ RescaledHmmLikelihood( HmmStateAlphabet* hiddenAlphabet, HmmTransitionMatrix* transitionMatrix, HmmEmissionProbabilities* emissionProbabilities, const std::string& prefix) throw (Exception); RescaledHmmLikelihood(const RescaledHmmLikelihood& lik): AbstractHmmLikelihood(lik), AbstractParametrizable(lik), hiddenAlphabet_(dynamic_cast(lik.hiddenAlphabet_->clone())), transitionMatrix_(dynamic_cast(lik.transitionMatrix_->clone())), emissionProbabilities_(dynamic_cast(lik.emissionProbabilities_->clone())), likelihood_(lik.likelihood_), dLikelihood_(lik.dLikelihood_), d2Likelihood_(lik.d2Likelihood_), backLikelihood_(lik.backLikelihood_), backLikelihoodUpToDate_(lik.backLikelihoodUpToDate_), scales_(lik.scales_), dScales_(lik.dScales_), d2Scales_(lik.d2Scales_), logLik_(lik.logLik_), breakPoints_(lik.breakPoints_), nbStates_(lik.nbStates_), nbSites_(lik.nbSites_) { // Now adjust pointers: transitionMatrix_->setHmmStateAlphabet(hiddenAlphabet_.get()); emissionProbabilities_->setHmmStateAlphabet(hiddenAlphabet_.get()); } RescaledHmmLikelihood& operator=(const RescaledHmmLikelihood& lik) { AbstractHmmLikelihood::operator=(lik); AbstractParametrizable::operator=(lik); hiddenAlphabet_ = std::auto_ptr(dynamic_cast(lik.hiddenAlphabet_->clone())); transitionMatrix_ = std::auto_ptr(dynamic_cast(lik.transitionMatrix_->clone())); emissionProbabilities_ = std::auto_ptr(dynamic_cast(lik.emissionProbabilities_->clone())); likelihood_ = lik.likelihood_; dLikelihood_ = lik.dLikelihood_; d2Likelihood_ = lik.d2Likelihood_; backLikelihood_ = lik.backLikelihood_; backLikelihoodUpToDate_= lik.backLikelihoodUpToDate_; scales_ = lik.scales_; dScales_ = lik.dScales_; d2Scales_ = lik.d2Scales_; logLik_ = lik.logLik_; breakPoints_ = lik.breakPoints_; nbStates_ = lik.nbStates_; nbSites_ = lik.nbSites_; // Now adjust pointers: transitionMatrix_->setHmmStateAlphabet(hiddenAlphabet_.get()); emissionProbabilities_->setHmmStateAlphabet(hiddenAlphabet_.get()); return *this; } virtual ~RescaledHmmLikelihood() {} #ifndef NO_VIRTUAL_COV RescaledHmmLikelihood* #else Clonable* #endif clone() const { return new RescaledHmmLikelihood(*this); } public: const HmmStateAlphabet& getHmmStateAlphabet() const { return *hiddenAlphabet_; } HmmStateAlphabet& getHmmStateAlphabet() { return *hiddenAlphabet_; } const HmmTransitionMatrix& getHmmTransitionMatrix() const { return *transitionMatrix_; } HmmTransitionMatrix& getHmmTransitionMatrix() { return *transitionMatrix_; } const HmmEmissionProbabilities& getHmmEmissionProbabilities() const { return *emissionProbabilities_; } HmmEmissionProbabilities& getHmmEmissionProbabilities() { return *emissionProbabilities_; } void setBreakPoints(const std::vector& breakPoints) { breakPoints_ = breakPoints; computeForward_(); backLikelihoodUpToDate_=false; } const std::vector& getBreakPoints() const { return breakPoints_; } void setParameters(const ParameterList& pl) throw (Exception) { setParametersValues(pl); } double getValue() const throw (Exception) { return -logLik_; } double getLogLikelihood() const { return logLik_; } double getLikelihoodForASite(size_t site) const; Vdouble getLikelihoodForEachSite() const; void fireParameterChanged(const ParameterList& pl); Vdouble getHiddenStatesPosteriorProbabilitiesForASite(size_t site) const; void getHiddenStatesPosteriorProbabilities(std::vector< std::vector >& probs, bool append = false) const throw (Exception); protected: void computeForward_(); void computeBackward_() const; void computeDLikelihood_() const { computeDForward_(); } void computeD2Likelihood_() const { computeD2Forward_(); } void computeDForward_() const; void computeD2Forward_() const; }; } #endif //_RESCALEDHMMLIKELIHOOD_H_ bpp-core-2.2.0/src/Bpp/Numeric/Hmm/LogsumHmmLikelihood.cpp000664 001750 001750 00000044620 12370705300 024764 0ustar00jdutheiljdutheil000000 000000 // // File: LogsumHmmLikelihood.cpp // Created by: Julien Dutheil // Created on: Fri Oct 26 11:57 2007 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "LogsumHmmLikelihood.h" // from the STL: #include #include using namespace bpp; using namespace std; LogsumHmmLikelihood::LogsumHmmLikelihood( HmmStateAlphabet* hiddenAlphabet, HmmTransitionMatrix* transitionMatrix, HmmEmissionProbabilities* emissionProbabilities, const std::string& prefix) throw (Exception): AbstractHmmLikelihood(), AbstractParametrizable(prefix), hiddenAlphabet_(hiddenAlphabet), transitionMatrix_(transitionMatrix), emissionProbabilities_(emissionProbabilities), logLikelihood_(), partialLogLikelihoods_(), logLik_(), dLogLikelihood_(), partialDLogLikelihoods_(), d2LogLikelihood_(), partialD2LogLikelihoods_(), backLogLikelihood_(), backLogLikelihoodUpToDate_(false), breakPoints_(), nbStates_(), nbSites_() { if (!hiddenAlphabet) throw Exception("LogsumHmmLikelihood: null pointer passed for HmmStateAlphabet."); if (!transitionMatrix) throw Exception("LogsumHmmLikelihood: null pointer passed for HmmTransitionMatrix."); if (!emissionProbabilities) throw Exception("LogsumHmmLikelihood: null pointer passed for HmmEmissionProbabilities."); if (!hiddenAlphabet_->worksWith(transitionMatrix->getHmmStateAlphabet())) throw Exception("LogsumHmmLikelihood: HmmTransitionMatrix and HmmEmissionProbabilities should point toward the same HmmStateAlphabet object."); if (!hiddenAlphabet_->worksWith(emissionProbabilities->getHmmStateAlphabet())) throw Exception("LogsumHmmLikelihood: HmmTransitionMatrix and HmmEmissionProbabilities should point toward the same HmmStateAlphabet object."); nbStates_ = hiddenAlphabet_->getNumberOfStates(); nbSites_ = emissionProbabilities_->getNumberOfPositions(); //Manage parameters: addParameters_(hiddenAlphabet_->getParameters()); addParameters_(transitionMatrix_->getParameters()); addParameters_(emissionProbabilities_->getParameters()); //Init arrays: logLikelihood_.resize(nbSites_ * nbStates_); //Compute: computeForward_(); } void LogsumHmmLikelihood::fireParameterChanged(const ParameterList& pl) { dVariable_=""; d2Variable_=""; bool alphabetChanged = hiddenAlphabet_->matchParametersValues(pl); bool transitionsChanged = transitionMatrix_->matchParametersValues(pl); bool emissionChanged = emissionProbabilities_->matchParametersValues(pl); // these lines are necessary because the transitions and emissions can depend on the alphabet. // we could use a StateChangeEvent, but this would result in computing some calculations twice in some cases // (when both the alphabet and other parameter changed). if (alphabetChanged && !transitionsChanged) transitionMatrix_->setParametersValues(transitionMatrix_->getParameters()); if (alphabetChanged && !emissionChanged) emissionProbabilities_->setParametersValues(emissionProbabilities_->getParameters()); computeForward_(); backLogLikelihoodUpToDate_=false; } /***************************************************************************************************************************/ void LogsumHmmLikelihood::computeForward_() { double x, a; vector logTrans(nbStates_ * nbStates_); //Transition probabilities: for (size_t i = 0; i < nbStates_; i++) { size_t ii = i * nbStates_; for (size_t j = 0; j < nbStates_; j++) logTrans[ii + j] = log(transitionMatrix_->Pij(j, i)); } //Initialisation: const vector* emissions = &(*emissionProbabilities_)(0); for (size_t j = 0; j < nbStates_; j++) { size_t jj = j * nbStates_; x = logTrans[jj] + log(transitionMatrix_->getEquilibriumFrequencies()[0]); for (size_t k = 1; k < nbStates_; k++) { a = logTrans[k + jj] + log(transitionMatrix_->getEquilibriumFrequencies()[k]); x = NumTools::logsum(x, a); } logLikelihood_[j] = log((*emissions)[j]) + x; } //Recursion: size_t nextBrkPt = nbSites_; //next break point vector::const_iterator bpIt = breakPoints_.begin(); if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; partialLogLikelihoods_.clear(); for (size_t i = 1; i < nbSites_; i++) { size_t ii = i * nbStates_; size_t iip = (i - 1) * nbStates_; emissions = &(*emissionProbabilities_)(i); if (i < nextBrkPt) { for (size_t j = 0; j < nbStates_; j++) { size_t jj = j * nbStates_; x = logTrans[jj] + logLikelihood_[iip]; for (size_t k = 1; k < nbStates_; k++) { a = logTrans[jj + k] + logLikelihood_[iip + k]; x = NumTools::logsum(x, a); } logLikelihood_[ii + j] = log((*emissions)[j]) + x; } } else //Reset markov chain: { //Termination of previous segment: double tmpLog = logLikelihood_[(i - 1) * nbStates_]; for (size_t k = 1; k < nbStates_; k++) tmpLog = NumTools::logsum(tmpLog, logLikelihood_[(i - 1) * nbStates_ + k]); partialLogLikelihoods_.push_back(tmpLog); for (size_t j = 0; j < nbStates_; j++) { size_t jj = j * nbStates_; x = logTrans[jj] + log(transitionMatrix_->getEquilibriumFrequencies()[0]); for (size_t k = 1; k < nbStates_; k++) { a = logTrans[jj + k] + log(transitionMatrix_->getEquilibriumFrequencies()[k]); x = NumTools::logsum(x, a); } logLikelihood_[ii + j] = log((*emissions)[j]) + x; } bpIt++; if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; else nextBrkPt = nbSites_; } } //Termination: double tmpLog = logLikelihood_[(nbSites_ - 1) * nbStates_]; for (size_t k = 1; k < nbStates_; k++) tmpLog = NumTools::logsum(tmpLog, logLikelihood_[(nbSites_ - 1) * nbStates_ + k]); partialLogLikelihoods_.push_back(tmpLog); //Compute likelihood: logLik_ = 0; vector copy = partialLogLikelihoods_; //We need to keep the original order for posterior decoding. sort(copy.begin(), copy.end()); for (size_t i = copy.size(); i > 0; --i) logLik_ += copy[i - 1]; } /***************************************************************************************************************************/ void LogsumHmmLikelihood::computeBackward_() const { if (backLogLikelihood_.size()==0) { backLogLikelihood_.resize(nbSites_); for (size_t i=0;i logTrans(nbStates_ * nbStates_); for (size_t i = 0; i < nbStates_; i++) { size_t ii = i * nbStates_; for (size_t j = 0; j < nbStates_; j++) logTrans[ii + j] = log(transitionMatrix_->Pij(i, j)); } //Initialisation: const vector* emissions = 0; size_t nextBrkPt = 0; //next break point vector::const_reverse_iterator bpIt = breakPoints_.rbegin(); if (bpIt != breakPoints_.rend()) nextBrkPt = *bpIt; for (size_t k = 0; k < nbStates_; k++) { backLogLikelihood_[nbSites_ - 1][k] = 0.; } //Recursion: for (size_t i = nbSites_ - 1; i > 0; i--) { emissions = &(*emissionProbabilities_)(i); if (i > nextBrkPt) { for (size_t j = 0; j < nbStates_; j++) { size_t jj = j * nbStates_; x = log((*emissions)[0]) + logTrans[jj] + backLogLikelihood_[i][0]; for (size_t k = 1; k < nbStates_; k++) { x = NumTools::logsum(x, log((*emissions)[k]) + logTrans[jj + k] + backLogLikelihood_[i][k]); } backLogLikelihood_[i - 1][j] = x; } } else //Reset markov chain { for (unsigned int j = 0; j < nbStates_; j++) { backLogLikelihood_[i - 1][j] = 0.; } bpIt++; if (bpIt != breakPoints_.rend()) nextBrkPt = *bpIt; else nextBrkPt = 0; } } backLogLikelihoodUpToDate_=true; } /***************************************************************************************************************************/ double LogsumHmmLikelihood::getLikelihoodForASite(size_t site) const { Vdouble probs=getHiddenStatesPosteriorProbabilitiesForASite(site); double x=0; for (size_t i=0;i > vv; getHiddenStatesPosteriorProbabilities(vv); Vdouble ret(nbSites_); for (size_t i=0;i::const_iterator bpIt = breakPoints_.begin(); vector::const_iterator logLikIt = partialLogLikelihoods_.begin(); while (bpIt != breakPoints_.end()) { if (site>=(*bpIt)) logLikIt++; else break; bpIt++; } for (size_t j = 0; j < nbStates_; j++) { probs[j] = exp(logLikelihood_[site * nbStates_ + j] + backLogLikelihood_[site][j] - *logLikIt); } return probs; } void LogsumHmmLikelihood::getHiddenStatesPosteriorProbabilities(std::vector< std::vector >& probs, bool append) const throw (Exception) { size_t offset = append ? probs.size() : 0; probs.resize(offset + nbSites_); for (size_t i = 0; i < nbSites_; i++) { probs[offset + i].resize(nbStates_); } if (!backLogLikelihoodUpToDate_) computeBackward_(); size_t nextBrkPt = nbSites_; //next break point vector::const_iterator bpIt = breakPoints_.begin(); if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; vector::const_iterator logLikIt = partialLogLikelihoods_.begin(); for (size_t i = 0; i < nbSites_; i++) { if (i == nextBrkPt) { logLikIt++; bpIt++; if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; else nextBrkPt = nbSites_; } size_t ii = i * nbStates_; for (size_t j = 0; j < nbStates_; j++) { probs[offset + i][j] = exp(logLikelihood_[ii + j] + backLogLikelihood_[i][j] - *logLikIt); } } } /***************************************************************************************************************************/ void LogsumHmmLikelihood::computeDForward_() const { //Init arrays: if (dLogLikelihood_.size()==0){ dLogLikelihood_.resize(nbSites_); for (size_t i=0;i num(nbStates_); //Transition probabilities: const ColMatrix trans(transitionMatrix_->getPij()); //Initialisation: const vector* emissions = &(*emissionProbabilities_)(0); const vector* dEmissions = &emissionProbabilities_->getDEmissionProbabilities(0); for (size_t j = 0; j < nbStates_; j++) dLogLikelihood_[0][j] = (*dEmissions)[j] / (*emissions)[j]; //Recursion: size_t nextBrkPt = nbSites_; //next break point vector::const_iterator bpIt = breakPoints_.begin(); if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; partialDLogLikelihoods_.clear(); for (size_t i = 1; i < nbSites_; i++) { size_t iip = (i - 1) * nbStates_; emissions = &(*emissionProbabilities_)(i); dEmissions = &emissionProbabilities_->getDEmissionProbabilities(i); if (i < nextBrkPt) { for (size_t j = 0; j < nbStates_; j++) { x=(*dEmissions)[j]/(*emissions)[j]; for (size_t k = 0; k < nbStates_; k++) { for (size_t kp = 0; kp < nbStates_; kp++) num[kp]=logLikelihood_[iip+kp]-logLikelihood_[iip+k]; x+=dLogLikelihood_[i-1][k]*trans(k,j)/VectorTools::sumExp(num,trans.getCol(j)); } dLogLikelihood_[i][j] = x; } } else //Reset markov chain: { //Termination of previous segment x = 0; for (size_t k = 0; k < nbStates_; k++) { for (size_t kp = 0; kp < nbStates_; kp++) num[kp]=logLikelihood_[iip+kp]-logLikelihood_[iip+k]; x += dLogLikelihood_[i-1][k] / VectorTools::sumExp(num); } partialDLogLikelihoods_.push_back(x); for (size_t j = 0; j < nbStates_; j++) dLogLikelihood_[i][j] = (*dEmissions)[j] / (*emissions)[j]; bpIt++; if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; else nextBrkPt = nbSites_; } } //Termination: x=0; for (size_t k = 0; k < nbStates_; k++) { for (size_t kp = 0; kp < nbStates_; kp++) num[kp]=logLikelihood_[nbStates_*(nbSites_-1)+kp]-logLikelihood_[nbStates_*(nbSites_-1)+k]; x += dLogLikelihood_[nbSites_-1][k] / VectorTools::sumExp(num); } partialDLogLikelihoods_.push_back(x); //Compute dLogLikelihood dLogLik_ = 0; vector copy = partialDLogLikelihoods_; //We need to keep the original order for posterior decoding. sort(copy.begin(), copy.end()); for (size_t i = copy.size(); i > 0; --i) dLogLik_ += copy[i - 1]; } /***************************************************************************************************************************/ void LogsumHmmLikelihood::computeD2Forward_() const { // Make sure that Dlikelihoods are correctly computed getFirstOrderDerivative(d2Variable_); //Init arrays: if (d2LogLikelihood_.size()==0){ d2LogLikelihood_.resize(nbSites_); for (size_t i=0;i num(nbStates_); //Transition probabilities: const ColMatrix trans(transitionMatrix_->getPij()); //Initialisation: const vector* emissions = &(*emissionProbabilities_)(0); const vector* dEmissions = &emissionProbabilities_->getDEmissionProbabilities(0); const vector* d2Emissions = &emissionProbabilities_->getD2EmissionProbabilities(0); for (size_t j = 0; j < nbStates_; j++) d2LogLikelihood_[0][j] = (*d2Emissions)[j] / (*emissions)[j] - pow((*dEmissions)[j] / (*emissions)[j],2); //Recursion: size_t nextBrkPt = nbSites_; //next break point vector::const_iterator bpIt = breakPoints_.begin(); if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; partialDLogLikelihoods_.clear(); for (size_t i = 1; i < nbSites_; i++) { size_t iip = (i - 1) * nbStates_; emissions = &(*emissionProbabilities_)(i); dEmissions = &emissionProbabilities_->getDEmissionProbabilities(i); d2Emissions = &emissionProbabilities_->getD2EmissionProbabilities(i); if (i < nextBrkPt) { for (size_t j = 0; j < nbStates_; j++) { x=(*d2Emissions)[j] / (*emissions)[j] - pow((*dEmissions)[j] / (*emissions)[j],2); for (size_t k = 0; k < nbStates_; k++) { for (size_t kp = 0; kp < nbStates_; kp++) num[kp]=logLikelihood_[iip+kp]-logLikelihood_[iip+k]; snum=VectorTools::sumExp(num,trans.getCol(j)); z=d2LogLikelihood_[i-1][k]+pow(dLogLikelihood_[i-1][k],2) - dLogLikelihood_[i-1][k] * VectorTools::sumExp(num, trans.getCol(j) * dLogLikelihood_[i-1])/snum; x += z * trans(k,j) / snum; } d2LogLikelihood_[i][j] = x; } } else //Reset markov chain: { x=0; //Termination of previous segment: for (size_t k = 1; k < nbStates_; k++) { for (size_t kp = 0; kp < nbStates_; kp++) num[kp]=logLikelihood_[iip+kp]-logLikelihood_[iip+k]; snum=VectorTools::sumExp(num); x += (d2LogLikelihood_[i-1][k]+pow(dLogLikelihood_[i-1][k],2) - dLogLikelihood_[i-1][k] * VectorTools::sumExp(num, dLogLikelihood_[i-1])/snum)/snum; } partialD2LogLikelihoods_.push_back(x); for (size_t j = 0; j < nbStates_; j++) d2LogLikelihood_[i][j] = (*d2Emissions)[j] / (*emissions)[j] - pow((*dEmissions)[j] / (*emissions)[j],2); bpIt++; if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; else nextBrkPt = nbSites_; } } //Termination: x=0; for (size_t k = 0; k < nbStates_; k++) { for (size_t kp = 0; kp < nbStates_; kp++) num[kp]=logLikelihood_[nbStates_*(nbSites_-1)+kp]-logLikelihood_[nbStates_*(nbSites_-1)+k]; snum=VectorTools::sumExp(num); x += (d2LogLikelihood_[nbSites_-1][k]+pow(dLogLikelihood_[nbSites_-1][k],2) - dLogLikelihood_[nbSites_-1][k] * VectorTools::sumExp(num, dLogLikelihood_[nbSites_-1])/snum)/snum; } partialD2LogLikelihoods_.push_back(x); //Compute dLogLikelihood d2LogLik_ = 0; vector copy = partialD2LogLikelihoods_; //We need to keep the original order for posterior decoding. sort(copy.begin(), copy.end()); for (size_t i = copy.size(); i > 0; --i) d2LogLik_ += copy[i - 1]; } bpp-core-2.2.0/src/Bpp/Numeric/Hmm/RescaledHmmLikelihood.cpp000664 001750 001750 00000044640 12370705300 025242 0ustar00jdutheiljdutheil000000 000000 // // File: RescaledHmmLikelihood.cpp // Created by: Julien Dutheil // Created on: Fri Oct 26 11:57 2007 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "RescaledHmmLikelihood.h" #include "../../App/ApplicationTools.h" // from the STL: #include #include using namespace bpp; using namespace std; RescaledHmmLikelihood::RescaledHmmLikelihood( HmmStateAlphabet* hiddenAlphabet, HmmTransitionMatrix* transitionMatrix, HmmEmissionProbabilities* emissionProbabilities, const std::string& prefix) throw (Exception): AbstractHmmLikelihood(), AbstractParametrizable(prefix), hiddenAlphabet_(hiddenAlphabet), transitionMatrix_(transitionMatrix), emissionProbabilities_(emissionProbabilities), likelihood_(), dLikelihood_(), d2Likelihood_(), backLikelihood_(), backLikelihoodUpToDate_(false), scales_(), dScales_(), d2Scales_(), logLik_(), breakPoints_(), nbStates_(), nbSites_() { if (!hiddenAlphabet) throw Exception("RescaledHmmLikelihood: null pointer passed for HmmStateAlphabet."); if (!transitionMatrix) throw Exception("RescaledHmmLikelihood: null pointer passed for HmmTransitionMatrix."); if (!emissionProbabilities) throw Exception("RescaledHmmLikelihood: null pointer passed for HmmEmissionProbabilities."); if (!hiddenAlphabet_->worksWith(transitionMatrix->getHmmStateAlphabet())) throw Exception("RescaledHmmLikelihood: HmmTransitionMatrix and HmmEmissionProbabilities should point toward the same HmmStateAlphabet object."); if (!hiddenAlphabet_->worksWith(emissionProbabilities->getHmmStateAlphabet())) throw Exception("RescaledHmmLikelihood: HmmTransitionMatrix and HmmEmissionProbabilities should point toward the same HmmStateAlphabet object."); nbStates_ = hiddenAlphabet_->getNumberOfStates(); nbSites_ = emissionProbabilities_->getNumberOfPositions(); //Manage parameters: addParameters_(hiddenAlphabet_->getParameters()); addParameters_(transitionMatrix_->getParameters()); addParameters_(emissionProbabilities_->getParameters()); //Init arrays: likelihood_.resize(nbSites_ * nbStates_); scales_.resize(nbSites_); //Compute: computeForward_(); } void RescaledHmmLikelihood::fireParameterChanged(const ParameterList& pl) { bool alphabetChanged = hiddenAlphabet_->matchParametersValues(pl); bool transitionsChanged = transitionMatrix_->matchParametersValues(pl); bool emissionChanged = emissionProbabilities_->matchParametersValues(pl); // these lines are necessary because the transitions and emissions can depend on the alphabet. // we could use a StateChangeEvent, but this would result in computing some calculations twice in some cases // (when both the alphabet and other parameter changed). if (alphabetChanged && !transitionsChanged) transitionMatrix_->setParametersValues(transitionMatrix_->getParameters()); if (alphabetChanged && !emissionChanged) emissionProbabilities_->setParametersValues(emissionProbabilities_->getParameters()); computeForward_(); backLikelihoodUpToDate_=false; } /***************************************************************************************************************************/ void RescaledHmmLikelihood::computeForward_() { double x; vector tmp(nbStates_); vector lScales(nbSites_); vector trans(nbStates_ * nbStates_); //Transition probabilities: for (size_t i = 0; i < nbStates_; i++) { size_t ii = i * nbStates_; for (size_t j = 0; j < nbStates_; j++) { trans[ii + j] = transitionMatrix_->Pij(j, i); if (isnan(trans[ii + j])) throw Exception("RescaledHmmLikelihood::computeForward_. NaN transition probability"); if (trans[ii + j] < 0) throw Exception("RescaledHmmLikelihood::computeForward_. Negative transition probability: " + TextTools::toString(trans[ii + j])); } } //Initialisation: scales_[0] = 0; const vector* emissions = &(*emissionProbabilities_)(0); for (size_t j = 0; j < nbStates_; j++) { size_t jj = j * nbStates_; x = 0; for (size_t k = 0; k < nbStates_; k++) { x += trans[k + jj] * transitionMatrix_->getEquilibriumFrequencies()[k]; //cerr << j << "\t" << k << "\t" << trans[k + jj] << "\t" << transitionMatrix_->getEquilibriumFrequencies()[k] << "\t" << trans[k + jj] * transitionMatrix_->getEquilibriumFrequencies()[k] << "\t" << x << endl; } tmp[j] = (*emissions)[j] * x; //cerr << "e[j]=" << (*emissions)[j] << "\t" << tmp[j] << endl; scales_[0] += tmp[j]; } for (size_t j = 0; j < nbStates_; j++) { likelihood_[j] = tmp[j] / scales_[0]; } lScales[0] = log(scales_[0]); //Recursion: size_t nextBrkPt = nbSites_; //next break point vector::const_iterator bpIt = breakPoints_.begin(); if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; double a; for (size_t i = 1; i < nbSites_; i++) { size_t ii = i * nbStates_; size_t iip = (i - 1) * nbStates_; scales_[i] = 0 ; emissions = &(*emissionProbabilities_)(i); if (i < nextBrkPt) { for (size_t j = 0; j < nbStates_; j++) { size_t jj = j * nbStates_; x = 0; for (size_t k = 0; k < nbStates_; k++) { a = trans[jj + k] * likelihood_[iip + k]; //if (a < 0) //{ // (*ApplicationTools::warning << "Negative value for likelihood at " << i << ", state " << j << ": " << likelihood_[iip + k] << ", Pij = " << trans[jj + k]).endLine(); // a = 0; //} x += a; } tmp[j] = (*emissions)[j] * x; if (tmp[j] < 0) { (*ApplicationTools::warning << "Negative probability at " << i << ", state " << j << ": " << (*emissions)[j] << "\t" << x).endLine(); tmp[j] = 0; } scales_[i] += tmp[j]; } } else //Reset markov chain: { for (size_t j = 0; j < nbStates_; j++) { size_t jj = j * nbStates_; x = 0; for (size_t k = 0; k < nbStates_; k++) { a = trans[jj + k] * transitionMatrix_->getEquilibriumFrequencies()[k]; //if (a < 0) //{ // (*ApplicationTools::warning << "Negative value for likelihood at " << i << ", state " << j << ": ,Pij = " << trans[jj + k]).endLine(); // a = 0; //} x += a; } tmp[j] = (*emissions)[j] * x; //if (tmp[j] < 0) //{ // (*ApplicationTools::warning << "Negative emission probability at " << i << ", state " << j << ": " << (*emissions)[j]).endLine(); // tmp[j] = 0; //} scales_[i] += tmp[j]; } bpIt++; if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; else nextBrkPt = nbSites_; } for (size_t j = 0; j < nbStates_; j++) { if (scales_[i] > 0) likelihood_[ii + j] = tmp[j] / scales_[i]; else likelihood_[ii + j] = 0; } lScales[i] = log(scales_[i]); } greater cmp; sort(lScales.begin(), lScales.end(), cmp); logLik_ = 0; for (size_t i = 0; i < nbSites_; ++i) { logLik_ += lScales[i]; } } /***************************************************************************************************************************/ void RescaledHmmLikelihood::computeBackward_() const { if (backLikelihood_.size()==0) { backLikelihood_.resize(nbSites_); for (size_t i=0;i trans(nbStates_ * nbStates_); for (size_t i = 0; i < nbStates_; i++) { size_t ii = i * nbStates_; for (size_t j = 0; j < nbStates_; j++) trans[ii + j] = transitionMatrix_->Pij(i, j); } //Initialisation: const vector* emissions = 0; size_t nextBrkPt = 0; //next break point vector::const_reverse_iterator bpIt = breakPoints_.rbegin(); if (bpIt != breakPoints_.rend()) nextBrkPt = *bpIt; for (size_t j = 0; j < nbStates_; j++) { x = 0; backLikelihood_[nbSites_ - 1][j] = 1.; } //Recursion: for (size_t i = nbSites_ - 1; i > 0; i--) { emissions = &(*emissionProbabilities_)(i); if (i > nextBrkPt) { for (size_t j = 0; j < nbStates_; j++) { x = 0; size_t jj = j * nbStates_; for (size_t k = 0; k < nbStates_; k++) { x += (*emissions)[k] * trans[jj + k] * backLikelihood_[i][k]; } backLikelihood_[i-1][j] = x / scales_[i]; } } else //Reset markov chain { for (size_t j = 0; j < nbStates_; j++) { backLikelihood_[i-1][j] = 1.; } bpIt++; if (bpIt != breakPoints_.rend()) nextBrkPt = *bpIt; else nextBrkPt = 0; } } backLikelihoodUpToDate_=true; } /***************************************************************************************************************************/ double RescaledHmmLikelihood::getLikelihoodForASite(size_t site) const { Vdouble probs=getHiddenStatesPosteriorProbabilitiesForASite(site); double x=0; for (size_t i=0;i > vv; getHiddenStatesPosteriorProbabilities(vv); Vdouble ret(nbSites_); for (size_t i=0;i >& probs, bool append) const throw (Exception) { size_t offset = append ? probs.size() : 0; probs.resize(offset + nbSites_); for (size_t i = 0; i < nbSites_; i++) { probs[offset + i].resize(nbStates_); } if (!backLikelihoodUpToDate_) computeBackward_(); for (size_t i = 0; i < nbSites_; i++) { size_t ii = i * nbStates_; for (size_t j = 0; j < nbStates_; j++) { probs[offset + i][j] = likelihood_[ii + j] * backLikelihood_[i][j]; } } } /***************************************************************************************************************************/ void RescaledHmmLikelihood::computeDForward_() const { //Init arrays: if (dLikelihood_.size()==0){ dLikelihood_.resize(nbSites_); for (size_t i=0;i tmp(nbStates_), dTmp(nbStates_); vector dLScales(nbSites_); //Transition probabilities: const ColMatrix trans(transitionMatrix_->getPij()); //Initialisation: dScales_[0] = 0; const vector* emissions = &(*emissionProbabilities_)(0); const vector* dEmissions = &emissionProbabilities_->getDEmissionProbabilities(0); for (size_t j = 0; j < nbStates_; j++) { dTmp[j] = (*dEmissions)[j] * transitionMatrix_->getEquilibriumFrequencies()[j]; tmp[j] = (*emissions)[j] * transitionMatrix_->getEquilibriumFrequencies()[j]; dScales_[0] += dTmp[j]; } dLScales[0]=dScales_[0]/scales_[0]; for (size_t j = 0; j < nbStates_; j++) dLikelihood_[0][j] = (dTmp[j] * scales_[0] - tmp[j] * dScales_[0]) / pow(scales_[0],2); //Recursion: size_t nextBrkPt = nbSites_; //next break point vector::const_iterator bpIt = breakPoints_.begin(); if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; for (size_t i = 1; i < nbSites_; i++) { size_t iip = (i - 1) * nbStates_; dScales_[i] = 0 ; emissions = &(*emissionProbabilities_)(i); dEmissions = &emissionProbabilities_->getDEmissionProbabilities(i); if (i < nextBrkPt) { for (size_t j = 0; j < nbStates_; j++) { x = 0; for (size_t k = 0; k < nbStates_; k++) x += trans(k,j) * likelihood_[iip + k]; tmp[j] = (*emissions)[j] * x; dTmp[j] = (*dEmissions)[j] * x + (*emissions)[j] * VectorTools::sum(trans.getCol(j) * dLikelihood_[i-1]); dScales_[i] += dTmp[j]; } } else //Reset markov chain: { for (size_t j = 0; j < nbStates_; j++) { dTmp[j] = (*dEmissions)[j] * transitionMatrix_->getEquilibriumFrequencies()[j]; tmp[j] = (*emissions)[j] * transitionMatrix_->getEquilibriumFrequencies()[j]; dScales_[i] += dTmp[j]; } bpIt++; if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; else nextBrkPt = nbSites_; } dLScales[i]=dScales_[i]/scales_[i]; for (size_t j = 0; j < nbStates_; j++) dLikelihood_[i][j] = (dTmp[j] * scales_[i] - tmp[j] * dScales_[i]) / pow(scales_[i],2); } greater cmp; sort(dLScales.begin(), dLScales.end(), cmp); dLogLik_ = 0; for (size_t i = 0; i < nbSites_; ++i) { dLogLik_ += dLScales[i]; } } /***************************************************************************************************************************/ void RescaledHmmLikelihood::computeD2Forward_() const { //Init arrays: if (d2Likelihood_.size()==0){ d2Likelihood_.resize(nbSites_); for (size_t i=0;i tmp(nbStates_), dTmp(nbStates_), d2Tmp(nbStates_); vector d2LScales(nbSites_); //Transition probabilities: const ColMatrix trans(transitionMatrix_->getPij()); //Initialisation: d2Scales_[0] = 0; const vector* emissions = &(*emissionProbabilities_)(0); const vector* dEmissions = &emissionProbabilities_->getDEmissionProbabilities(0); const vector* d2Emissions = &emissionProbabilities_->getD2EmissionProbabilities(0); for (size_t j = 0; j < nbStates_; j++) { tmp[j] = (*emissions)[j] * transitionMatrix_->getEquilibriumFrequencies()[j]; dTmp[j] = (*dEmissions)[j] * transitionMatrix_->getEquilibriumFrequencies()[j]; d2Tmp[j] = (*d2Emissions)[j] * transitionMatrix_->getEquilibriumFrequencies()[j]; d2Scales_[0] += d2Tmp[j]; } d2LScales[0]=d2Scales_[0]/scales_[0]-pow(dScales_[0]/scales_[0],2); for (size_t j = 0; j < nbStates_; j++) d2Likelihood_[0][j] = d2Tmp[j] / scales_[0] - (d2Scales_[0] * tmp[j] + 2 * dScales_[0] * dTmp[j]) / pow(scales_[0],2) + 2 * pow(dScales_[0],2) * tmp[j] / pow(scales_[0],3); //Recursion: size_t nextBrkPt = nbSites_; //next break point vector::const_iterator bpIt = breakPoints_.begin(); if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; for (size_t i = 1; i < nbSites_; i++) { dScales_[i] = 0 ; emissions = &(*emissionProbabilities_)(i); dEmissions = &emissionProbabilities_->getDEmissionProbabilities(i); d2Emissions = &emissionProbabilities_->getD2EmissionProbabilities(i); if (i < nextBrkPt) { size_t iip = (i - 1) * nbStates_; for (size_t j = 0; j < nbStates_; j++) { x = 0; for (size_t k = 0; k < nbStates_; k++) x += trans(k,j) * likelihood_[iip + k]; tmp[j] = (*emissions)[j] * x; dTmp[j] = (*dEmissions)[j] * x + (*emissions)[j] * VectorTools::sum(trans.getCol(j) * dLikelihood_[i-1]); d2Tmp[j] = (*d2Emissions)[j] * x + 2 * (*dEmissions)[j] * VectorTools::sum(trans.getCol(j) * dLikelihood_[i-1]) + (*emissions)[j] * VectorTools::sum(trans.getCol(j) * d2Likelihood_[i-1]); d2Scales_[i] += d2Tmp[j]; } } else //Reset markov chain: { for (size_t j = 0; j < nbStates_; j++) { tmp[j] = (*emissions)[j] * transitionMatrix_->getEquilibriumFrequencies()[j]; dTmp[j] = (*dEmissions)[j] * transitionMatrix_->getEquilibriumFrequencies()[j]; d2Tmp[j] = (*d2Emissions)[j] * transitionMatrix_->getEquilibriumFrequencies()[j]; d2Scales_[i] += d2Tmp[j]; } bpIt++; if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; else nextBrkPt = nbSites_; } d2LScales[i]=d2Scales_[i]/scales_[i]-pow(dScales_[i]/scales_[i],2); for (size_t j = 0; j < nbStates_; j++) d2Likelihood_[i][j] = d2Tmp[j] / scales_[i] - (d2Scales_[i] * tmp[j] + 2 * dScales_[i] * dTmp[j]) / pow(scales_[i],2) + 2 * pow(dScales_[i],2) * tmp[j] / pow(scales_[i],3); } greater cmp; sort(d2LScales.begin(), d2LScales.end(), cmp); dLogLik_ = 0; for (size_t i = 0; i < nbSites_; ++i) { d2LogLik_ += d2LScales[i]; } } /***************************************************************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Hmm/LowMemoryRescaledHmmLikelihood.cpp000664 001750 001750 00000021356 12370705300 027114 0ustar00jdutheiljdutheil000000 000000 // // File: LowMemoryRescaledHmmLikelihood.h // Created by: Julien Dutheil // Created on: Wed Dec 16 10:47 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "LowMemoryRescaledHmmLikelihood.h" // from the STL: #include #include using namespace bpp; using namespace std; LowMemoryRescaledHmmLikelihood::LowMemoryRescaledHmmLikelihood( HmmStateAlphabet* hiddenAlphabet, HmmTransitionMatrix* transitionMatrix, HmmEmissionProbabilities* emissionProbabilities, const std::string& prefix, size_t maxSize) throw (Exception) : AbstractHmmLikelihood(), AbstractParametrizable(prefix), hiddenAlphabet_(hiddenAlphabet), transitionMatrix_(transitionMatrix), emissionProbabilities_(emissionProbabilities), likelihood1_(), likelihood2_(), logLik_(), maxSize_(maxSize), breakPoints_(), nbStates_(), nbSites_() { if (!hiddenAlphabet) throw Exception("LowMemoryRescaledHmmLikelihood: null pointer passed for HmmStateAlphabet."); if (!transitionMatrix) throw Exception("LowMemoryRescaledHmmLikelihood: null pointer passed for HmmTransitionMatrix."); if (!emissionProbabilities) throw Exception("LowMemoryRescaledHmmLikelihood: null pointer passed for HmmEmissionProbabilities."); if (!hiddenAlphabet_->worksWith(transitionMatrix->getHmmStateAlphabet())) throw Exception("LowMemoryRescaledHmmLikelihood: HmmTransitionMatrix and HmmEmissionProbabilities should point toward the same HmmStateAlphabet object."); if (!hiddenAlphabet_->worksWith(emissionProbabilities->getHmmStateAlphabet())) throw Exception("LowMemoryRescaledHmmLikelihood: HmmTransitionMatrix and HmmEmissionProbabilities should point toward the same HmmStateAlphabet object."); nbStates_ = hiddenAlphabet_->getNumberOfStates(); nbSites_ = emissionProbabilities_->getNumberOfPositions(); // Manage parameters: addParameters_(hiddenAlphabet_->getParameters()); addParameters_(transitionMatrix_->getParameters()); addParameters_(emissionProbabilities_->getParameters()); // Init arrays: likelihood1_.resize(nbStates_); likelihood2_.resize(nbStates_); // Compute: computeForward_(); } void LowMemoryRescaledHmmLikelihood::fireParameterChanged(const ParameterList& pl) { bool alphabetChanged = hiddenAlphabet_->matchParametersValues(pl); bool transitionsChanged = transitionMatrix_->matchParametersValues(pl); bool emissionChanged = emissionProbabilities_->matchParametersValues(pl); // these lines are necessary because the transitions and emissions can depend on the alphabet. // we could use a StateChangeEvent, but this would result in computing some calculations twice in some cases // (when both the alphabet and other parameter changed). if (alphabetChanged && !transitionsChanged) transitionMatrix_->setParametersValues(transitionMatrix_->getParameters()); if (alphabetChanged && !emissionChanged) emissionProbabilities_->setParametersValues(emissionProbabilities_->getParameters()); computeForward_(); } /***************************************************************************************************************************/ void LowMemoryRescaledHmmLikelihood::computeForward_() { double x; vector tmp(nbStates_); vector lScales(min(maxSize_, nbSites_)); vector trans(nbStates_ * nbStates_); // Transition probabilities: for (size_t i = 0; i < nbStates_; i++) { size_t ii = i * nbStates_; for (size_t j = 0; j < nbStates_; j++) { trans[ii + j] = transitionMatrix_->Pij(j, i); } } // Initialisation: double scale = 0; const vector* emissions = &(*emissionProbabilities_)(0); for (size_t j = 0; j < nbStates_; j++) { size_t jj = j * nbStates_; x = 0; for (size_t k = 0; k < nbStates_; k++) { x += trans[k + jj] * transitionMatrix_->getEquilibriumFrequencies()[k]; } tmp[j] = (*emissions)[j] * x; scale += tmp[j]; } for (size_t j = 0; j < nbStates_; j++) { likelihood1_[j] = tmp[j] / scale; } lScales[0] = log(scale); vector* previousLikelihood = &likelihood2_, * currentLikelihood = &likelihood1_, * tmpLikelihood; // Recursion: size_t nextBrkPt = nbSites_; // next break point vector::const_iterator bpIt = breakPoints_.begin(); if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; double a; logLik_ = 0; size_t offset = 0; greater cmp; for (size_t i = 1; i < nbSites_; i++) { //Swap pointers: tmpLikelihood = previousLikelihood; previousLikelihood = currentLikelihood; currentLikelihood = tmpLikelihood; scale = 0; emissions = &(*emissionProbabilities_)(i); if (i < nextBrkPt) { for (size_t j = 0; j < nbStates_; j++) { size_t jj = j * nbStates_; x = 0; for (size_t k = 0; k < nbStates_; k++) { a = trans[jj + k] * (*previousLikelihood)[k]; if (a < 0) { // *ApplicationTools::warning << "Negative value for likelihood at " << i << ", state " << j << ": " << _likelihood[i-1][k] << ", Pij = " << _hiddenModel->Pij(k, j) << endl; a = 0; } x += a; } tmp[j] = (*emissions)[j] * x; if (tmp[j] < 0) { // *ApplicationTools::warning << "Negative emission probability at " << i << ", state " << j << ": " << _emissions[i][j] << endl; tmp[j] = 0; } scale += tmp[j]; } } else // Reset markov chain: { for (size_t j = 0; j < nbStates_; j++) { size_t jj = j * nbStates_; x = 0; for (size_t k = 0; k < nbStates_; k++) { a = trans[jj + k] * transitionMatrix_->getEquilibriumFrequencies()[k]; if (a < 0) { // *ApplicationTools::warning << "Negative value for likelihood at " << i << ", state " << j << ": " << _likelihood[i-1][k] << ", Pij = " << _hiddenModel->Pij(k, j) << endl; a = 0; } x += a; } tmp[j] = (*emissions)[j] * x; if (tmp[j] < 0) { // *ApplicationTools::warning << "Negative emission probability at " << i << ", state " << j << ": " << _emissions[i][j] << endl; tmp[j] = 0; } scale += tmp[j]; } bpIt++; if (bpIt != breakPoints_.end()) nextBrkPt = *bpIt; else nextBrkPt = nbSites_; } for (size_t j = 0; j < nbStates_; j++) { if (scale > 0) (*currentLikelihood)[j] = tmp[j] / scale; else (*currentLikelihood)[j] = 0; } lScales[i - offset] = log(scale); if (i - offset == maxSize_ - 1) { //We make partial calculations and reset the arrays: double partialLogLik = 0; sort(lScales.begin(), lScales.end(), cmp); for (size_t j = 0; j < maxSize_; ++j) { partialLogLik += lScales[j]; } logLik_ += partialLogLik; offset += maxSize_; } } sort(lScales.begin(), lScales.begin() + static_cast(nbSites_ - offset), cmp); double partialLogLik = 0; for (size_t i = 0; i < nbSites_ - offset; ++i) { partialLogLik += lScales[i]; } logLik_ += partialLogLik; } /***************************************************************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/Hmm/LogsumHmmLikelihood.h000664 001750 001750 00000022724 12370705300 024432 0ustar00jdutheiljdutheil000000 000000 // // File: LogsumHmmLikelihood.h // Created by: Julien Dutheil // Created on: Mon Nov 23 11:27 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _LOGSUMHMMLIKELIHOOD_H_ #define _LOGSUMHMMLIKELIHOOD_H_ #include "HmmLikelihood.h" #include "../AbstractParametrizable.h" #include "../NumTools.h" #include "../Matrix/Matrix.h" //From the STL: #include #include namespace bpp { /** * @brief A simple implementation of hidden Markov models recursion. * * This implementation uses the logsum method described in Durbin et al "Biological sequence analysis", Cambridge University Press, * and further developped in Tobias P. Mann "Numerically Stable Hidden Markov Model Implementation" (2006) http://bozeman.genome.washington.edu/compbio/mbt599_2006/hmm_scaling_revised.pdf . * It also offer the possibility to specify "breakpoints", where the chain will be reset to the equilibrium frequencies. * * Although probably more numerically accurate, this method is slower than the rescaling, as it involves one exponentiation per site and per hidden state! * * @see RescaledHmmLikelihood */ class LogsumHmmLikelihood: public virtual AbstractHmmLikelihood, public AbstractParametrizable { protected: /** * @brief The alphabet describing the hidden states. */ std::auto_ptr hiddenAlphabet_; std::auto_ptr transitionMatrix_; std::auto_ptr emissionProbabilities_; /** * @brief The likelihood array. * * logLikelihood_[i * nbStates_ + j] corresponds to log(Pr(x1...xi, yi=j)), * where the x are the observed states, and y the hidden states. */ std::vector logLikelihood_; std::vector partialLogLikelihoods_; double logLik_; /** * @brief The DLogLikelihood arrays. * * dLogLikelihood_[i][j] corresponds to d(log(Pr(x1...xi, yi=j))), * where the x are the observed states, and y the hidden states. * * d2LogLikelihood_[i][j] corresponds to d2(log(Pr(x1...xi, yi=j))), * where the x are the observed states, and y the hidden states. * */ mutable std::vector< std::vector > dLogLikelihood_; mutable std::vector partialDLogLikelihoods_; mutable std::vector< std::vector > d2LogLikelihood_; mutable std::vector partialD2LogLikelihoods_; /** * @brief backward logLikelihood * * backLogLikelihood_[i][j] corresponds to log(Pr(x_i+1...x_n | yi=j)), * where the x are the observed states, and y the hidden states. */ mutable std::vector > backLogLikelihood_; mutable bool backLogLikelihoodUpToDate_; std::vector breakPoints_; size_t nbStates_, nbSites_; public: /** * @brief Build a new LogsumHmmLikelihood object. * * @warning the HmmTransitionMatrix and HmmEmissionProbabilities object passed as argument must be non-null * and point toward the same HmmStateAlphabet instance. The three object will be copied if needed, and * deleted when the hmm likelihood objet is deleted. You should secure a copy before if you don't want them to * be destroyed with this object. */ LogsumHmmLikelihood( HmmStateAlphabet* hiddenAlphabet, HmmTransitionMatrix* transitionMatrix, HmmEmissionProbabilities* emissionProbabilities, const std::string& prefix) throw (Exception); LogsumHmmLikelihood(const LogsumHmmLikelihood& lik): AbstractHmmLikelihood(lik), AbstractParametrizable(lik), hiddenAlphabet_(dynamic_cast(lik.hiddenAlphabet_->clone())), transitionMatrix_(dynamic_cast(lik.transitionMatrix_->clone())), emissionProbabilities_(dynamic_cast(lik.emissionProbabilities_->clone())), logLikelihood_(lik.logLikelihood_), partialLogLikelihoods_(lik.partialLogLikelihoods_), logLik_(lik.logLik_), dLogLikelihood_(lik.dLogLikelihood_), partialDLogLikelihoods_(lik.partialDLogLikelihoods_), d2LogLikelihood_(lik.d2LogLikelihood_), partialD2LogLikelihoods_(lik.partialD2LogLikelihoods_), backLogLikelihood_(lik.backLogLikelihood_), backLogLikelihoodUpToDate_(lik.backLogLikelihoodUpToDate_), breakPoints_(lik.breakPoints_), nbStates_(lik.nbStates_), nbSites_(lik.nbSites_) { // Now adjust pointers: transitionMatrix_->setHmmStateAlphabet(hiddenAlphabet_.get()); emissionProbabilities_->setHmmStateAlphabet(hiddenAlphabet_.get()); } LogsumHmmLikelihood& operator=(const LogsumHmmLikelihood& lik) { AbstractHmmLikelihood::operator=(lik); AbstractParametrizable::operator =(lik); hiddenAlphabet_ = std::auto_ptr(dynamic_cast(lik.hiddenAlphabet_->clone())); transitionMatrix_ = std::auto_ptr(dynamic_cast(lik.transitionMatrix_->clone())); emissionProbabilities_ = std::auto_ptr(dynamic_cast(lik.emissionProbabilities_->clone())); logLikelihood_ = lik.logLikelihood_; partialLogLikelihoods_ = lik.partialLogLikelihoods_; dLogLikelihood_ = lik.dLogLikelihood_; partialDLogLikelihoods_= lik.partialDLogLikelihoods_; d2LogLikelihood_ = lik.d2LogLikelihood_; partialD2LogLikelihoods_ = lik.partialD2LogLikelihoods_; backLogLikelihood_ = lik.backLogLikelihood_; backLogLikelihoodUpToDate_= lik.backLogLikelihoodUpToDate_; logLik_ = lik.logLik_; breakPoints_ = lik.breakPoints_; nbStates_ = lik.nbStates_; nbSites_ = lik.nbSites_; // Now adjust pointers: transitionMatrix_->setHmmStateAlphabet(hiddenAlphabet_.get()); emissionProbabilities_->setHmmStateAlphabet(hiddenAlphabet_.get()); return *this; } virtual ~LogsumHmmLikelihood() {} #ifndef NO_VIRTUAL_COV LogsumHmmLikelihood* #else Clonable* #endif clone() const { return new LogsumHmmLikelihood(*this); } public: const HmmStateAlphabet& getHmmStateAlphabet() const { return *hiddenAlphabet_; } HmmStateAlphabet& getHmmStateAlphabet() { return *hiddenAlphabet_; } const HmmTransitionMatrix& getHmmTransitionMatrix() const { return *transitionMatrix_; } HmmTransitionMatrix& getHmmTransitionMatrix() { return *transitionMatrix_; } const HmmEmissionProbabilities& getHmmEmissionProbabilities() const { return *emissionProbabilities_; } HmmEmissionProbabilities& getHmmEmissionProbabilities() { return *emissionProbabilities_; } void setBreakPoints(const std::vector& breakPoints) { breakPoints_ = breakPoints; computeForward_(); backLogLikelihoodUpToDate_=false; } const std::vector& getBreakPoints() const { return breakPoints_; } void setParameters(const ParameterList& pl) throw (Exception) { setParametersValues(pl); } double getValue() const throw (Exception) { return -logLik_; } double getLogLikelihood() const { return logLik_; } double getLikelihoodForASite(size_t site) const; Vdouble getLikelihoodForEachSite() const; virtual void fireParameterChanged(const ParameterList& pl); Vdouble getHiddenStatesPosteriorProbabilitiesForASite(size_t site) const; void getHiddenStatesPosteriorProbabilities(std::vector< std::vector >& probs, bool append = false) const throw (Exception); protected: void computeForward_(); void computeBackward_() const; void computeDLikelihood_() const { computeDForward_(); } void computeD2Likelihood_() const { computeD2Forward_(); } void computeDForward_() const; void computeD2Forward_() const; }; } #endif //_LOGSUMHMMLIKELIHOOD_H_ bpp-core-2.2.0/src/Bpp/Numeric/Hmm/AbstractHmmTransitionMatrix.h000664 001750 001750 00000006132 12370705300 026156 0ustar00jdutheiljdutheil000000 000000 // // File: AbstractHmmTransitionMatrix.h // Created by: Laurent Guéguen // Created on: lundi 10 février 2014, à 10h 55 // /* Copyright or © or Copr. Bio++Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _ABSTRACTHMMTRANSITIONMATRIX_H_ #define _ABSTRACTHMMTRANSITIONMATRIX_H_ #include "HmmStateAlphabet.h" #include "HmmTransitionMatrix.h" #include "../VectorTools.h" namespace bpp { /** * @brief Partial implementation of HmmTransitionMatrix. * */ class AbstractHmmTransitionMatrix: public virtual HmmTransitionMatrix { private: const HmmStateAlphabet* alph_; protected: mutable RowMatrix pij_, tmpmat_; mutable Vdouble eqFreq_; mutable bool upToDate_; public: AbstractHmmTransitionMatrix(const HmmStateAlphabet* alph, const std::string& prefix = ""); AbstractHmmTransitionMatrix(const AbstractHmmTransitionMatrix& hptm); AbstractHmmTransitionMatrix& operator=(const AbstractHmmTransitionMatrix& hptm); /** * @return The hidden alphabet associated to this model. */ const HmmStateAlphabet* getHmmStateAlphabet() const { return alph_; } /** * @brief Set the new hidden state alphabet * @param stateAlphabet The new state alphabet * @throw UnvalidStateAlphabetException if the new alphabet is uncorrect (for instance is NULL pointer). */ void setHmmStateAlphabet(const HmmStateAlphabet* stateAlphabet) throw (HmmUnvalidAlphabetException); /** * @return The number of states in the model. */ size_t getNumberOfStates() const { return alph_->getNumberOfStates(); } }; } //end of namespace bpp #endif //_ABSTRACTHMMTRANSITIONMATRIX_H_ bpp-core-2.2.0/src/Bpp/Numeric/Hmm/HmmExceptions.h000664 001750 001750 00000004673 12370705300 023304 0ustar00jdutheiljdutheil000000 000000 // // File: HmmExceptions.h // Created by: Julien Dutheil // Created on: Fri Sep 04 15:30 2009 // /* Copyright or © or Copr. CNRS, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _HMMEXCEPTIONS_H_ #define _HMMEXCEPTIONS_H_ #include "../../Exceptions.h" namespace bpp { /** * @brief Exception thrown when an unvalid state is requested. * * This class belongs to the HMM framework. * * @author Julien Dutheil */ class HmmBadStateException: public Exception { public: HmmBadStateException(const std::string& description): Exception(description) {} }; /** * @brief Exception thrown when an unvalid alphabet is specified. * * This class belongs to the HMM fra;ework. * * @author Julien Dutheil */ class HmmUnvalidAlphabetException: public Exception { public: HmmUnvalidAlphabetException(const std::string& description): Exception(description) {} }; }; //end of namespace bpp. #endif //_HMMEXCEPTIONS_H_ bpp-core-2.2.0/src/Bpp/Numeric/Hmm/AbstractHmmTransitionMatrix.cpp000664 001750 001750 00000005653 12370705300 026520 0ustar00jdutheiljdutheil000000 000000 // // File: AbstractHmmTransitionMatrix.cpp // Created by: Laurent Guéguen // Created on: lundi 10 février 2014, à 10h 59 // /* Copyright or © or Copr. Bio++Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "AbstractHmmTransitionMatrix.h" #include "../Matrix/MatrixTools.h" #include "../VectorTools.h" using namespace bpp; using namespace std; AbstractHmmTransitionMatrix::AbstractHmmTransitionMatrix(const HmmStateAlphabet* alph, const string& prefix) : alph_(alph), pij_((size_t)alph->getNumberOfStates(), (size_t)alph->getNumberOfStates()), tmpmat_((size_t)alph->getNumberOfStates(), (size_t)alph->getNumberOfStates()), eqFreq_((size_t)alph->getNumberOfStates()), upToDate_(false) { } AbstractHmmTransitionMatrix::AbstractHmmTransitionMatrix(const AbstractHmmTransitionMatrix& hptm) : alph_(hptm.alph_), pij_(hptm.pij_), tmpmat_(hptm.tmpmat_), eqFreq_(hptm.eqFreq_), upToDate_(hptm.upToDate_) { } AbstractHmmTransitionMatrix& AbstractHmmTransitionMatrix::operator=(const AbstractHmmTransitionMatrix& hptm) { alph_=hptm.alph_; pij_=hptm.pij_; tmpmat_=hptm.tmpmat_; eqFreq_=hptm.eqFreq_; upToDate_=hptm.upToDate_; return *this; } void AbstractHmmTransitionMatrix::setHmmStateAlphabet(const HmmStateAlphabet* stateAlphabet) throw (HmmUnvalidAlphabetException) { if (stateAlphabet==NULL) throw HmmUnvalidAlphabetException("Null alphabet in AbstractHmmTransitionMatrix::setHmmStateAlphabet"); alph_=stateAlphabet; } bpp-core-2.2.0/src/Bpp/Numeric/Hmm/AutoCorrelationTransitionMatrix.h000664 001750 001750 00000007352 12370705300 027070 0ustar00jdutheiljdutheil000000 000000 // // File: AutoCorrelationTransitionMatrix.h // Created by: Laurent Guéguen // Created on: lundi 10 février 2014, à 09h 56 // /* Copyright or © or Copr. Bio++Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _AUTOCORRELATIONTRANSITIONMATRIX_H_ #define _AUTOCORRELATIONTRANSITIONMATRIX_H_ #include "AbstractHmmTransitionMatrix.h" #include "../AbstractParameterAliasable.h" namespace bpp { /** * @brief Describe the auto-correlation probabilities inside hidden * states of a Hidden Markov Model. * * This modelling behaves like a HMM in which, from a given state, * all transition probabilities to the other states are equal. * * The parameters are the within states transition probabilities, * denoted as \c "lambaN" with N the number of the state (1 is the * first). */ class AutoCorrelationTransitionMatrix: public virtual AbstractHmmTransitionMatrix, public AbstractParametrizable { private: std::vector vAutocorrel_; public: AutoCorrelationTransitionMatrix(const HmmStateAlphabet* alph, const std::string& prefix = ""); AutoCorrelationTransitionMatrix(const AutoCorrelationTransitionMatrix& hptm); AutoCorrelationTransitionMatrix& operator=(const AutoCorrelationTransitionMatrix& hptm); AutoCorrelationTransitionMatrix* clone() const { return new AutoCorrelationTransitionMatrix(*this);} /** * @brief Get the transition probability between two states. * * @param i initial state. * @param j final state. * @return the transition probability between the two states. */ double Pij(size_t i, size_t j) const { return (i == j) ? vAutocorrel_[i] : (1 - vAutocorrel_[i]) / static_cast(getNumberOfStates() - 1); } /** * @brief Get all transition probabilities as a matrix. * * @return A n*n matrix will all transition probabilities (n being the number of hidden states). */ const Matrix& getPij() const; /** * @return The vector of equilibrium frequencies of the Markov chain described by the matrix. */ const std::vector& getEquilibriumFrequencies() const; /* * @brief From AbstractParametrizable interface * */ void fireParameterChanged(const ParameterList& parameters); }; } //end of namespace bpp #endif //_AUTOCORRELATIONTRANSITIONMATRIX_H_ bpp-core-2.2.0/src/Bpp/Numeric/Hmm/AutoCorrelationTransitionMatrix.cpp000664 001750 001750 00000007162 12370705300 027422 0ustar00jdutheiljdutheil000000 000000 // // File: AutoCorrelationTransitionMatrix.cpp // Created by: Laurent Guéguen // Created on: lundi 10 février 2014, à 09h 56 // /* Copyright or © or Copr. Bio++Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "AutoCorrelationTransitionMatrix.h" #include "../../Text/TextTools.h" #include "../Matrix/MatrixTools.h" #include "../VectorTools.h" using namespace bpp; using namespace std; AutoCorrelationTransitionMatrix::AutoCorrelationTransitionMatrix(const HmmStateAlphabet* alph, const string& prefix) : AbstractHmmTransitionMatrix(alph), AbstractParametrizable(prefix), vAutocorrel_() { size_t size=(size_t)getNumberOfStates(); for (size_t i=0; i& AutoCorrelationTransitionMatrix::getPij() const { if (!upToDate_){ for (size_t i = 0; i < vAutocorrel_.size(); ++i) for (size_t j = 0; j < vAutocorrel_.size(); ++j) pij_(i,j) = (i==j) ? vAutocorrel_[i] : (1 - vAutocorrel_[i]) / static_cast(getNumberOfStates()-1); upToDate_ = true; } return pij_; } const std::vector& AutoCorrelationTransitionMatrix::getEquilibriumFrequencies() const { return eqFreq_; } void AutoCorrelationTransitionMatrix::fireParameterChanged(const ParameterList& parameters) { size_t salph=getNumberOfStates(); for (size_t i=0; i< salph; i++) vAutocorrel_[i]=getParameterValue("lambda"+TextTools::toString(i+1)); upToDate_=false; } bpp-core-2.2.0/src/Bpp/Numeric/Hmm/FullHmmTransitionMatrix.cpp000664 001750 001750 00000010744 12370705300 025654 0ustar00jdutheiljdutheil000000 000000 // // File: FullHmmTransitionMatrix.cpp // Created by: Laurent Guéguen // Created on: samedi 21 septembre 2013, à 14h 43 // /* Copyright or © or Copr. Bio++Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "FullHmmTransitionMatrix.h" #include "../../Text/TextTools.h" #include "../Matrix/MatrixTools.h" #include "../VectorTools.h" using namespace bpp; using namespace std; FullHmmTransitionMatrix::FullHmmTransitionMatrix(const HmmStateAlphabet* alph, const string& prefix) : AbstractHmmTransitionMatrix(alph), AbstractParametrizable(prefix), vSimplex_() { size_t size=(size_t)getNumberOfStates(); for (size_t i=0; isetName(TextTools::toString(i+1)+"."+p->getName()); addParameter_(p); } } } FullHmmTransitionMatrix::FullHmmTransitionMatrix(const FullHmmTransitionMatrix& hptm) : AbstractHmmTransitionMatrix(hptm), AbstractParametrizable(hptm), vSimplex_(hptm.vSimplex_) { } FullHmmTransitionMatrix& FullHmmTransitionMatrix::operator=(const FullHmmTransitionMatrix& hptm) { AbstractHmmTransitionMatrix::operator=(hptm); AbstractParametrizable::operator=(hptm); return *this; } void FullHmmTransitionMatrix::setTransitionProbabilities(const Matrix& mat) { if (mat.getNumberOfRows()!=vSimplex_.size()) throw BadSizeException("FullHmmTransitionMatrix::setTransitionProbabilities: Wrong number of rows in given Matrix", mat.getNumberOfRows(), vSimplex_.size()); ParameterList pl; for (size_t i=0; isetName(TextTools::toString(i+1)+"."+p->getName()); pl.addParameter(p); } } matchParametersValues(pl); } const Matrix& FullHmmTransitionMatrix::getPij() const { if (!upToDate_){ for (size_t i=0; i& FullHmmTransitionMatrix::getEquilibriumFrequencies() const { size_t salph=getNumberOfStates(); if (!upToDate_){ pij_=getPij(); MatrixTools::pow(pij_, 256, tmpmat_); for (size_t i = 0; i < salph; i++) eqFreq_[i] = tmpmat_(0,i); upToDate_=true; } return eqFreq_; } void FullHmmTransitionMatrix::fireParameterChanged(const ParameterList& parameters) { size_t salph=getNumberOfStates(); for (size_t i=0; i< salph; i++) { ParameterList pl=vSimplex_[i].getParameters(); for (size_t j=0; j #include namespace bpp { /** * @brief A modified implementation of the RescaledHmmLikelihood implementation, with lower memory usage. * * This implementation is similar to the one used in the RescaledHmmLikelihood class, * but does not store the full likelihood array. The benefit of it is a significantly reduced * memory usage, allowing to compute likelihood for very large data sets. * * The drawback is that this class can't compute posterior * probabilities, neither derivatives of the likelihoods, and can * hence only be used to compute likelihoods. * */ class LowMemoryRescaledHmmLikelihood : public AbstractHmmLikelihood, public AbstractParametrizable { private: /** * @brief The alphabet describing the hidden states. */ std::auto_ptr hiddenAlphabet_; std::auto_ptr transitionMatrix_; std::auto_ptr emissionProbabilities_; /** * @brief The likelihood array. * * Here we use two arrays for the i and i-1 positions */ std::vector likelihood1_; std::vector likelihood2_; double logLik_; size_t maxSize_; std::vector breakPoints_; size_t nbStates_, nbSites_; public: /** * @brief Build a new LowMemoryRescaledHmmLikelihood object. * * @warning the HmmTransitionMatrix and HmmEmissionProbabilities object passed as argument must be non-null * and point toward the same HmmStateAlphabet instance. The three object will be copied if needed, and * deleted when the hmm likelihood objet is deleted. You should secure a copy before if you don't want them to * be destroyed with this object. * * @param hiddenAlphabet The hidden states alphabet to use. * @param transitionMatrix The transition matrix to use. * @param emissionProbabilities The emission probabilities to use. * @param prefix A namespace for parameter names. * @param maxSize the maximum size of the vector of scales. If this size is exceeded, then a temporary likelihood computation is made and stored, and the vector is reset. * the size of the vector specify the memory usage of the class. A two low value can lead to numerical precision errors. */ LowMemoryRescaledHmmLikelihood( HmmStateAlphabet* hiddenAlphabet, HmmTransitionMatrix* transitionMatrix, HmmEmissionProbabilities* emissionProbabilities, const std::string& prefix, size_t maxSize = 1000000) throw (Exception); LowMemoryRescaledHmmLikelihood(const LowMemoryRescaledHmmLikelihood& lik) : AbstractHmmLikelihood(lik), AbstractParametrizable(lik), hiddenAlphabet_(dynamic_cast(lik.hiddenAlphabet_->clone())), transitionMatrix_(dynamic_cast(lik.transitionMatrix_->clone())), emissionProbabilities_(dynamic_cast(lik.emissionProbabilities_->clone())), likelihood1_(lik.likelihood1_), likelihood2_(lik.likelihood2_), logLik_(lik.logLik_), maxSize_(lik.maxSize_), breakPoints_(lik.breakPoints_), nbStates_(lik.nbStates_), nbSites_(lik.nbSites_) { // Now adjust pointers: transitionMatrix_->setHmmStateAlphabet(hiddenAlphabet_.get()); emissionProbabilities_->setHmmStateAlphabet(hiddenAlphabet_.get()); } LowMemoryRescaledHmmLikelihood& operator=(const LowMemoryRescaledHmmLikelihood& lik) { AbstractHmmLikelihood::operator=(lik); AbstractParametrizable::operator=(lik); hiddenAlphabet_ = std::auto_ptr(dynamic_cast(lik.hiddenAlphabet_->clone())); transitionMatrix_ = std::auto_ptr(dynamic_cast(lik.transitionMatrix_->clone())); emissionProbabilities_ = std::auto_ptr(dynamic_cast(lik.emissionProbabilities_->clone())); likelihood1_ = lik.likelihood1_; likelihood2_ = lik.likelihood2_; logLik_ = lik.logLik_; maxSize_ = lik.maxSize_; breakPoints_ = lik.breakPoints_; nbStates_ = lik.nbStates_; nbSites_ = lik.nbSites_; // Now adjust pointers: transitionMatrix_->setHmmStateAlphabet(hiddenAlphabet_.get()); emissionProbabilities_->setHmmStateAlphabet(hiddenAlphabet_.get()); return *this; } virtual ~LowMemoryRescaledHmmLikelihood() {} #ifndef NO_VIRTUAL_COV LowMemoryRescaledHmmLikelihood* #else Clonable* #endif clone() const { return new LowMemoryRescaledHmmLikelihood(*this); } public: const HmmStateAlphabet& getHmmStateAlphabet() const { return *hiddenAlphabet_; } HmmStateAlphabet& getHmmStateAlphabet() { return *hiddenAlphabet_; } const HmmTransitionMatrix& getHmmTransitionMatrix() const { return *transitionMatrix_; } HmmTransitionMatrix& getHmmTransitionMatrix() { return *transitionMatrix_; } const HmmEmissionProbabilities& getHmmEmissionProbabilities() const { return *emissionProbabilities_; } HmmEmissionProbabilities& getHmmEmissionProbabilities() { return *emissionProbabilities_; } void setBreakPoints(const std::vector& breakPoints) { breakPoints_ = breakPoints; computeForward_(); } const std::vector& getBreakPoints() const { return breakPoints_; } void setParameters(const ParameterList& pl) throw (Exception) { setParametersValues(pl); } double getValue() const throw (Exception) { return -logLik_; } double getLogLikelihood() const { return logLik_; } void fireParameterChanged(const ParameterList& pl); double getLikelihoodForASite(size_t site) const { throw (NotImplementedException("LowMemoryRescaledHmmLikelihood::getLikelihoodForASite. This class can't compute posterior probabilities, use RescaledHmmLikelihood instead.")); } Vdouble getLikelihoodForEachSite() const { throw (NotImplementedException("LowMemoryRescaledHmmLikelihood::getLikelihoodForEachSite. This class can't compute posterior probabilities, use RescaledHmmLikelihood instead.")); } Vdouble getHiddenStatesPosteriorProbabilitiesForASite(size_t site) const { throw (NotImplementedException("LowMemoryRescaledHmmLikelihood::getHiddenStatesPosteriorProbabilitiesForASite. This class can't compute posterior probabilities, use RescaledHmmLikelihood instead.")); } void getHiddenStatesPosteriorProbabilities(std::vector< std::vector >& probs, bool append = false) const throw (NotImplementedException) { throw (NotImplementedException("LowMemoryRescaledHmmLikelihood::getHiddenStatesPosteriorProbabilities. This class can't compute posterior probabilities, use RescaledHmmLikelihood instead.")); } protected: void computeForward_(); void computeDLikelihood_() const { // computeDForward_(); } void computeD2Likelihood_() const { // computeD2Forward_(); } }; } #endif // _LOWMEMORYRESCALEDHMMLIKELIHOOD_H_ bpp-core-2.2.0/src/Bpp/Numeric/Hmm/FullHmmTransitionMatrix.h000664 001750 001750 00000007323 12370705300 025320 0ustar00jdutheiljdutheil000000 000000 // // File: FullHmmTransitionMatrix.h // Created by: Laurent Guéguen // Created on: samedi 21 septembre 2013, à 00h 41 // /* Copyright or © or Copr. Bio++Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _FULLHMMTRANSITIONMATRIX_H_ #define _FULLHMMTRANSITIONMATRIX_H_ #include "../Prob/Simplex.h" #include "AbstractHmmTransitionMatrix.h" #include "../AbstractParameterAliasable.h" namespace bpp { /** * @brief Describe the transition probabilities between hidden states of a Hidden Markov Model. * * * Transition probabilities are described through simplexes. * * * Parameters are denoted \c "I.Simplex.thetaJ" where \c I is the line number * of the transition matrix, and \c "thetaJ" is the matching parameter * in the Ith Simplex. * * @see Simplex */ class FullHmmTransitionMatrix: public virtual AbstractHmmTransitionMatrix, public AbstractParametrizable { private: std::vector vSimplex_; public: FullHmmTransitionMatrix(const HmmStateAlphabet* alph, const std::string& prefix = ""); FullHmmTransitionMatrix(const FullHmmTransitionMatrix& hptm); FullHmmTransitionMatrix& operator=(const FullHmmTransitionMatrix& hptm); FullHmmTransitionMatrix* clone() const { return new FullHmmTransitionMatrix(*this);} /** * @brief Set the matrix of the transition probabilities. * */ void setTransitionProbabilities(const Matrix& mat); /** * @brief Get the transition probability between two states. * * @param i initial state. * @param j final state. * @return the transition probability between the two states. */ double Pij(size_t i, size_t j) const { return vSimplex_[i].prob(j); } /** * @brief Get all transition probabilities as a matrix. * * @return A n*n matrix will all transition probabilities (n being the number of hidden states). */ const Matrix& getPij() const; /** * @return The vector of equilibrium frequencies of the Markov chain described by the matrix. */ const std::vector& getEquilibriumFrequencies() const; /* * @brief From AbstractParametrizable interface * */ void fireParameterChanged(const ParameterList& parameters); }; } //end of namespace bpp #endif //_FULLHMMTRANSITIONMATRIX_H_ bpp-core-2.2.0/src/Bpp/Numeric/Hmm/HmmTransitionMatrix.h000664 001750 001750 00000007006 12370705300 024473 0ustar00jdutheiljdutheil000000 000000 // // File: HmmTransitionMatrix.h // Created by: Julien Dutheil // Created on: Sat Oct 27 10:24 2007 // /* Copyright or © or Copr. Bio++Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _HMMTRANSITIONMATRIX_H_ #define _HMMTRANSITIONMATRIX_H_ #include "HmmStateAlphabet.h" #include "HmmExceptions.h" #include "../Matrix/Matrix.h" #include "../Parametrizable.h" //Fron the STL: #include namespace bpp { /** * @brief Describe the transition probabilities between hidden states of a Hidden Markov Model. * * This class is part of the HMM framework. */ class HmmTransitionMatrix: public virtual Parametrizable { public: /** * @return The hidden alphabet associated to this model. */ virtual const HmmStateAlphabet* getHmmStateAlphabet() const = 0; /** * @brief Set the new hidden state alphabet. * @param stateAlphabet The new state alphabet. * @throw UnvalidStateAlphabetException if the new alphabet is uncorrect (for instance is NULL pointer). */ virtual void setHmmStateAlphabet(const HmmStateAlphabet* stateAlphabet) throw (HmmUnvalidAlphabetException) = 0; /** * @return The number of states in the model. */ virtual size_t getNumberOfStates() const = 0; /** * @brief Get the transition probability between two states. * * @param i initial state. * @param j final state. * @return the transition probability between the two states. */ virtual double Pij(size_t i, size_t j) const = 0; /** * @brief Get all transition probabilities as a matrix. * * @return A n*n matrix will all transition probabilities (n being the number of hidden states). */ virtual const Matrix& getPij() const = 0; /** * @return The vector of equilibrium frequencies of the Markov chain described by the matrix. */ virtual const std::vector& getEquilibriumFrequencies() const = 0; }; } //end of namespace bpp #endif //_HMMTRANSITIONMATRIX_H_ bpp-core-2.2.0/src/Bpp/Numeric/Hmm/HmmLikelihood.cpp000664 001750 001750 00000005703 12370705300 023574 0ustar00jdutheiljdutheil000000 000000 // // File: HmmLikelihood.cpp // Created by: Laurent Guéguen // Created on: jeudi 26 septembre 2013, à 13h 55 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "HmmLikelihood.h" using namespace bpp; using namespace std; AbstractHmmLikelihood::AbstractHmmLikelihood() : dLogLik_(0), dVariable_(""), d2LogLik_(0), d2Variable_("") {} AbstractHmmLikelihood::AbstractHmmLikelihood(const AbstractHmmLikelihood& adhlik) : dLogLik_(adhlik.dLogLik_), dVariable_(adhlik.dVariable_), d2LogLik_(adhlik.d2LogLik_), d2Variable_(adhlik.d2Variable_) {} AbstractHmmLikelihood& AbstractHmmLikelihood::operator=(const AbstractHmmLikelihood& adhlik) { dLogLik_=adhlik.dLogLik_; dVariable_=adhlik.dVariable_; d2LogLik_=adhlik.d2LogLik_; d2Variable_=adhlik.d2Variable_; return *this; } double AbstractHmmLikelihood::getFirstOrderDerivative(const std::string& variable) const throw (Exception) { if (variable!=dVariable_){ dVariable_=variable; getHmmEmissionProbabilities().computeDEmissionProbabilities(dVariable_); computeDLikelihood_(); } return -dLogLik_; } double AbstractHmmLikelihood::getSecondOrderDerivative(const std::string& variable) const throw (Exception) { if (variable!=d2Variable_){ d2Variable_=variable; getHmmEmissionProbabilities().computeD2EmissionProbabilities(d2Variable_); computeD2Likelihood_(); } return -d2LogLik_; } bpp-core-2.2.0/src/Bpp/Numeric/Hmm/HmmStateAlphabet.h000664 001750 001750 00000007133 12370705300 023676 0ustar00jdutheiljdutheil000000 000000 // // File: HmmStateAlphabet.h // Created by: Julien Dutheil // Created on: Fri Oct 26 11:07 2007 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2004) This software is a computer program whose purpose is to provide classes for phylogenetic data analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _HMMSTATEALPHABET_H_ #define _HMMSTATEALPHABET_H_ #include "HmmExceptions.h" #include "../Parametrizable.h" #include "../../Exceptions.h" //From the STL: #include //using namespace bpp; namespace bpp { class StateListener; class StateChangedEvent; /** * @brief Hidden states alphabet. * * Implementations of this interface describe the set of hidden states of a Hidden Markov Model. */ class HmmStateAlphabet: public virtual Parametrizable { public: HmmStateAlphabet() {} virtual ~HmmStateAlphabet() {} public: /** * @param stateIndex The index of a hidden state. * @return The corresponding hidden state. * @see getNumberOfStates */ virtual const Clonable& getState(size_t stateIndex) const throw (HmmBadStateException) = 0; virtual size_t getNumberOfStates() const = 0; /** * @brief Tell if this instance can work with the instance of alphabet given as input. * * In many case, this will return true is the pointer provided as argument refers to this object. * * @param stateAlphabet The alphabet to check. * @return true if the matrix is compatible with the given alphabet. */ virtual bool worksWith(const HmmStateAlphabet* stateAlphabet) const = 0; }; class StateListener { public: StateListener() {} virtual ~StateListener() {} public: virtual void stateChanged(StateChangedEvent& event) = 0; }; class StateChangedEvent { protected: std::vector states_; public: StateChangedEvent(unsigned int stateIndex): states_(1) { states_[0] = stateIndex; } StateChangedEvent(std::vector& states): states_(states) {} public: const std::vector& getStates() const { return states_; } std::vector& getStates() { return states_; } }; } #endif //_HMMSTATEALPHABET_H_ bpp-core-2.2.0/src/Bpp/Numeric/DataTable.cpp000664 001750 001750 00000055765 12370705300 022164 0ustar00jdutheiljdutheil000000 000000 // // File: DataTable.cpp // Created by: Julien Dutheil // Created on: Aug 2005 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "DataTable.h" #include "VectorTools.h" #include "../Io/FileTools.h" #include "../Text/TextTools.h" #include "../Text/StringTokenizer.h" using namespace bpp; using namespace std; /******************************************************************************/ DataTable::DataTable(size_t nRow, size_t nCol) : nRow_(nRow), nCol_(nCol), data_(nCol), rowNames_(0), colNames_(0) { for (size_t i = 0; i < nCol; i++) { data_[i].resize(nRow); } } DataTable::DataTable(size_t nCol) : nRow_(0), nCol_(nCol), data_(nCol), rowNames_(0), colNames_(0) {} DataTable::DataTable(const std::vector& colNames) throw (DuplicatedTableColumnNameException) : nRow_(0), nCol_(colNames.size()), data_(colNames.size()), rowNames_(0), colNames_(0) { setColumnNames(colNames); // May throw an exception. } DataTable::DataTable(const DataTable& table) : nRow_(table.nRow_), nCol_(table.nCol_), data_(table.data_), rowNames_(0), colNames_(0) { if (table.rowNames_) rowNames_ = new vector(*table.rowNames_); if (table.colNames_) colNames_ = new vector(*table.colNames_); } DataTable& DataTable::operator=(const DataTable& table) { nRow_ = table.nRow_; nCol_ = table.nCol_; data_ = table.data_; if (rowNames_) delete rowNames_; if (colNames_) delete colNames_; rowNames_ = 0; colNames_ = 0; if (table.rowNames_) rowNames_ = new vector(*table.rowNames_); if (table.colNames_) colNames_ = new vector(*table.colNames_); return *this; } /******************************************************************************/ DataTable::~DataTable() { if (rowNames_ != NULL) delete rowNames_; if (colNames_ != NULL) delete colNames_; } /******************************************************************************/ /* Cell access */ /******************************************************************************/ string& DataTable::operator()(size_t rowIndex, size_t colIndex) throw (IndexOutOfBoundsException) { if (colIndex >= nCol_) throw IndexOutOfBoundsException("DataTable::operator(size_t, size_t).", colIndex, 0, nCol_ - 1); if (rowIndex >= data_[colIndex].size()) throw IndexOutOfBoundsException("DataTable::operator(size_t, size_t).", rowIndex, 0, data_[colIndex].size() - 1); return data_[colIndex][rowIndex]; } const string& DataTable::operator()(size_t rowIndex, size_t colIndex) const throw (IndexOutOfBoundsException) { if (colIndex >= nCol_) throw IndexOutOfBoundsException("DataTable::operator(size_t, size_t).", colIndex, 0, nCol_ - 1); if (rowIndex >= data_[colIndex].size()) throw IndexOutOfBoundsException("DataTable::operator(size_t, size_t).", rowIndex, 0, data_[colIndex].size() - 1); return data_[colIndex][rowIndex]; } /******************************************************************************/ string& DataTable::operator()(const string& rowName, const string& colName) throw (NoTableRowNamesException, NoTableColumnNamesException, TableNameNotFoundException) { if (rowNames_ == NULL) throw NoTableRowNamesException("DataTable::operator(const string &, const string &)."); if (colNames_ == NULL) throw NoTableColumnNamesException("DataTable::operator(const string &, const string &)."); try { size_t rowIndex = VectorTools::which(*rowNames_, rowName); size_t colIndex = VectorTools::which(*colNames_, colName); return (*this)(rowIndex, colIndex); } catch (ElementNotFoundException& ex) { throw TableNameNotFoundException("DataTable::operator(const string &, const string &).", *ex.getElement()); } } const string& DataTable::operator()(const string& rowName, const string& colName) const throw (NoTableRowNamesException, NoTableColumnNamesException, TableNameNotFoundException) { if (rowNames_ == NULL) throw NoTableRowNamesException("DataTable::operator(const string &, const string &)."); if (colNames_ == NULL) throw NoTableColumnNamesException("DataTable::operator(const string &, const string &)."); try { size_t rowIndex = VectorTools::which(*rowNames_, rowName); size_t colIndex = VectorTools::which(*colNames_, colName); return (*this)(rowIndex, colIndex); } catch (ElementNotFoundException& ex) { throw TableNameNotFoundException("DataTable::operator(const string &, const string &).", *ex.getElement()); } } /******************************************************************************/ string& DataTable::operator()(const string& rowName, size_t colIndex) throw (NoTableRowNamesException, TableNameNotFoundException, IndexOutOfBoundsException) { if (rowNames_ == NULL) throw NoTableRowNamesException("DataTable::operator(const string &, size_t)."); if (colIndex >= nCol_) throw IndexOutOfBoundsException("DataTable::operator(const string &, size_t).", colIndex, 0, nCol_ - 1); try { size_t rowIndex = VectorTools::which(*rowNames_, rowName); return (*this)(rowIndex, colIndex); } catch (ElementNotFoundException& ex) { throw TableNameNotFoundException("DataTable::operator(const string &, size_t).", *ex.getElement()); } } const string& DataTable::operator()(const string& rowName, size_t colIndex) const throw (NoTableRowNamesException, TableNameNotFoundException, IndexOutOfBoundsException) { if (rowNames_ == NULL) throw NoTableRowNamesException("DataTable::operator(const string &, size_t)."); if (colIndex >= nCol_) throw IndexOutOfBoundsException("DataTable::operator(const string &, size_t).", colIndex, 0, nCol_ - 1); try { size_t rowIndex = VectorTools::which(*rowNames_, rowName); return (*this)(rowIndex, colIndex); } catch (ElementNotFoundException& ex) { throw TableNameNotFoundException("DataTable::operator(const string &, size_t).", *ex.getElement()); } } /******************************************************************************/ string& DataTable::operator()(size_t rowIndex, const string& colName) throw (IndexOutOfBoundsException, NoTableColumnNamesException, TableNameNotFoundException) { if (colNames_ == NULL) throw NoTableColumnNamesException("DataTable::operator(size_t, const string &)."); try { size_t colIndex = VectorTools::which(*colNames_, colName); if (rowIndex >= data_[colIndex].size()) throw IndexOutOfBoundsException("DataTable::operator(size_t, const string &).", rowIndex, 0, data_[colIndex].size() - 1); return (*this)(rowIndex, colIndex); } catch (ElementNotFoundException& ex) { throw TableNameNotFoundException("DataTable::operator(const string &, const string &).", *ex.getElement()); } } const string& DataTable::operator()(size_t rowIndex, const string& colName) const throw (IndexOutOfBoundsException, NoTableColumnNamesException, TableNameNotFoundException) { if (colNames_ == NULL) throw NoTableColumnNamesException("DataTable::operator(size_t, const string &)."); try { size_t colIndex = VectorTools::which(*colNames_, colName); if (rowIndex >= data_[colIndex].size()) throw IndexOutOfBoundsException("DataTable::operator(size_t, const string &).", rowIndex, 0, data_[colIndex].size() - 1); return (*this)(rowIndex, colIndex); } catch (ElementNotFoundException& ex) { throw TableNameNotFoundException("DataTable::operator(const string &, const string &).", *ex.getElement()); } } /******************************************************************************/ /* Work with names */ /******************************************************************************/ void DataTable::setRowNames(const vector& rowNames) throw (DimensionException, DuplicatedTableRowNameException) { if (!VectorTools::isUnique(rowNames)) { throw DuplicatedTableRowNameException("DataTable::setRowNames(...). Row names must be unique."); } if (rowNames.size() != nRow_) throw DimensionException("DataTable::setRowNames.", rowNames.size(), nRow_); else { if (rowNames_ != NULL) delete rowNames_; rowNames_ = new vector(rowNames.begin(), rowNames.end()); } } vector DataTable::getRowNames() const throw (NoTableRowNamesException) { if (rowNames_ == NULL) throw NoTableRowNamesException("DataTable::getRowNames()."); return *rowNames_; } string DataTable::getRowName(size_t index) const throw (NoTableRowNamesException, IndexOutOfBoundsException) { if (rowNames_ == NULL) throw NoTableRowNamesException("DataTable::getRowName(size_t)."); if (index >= nRow_) throw IndexOutOfBoundsException("DataTable::getRowName(size_t).", index, 0, nRow_ - 1); return (*rowNames_)[index]; } /******************************************************************************/ void DataTable::setColumnNames(const vector& colNames) throw (DimensionException, DuplicatedTableColumnNameException) { if (!VectorTools::isUnique(colNames)) throw DuplicatedTableColumnNameException("DataTable::setColumnNames(...). Column names must be unique."); if (colNames.size() != nCol_) throw DimensionException("DataTable::setColumnNames.", colNames.size(), nCol_); else { if (colNames_ != NULL) delete colNames_; colNames_ = new vector(colNames.begin(), colNames.end()); } } vector DataTable::getColumnNames() const throw (NoTableColumnNamesException) { if (colNames_ == NULL) throw NoTableColumnNamesException("DataTable::getColumnNames()."); return *colNames_; } string DataTable::getColumnName(size_t index) const throw (NoTableColumnNamesException, IndexOutOfBoundsException) { if (colNames_ == NULL) throw NoTableColumnNamesException("DataTable::getColumnName(size_t)."); if (index >= nCol_) throw IndexOutOfBoundsException("DataTable::getColumnName(size_t).", index, 0, nCol_ - 1); return (*colNames_)[index]; } /******************************************************************************/ /* Work on columns */ /******************************************************************************/ vector& DataTable::getColumn(size_t index) throw (IndexOutOfBoundsException) { if (index >= nCol_) throw IndexOutOfBoundsException("DataTable::getColumn(size_t).", index, 0, nCol_ - 1); return data_[index]; } const vector& DataTable::getColumn(size_t index) const throw (IndexOutOfBoundsException) { if (index >= nCol_) throw IndexOutOfBoundsException("DataTable::getColumn(size_t).", index, 0, nCol_ - 1); return data_[index]; } vector& DataTable::getColumn(const string& colName) throw (NoTableColumnNamesException, TableColumnNameNotFoundException) { if (colNames_ == NULL) throw NoTableColumnNamesException("DataTable::getColumn(const string &)."); try { size_t colIndex = VectorTools::which(*colNames_, colName); return data_[colIndex]; } catch (ElementNotFoundException& ex) { throw TableColumnNameNotFoundException("DataTable::getColumn(const string &).", colName); } } const vector& DataTable::getColumn(const string& colName) const throw (NoTableColumnNamesException, TableColumnNameNotFoundException) { if (colNames_ == NULL) throw NoTableColumnNamesException("DataTable::getColumn(const string &)."); try { size_t colIndex = VectorTools::which(*colNames_, colName); return data_[colIndex]; } catch (ElementNotFoundException& ex) { throw TableColumnNameNotFoundException("DataTable::getColumn(const string &).", colName); } } bool DataTable::hasColumn(const string& colName) const { if (colNames_ == NULL) return false; for (size_t i = 0; i < colNames_->size(); i++) { if ((*colNames_)[i] == colName) return true; } return false; } void DataTable::deleteColumn(size_t index) throw (IndexOutOfBoundsException) { if (index >= nCol_) throw IndexOutOfBoundsException("DataTable::deleteColumn(size_t).", index, 0, nCol_ - 1); data_.erase(data_.begin() + static_cast(index)); if (colNames_) colNames_->erase(colNames_->begin() + static_cast(index)); nCol_--; } void DataTable::deleteColumn(const string& colName) throw (NoTableColumnNamesException, TableColumnNameNotFoundException) { if (!colNames_) throw NoTableColumnNamesException("DataTable::deleteColumn(const string &)."); try { size_t colIndex = VectorTools::which(*colNames_, colName); data_.erase(data_.begin() + static_cast(colIndex)); colNames_->erase(colNames_->begin() + static_cast(colIndex)); nCol_--; } catch (ElementNotFoundException& ex) { throw TableColumnNameNotFoundException("DataTable::deleteColumn(const string &).", colName); } } void DataTable::addColumn(const vector& newColumn) throw (DimensionException, TableColumnNamesException) { if (colNames_) throw TableColumnNamesException("DataTable::addColumn. Table has column names."); if (newColumn.size() != nRow_) throw DimensionException("DataTable::addColumn.", newColumn.size(), nRow_); data_.push_back(newColumn); nCol_++; } void DataTable::addColumn(const string& colName, const vector& newColumn) throw (DimensionException, NoTableColumnNamesException, DuplicatedTableColumnNameException) { if (!colNames_) { if (nCol_ == 0) colNames_ = new vector(); else throw NoTableColumnNamesException("DataTable::addColumn. Table has column names."); } if (newColumn.size() != nRow_) throw DimensionException("DataTable::addColumn.", newColumn.size(), nRow_); if (nCol_ > 0 && find(colNames_->begin(), colNames_->end(), colName) != colNames_->end()) throw DuplicatedTableColumnNameException("DataTable::addColumn(const string &, const vector &). Column names must be unique."); colNames_->push_back(colName); data_.push_back(newColumn); nCol_++; } /******************************************************************************/ /* Work on rows */ /******************************************************************************/ vector DataTable::getRow(size_t index) const throw (IndexOutOfBoundsException) { if (index >= nRow_) throw IndexOutOfBoundsException("DataTable::getRow(size_t).", index, 0, nRow_ - 1); vector row; for (size_t i = 0; i < nCol_; i++) { row.push_back(data_[i][index]); } return row; } vector DataTable::getRow(const string& rowName) const throw (NoTableRowNamesException, TableRowNameNotFoundException) { if (!rowNames_) throw NoTableRowNamesException("DataTable::getRow(const string &)."); try { size_t rowIndex = VectorTools::which(*rowNames_, rowName); vector row; for (size_t i = 0; i < nCol_; i++) { row.push_back(data_[i][rowIndex]); } return row; } catch (ElementNotFoundException& ex) { throw TableRowNameNotFoundException("DataTable::getRow(const string &).", rowName); } } bool DataTable::hasRow(const string& rowName) const { if (rowNames_ == NULL) return false; for (size_t i = 0; i < rowNames_->size(); i++) { if ((*rowNames_)[i] == rowName) return true; } return false; } void DataTable::deleteRow(size_t index) throw (IndexOutOfBoundsException) { for (size_t j = 0; j < nCol_; j++) { vector* column = &data_[j]; if (index >= column->size()) throw IndexOutOfBoundsException("DataTable::deleteRow(size_t).", index, 0, column->size() - 1); column->erase(column->begin() + static_cast(index)); } if (rowNames_) rowNames_->erase(rowNames_->begin() + static_cast(index)); nRow_--; } void DataTable::deleteRow(const string& rowName) throw (NoTableRowNamesException, TableRowNameNotFoundException) { if (!rowNames_) throw NoTableRowNamesException("DataTable::deleteRow(const string &)."); try { size_t rowIndex = VectorTools::which(*rowNames_, rowName); for (size_t j = 0; j < nCol_; j++) { vector* column = &data_[j]; column->erase(column->begin() + static_cast(rowIndex)); } rowNames_->erase(rowNames_->begin() + static_cast(rowIndex)); nRow_--; } catch (ElementNotFoundException& ex) { throw TableRowNameNotFoundException("DataTable::deleteRow(const string &).", rowName); } } void DataTable::addRow(const vector& newRow) throw (DimensionException, TableRowNamesException) { if (rowNames_) throw TableRowNamesException("DataTable::addRow. Table has row names."); if (newRow.size() != nCol_) throw DimensionException("DataTable::addRow.", newRow.size(), nCol_); for (size_t j = 0; j < nCol_; j++) { data_[j].push_back(newRow[j]); } nRow_++; } void DataTable::addRow(const string& rowName, const vector& newRow) throw (DimensionException, NoTableRowNamesException, DuplicatedTableRowNameException) { if (!rowNames_) { if (nRow_ == 0) rowNames_ = new vector(); else throw NoTableRowNamesException("DataTable::addRow. Table has row names."); } if (newRow.size() != nCol_) throw DimensionException("DataTable::addRow.", newRow.size(), nCol_); if (nRow_ > 0 && find(rowNames_->begin(), rowNames_->end(), rowName) != rowNames_->end()) throw DuplicatedTableRowNameException("DataTable::addRow(const string &, const vector &). Row names must be unique."); rowNames_->push_back(rowName); for (size_t j = 0; j < nCol_; j++) { data_[j].push_back(newRow[j]); } nRow_++; } /******************************************************************************/ /* Read from a CSV file */ /******************************************************************************/ DataTable* DataTable::read(istream& in, const string& sep, bool header, int rowNames) throw (DimensionException, IndexOutOfBoundsException, DuplicatedTableRowNameException) { string firstLine = FileTools::getNextLine(in); StringTokenizer st1(firstLine, sep, false, true); vector row1(st1.getTokens().begin(), st1.getTokens().end()); string secondLine = FileTools::getNextLine(in); StringTokenizer st2(secondLine, sep, false, true); vector row2(st2.getTokens().begin(), st2.getTokens().end()); size_t nCol = row1.size(); bool hasRowNames; DataTable* dt; if (row1.size() == row2.size()) { dt = new DataTable(nCol); if (header) { // Use first line as header. dt->setColumnNames(row1); } else { dt->addRow(row1); } dt->addRow(row2); hasRowNames = false; } else if (row1.size() == row2.size() - 1) { dt = new DataTable(nCol); dt->setColumnNames(row1); string rowName = *row2.begin(); dt->addRow(rowName, vector(row2.begin() + 1, row2.end())); hasRowNames = true; } else throw DimensionException("DataTable::read(...). Row 2 has not the correct number of columns.", row2.size(), nCol); // Now read each line: string line = FileTools::getNextLine(in); while (!TextTools::isEmpty(line)) { StringTokenizer st(line, sep, false, true); if (hasRowNames) { string rowName = *st.getTokens().begin(); vector row(st.getTokens().begin() + 1, st.getTokens().end()); dt->addRow(rowName, row); } else { vector row(st.getTokens().begin(), st.getTokens().end()); dt->addRow(row); } line = FileTools::getNextLine(in); } // Row names: if (rowNames > -1) { if (static_cast(rowNames) >= nCol) throw IndexOutOfBoundsException("DataTable::read(...). Invalid column specified for row names.", static_cast(rowNames), 0, nCol - 1); vector col = dt->getColumn(static_cast(rowNames)); dt->setRowNames(col); dt->deleteColumn(static_cast(rowNames)); } return dt; } /******************************************************************************/ void DataTable::write(const DataTable& data, ostream& out, const string& sep, bool alignHeaders) { size_t n = data.getNumberOfColumns(); if (n == 0) return; if (data.hasColumnNames()) { // Write header vector colNames = data.getColumnNames(); if (alignHeaders && data.hasRowNames()) out << sep; out << colNames[0]; for (size_t i = 1; i < n; i++) { out << sep << colNames[i]; } out << endl; } // Now write each row: for (size_t i = 0; i < data.getNumberOfRows(); i++) { if (data.hasRowNames()) out << data.getRowName(i) << sep; out << data(i, 0); for (size_t j = 1; j < n; j++) { out << sep << data(i, j); } out << endl; } } void DataTable::write(const DataTable& data, bpp::OutputStream& out, const string& sep, bool alignHeaders) { size_t n = data.getNumberOfColumns(); if (n == 0) return; if (data.hasColumnNames()) { // Write header vector colNames = data.getColumnNames(); if (alignHeaders && data.hasRowNames()) out << sep; out << colNames[0]; for (size_t i = 1; i < n; i++) { out << sep << colNames[i]; } out.endLine(); } // Now write each row: for (size_t i = 0; i < data.getNumberOfRows(); i++) { if (data.hasRowNames()) out << data.getRowName(i) << sep; out << data(i, 0); for (size_t j = 1; j < n; j++) { out << sep << data(i, j); } out.endLine(); } } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Numeric/VectorTools.cpp000664 001750 001750 00000006215 12370705300 022610 0ustar00jdutheiljdutheil000000 000000 // // File: VectorTools.cpp // Created by: Julien Dutheil // Created on: Fri Mar 14 14:16:32 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide classes for numerical calculus. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ // From Utils: #include "../Text/TextTools.h" #include "VectorTools.h" using namespace bpp; // From the STL: #include #include using namespace std; /******************************************************************************/ vector VectorTools::breaks(const vector& v, unsigned int n) { vector out; vector r = VectorTools::range(v); double part = (r[1] - r[0]) / n; for (unsigned int i = 0; i < n; ++i) { out.push_back(r[0] + (part * i)); } out.push_back(r[1]); return out; } /******************************************************************************/ bool VectorTools::test() { vector x1(5); vector x2(5); x1[0] = -3.4; x1[1] = 1.8; x1[2] = -2.1; x1[3] = -2.5; x1[4] = 1.0; x2[0] = -5.3; x2[1] = -4.8; x2[2] = 2.7; x2[3] = 7.2; x2[4] = 0.4; print(x1); print(x2); double m1 = mean(x1); double m2 = mean(x2); double v1 = var(x1); double v2 = var(x2); cout << "Mean x1 = " << m1 << "\tVar x1 = " << v1 << endl; cout << "Mean x2 = " << m2 << "\tVar x2 = " << v2 << endl; cov(x1, x2); cor(x1, x2); cos(x1, x2); shannon(x1); return m1 == -0.2 && m2 == 0.04 && v1 == 6.565 && v2 == 27.603; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Utils/AttributesTools.h000664 001750 001750 00000021233 12406244530 022637 0ustar00jdutheiljdutheil000000 000000 // // File: AttributesTools.h // Created by: Julien Dutheil // Created on: 2003 // /* Copyright or © or Copr. Bio++ Development Tools, (November 17, 2004) This software is a computer program whose purpose is to provide basal and utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _ATTRIBUTES_TOOLS_H_ #define _ATTRIBUTES_TOOLS_H_ #include "../Exceptions.h" // From the STL: #include #include #include #include namespace bpp { /** * @brief Some functions to deal with attributes, i.e. parameters passed to a program/method. * * These methods allows you to retrieve attributes from command line arguments or * from a file. * The underlying syntax is attributeName = argument . * Here the delimiter char is '=', but another character may be used. * * In files, shell comments: # my comment line here , * C comments: / * my comment block here * / (but multiline not supported!) * and C++ comments: // my comment line here are allowed, and ignored while parsing. * * Lines may be broken, using the bash character '\' at the end of the line: * @code * optionfile=/home/foo/\ * bar.txt * @endcode * will be read as * @code * optionfile=/home/foo/bar.txt * @endcode * * Attributes are stored as a map, with attributes names as keys, * and arguments as values. * * Here is an example of use. * This piece of code typically is at the begining of the main function. * It uses the FileTools and ApplicationTools classes, for checking file existence and displaying messages respectively. * @code * // Get the parameters from command line: * map cmdParams = AttributesTools::getAttributesMap( * AttributesTools::getVector(argc, argv), "="); * * // Look for a specified file with parameters: * int main(int argc, char *argv[]) { * map params; * if(cmdParams.find("param") != cmdParams.end()) { * string file = cmdParams["param"]; * if(!FileTools::fileExists(file)) { * ApplicationTools::displayError("Parameter file not found."); * exit(-1); * } else { * params = AttributesTools::getAttributesMapFromFile(file, "="); * // Actualize attributes with the ones passed to command line: * AttributesTools::actualizeAttributesMap(params, cmdParams); * } * } else { * params = cmdParams; * } * ... * @endcode * These pieces of code does the following: * - get all parameters from the command line and store them in a map, * - check if some parameter is called 'param' or 'params'. If so, look for the file * given as value and try to read some parameters from it. * - If an parameter file was found, update the parameter in it with those from * the command line. This implies that when a parameter is found in both the * command line and the option file, the value from the command line will be * retained. * * Support for variable is also available. * A variable character is specified (typically '$()') and may be used to de-reference any argument. * For instance, * @code * data=LSU * file=$(data).out * @endcode * * will be equivalent to * @code * data=LSU * file=LSU.out * @endcode */ class AttributesTools { public: AttributesTools() {} virtual ~AttributesTools() {} /** * @brief Get attributes a vector of strings from command line arguments. * * @param argc The number of arguments. * @param argv The array with all arguments. * @return A vector with all arguments as strings. */ static std::vector getVector(int argc, char* argv[]); /** * @brief Get an attribute map from a vector of arguments. * * This method also resolve all variable calls. * * @param argv The vector of arguments. * @param delimiter The string that separates attribute names from arguments (for instance '='). * @return The attribute map. */ static std::map getAttributesMap( const std::vector& argv, const std::string& delimiter = "="); /** * @brief Get an attribute map from a vector of arguments. * * This method also resolve all variable calls. * * @param argv The vector of arguments. * @param am The attribute map to fill. * @param delimiter The string that separates attribute names from arguments (for instance '='). */ static void getAttributesMap( const std::vector& argv, std::map& am, const std::string& delimiter = "="); /** * @brief Get an attribute map from a file. * * @param file The file with all arguments. * @param delimiter The string that separates attribute names from arguments (for instance '='). * @return An attribute map. */ static std::map getAttributesMapFromFile( const std::string& file, const std::string& delimiter); /** * @brief Get an attribute map from a file. * * @param file The file with all arguments. * @param params An attribute map to fill. * @param delimiter The string that separates attribute names from arguments (for instance '='). */ static void getAttributesMapFromFile( const std::string& file, std::map& params, const std::string& delimiter); /** * @brief Actualizes an attribute map with another. * * All fields in map 2 will be added to map 1. * If two attributes have the same name, then map 1 value will be overwritten. * * @param attMap The attributes map. * @param atts The attributes to add to the map. */ static void actualizeAttributesMap( std::map& attMap, const std::map& atts); /** * @brief Resolve the variables. * * If used prior to the actualizeAttributesMap, this function will make the * variables 'local', whereas using them after will make them 'global'. * * @param am The attributes map. * @param varCode The code that defines variable recalls. * @param varBeg Variables begin name code. * @param varEnd Variables end name code. * @throw Exception If there is a syntax error. */ static void resolveVariables(std::map& am, char varCode = '$', char varBeg = '(', char varEnd = ')') throw (Exception); /** * @brief Global function that reads all parameters from command line and files, * and set the values in a map. * * @param args Number of arguments, as passed to the main function. * @param argv Array of values, as passed to the main function. * @return An attributes map. * @throw Exception in case an option file is not found. */ static std::map parseOptions(int args, char** argv) throw (Exception); private: /** * @brief Remove comments from a string. * * @param s The string to parse. * @param begin Comments front delimiter. * @param end Comments end delimiter. */ static std::string removeComments(const std::string& s, const std::string& begin, const std::string& end); }; } // end of namespace bpp. #endif // _ATTRIBUTES_TOOLS_H_ bpp-core-2.2.0/src/Bpp/Utils/MapTools.h000664 001750 001750 00000007103 12370705300 021223 0ustar00jdutheiljdutheil000000 000000 // // File: MapTools.h // Created by: Julien Dutheil // Created on: Tue May 13 18:16:10 2003 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _MAPTOOLS_H_ #define _MAPTOOLS_H_ #include #include namespace bpp { /** * @brief A fiew tools working on map objects. */ class MapTools { public: /** * @brief Get a vector of all keys in a map. * * @param myMap the map to check. * @return a vector of all keys. */ template static std::vector getKeys(const std::map & myMap) { std::vector keys; for(typename std::map::const_iterator i = myMap.begin(); i != myMap.end(); i++) { keys.push_back(i->first); } return keys; } /** * @brief Get a vector of all keys in a map. * * @param myMap the map to check. * @return a vector of all keys. */ template static std::vector getKeys(const std::map & myMap) { std::vector keys; for(typename std::map::const_iterator i = myMap.begin(); i != myMap.end(); i++) { keys.push_back(i->first); } return keys; } /** * @brief Get a vector of all values in a map. * * @param myMap the map to check. * @return a vector of all values. */ template static std::vector getValues(const std::map & myMap) { std::vector values; for(typename std::map::const_iterator i = myMap.begin(); i != myMap.end(); i++) { values.push_back(i->second); } return values; } /** * @brief Get a vector of all values in a map. * * @param myMap the map to check. * @return a vector of all values. */ template static std::vector getValues(const std::map & myMap) { std::vector values; for(typename std::map::const_iterator i = myMap.begin(); i != myMap.end(); i++) { values.push_back(i->second); } return values; } }; } //end of namespace bpp. #endif //_MAPTOOLS_H_ bpp-core-2.2.0/src/Bpp/Utils/AttributesTools.cpp000664 001750 001750 00000023235 12406244530 023176 0ustar00jdutheiljdutheil000000 000000 // // File: AttributesTools.cpp // Created by: Julien Dutheil // Created on: 2003 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide basal and utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ // From the STL: #include #include #include #include #include using namespace std; #include "AttributesTools.h" #include "../App/ApplicationTools.h" #include "../Text/TextTools.h" #include "../Io/FileTools.h" using namespace bpp; /******************************************************************************/ std::vector AttributesTools::getVector(int argc, char* argv[]) { size_t n = static_cast(argc); vector result(n); for (size_t i = 1; i < n; ++i) { result[i] = string(argv[i]); } // Ignore first argc which is the program name! return result; } /******************************************************************************/ std::map AttributesTools::getAttributesMap( const std::vector& argv, const std::string& delimiter) { map am; getAttributesMap(argv, am, delimiter); return am; } /******************************************************************************/ void AttributesTools::getAttributesMap( const std::vector& argv, std::map& am, const std::string& delimiter) { vector argv2(argv.size()); // First make a few cleaning: for (size_t i = 0; i < argv.size(); i++) { // Make a few corrections first: string arg = removeComments(argv[i], string("#"), string("\n")); // remove shell comments. arg = removeComments(arg, string("//"), string("\n")); // remove C simple comments. arg = removeComments(arg, string("/*"), string("*/")); // remove C multiple comments. arg = TextTools::removeWhiteSpaces(arg); argv2[i] = arg; } // Now parse arguments: for (size_t i = 0; i < argv.size(); i++) { string arg = argv2[i]; if (arg == "") continue; // Skipping void line. while (arg[arg.size() - 1] == '\\') { // Splitted line i++; arg = arg.substr(0, arg.length() - 1) + argv2[i]; } // Parsing: string::size_type limit = arg.find(delimiter, 0); if (limit == string::npos) { // Invalid parameter (*ApplicationTools::warning << "WARNING!!! Parameter '" << arg << "' has been ignored.").endLine(); } else { string name = string(arg.begin(), arg.begin() + static_cast(limit)); string value = string(arg.begin() + static_cast(limit + delimiter.size()), arg.end()); // if ((name == "param") || (name == "params")) // { // //Recursive inclusion: // getAttributesMapFromFile(value, am, delimiter); // } // else am[name] = value; } } } /******************************************************************************/ void AttributesTools::getAttributesMapFromFile( const std::string& file, std::map& params, const std::string& delimiter) { cout << "Parsing file " << file << " for options." << endl; ifstream input(file.c_str(), ios::in); vector lines = FileTools::putStreamIntoVectorOfStrings(input); getAttributesMap(lines, params, delimiter); } /******************************************************************************/ std::map AttributesTools::getAttributesMapFromFile( const std::string& file, const std::string& delimiter) { map params; getAttributesMapFromFile(file, params, delimiter); return params; } /******************************************************************************/ void AttributesTools::actualizeAttributesMap( std::map& attMap, const std::map& atts) { for (map::const_iterator i = atts.begin(); i != atts.end(); i++) { if ((i->first != "param") && (i->first != "params")) attMap[i->first] = i->second; } } /******************************************************************************/ void AttributesTools::resolveVariables( std::map& am, char varCode, char varBeg, char varEnd) throw (Exception) { // Now resolve any variable: for (map::iterator it = am.begin(); it != am.end(); it++) { string value = it->second; string::size_type index1 = value.find(TextTools::toString(varCode) + TextTools::toString(varBeg)); while (index1 != string::npos) { string::size_type index2 = value.find(TextTools::toString(varEnd), index1); if (index2 != string::npos) { string varName = value.substr(index1 + 2, index2 - index1 - 2); map::iterator varIt = am.find(varName); string varValue = ""; if (varIt == am.end()) { if (ApplicationTools::error) (*ApplicationTools::error << "Variable '" << varName << "' is undefined and was ignored.").endLine(); } else { varValue = varIt->second; } // Modify original field: string newValue = value.substr(0, index1) + varValue + value.substr(index2 + 1); it->second = newValue; } else throw Exception("Syntax error, variable name is not closed."); value = it->second; index1 = value.find(TextTools::toString(varCode) + TextTools::toString(varBeg)); } } } /******************************************************************************/ std::string AttributesTools::removeComments( const std::string& s, const std::string& begin, const std::string& end) { string r = s; string::size_type last = 0; do { string::size_type first = r.find(begin, last); if (first == string::npos) return r; // No shell comment. // else: last = r.find(end, first); if (last == string::npos) { r.erase(r.begin() + static_cast(first), r.end()); } else { r.erase(r.begin() + static_cast(first), r.begin() + static_cast(last)); } } while (last != string::npos); return r; } /******************************************************************************/ std::map AttributesTools::parseOptions(int args, char** argv) throw (Exception) { // Get the parameters from command line: map cmdParams = AttributesTools::getAttributesMap( AttributesTools::getVector(args, argv), "="); // Look for a specified file with parameters: map params; std::map::iterator it; if (cmdParams.find("param") != cmdParams.end()) { string file = cmdParams["param"]; if (!FileTools::fileExists(file)) { throw Exception("AttributesTools::parseOptions(). Parameter file not found."); } else { params = getAttributesMapFromFile(file, "="); // Actualize attributes with ones passed to command line: actualizeAttributesMap(params, cmdParams); } } else { params = cmdParams; } // Resolve variables: resolveVariables(params); std::vector mapfile; std::vector::iterator imapfile; string file; while (true) { it = params.find("param"); if (it != params.end()) { file = it->second; if (std::find(mapfile.begin(), mapfile.end(), file) == mapfile.end()) { params.erase(it); mapfile.push_back(file); getAttributesMapFromFile(file, params, "="); resolveVariables(params); continue; } else throw Exception("parsing error : Already used file " + file); } it = params.find("params"); if (it != params.end()) { file = it->second; if (find(mapfile.begin(), mapfile.end(), file) == mapfile.end()) { params.erase(it); mapfile.push_back(file); getAttributesMapFromFile(file, params, "="); resolveVariables(params); continue; } else throw Exception("parsing error : Already used file " + file); } break; } return params; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Graphics/GraphicDevice.cpp000664 001750 001750 00000004415 12370705300 023160 0ustar00jdutheiljdutheil000000 000000 // // File: GraphicDevice.cpp // Created by: Julien Dutheil // Created on: Mon Mar 03 2008 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to map data onto a sequence or a phylogenetic tree. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "GraphicDevice.h" using namespace bpp; short GraphicDevice::TEXT_HORIZONTAL_CENTER = 0; short GraphicDevice::TEXT_HORIZONTAL_LEFT = 1; short GraphicDevice::TEXT_HORIZONTAL_RIGHT = 2; short GraphicDevice::TEXT_VERTICAL_CENTER = 3; short GraphicDevice::TEXT_VERTICAL_BOTTOM = 4; short GraphicDevice::TEXT_VERTICAL_TOP = 5; short GraphicDevice::FILL_EMPTY = 10; short GraphicDevice::FILL_FILLED = 11; short GraphicDevice::FILL_PATTERN = 12; short GraphicDevice::LINE_SOLID = 20; short GraphicDevice::LINE_DASHED = 21; short GraphicDevice::LINE_DOTTED = 22; bpp-core-2.2.0/src/Bpp/Graphics/RgbColor.h000664 001750 001750 00000010650 12370705300 021637 0ustar00jdutheiljdutheil000000 000000 // // File: RGBColor.h // Created by: Julien Dutheil // Created on: Thu Mar 16 2006 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _RGBCOLOR_H_ #define _RGBCOLOR_H_ // From the STL: #include #include "../Text/TextTools.h" #include "../Exceptions.h" #include "../Clonable.h" namespace bpp { /** * @brief Describe a color according to its red, green and blue componants. */ class RGBColor: public virtual Clonable { protected: unsigned int red_; unsigned int green_; unsigned int blue_; public: RGBColor(unsigned int red, unsigned int green, unsigned int blue): red_(red), green_(green), blue_(blue) {} RGBColor(): red_(0), green_(0), blue_(0) {} virtual ~RGBColor() {} #ifdef NO_VIRTUAL_COV Clonable* #else RGBColor* #endif clone() const { return new RGBColor(*this); } public: bool operator==(const RGBColor & color) const { return red_ == color.red_ && green_ == color.green_ && blue_ == color.blue_; } /** * @brief Comparison operator (for sorting purposes). * * The hexadecimal string representation is used for comparison. * * @param color The color to compare with. */ bool operator<(const RGBColor & color) const { return toHex() < color.toHex(); } /** * @brief Get the HTML-like, hexadecimal description of this color. */ std::string toHex() const { std::string hex = "#"; hex += decToHex(red_); hex += decToHex(green_); hex += decToHex(blue_); return hex; } /** * @brief Access to each color componant: 0=red, 1=green, 2=blue. */ const unsigned int & operator[](unsigned int i) const { if(i == 0) return red_; if(i == 1) return green_; if(i == 2) return blue_; throw Exception("Invalid color index"); } /** * @brief Access to each color componant: 0=red, 1=green, 2=blue. */ unsigned int & operator[](unsigned int i) { if(i == 0) return red_; if(i == 1) return green_; if(i == 2) return blue_; throw Exception("Invalid color index"); } /** * @brief Get a string description of the color, e.g. [R255,G0,B255]. */ std::string toString() const { return "[R" + TextTools::toString(red_) + ",G" + TextTools::toString(green_) + ",B" + TextTools::toString(blue_) + "]"; } protected: static std::string decToHex(unsigned int dec) { std::string hexa = "0123456789ABCDEF"; std::string hex = ""; while (dec > 15) { unsigned int tmp = dec - static_cast(floor(static_cast(dec)/16.)*16); hex = hexa[tmp] + hex; dec = static_cast(floor(static_cast(dec)/16.)); } hex = hexa[dec] + hex; if (hex.size() == 1) hex = "0" + hex; return hex; } }; } // end of namespace bpp; #endif //_RGBCOLOR_H_ bpp-core-2.2.0/src/Bpp/Graphics/ColorTools.h000664 001750 001750 00000010356 12370705300 022230 0ustar00jdutheiljdutheil000000 000000 // // File: ColorTools.h // Created by: Julien Dutheil // Created on: Thu Mar 16 2006 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _COLORTOOLS_H_ #define _COLORTOOLS_H_ #include "../Text/TextTools.h" #include "../Exceptions.h" #include "RgbColor.h" namespace bpp { /** * @brief Provide tools to deal with color objects. */ class ColorTools { public: ColorTools() {} virtual ~ColorTools() {} public: /** * @brief Create a set of colors according to a gradient defined by two extrema. * * @param n Number of colors to output. * @param low First color in gradient. * @param high Last color in gradient. * @return A set of ordered colors defining a gradient. */ static std::vector gradient(unsigned int n, const RGBColor & low, const RGBColor & high); /** * @brief Create a set of colors according to a gradient defined by two extrema and a midpoint. * * @param n Number of colors to output. * @param low First color in gradient. * @param mid Midpoint color. * @param high Last color in gradient. * @return A set of ordered colors defining a gradient. */ static std::vector gradient(unsigned int n, const RGBColor & low, const RGBColor & mid, const RGBColor & high); /** * @return A gray color. * @param level Gray intensity ([0,1]). */ static RGBColor gray(double level) { unsigned int i = (unsigned int)round(255*level); return RGBColor(i, i, i); } /** * @brief Get a RGBColor from a cyan-magenta-yellow-key description. * * The following formula are used for the transformation: * @f[ * \begin{array}{rcl} * r &=& 255 * (1 - c)(1 - k)\\ * g &=& 255 * (1 - m)(1 - k)\\ * b &=& 255 * (1 - y)(1 - k) * \end{array} * @f] * * @param c Cyan proportion. * @param m Magenta proportion. * @param y Yellow proportion. * @param k Black proportion. * @return A RGBColor object. */ static RGBColor cmyk2rgb(double c, double m, double y, double k) { unsigned int r = static_cast(round(255 * (1. - c) * (1. - k))); unsigned int g = static_cast(round(255 * (1. - m) * (1. - k))); unsigned int b = static_cast(round(255 * (1. - y) * (1. - k))); return RGBColor(r, g, b); } public: static const RGBColor RED; static const RGBColor GREEN; static const RGBColor BLUE; static const RGBColor BLACK; static const RGBColor WHITE; static const RGBColor YELLOW; static const RGBColor CYAN; static const RGBColor MAGENTA; static const RGBColor ORANGE; }; } // end of namespace bpp. #endif //_COLORTOOLS_H_ bpp-core-2.2.0/src/Bpp/Graphics/ColorManager.h000664 001750 001750 00000015074 12370705300 022504 0ustar00jdutheiljdutheil000000 000000 // // File: ColorManager.h // Created by: Julien Dutheil // Created on: Mon May 08 2006 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _COLORMANAGER_H_ #define _COLORMANAGER_H_ #include "RgbColor.h" #include "ColorTools.h" #include "../Text/TextTools.h" // From the STL: #include namespace bpp { /** * @brief Associate special colors to a code. * * Instances of this interface are used in some vector format. */ template class ColorManager { public: ColorManager() {} virtual ~ColorManager() {} public: /** * @param color The color to look for. * @return The code associated to a given color. */ virtual CodeType getCode(const RGBColor& color) = 0; /** * @param code The code to look for. * @return The color associated to a given code. * @throw exception if the code is not valid. */ virtual const RGBColor& getColor(CodeType& code) const throw (Exception) = 0; /** * @return All valid codes. */ virtual const std::vector& getCodes() const = 0; /** * @return All available colors. */ virtual const std::vector& getColors() const = 0; /** * @return The total number of colors available. */ virtual size_t getNumberOfColors() const = 0; }; /** * @brief Color manager for the XFig format. * * Default colors are coded from 0 to 31. * New colors may be added from code 32. */ class XFigColorManager: public ColorManager { protected: unsigned int currentCode_; std::vector colors_; std::vector codes_; public: XFigColorManager(): currentCode_(31), colors_(), codes_() { // Add "official" color codes, from 0 to 31: codes_.push_back(0); colors_.push_back(ColorTools::BLACK); codes_.push_back(1); colors_.push_back(ColorTools::BLUE); codes_.push_back(2); colors_.push_back(ColorTools::GREEN); codes_.push_back(3); colors_.push_back(ColorTools::CYAN); codes_.push_back(4); colors_.push_back(ColorTools::RED); codes_.push_back(5); colors_.push_back(ColorTools::MAGENTA); codes_.push_back(6); colors_.push_back(ColorTools::YELLOW); codes_.push_back(7); colors_.push_back(ColorTools::WHITE); codes_.push_back(8); colors_.push_back(RGBColor(0,0,140)); codes_.push_back(9); colors_.push_back(RGBColor(0,0,173)); codes_.push_back(10); colors_.push_back(RGBColor(0,0,206)); codes_.push_back(11); colors_.push_back(RGBColor(132,207,205)); codes_.push_back(12); colors_.push_back(RGBColor(0,142,0)); codes_.push_back(13); colors_.push_back(RGBColor(0,174,0)); codes_.push_back(14); colors_.push_back(RGBColor(0,207,0)); codes_.push_back(15); colors_.push_back(RGBColor(0,142,140)); codes_.push_back(16); colors_.push_back(RGBColor(0,174,173)); codes_.push_back(17); colors_.push_back(RGBColor(0,207,206)); codes_.push_back(18); colors_.push_back(RGBColor(140,0,0)); codes_.push_back(19); colors_.push_back(RGBColor(173,0,0)); codes_.push_back(20); colors_.push_back(RGBColor(206,0,0)); codes_.push_back(21); colors_.push_back(RGBColor(140,0,140)); codes_.push_back(22); colors_.push_back(RGBColor(173,0,173)); codes_.push_back(23); colors_.push_back(RGBColor(206,0,206)); codes_.push_back(24); colors_.push_back(RGBColor(132,48,0)); codes_.push_back(25); colors_.push_back(RGBColor(156,65,0)); codes_.push_back(26); colors_.push_back(RGBColor(189,97,0)); codes_.push_back(27); colors_.push_back(RGBColor(255,130,132)); codes_.push_back(28); colors_.push_back(RGBColor(255,158,156)); codes_.push_back(29); colors_.push_back(RGBColor(255,190,189)); codes_.push_back(30); colors_.push_back(RGBColor(255,223,222)); codes_.push_back(31); colors_.push_back(RGBColor(255,215,0)); } virtual ~XFigColorManager() {} public: unsigned int getCode(const RGBColor & color) { for (unsigned int i = 0; i < colors_.size(); i++) { if (colors_[i] == color) { return codes_[i]; } } currentCode_++; colors_.push_back(color); codes_.push_back(currentCode_); return currentCode_; } const RGBColor& getColor(unsigned int &code) const throw (Exception) { for(unsigned int i = 0; i < codes_.size(); i++) { if(codes_[i] == code) { return colors_[i]; } } throw Exception("XFigColorManager::getColor. No color associated to this code: " + TextTools::toString(code)); } const std::vector& getCodes() const { return codes_; } const std::vector& getColors() const { return colors_; } size_t getNumberOfColors() const { return colors_.size(); } }; } // end of namespace bpp; #endif //_COLORMANAGER_H_ bpp-core-2.2.0/src/Bpp/Graphics/Fig/XFigLaTeXFontManager.cpp000664 001750 001750 00000004477 12370705300 025055 0ustar00jdutheiljdutheil000000 000000 // // File: XFigLaTeXFontManager.cpp // Created by: Julien Dutheil // Created on: Wed Dec 30 2009 // From file: FontManager.h // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "XFigLaTeXFontManager.h" using namespace bpp; XFigLaTeXFontManager::XFigLaTeXFontManager() { // Add "official" font codes, from 0 to 5: registerFont_(Font("Default", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 0); registerFont_(Font("Roman", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 1); registerFont_(Font("Bold", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 2); registerFont_(Font("Italic", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 3); registerFont_(Font("Sans Serif", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 4); registerFont_(Font("Typewriter", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 5); } bpp-core-2.2.0/src/Bpp/Graphics/Fig/XFigGraphicDevice.h000664 001750 001750 00000010255 12370705300 024107 0ustar00jdutheiljdutheil000000 000000 // // File: XFigGraphicDevice.h // Created by: Julien Dutheil // Created on: Mon Mar 03 2008 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _XFIGGRAPHICDEVICE_H_ #define _XFIGGRAPHICDEVICE_H_ #include "../AbstractGraphicDevice.h" #include "../ColorManager.h" #include "XFigLaTeXFontManager.h" #include "XFigPostscriptFontManager.h" // From the STL: #include #include namespace bpp { /** * @brief XFig plotting format. */ class XFigGraphicDevice: public AbstractGraphicDevice { private: std::ostream& out_; std::vector content_; XFigColorManager colorManager_; XFigLaTeXFontManager latexFontManager_; XFigPostscriptFontManager postscriptFontManager_; unsigned int fgColorCode_; unsigned int bgColorCode_; int fontCode_; unsigned int fontSize_; unsigned int fontFlag_; short lineTypeCode_; public: XFigGraphicDevice(std::ostream& out): out_(out), content_(), colorManager_(), latexFontManager_(), postscriptFontManager_(), fgColorCode_(0), bgColorCode_(0), fontCode_(-1), fontSize_(12), fontFlag_(FONTFLAG_POSTSCRIPT), lineTypeCode_(LINE_SOLID) { setCurrentLayer(0); } virtual ~XFigGraphicDevice() {} public: void begin(); void end(); void setCurrentForegroundColor(const RGBColor& color); void setCurrentBackgroundColor(const RGBColor& color); void setCurrentFont(const Font& font); void setCurrentLineType(short type) throw (Exception) { if(type == LINE_SOLID) lineTypeCode_ = 0; else if(type == LINE_DASHED) lineTypeCode_ = 1; else if(type == LINE_DOTTED) lineTypeCode_ = 2; else throw Exception("XFigGraphicDevice::setCurrentLineType. Unknown line type: " + TextTools::toString(type)); AbstractGraphicDevice::setCurrentLineType(type); } void drawLine(double x1, double y1, double x2, double y2); void drawRect(double x, double y, double width, double height, short fill = FILL_EMPTY); void drawCircle(double x, double y, double radius, short fill = FILL_EMPTY); void drawText(double x, double y, const std::string& text, short hpos = TEXT_HORIZONTAL_LEFT, short vpos = TEXT_VERTICAL_BOTTOM, double angle = 0) throw (UnvalidFlagException); void comment(const std::string& text) { content_.push_back("#" + text); } //Specific: void setFontFlag(unsigned int flag) { fontFlag_ = flag; } protected: int getFillCode(short fill); public: static const unsigned int FONTFLAG_LATEX; static const unsigned int FONTFLAG_POSTSCRIPT; }; } // end of namespace bpp; #endif //_XFIGGRAPHICDEVICE_H_ bpp-core-2.2.0/src/Bpp/Graphics/Fig/XFigLaTeXFontManager.h000664 001750 001750 00000004065 12370705300 024513 0ustar00jdutheiljdutheil000000 000000 // // File: XFigLaTeXFontManager.h // Created by: Julien Dutheil // Created on: Wed Dec 30 2009 // From file: FontManager.h // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _XFIGLATEXFONTMANAGER_H_ #define _XFIGLATEXFONTMANAGER_H_ #include "../Font/FontManager.h" namespace bpp { /** * @brief LaTeX font manager for the XFig format. */ class XFigLaTeXFontManager: public AbstractFontManager { public: XFigLaTeXFontManager(); virtual ~XFigLaTeXFontManager() {} }; } //end of namespace bpp; #endif //_XFIGLATEXFONTMANAGER_H_ bpp-core-2.2.0/src/Bpp/Graphics/Fig/XFigGraphicDevice.cpp000664 001750 001750 00000015163 12370705300 024445 0ustar00jdutheiljdutheil000000 000000 // // File: XFigGraphicDevice.cpp // Created by: Julien Dutheil // Created on: Mon Mar 03 2008 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "XFigGraphicDevice.h" using namespace bpp; using namespace std; const unsigned int XFigGraphicDevice::FONTFLAG_LATEX = 0; const unsigned int XFigGraphicDevice::FONTFLAG_POSTSCRIPT = 4; void XFigGraphicDevice::begin() { content_.clear(); } void XFigGraphicDevice::end() { //Print to file: //Header: out_ << "#FIG 3.2 Produced by the Bio++ Graphic Device System" << endl; out_ << "Portrait" << endl; out_ << "Flush left" << endl; out_ << "Metric" << endl; out_ << "A4" << endl; out_ << "100" << endl; out_ << "Single" << endl; out_ << "0" << endl; //out << "254 2" << endl; // 1fig unit = 0.1mm out_ << "72 2" << endl; // 1fig unit = 1pt // Color definitions: out_ << "#Color definitions:" << endl; vector codes = colorManager_.getCodes(); vector colors = colorManager_.getColors(); for(unsigned int i = 32; i < colorManager_.getNumberOfColors(); i++) { string hexCode = colors[i].toHex(); out_ << "0 " << codes[i] << " " << hexCode << endl; } // Print content: out_ << "#Drawing content:" << endl; for(unsigned int i = 0; i < content_.size(); i++) { out_ << content_[i] << endl; } } void XFigGraphicDevice::setCurrentForegroundColor(const RGBColor& color) { fgColorCode_ = colorManager_.getCode(color); AbstractGraphicDevice::setCurrentForegroundColor(color); } void XFigGraphicDevice::setCurrentBackgroundColor(const RGBColor& color) { bgColorCode_ = colorManager_.getCode(color); AbstractGraphicDevice::setCurrentBackgroundColor(color); } void XFigGraphicDevice::setCurrentFont(const Font& font) { if (fontFlag_ == FONTFLAG_LATEX) fontCode_ = latexFontManager_.getCode(font); else if (fontFlag_ == FONTFLAG_POSTSCRIPT) fontCode_ = postscriptFontManager_.getCode(font); else fontCode_ = 0; fontSize_ = font.getSize(); AbstractGraphicDevice::setCurrentFont(font); } void XFigGraphicDevice::drawLine(double x1, double y1, double x2, double y2) { ostringstream oss; oss << "2 1 " << lineTypeCode_ << " " << getCurrentPointSize() << " " << fgColorCode_ << " " << bgColorCode_ << " " << getCurrentLayer() << " " << "-1 -1 -1 0 0 0 0 0 2" << endl; oss << round(x_(x1)) << " " << round(y_(y1)) << endl; oss << round(x_(x2)) << " " << round(y_(y2)); content_.push_back(oss.str()); } void XFigGraphicDevice::drawRect(double x, double y, double width, double height, short fill) { ostringstream oss; oss << "2 2 0 " << getCurrentPointSize() << " " << fgColorCode_ << " " << bgColorCode_ << " " << getCurrentLayer() << " " << "-1" << " " << getFillCode(fill) << " -1 0 0 0 0 0 5" << endl; oss << round(x) << " " << round(y) << endl; oss << round(x_(x + width)) << " " << round(y_(y)) << endl; oss << round(x_(x + width)) << " " << round(y_(y + height)) << endl; oss << round(x_(x)) << " " << round(y_(y + height)) << endl; oss << round(x_(x)) << " " << round(y_(y)); content_.push_back(oss.str()); } void XFigGraphicDevice::drawCircle(double x, double y, double radius, short fill) { ostringstream oss; oss << "1 3 0 " << getCurrentPointSize() << " " << fgColorCode_ << " " << bgColorCode_ << " " << getCurrentLayer() << " " << "-1" << " " << getFillCode(fill) << " -1 1 0 " << round(x_(x)) << " " << round(y_(y)) << " " << round(x_(radius)) << " " << round(y_(radius)) << " " << round(x_(x + radius)) << " " << round(y_(y)) << " " << round(x_(x + radius)) << " " << round(y_(y)) << endl; content_.push_back(oss.str()); } void XFigGraphicDevice::drawText(double x, double y, const std::string& text, short hpos, short vpos, double angle) throw (UnvalidFlagException) { int xrel = static_cast(round(x_(x))); short sub = 0; if (hpos == TEXT_HORIZONTAL_LEFT) sub = 0; else if (hpos == TEXT_HORIZONTAL_CENTER) sub = 1; else if (hpos == TEXT_HORIZONTAL_RIGHT) sub = 2; else throw UnvalidFlagException("XFigGraphicDevice::drawText(). Bad horizontal text alignment flag: " + TextTools::toString(hpos)); int yrel = 0; if (vpos == TEXT_VERTICAL_BOTTOM) yrel = static_cast(round(y_(y - 1.))); else if (vpos == TEXT_VERTICAL_CENTER) yrel = static_cast(round(y + fontSize_ / 2 - 1)); else if (vpos == TEXT_VERTICAL_TOP) yrel = static_cast(round(y - fontSize_)); else throw UnvalidFlagException("XFigGraphicDevice::drawText(). Bad vertical text alignment flag: " + TextTools::toString(vpos)); ostringstream oss; oss << "4 " << sub << " " << fgColorCode_ << " " << 50 << " " << -1 << " " << fontCode_ << " " << fontSize_ << " " << angle << " " << fontFlag_ << " " << -1 << " " << -1 << " " << xrel << " " << yrel << " " << text << "\\001"; content_.push_back(oss.str()); } int XFigGraphicDevice::getFillCode(short fill) { if (fill == FILL_EMPTY) return -1; if (fill == FILL_FILLED) return 20; if (fill == FILL_PATTERN) { //TODO: define a field names currentPattern_, etc. } //Temp: return 20; } bpp-core-2.2.0/src/Bpp/Graphics/Fig/XFigPostscriptFontManager.cpp000664 001750 001750 00000012203 12370705300 026234 0ustar00jdutheiljdutheil000000 000000 // // File: XFigPostscriptFontManager.cpp // Created by: Julien Dutheil // Created on: Wed Dec 30 2009 // From file: FontManager.h // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "XFigPostscriptFontManager.h" using namespace bpp; XFigPostscriptFontManager::XFigPostscriptFontManager() { // Add "official" font codes, from 0 to 34: registerFont_(Font("Default", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), -1); registerFont_(Font("Times", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 0); //Roman registerFont_(Font("Times", Font::STYLE_ITALIC, Font::WEIGHT_NORMAL, 12), 1); registerFont_(Font("Times", Font::STYLE_NORMAL, Font::WEIGHT_BOLD, 12), 2); registerFont_(Font("Times", Font::STYLE_ITALIC, Font::WEIGHT_BOLD, 12), 3); registerFont_(Font("AvantGarde", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 4); //Book registerFont_(Font("AvantGarde", Font::STYLE_ITALIC, Font::WEIGHT_NORMAL, 12), 5); //Book Oblique registerFont_(Font("AvantGarde", Font::STYLE_NORMAL, Font::WEIGHT_BOLD, 12), 6); //Demi registerFont_(Font("AvantGarde", Font::STYLE_ITALIC, Font::WEIGHT_BOLD, 12), 7); //Demi Oblique registerFont_(Font("Bookman", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 8); //Light registerFont_(Font("Bookman", Font::STYLE_ITALIC, Font::WEIGHT_NORMAL, 12), 9); //Light Italic registerFont_(Font("Bookman", Font::STYLE_NORMAL, Font::WEIGHT_BOLD, 12), 10); //Demi registerFont_(Font("Bookman", Font::STYLE_ITALIC, Font::WEIGHT_BOLD, 12), 11); //Demi Italic registerFont_(Font("Courier", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 12); registerFont_(Font("Courier", Font::STYLE_ITALIC, Font::WEIGHT_NORMAL, 12), 13); //Oblique registerFont_(Font("Courier", Font::STYLE_NORMAL, Font::WEIGHT_BOLD, 12), 14); //Bold registerFont_(Font("Courier", Font::STYLE_ITALIC, Font::WEIGHT_BOLD, 12), 15); //Bold Oblique registerFont_(Font("Helvetica", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 16); registerFont_(Font("Helvetica", Font::STYLE_ITALIC, Font::WEIGHT_NORMAL, 12), 17); //Oblique registerFont_(Font("Helvetica", Font::STYLE_NORMAL, Font::WEIGHT_BOLD, 12), 18); //Bold registerFont_(Font("Helvetica", Font::STYLE_ITALIC, Font::WEIGHT_BOLD, 12), 19); //Bold Oblique registerFont_(Font("Helvetica", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 20); //Narrow registerFont_(Font("Helvetica", Font::STYLE_ITALIC, Font::WEIGHT_NORMAL, 12), 21); //Narrow Oblique registerFont_(Font("Helvetica", Font::STYLE_NORMAL, Font::WEIGHT_BOLD, 12), 22); //Narrow Bold registerFont_(Font("Helvetica", Font::STYLE_ITALIC, Font::WEIGHT_BOLD, 12), 23); //Narrow Bold Oblique registerFont_(Font("New Century Schoolbook", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 24); //Roman registerFont_(Font("New Century Schoolbook", Font::STYLE_ITALIC, Font::WEIGHT_NORMAL, 12), 25); //Italic registerFont_(Font("New Century Schoolbook", Font::STYLE_NORMAL, Font::WEIGHT_BOLD, 12), 26); //Bold registerFont_(Font("New Century Schoolbook", Font::STYLE_ITALIC, Font::WEIGHT_BOLD, 12), 27); //Bold Italic registerFont_(Font("Palatino", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 28); //Roman registerFont_(Font("Palatino", Font::STYLE_ITALIC, Font::WEIGHT_NORMAL, 12), 29); //Italic registerFont_(Font("Palatino", Font::STYLE_NORMAL, Font::WEIGHT_BOLD, 12), 30); //Bold registerFont_(Font("Palatino", Font::STYLE_ITALIC, Font::WEIGHT_BOLD, 12), 31); //Bold Italic registerFont_(Font("Symbol", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 32); registerFont_(Font("Zapf Chancery Medium", Font::STYLE_ITALIC, Font::WEIGHT_NORMAL, 12), 33); //Italic registerFont_(Font("Zapf Dingbats", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12), 34); } bpp-core-2.2.0/src/Bpp/Graphics/Fig/XFigPostscriptFontManager.h000664 001750 001750 00000004137 12370705300 025710 0ustar00jdutheiljdutheil000000 000000 // // File: XFigPostscriptFontManager.h // Created by: Julien Dutheil // Created on: Wed Dec 30 2009 // From file: FontManager.h // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _XFIGPOSTSCRIPTFONTMANAGER_H_ #define _XFIGPOSTSCRIPTFONTMANAGER_H_ #include "../Font/FontManager.h" namespace bpp { /** * @brief Postscript font manager for the XFig format. */ class XFigPostscriptFontManager: public AbstractFontManager { public: XFigPostscriptFontManager(); virtual ~XFigPostscriptFontManager() {} }; } //end of namespace bpp; #endif //_XFIGPOSTSCRIPTFONTMANAGER_H_ bpp-core-2.2.0/src/Bpp/Graphics/Svg/SvgGraphicDevice.h000664 001750 001750 00000007025 12370705300 024044 0ustar00jdutheiljdutheil000000 000000 // // File: SvgGraphicDevice.h // Created by: Julien Dutheil // Created on: Mon Mar 10 2008 // /* Copyright or © or Copr. CNRS, (November 16, 2006) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _SVGGRAPHICDEVICE_H_ #define _SVGGRAPHICDEVICE_H_ #include "../AbstractGraphicDevice.h" #include "../ColorTools.h" // From the STL: #include namespace bpp { /** * @brief SVG plotting format. */ class SvgGraphicDevice: public AbstractGraphicDevice { private: std::ostream& out_; std::map, std::greater > layers_; //Layer display as in xfig bool inkscapeEnabled_; double minx_, maxx_, miny_, maxy_; std::map fontStyles_; std::map fontWeights_; public: SvgGraphicDevice(std::ostream& out, bool inkscapeEnabled = false): out_(out), layers_(), inkscapeEnabled_(inkscapeEnabled), minx_(0), maxx_(0), miny_(0), maxy_(0), fontStyles_(), fontWeights_() { fontStyles_[Font::STYLE_NORMAL] = ""; fontStyles_[Font::STYLE_ITALIC] = "italic"; fontWeights_[Font::WEIGHT_NORMAL] = ""; fontWeights_[Font::WEIGHT_BOLD] = "bold"; } virtual ~SvgGraphicDevice() {} public: void begin(); void end(); void drawLine(double x1, double y1, double x2, double y2); void drawRect(double x, double y, double width, double height, short fill = FILL_EMPTY); void drawCircle(double x, double y, double radius, short fill = FILL_EMPTY); void drawText(double x, double y, const std::string& text, short hpos = TEXT_HORIZONTAL_LEFT, short vpos = TEXT_VERTICAL_BOTTOM, double angle = 0) throw (UnvalidFlagException); void comment(const std::string& text) { layers_[getCurrentLayer()].push_back(""); } public: static std::string colorToText(const RGBColor& color) { return "rgb(" + TextTools::toString(color[0]) + "," + TextTools::toString(color[1]) + "," + TextTools::toString(color[2]) + ")"; } }; } // end of namespace bpp. #endif //_SVGGRAPHICDEVICE_H_ bpp-core-2.2.0/src/Bpp/Graphics/Svg/SvgGraphicDevice.cpp000664 001750 001750 00000014606 12370705300 024402 0ustar00jdutheiljdutheil000000 000000 // // File: SvgGraphicDevice.cpp // Created by: Julien Dutheil // Created on: Mon Mar 10 2008 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "SvgGraphicDevice.h" using namespace bpp; using namespace std; void SvgGraphicDevice::begin() { layers_.clear(); minx_ = maxx_ = miny_ = maxy_ = 0; } void SvgGraphicDevice::end() { //Header: out_ << "" << endl; out_ << "" << endl; out_ << "" << endl; out_ << "" << endl; for(map >::iterator it = layers_.begin(); it != layers_.end(); it++) { out_ << "first << "\""; if(inkscapeEnabled_) { out_ << " inkscape:groupmode=\"layer\""; } out_ << " >" << endl; vector * v = &it->second; for(unsigned int i = 0; i < v->size(); i++) { out_ << (*v)[i] << endl; } out_ << "" << endl; } out_ << "" << endl; out_ << "" << endl; } void SvgGraphicDevice::drawLine(double x1, double y1, double x2, double y2) { x1 = x_(x1); x2 = x_(x2); y1 = y_(y1); y2 = y_(y2); string style = "stroke:" + colorToText(getCurrentForegroundColor()) + ";stroke-width:" + TextTools::toString(getCurrentPointSize()); if(getCurrentLineType() == LINE_DASHED) style += ";stroke-dasharray:4,4"; else if(getCurrentLineType() == LINE_DOTTED) style += ";stroke-dasharray:1,2"; ostringstream oss; oss << ""; layers_[getCurrentLayer()].push_back(oss.str()); if (x1 < minx_) minx_ = x1; if (x2 < minx_) minx_ = x2; if (y1 < miny_) miny_ = y1; if (y2 < miny_) miny_ = y2; if (x1 > maxx_) maxx_ = x1; if (x2 > maxx_) maxx_ = x2; if (y1 > maxy_) maxy_ = y1; if (y2 > maxy_) maxy_ = y2; } void SvgGraphicDevice::drawRect(double x, double y, double width, double height, short fill) { x = x_(x); y = y_(y); width = x_(width); height = y_(height); string style = "stroke:" + colorToText(getCurrentForegroundColor()) + ";stroke-width:" + TextTools::toString(getCurrentPointSize()); if(fill == FILL_FILLED) { style += ";fill:" + colorToText(getCurrentBackgroundColor()); } ostringstream oss; oss << ""; layers_[getCurrentLayer()].push_back(oss.str()); if (x < minx_) minx_ = x; if (y < miny_) miny_ = y; if (x + width > maxx_) maxx_ = x + width; if (y + height > maxy_) maxx_ = y + height; } void SvgGraphicDevice::drawCircle(double x, double y, double radius, short fill) { x = x_(x); y = y_(y); radius = x_(radius); string style = "stroke:" + colorToText(getCurrentForegroundColor()) + ";stroke-width:" + TextTools::toString(getCurrentPointSize()); if(fill == FILL_FILLED) { style += ";fill:" + colorToText(getCurrentBackgroundColor()); } ostringstream oss; oss << ""; layers_[getCurrentLayer()].push_back(oss.str()); } void SvgGraphicDevice::drawText(double x, double y, const std::string & text, short hpos, short vpos, double angle) throw (UnvalidFlagException) { x = x_(x); y = y_(y); string style = "font-family:" + getCurrentFont().getFamily() + ";font-style:" + fontStyles_[getCurrentFont().getStyle()] + ";font-weight:" + fontWeights_[getCurrentFont().getWeight()] + ";font-size:" + TextTools::toString(getCurrentFont().getSize()) + "px"; style += ";dominant-baseline:"; if (vpos == TEXT_VERTICAL_BOTTOM) style += "before-edge"; else if (vpos == TEXT_VERTICAL_TOP) style += "after-edge"; else if (vpos == TEXT_VERTICAL_CENTER) style += "middle"; else throw UnvalidFlagException("SvgGraphicDevice::drawText. Invalid vertical alignment option."); style += ";text-anchor:"; if (hpos == TEXT_HORIZONTAL_LEFT) style += "start"; else if (hpos == TEXT_HORIZONTAL_RIGHT) style += "end"; else if (hpos == TEXT_HORIZONTAL_CENTER) style += "middle"; else throw UnvalidFlagException("SvgGraphicDevice::drawText. Invalid horizontal alignment option."); style += ";fill:" + colorToText(getCurrentForegroundColor()); ostringstream oss; oss << "" << text << ""; layers_[getCurrentLayer()].push_back(oss.str()); } bpp-core-2.2.0/src/Bpp/Graphics/R/RColorSet.h000664 001750 001750 00000004531 12370705300 022204 0ustar00jdutheiljdutheil000000 000000 // // File: RColorSet.h // Created by: Julien Dutheil // Created on: Mon Apr 14 2008 // /* Copyright or © or Copr. CNRS, (November 17, 2008) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _RCOLORSET_H_ #define _RCOLORSET_H_ #include "../ColorSet.h" namespace bpp { /** * @brief R color definitions. */ class RColorSet: public AbstractColorSet { public: /** * The following R code has been used to generate this code: * @code * c<-colors() * file<-"Rcolors.cpp" * unlink(file) * for(i in c) * { * r<-col2rgb(i)["red",1] * g<-col2rgb(i)["green",1] * b<-col2rgb(i)["blue",1] * cat(file=file, append=TRUE, paste(" _colors[\"",i,"\"] = RGBColor(",r ,", ",g,", ", b, ");\n",sep="")); * } * @endcode */ RColorSet(); virtual ~RColorSet() {} }; } // end of namespace bpp; #endif //_RCOLORSET_H_ bpp-core-2.2.0/src/Bpp/Graphics/R/RColorSet.cpp000664 001750 001750 00000101316 12370705300 022536 0ustar00jdutheiljdutheil000000 000000 // // File: RColorSet.cpp // Created by: Julien Dutheil // Created on: Mon Apr 14 2008 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2008) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "RColorSet.h" using namespace bpp; RColorSet::RColorSet() { colors_["white"] = RGBColor(255, 255, 255); colors_["aliceblue"] = RGBColor(240, 248, 255); colors_["antiquewhite"] = RGBColor(250, 235, 215); colors_["antiquewhite1"] = RGBColor(255, 239, 219); colors_["antiquewhite2"] = RGBColor(238, 223, 204); colors_["antiquewhite3"] = RGBColor(205, 192, 176); colors_["antiquewhite4"] = RGBColor(139, 131, 120); colors_["aquamarine"] = RGBColor(127, 255, 212); colors_["aquamarine1"] = RGBColor(127, 255, 212); colors_["aquamarine2"] = RGBColor(118, 238, 198); colors_["aquamarine3"] = RGBColor(102, 205, 170); colors_["aquamarine4"] = RGBColor(69, 139, 116); colors_["azure"] = RGBColor(240, 255, 255); colors_["azure1"] = RGBColor(240, 255, 255); colors_["azure2"] = RGBColor(224, 238, 238); colors_["azure3"] = RGBColor(193, 205, 205); colors_["azure4"] = RGBColor(131, 139, 139); colors_["beige"] = RGBColor(245, 245, 220); colors_["bisque"] = RGBColor(255, 228, 196); colors_["bisque1"] = RGBColor(255, 228, 196); colors_["bisque2"] = RGBColor(238, 213, 183); colors_["bisque3"] = RGBColor(205, 183, 158); colors_["bisque4"] = RGBColor(139, 125, 107); colors_["black"] = RGBColor(0, 0, 0); colors_["blanchedalmond"] = RGBColor(255, 235, 205); colors_["blue"] = RGBColor(0, 0, 255); colors_["blue1"] = RGBColor(0, 0, 255); colors_["blue2"] = RGBColor(0, 0, 238); colors_["blue3"] = RGBColor(0, 0, 205); colors_["blue4"] = RGBColor(0, 0, 139); colors_["blueviolet"] = RGBColor(138, 43, 226); colors_["brown"] = RGBColor(165, 42, 42); colors_["brown1"] = RGBColor(255, 64, 64); colors_["brown2"] = RGBColor(238, 59, 59); colors_["brown3"] = RGBColor(205, 51, 51); colors_["brown4"] = RGBColor(139, 35, 35); colors_["burlywood"] = RGBColor(222, 184, 135); colors_["burlywood1"] = RGBColor(255, 211, 155); colors_["burlywood2"] = RGBColor(238, 197, 145); colors_["burlywood3"] = RGBColor(205, 170, 125); colors_["burlywood4"] = RGBColor(139, 115, 85); colors_["cadetblue"] = RGBColor(95, 158, 160); colors_["cadetblue1"] = RGBColor(152, 245, 255); colors_["cadetblue2"] = RGBColor(142, 229, 238); colors_["cadetblue3"] = RGBColor(122, 197, 205); colors_["cadetblue4"] = RGBColor(83, 134, 139); colors_["chartreuse"] = RGBColor(127, 255, 0); colors_["chartreuse1"] = RGBColor(127, 255, 0); colors_["chartreuse2"] = RGBColor(118, 238, 0); colors_["chartreuse3"] = RGBColor(102, 205, 0); colors_["chartreuse4"] = RGBColor(69, 139, 0); colors_["chocolate"] = RGBColor(210, 105, 30); colors_["chocolate1"] = RGBColor(255, 127, 36); colors_["chocolate2"] = RGBColor(238, 118, 33); colors_["chocolate3"] = RGBColor(205, 102, 29); colors_["chocolate4"] = RGBColor(139, 69, 19); colors_["coral"] = RGBColor(255, 127, 80); colors_["coral1"] = RGBColor(255, 114, 86); colors_["coral2"] = RGBColor(238, 106, 80); colors_["coral3"] = RGBColor(205, 91, 69); colors_["coral4"] = RGBColor(139, 62, 47); colors_["cornflowerblue"] = RGBColor(100, 149, 237); colors_["cornsilk"] = RGBColor(255, 248, 220); colors_["cornsilk1"] = RGBColor(255, 248, 220); colors_["cornsilk2"] = RGBColor(238, 232, 205); colors_["cornsilk3"] = RGBColor(205, 200, 177); colors_["cornsilk4"] = RGBColor(139, 136, 120); colors_["cyan"] = RGBColor(0, 255, 255); colors_["cyan1"] = RGBColor(0, 255, 255); colors_["cyan2"] = RGBColor(0, 238, 238); colors_["cyan3"] = RGBColor(0, 205, 205); colors_["cyan4"] = RGBColor(0, 139, 139); colors_["darkblue"] = RGBColor(0, 0, 139); colors_["darkcyan"] = RGBColor(0, 139, 139); colors_["darkgoldenrod"] = RGBColor(184, 134, 11); colors_["darkgoldenrod1"] = RGBColor(255, 185, 15); colors_["darkgoldenrod2"] = RGBColor(238, 173, 14); colors_["darkgoldenrod3"] = RGBColor(205, 149, 12); colors_["darkgoldenrod4"] = RGBColor(139, 101, 8); colors_["darkgray"] = RGBColor(169, 169, 169); colors_["darkgreen"] = RGBColor(0, 100, 0); colors_["darkgrey"] = RGBColor(169, 169, 169); colors_["darkkhaki"] = RGBColor(189, 183, 107); colors_["darkmagenta"] = RGBColor(139, 0, 139); colors_["darkolivegreen"] = RGBColor(85, 107, 47); colors_["darkolivegreen1"] = RGBColor(202, 255, 112); colors_["darkolivegreen2"] = RGBColor(188, 238, 104); colors_["darkolivegreen3"] = RGBColor(162, 205, 90); colors_["darkolivegreen4"] = RGBColor(110, 139, 61); colors_["darkorange"] = RGBColor(255, 140, 0); colors_["darkorange1"] = RGBColor(255, 127, 0); colors_["darkorange2"] = RGBColor(238, 118, 0); colors_["darkorange3"] = RGBColor(205, 102, 0); colors_["darkorange4"] = RGBColor(139, 69, 0); colors_["darkorchid"] = RGBColor(153, 50, 204); colors_["darkorchid1"] = RGBColor(191, 62, 255); colors_["darkorchid2"] = RGBColor(178, 58, 238); colors_["darkorchid3"] = RGBColor(154, 50, 205); colors_["darkorchid4"] = RGBColor(104, 34, 139); colors_["darkred"] = RGBColor(139, 0, 0); colors_["darksalmon"] = RGBColor(233, 150, 122); colors_["darkseagreen"] = RGBColor(143, 188, 143); colors_["darkseagreen1"] = RGBColor(193, 255, 193); colors_["darkseagreen2"] = RGBColor(180, 238, 180); colors_["darkseagreen3"] = RGBColor(155, 205, 155); colors_["darkseagreen4"] = RGBColor(105, 139, 105); colors_["darkslateblue"] = RGBColor(72, 61, 139); colors_["darkslategray"] = RGBColor(47, 79, 79); colors_["darkslategray1"] = RGBColor(151, 255, 255); colors_["darkslategray2"] = RGBColor(141, 238, 238); colors_["darkslategray3"] = RGBColor(121, 205, 205); colors_["darkslategray4"] = RGBColor(82, 139, 139); colors_["darkslategrey"] = RGBColor(47, 79, 79); colors_["darkturquoise"] = RGBColor(0, 206, 209); colors_["darkviolet"] = RGBColor(148, 0, 211); colors_["deeppink"] = RGBColor(255, 20, 147); colors_["deeppink1"] = RGBColor(255, 20, 147); colors_["deeppink2"] = RGBColor(238, 18, 137); colors_["deeppink3"] = RGBColor(205, 16, 118); colors_["deeppink4"] = RGBColor(139, 10, 80); colors_["deepskyblue"] = RGBColor(0, 191, 255); colors_["deepskyblue1"] = RGBColor(0, 191, 255); colors_["deepskyblue2"] = RGBColor(0, 178, 238); colors_["deepskyblue3"] = RGBColor(0, 154, 205); colors_["deepskyblue4"] = RGBColor(0, 104, 139); colors_["dimgray"] = RGBColor(105, 105, 105); colors_["dimgrey"] = RGBColor(105, 105, 105); colors_["dodgerblue"] = RGBColor(30, 144, 255); colors_["dodgerblue1"] = RGBColor(30, 144, 255); colors_["dodgerblue2"] = RGBColor(28, 134, 238); colors_["dodgerblue3"] = RGBColor(24, 116, 205); colors_["dodgerblue4"] = RGBColor(16, 78, 139); colors_["firebrick"] = RGBColor(178, 34, 34); colors_["firebrick1"] = RGBColor(255, 48, 48); colors_["firebrick2"] = RGBColor(238, 44, 44); colors_["firebrick3"] = RGBColor(205, 38, 38); colors_["firebrick4"] = RGBColor(139, 26, 26); colors_["floralwhite"] = RGBColor(255, 250, 240); colors_["forestgreen"] = RGBColor(34, 139, 34); colors_["gainsboro"] = RGBColor(220, 220, 220); colors_["ghostwhite"] = RGBColor(248, 248, 255); colors_["gold"] = RGBColor(255, 215, 0); colors_["gold1"] = RGBColor(255, 215, 0); colors_["gold2"] = RGBColor(238, 201, 0); colors_["gold3"] = RGBColor(205, 173, 0); colors_["gold4"] = RGBColor(139, 117, 0); colors_["goldenrod"] = RGBColor(218, 165, 32); colors_["goldenrod1"] = RGBColor(255, 193, 37); colors_["goldenrod2"] = RGBColor(238, 180, 34); colors_["goldenrod3"] = RGBColor(205, 155, 29); colors_["goldenrod4"] = RGBColor(139, 105, 20); colors_["gray"] = RGBColor(190, 190, 190); colors_["gray0"] = RGBColor(0, 0, 0); colors_["gray1"] = RGBColor(3, 3, 3); colors_["gray2"] = RGBColor(5, 5, 5); colors_["gray3"] = RGBColor(8, 8, 8); colors_["gray4"] = RGBColor(10, 10, 10); colors_["gray5"] = RGBColor(13, 13, 13); colors_["gray6"] = RGBColor(15, 15, 15); colors_["gray7"] = RGBColor(18, 18, 18); colors_["gray8"] = RGBColor(20, 20, 20); colors_["gray9"] = RGBColor(23, 23, 23); colors_["gray10"] = RGBColor(26, 26, 26); colors_["gray11"] = RGBColor(28, 28, 28); colors_["gray12"] = RGBColor(31, 31, 31); colors_["gray13"] = RGBColor(33, 33, 33); colors_["gray14"] = RGBColor(36, 36, 36); colors_["gray15"] = RGBColor(38, 38, 38); colors_["gray16"] = RGBColor(41, 41, 41); colors_["gray17"] = RGBColor(43, 43, 43); colors_["gray18"] = RGBColor(46, 46, 46); colors_["gray19"] = RGBColor(48, 48, 48); colors_["gray20"] = RGBColor(51, 51, 51); colors_["gray21"] = RGBColor(54, 54, 54); colors_["gray22"] = RGBColor(56, 56, 56); colors_["gray23"] = RGBColor(59, 59, 59); colors_["gray24"] = RGBColor(61, 61, 61); colors_["gray25"] = RGBColor(64, 64, 64); colors_["gray26"] = RGBColor(66, 66, 66); colors_["gray27"] = RGBColor(69, 69, 69); colors_["gray28"] = RGBColor(71, 71, 71); colors_["gray29"] = RGBColor(74, 74, 74); colors_["gray30"] = RGBColor(77, 77, 77); colors_["gray31"] = RGBColor(79, 79, 79); colors_["gray32"] = RGBColor(82, 82, 82); colors_["gray33"] = RGBColor(84, 84, 84); colors_["gray34"] = RGBColor(87, 87, 87); colors_["gray35"] = RGBColor(89, 89, 89); colors_["gray36"] = RGBColor(92, 92, 92); colors_["gray37"] = RGBColor(94, 94, 94); colors_["gray38"] = RGBColor(97, 97, 97); colors_["gray39"] = RGBColor(99, 99, 99); colors_["gray40"] = RGBColor(102, 102, 102); colors_["gray41"] = RGBColor(105, 105, 105); colors_["gray42"] = RGBColor(107, 107, 107); colors_["gray43"] = RGBColor(110, 110, 110); colors_["gray44"] = RGBColor(112, 112, 112); colors_["gray45"] = RGBColor(115, 115, 115); colors_["gray46"] = RGBColor(117, 117, 117); colors_["gray47"] = RGBColor(120, 120, 120); colors_["gray48"] = RGBColor(122, 122, 122); colors_["gray49"] = RGBColor(125, 125, 125); colors_["gray50"] = RGBColor(127, 127, 127); colors_["gray51"] = RGBColor(130, 130, 130); colors_["gray52"] = RGBColor(133, 133, 133); colors_["gray53"] = RGBColor(135, 135, 135); colors_["gray54"] = RGBColor(138, 138, 138); colors_["gray55"] = RGBColor(140, 140, 140); colors_["gray56"] = RGBColor(143, 143, 143); colors_["gray57"] = RGBColor(145, 145, 145); colors_["gray58"] = RGBColor(148, 148, 148); colors_["gray59"] = RGBColor(150, 150, 150); colors_["gray60"] = RGBColor(153, 153, 153); colors_["gray61"] = RGBColor(156, 156, 156); colors_["gray62"] = RGBColor(158, 158, 158); colors_["gray63"] = RGBColor(161, 161, 161); colors_["gray64"] = RGBColor(163, 163, 163); colors_["gray65"] = RGBColor(166, 166, 166); colors_["gray66"] = RGBColor(168, 168, 168); colors_["gray67"] = RGBColor(171, 171, 171); colors_["gray68"] = RGBColor(173, 173, 173); colors_["gray69"] = RGBColor(176, 176, 176); colors_["gray70"] = RGBColor(179, 179, 179); colors_["gray71"] = RGBColor(181, 181, 181); colors_["gray72"] = RGBColor(184, 184, 184); colors_["gray73"] = RGBColor(186, 186, 186); colors_["gray74"] = RGBColor(189, 189, 189); colors_["gray75"] = RGBColor(191, 191, 191); colors_["gray76"] = RGBColor(194, 194, 194); colors_["gray77"] = RGBColor(196, 196, 196); colors_["gray78"] = RGBColor(199, 199, 199); colors_["gray79"] = RGBColor(201, 201, 201); colors_["gray80"] = RGBColor(204, 204, 204); colors_["gray81"] = RGBColor(207, 207, 207); colors_["gray82"] = RGBColor(209, 209, 209); colors_["gray83"] = RGBColor(212, 212, 212); colors_["gray84"] = RGBColor(214, 214, 214); colors_["gray85"] = RGBColor(217, 217, 217); colors_["gray86"] = RGBColor(219, 219, 219); colors_["gray87"] = RGBColor(222, 222, 222); colors_["gray88"] = RGBColor(224, 224, 224); colors_["gray89"] = RGBColor(227, 227, 227); colors_["gray90"] = RGBColor(229, 229, 229); colors_["gray91"] = RGBColor(232, 232, 232); colors_["gray92"] = RGBColor(235, 235, 235); colors_["gray93"] = RGBColor(237, 237, 237); colors_["gray94"] = RGBColor(240, 240, 240); colors_["gray95"] = RGBColor(242, 242, 242); colors_["gray96"] = RGBColor(245, 245, 245); colors_["gray97"] = RGBColor(247, 247, 247); colors_["gray98"] = RGBColor(250, 250, 250); colors_["gray99"] = RGBColor(252, 252, 252); colors_["gray100"] = RGBColor(255, 255, 255); colors_["green"] = RGBColor(0, 255, 0); colors_["green1"] = RGBColor(0, 255, 0); colors_["green2"] = RGBColor(0, 238, 0); colors_["green3"] = RGBColor(0, 205, 0); colors_["green4"] = RGBColor(0, 139, 0); colors_["greenyellow"] = RGBColor(173, 255, 47); colors_["grey"] = RGBColor(190, 190, 190); colors_["grey0"] = RGBColor(0, 0, 0); colors_["grey1"] = RGBColor(3, 3, 3); colors_["grey2"] = RGBColor(5, 5, 5); colors_["grey3"] = RGBColor(8, 8, 8); colors_["grey4"] = RGBColor(10, 10, 10); colors_["grey5"] = RGBColor(13, 13, 13); colors_["grey6"] = RGBColor(15, 15, 15); colors_["grey7"] = RGBColor(18, 18, 18); colors_["grey8"] = RGBColor(20, 20, 20); colors_["grey9"] = RGBColor(23, 23, 23); colors_["grey10"] = RGBColor(26, 26, 26); colors_["grey11"] = RGBColor(28, 28, 28); colors_["grey12"] = RGBColor(31, 31, 31); colors_["grey13"] = RGBColor(33, 33, 33); colors_["grey14"] = RGBColor(36, 36, 36); colors_["grey15"] = RGBColor(38, 38, 38); colors_["grey16"] = RGBColor(41, 41, 41); colors_["grey17"] = RGBColor(43, 43, 43); colors_["grey18"] = RGBColor(46, 46, 46); colors_["grey19"] = RGBColor(48, 48, 48); colors_["grey20"] = RGBColor(51, 51, 51); colors_["grey21"] = RGBColor(54, 54, 54); colors_["grey22"] = RGBColor(56, 56, 56); colors_["grey23"] = RGBColor(59, 59, 59); colors_["grey24"] = RGBColor(61, 61, 61); colors_["grey25"] = RGBColor(64, 64, 64); colors_["grey26"] = RGBColor(66, 66, 66); colors_["grey27"] = RGBColor(69, 69, 69); colors_["grey28"] = RGBColor(71, 71, 71); colors_["grey29"] = RGBColor(74, 74, 74); colors_["grey30"] = RGBColor(77, 77, 77); colors_["grey31"] = RGBColor(79, 79, 79); colors_["grey32"] = RGBColor(82, 82, 82); colors_["grey33"] = RGBColor(84, 84, 84); colors_["grey34"] = RGBColor(87, 87, 87); colors_["grey35"] = RGBColor(89, 89, 89); colors_["grey36"] = RGBColor(92, 92, 92); colors_["grey37"] = RGBColor(94, 94, 94); colors_["grey38"] = RGBColor(97, 97, 97); colors_["grey39"] = RGBColor(99, 99, 99); colors_["grey40"] = RGBColor(102, 102, 102); colors_["grey41"] = RGBColor(105, 105, 105); colors_["grey42"] = RGBColor(107, 107, 107); colors_["grey43"] = RGBColor(110, 110, 110); colors_["grey44"] = RGBColor(112, 112, 112); colors_["grey45"] = RGBColor(115, 115, 115); colors_["grey46"] = RGBColor(117, 117, 117); colors_["grey47"] = RGBColor(120, 120, 120); colors_["grey48"] = RGBColor(122, 122, 122); colors_["grey49"] = RGBColor(125, 125, 125); colors_["grey50"] = RGBColor(127, 127, 127); colors_["grey51"] = RGBColor(130, 130, 130); colors_["grey52"] = RGBColor(133, 133, 133); colors_["grey53"] = RGBColor(135, 135, 135); colors_["grey54"] = RGBColor(138, 138, 138); colors_["grey55"] = RGBColor(140, 140, 140); colors_["grey56"] = RGBColor(143, 143, 143); colors_["grey57"] = RGBColor(145, 145, 145); colors_["grey58"] = RGBColor(148, 148, 148); colors_["grey59"] = RGBColor(150, 150, 150); colors_["grey60"] = RGBColor(153, 153, 153); colors_["grey61"] = RGBColor(156, 156, 156); colors_["grey62"] = RGBColor(158, 158, 158); colors_["grey63"] = RGBColor(161, 161, 161); colors_["grey64"] = RGBColor(163, 163, 163); colors_["grey65"] = RGBColor(166, 166, 166); colors_["grey66"] = RGBColor(168, 168, 168); colors_["grey67"] = RGBColor(171, 171, 171); colors_["grey68"] = RGBColor(173, 173, 173); colors_["grey69"] = RGBColor(176, 176, 176); colors_["grey70"] = RGBColor(179, 179, 179); colors_["grey71"] = RGBColor(181, 181, 181); colors_["grey72"] = RGBColor(184, 184, 184); colors_["grey73"] = RGBColor(186, 186, 186); colors_["grey74"] = RGBColor(189, 189, 189); colors_["grey75"] = RGBColor(191, 191, 191); colors_["grey76"] = RGBColor(194, 194, 194); colors_["grey77"] = RGBColor(196, 196, 196); colors_["grey78"] = RGBColor(199, 199, 199); colors_["grey79"] = RGBColor(201, 201, 201); colors_["grey80"] = RGBColor(204, 204, 204); colors_["grey81"] = RGBColor(207, 207, 207); colors_["grey82"] = RGBColor(209, 209, 209); colors_["grey83"] = RGBColor(212, 212, 212); colors_["grey84"] = RGBColor(214, 214, 214); colors_["grey85"] = RGBColor(217, 217, 217); colors_["grey86"] = RGBColor(219, 219, 219); colors_["grey87"] = RGBColor(222, 222, 222); colors_["grey88"] = RGBColor(224, 224, 224); colors_["grey89"] = RGBColor(227, 227, 227); colors_["grey90"] = RGBColor(229, 229, 229); colors_["grey91"] = RGBColor(232, 232, 232); colors_["grey92"] = RGBColor(235, 235, 235); colors_["grey93"] = RGBColor(237, 237, 237); colors_["grey94"] = RGBColor(240, 240, 240); colors_["grey95"] = RGBColor(242, 242, 242); colors_["grey96"] = RGBColor(245, 245, 245); colors_["grey97"] = RGBColor(247, 247, 247); colors_["grey98"] = RGBColor(250, 250, 250); colors_["grey99"] = RGBColor(252, 252, 252); colors_["grey100"] = RGBColor(255, 255, 255); colors_["honeydew"] = RGBColor(240, 255, 240); colors_["honeydew1"] = RGBColor(240, 255, 240); colors_["honeydew2"] = RGBColor(224, 238, 224); colors_["honeydew3"] = RGBColor(193, 205, 193); colors_["honeydew4"] = RGBColor(131, 139, 131); colors_["hotpink"] = RGBColor(255, 105, 180); colors_["hotpink1"] = RGBColor(255, 110, 180); colors_["hotpink2"] = RGBColor(238, 106, 167); colors_["hotpink3"] = RGBColor(205, 96, 144); colors_["hotpink4"] = RGBColor(139, 58, 98); colors_["indianred"] = RGBColor(205, 92, 92); colors_["indianred1"] = RGBColor(255, 106, 106); colors_["indianred2"] = RGBColor(238, 99, 99); colors_["indianred3"] = RGBColor(205, 85, 85); colors_["indianred4"] = RGBColor(139, 58, 58); colors_["ivory"] = RGBColor(255, 255, 240); colors_["ivory1"] = RGBColor(255, 255, 240); colors_["ivory2"] = RGBColor(238, 238, 224); colors_["ivory3"] = RGBColor(205, 205, 193); colors_["ivory4"] = RGBColor(139, 139, 131); colors_["khaki"] = RGBColor(240, 230, 140); colors_["khaki1"] = RGBColor(255, 246, 143); colors_["khaki2"] = RGBColor(238, 230, 133); colors_["khaki3"] = RGBColor(205, 198, 115); colors_["khaki4"] = RGBColor(139, 134, 78); colors_["lavender"] = RGBColor(230, 230, 250); colors_["lavenderblush"] = RGBColor(255, 240, 245); colors_["lavenderblush1"] = RGBColor(255, 240, 245); colors_["lavenderblush2"] = RGBColor(238, 224, 229); colors_["lavenderblush3"] = RGBColor(205, 193, 197); colors_["lavenderblush4"] = RGBColor(139, 131, 134); colors_["lawngreen"] = RGBColor(124, 252, 0); colors_["lemonchiffon"] = RGBColor(255, 250, 205); colors_["lemonchiffon1"] = RGBColor(255, 250, 205); colors_["lemonchiffon2"] = RGBColor(238, 233, 191); colors_["lemonchiffon3"] = RGBColor(205, 201, 165); colors_["lemonchiffon4"] = RGBColor(139, 137, 112); colors_["lightblue"] = RGBColor(173, 216, 230); colors_["lightblue1"] = RGBColor(191, 239, 255); colors_["lightblue2"] = RGBColor(178, 223, 238); colors_["lightblue3"] = RGBColor(154, 192, 205); colors_["lightblue4"] = RGBColor(104, 131, 139); colors_["lightcoral"] = RGBColor(240, 128, 128); colors_["lightcyan"] = RGBColor(224, 255, 255); colors_["lightcyan1"] = RGBColor(224, 255, 255); colors_["lightcyan2"] = RGBColor(209, 238, 238); colors_["lightcyan3"] = RGBColor(180, 205, 205); colors_["lightcyan4"] = RGBColor(122, 139, 139); colors_["lightgoldenrod"] = RGBColor(238, 221, 130); colors_["lightgoldenrod1"] = RGBColor(255, 236, 139); colors_["lightgoldenrod2"] = RGBColor(238, 220, 130); colors_["lightgoldenrod3"] = RGBColor(205, 190, 112); colors_["lightgoldenrod4"] = RGBColor(139, 129, 76); colors_["lightgoldenrodyellow"] = RGBColor(250, 250, 210); colors_["lightgray"] = RGBColor(211, 211, 211); colors_["lightgreen"] = RGBColor(144, 238, 144); colors_["lightgrey"] = RGBColor(211, 211, 211); colors_["lightpink"] = RGBColor(255, 182, 193); colors_["lightpink1"] = RGBColor(255, 174, 185); colors_["lightpink2"] = RGBColor(238, 162, 173); colors_["lightpink3"] = RGBColor(205, 140, 149); colors_["lightpink4"] = RGBColor(139, 95, 101); colors_["lightsalmon"] = RGBColor(255, 160, 122); colors_["lightsalmon1"] = RGBColor(255, 160, 122); colors_["lightsalmon2"] = RGBColor(238, 149, 114); colors_["lightsalmon3"] = RGBColor(205, 129, 98); colors_["lightsalmon4"] = RGBColor(139, 87, 66); colors_["lightseagreen"] = RGBColor(32, 178, 170); colors_["lightskyblue"] = RGBColor(135, 206, 250); colors_["lightskyblue1"] = RGBColor(176, 226, 255); colors_["lightskyblue2"] = RGBColor(164, 211, 238); colors_["lightskyblue3"] = RGBColor(141, 182, 205); colors_["lightskyblue4"] = RGBColor(96, 123, 139); colors_["lightslateblue"] = RGBColor(132, 112, 255); colors_["lightslategray"] = RGBColor(119, 136, 153); colors_["lightslategrey"] = RGBColor(119, 136, 153); colors_["lightsteelblue"] = RGBColor(176, 196, 222); colors_["lightsteelblue1"] = RGBColor(202, 225, 255); colors_["lightsteelblue2"] = RGBColor(188, 210, 238); colors_["lightsteelblue3"] = RGBColor(162, 181, 205); colors_["lightsteelblue4"] = RGBColor(110, 123, 139); colors_["lightyellow"] = RGBColor(255, 255, 224); colors_["lightyellow1"] = RGBColor(255, 255, 224); colors_["lightyellow2"] = RGBColor(238, 238, 209); colors_["lightyellow3"] = RGBColor(205, 205, 180); colors_["lightyellow4"] = RGBColor(139, 139, 122); colors_["limegreen"] = RGBColor(50, 205, 50); colors_["linen"] = RGBColor(250, 240, 230); colors_["magenta"] = RGBColor(255, 0, 255); colors_["magenta1"] = RGBColor(255, 0, 255); colors_["magenta2"] = RGBColor(238, 0, 238); colors_["magenta3"] = RGBColor(205, 0, 205); colors_["magenta4"] = RGBColor(139, 0, 139); colors_["maroon"] = RGBColor(176, 48, 96); colors_["maroon1"] = RGBColor(255, 52, 179); colors_["maroon2"] = RGBColor(238, 48, 167); colors_["maroon3"] = RGBColor(205, 41, 144); colors_["maroon4"] = RGBColor(139, 28, 98); colors_["mediumaquamarine"] = RGBColor(102, 205, 170); colors_["mediumblue"] = RGBColor(0, 0, 205); colors_["mediumorchid"] = RGBColor(186, 85, 211); colors_["mediumorchid1"] = RGBColor(224, 102, 255); colors_["mediumorchid2"] = RGBColor(209, 95, 238); colors_["mediumorchid3"] = RGBColor(180, 82, 205); colors_["mediumorchid4"] = RGBColor(122, 55, 139); colors_["mediumpurple"] = RGBColor(147, 112, 219); colors_["mediumpurple1"] = RGBColor(171, 130, 255); colors_["mediumpurple2"] = RGBColor(159, 121, 238); colors_["mediumpurple3"] = RGBColor(137, 104, 205); colors_["mediumpurple4"] = RGBColor(93, 71, 139); colors_["mediumseagreen"] = RGBColor(60, 179, 113); colors_["mediumslateblue"] = RGBColor(123, 104, 238); colors_["mediumspringgreen"] = RGBColor(0, 250, 154); colors_["mediumturquoise"] = RGBColor(72, 209, 204); colors_["mediumvioletred"] = RGBColor(199, 21, 133); colors_["midnightblue"] = RGBColor(25, 25, 112); colors_["mintcream"] = RGBColor(245, 255, 250); colors_["mistyrose"] = RGBColor(255, 228, 225); colors_["mistyrose1"] = RGBColor(255, 228, 225); colors_["mistyrose2"] = RGBColor(238, 213, 210); colors_["mistyrose3"] = RGBColor(205, 183, 181); colors_["mistyrose4"] = RGBColor(139, 125, 123); colors_["moccasin"] = RGBColor(255, 228, 181); colors_["navajowhite"] = RGBColor(255, 222, 173); colors_["navajowhite1"] = RGBColor(255, 222, 173); colors_["navajowhite2"] = RGBColor(238, 207, 161); colors_["navajowhite3"] = RGBColor(205, 179, 139); colors_["navajowhite4"] = RGBColor(139, 121, 94); colors_["navy"] = RGBColor(0, 0, 128); colors_["navyblue"] = RGBColor(0, 0, 128); colors_["oldlace"] = RGBColor(253, 245, 230); colors_["olivedrab"] = RGBColor(107, 142, 35); colors_["olivedrab1"] = RGBColor(192, 255, 62); colors_["olivedrab2"] = RGBColor(179, 238, 58); colors_["olivedrab3"] = RGBColor(154, 205, 50); colors_["olivedrab4"] = RGBColor(105, 139, 34); colors_["orange"] = RGBColor(255, 165, 0); colors_["orange1"] = RGBColor(255, 165, 0); colors_["orange2"] = RGBColor(238, 154, 0); colors_["orange3"] = RGBColor(205, 133, 0); colors_["orange4"] = RGBColor(139, 90, 0); colors_["orangered"] = RGBColor(255, 69, 0); colors_["orangered1"] = RGBColor(255, 69, 0); colors_["orangered2"] = RGBColor(238, 64, 0); colors_["orangered3"] = RGBColor(205, 55, 0); colors_["orangered4"] = RGBColor(139, 37, 0); colors_["orchid"] = RGBColor(218, 112, 214); colors_["orchid1"] = RGBColor(255, 131, 250); colors_["orchid2"] = RGBColor(238, 122, 233); colors_["orchid3"] = RGBColor(205, 105, 201); colors_["orchid4"] = RGBColor(139, 71, 137); colors_["palegoldenrod"] = RGBColor(238, 232, 170); colors_["palegreen"] = RGBColor(152, 251, 152); colors_["palegreen1"] = RGBColor(154, 255, 154); colors_["palegreen2"] = RGBColor(144, 238, 144); colors_["palegreen3"] = RGBColor(124, 205, 124); colors_["palegreen4"] = RGBColor(84, 139, 84); colors_["paleturquoise"] = RGBColor(175, 238, 238); colors_["paleturquoise1"] = RGBColor(187, 255, 255); colors_["paleturquoise2"] = RGBColor(174, 238, 238); colors_["paleturquoise3"] = RGBColor(150, 205, 205); colors_["paleturquoise4"] = RGBColor(102, 139, 139); colors_["palevioletred"] = RGBColor(219, 112, 147); colors_["palevioletred1"] = RGBColor(255, 130, 171); colors_["palevioletred2"] = RGBColor(238, 121, 159); colors_["palevioletred3"] = RGBColor(205, 104, 137); colors_["palevioletred4"] = RGBColor(139, 71, 93); colors_["papayawhip"] = RGBColor(255, 239, 213); colors_["peachpuff"] = RGBColor(255, 218, 185); colors_["peachpuff1"] = RGBColor(255, 218, 185); colors_["peachpuff2"] = RGBColor(238, 203, 173); colors_["peachpuff3"] = RGBColor(205, 175, 149); colors_["peachpuff4"] = RGBColor(139, 119, 101); colors_["peru"] = RGBColor(205, 133, 63); colors_["pink"] = RGBColor(255, 192, 203); colors_["pink1"] = RGBColor(255, 181, 197); colors_["pink2"] = RGBColor(238, 169, 184); colors_["pink3"] = RGBColor(205, 145, 158); colors_["pink4"] = RGBColor(139, 99, 108); colors_["plum"] = RGBColor(221, 160, 221); colors_["plum1"] = RGBColor(255, 187, 255); colors_["plum2"] = RGBColor(238, 174, 238); colors_["plum3"] = RGBColor(205, 150, 205); colors_["plum4"] = RGBColor(139, 102, 139); colors_["powderblue"] = RGBColor(176, 224, 230); colors_["purple"] = RGBColor(160, 32, 240); colors_["purple1"] = RGBColor(155, 48, 255); colors_["purple2"] = RGBColor(145, 44, 238); colors_["purple3"] = RGBColor(125, 38, 205); colors_["purple4"] = RGBColor(85, 26, 139); colors_["red"] = RGBColor(255, 0, 0); colors_["red1"] = RGBColor(255, 0, 0); colors_["red2"] = RGBColor(238, 0, 0); colors_["red3"] = RGBColor(205, 0, 0); colors_["red4"] = RGBColor(139, 0, 0); colors_["rosybrown"] = RGBColor(188, 143, 143); colors_["rosybrown1"] = RGBColor(255, 193, 193); colors_["rosybrown2"] = RGBColor(238, 180, 180); colors_["rosybrown3"] = RGBColor(205, 155, 155); colors_["rosybrown4"] = RGBColor(139, 105, 105); colors_["royalblue"] = RGBColor(65, 105, 225); colors_["royalblue1"] = RGBColor(72, 118, 255); colors_["royalblue2"] = RGBColor(67, 110, 238); colors_["royalblue3"] = RGBColor(58, 95, 205); colors_["royalblue4"] = RGBColor(39, 64, 139); colors_["saddlebrown"] = RGBColor(139, 69, 19); colors_["salmon"] = RGBColor(250, 128, 114); colors_["salmon1"] = RGBColor(255, 140, 105); colors_["salmon2"] = RGBColor(238, 130, 98); colors_["salmon3"] = RGBColor(205, 112, 84); colors_["salmon4"] = RGBColor(139, 76, 57); colors_["sandybrown"] = RGBColor(244, 164, 96); colors_["seagreen"] = RGBColor(46, 139, 87); colors_["seagreen1"] = RGBColor(84, 255, 159); colors_["seagreen2"] = RGBColor(78, 238, 148); colors_["seagreen3"] = RGBColor(67, 205, 128); colors_["seagreen4"] = RGBColor(46, 139, 87); colors_["seashell"] = RGBColor(255, 245, 238); colors_["seashell1"] = RGBColor(255, 245, 238); colors_["seashell2"] = RGBColor(238, 229, 222); colors_["seashell3"] = RGBColor(205, 197, 191); colors_["seashell4"] = RGBColor(139, 134, 130); colors_["sienna"] = RGBColor(160, 82, 45); colors_["sienna1"] = RGBColor(255, 130, 71); colors_["sienna2"] = RGBColor(238, 121, 66); colors_["sienna3"] = RGBColor(205, 104, 57); colors_["sienna4"] = RGBColor(139, 71, 38); colors_["skyblue"] = RGBColor(135, 206, 235); colors_["skyblue1"] = RGBColor(135, 206, 255); colors_["skyblue2"] = RGBColor(126, 192, 238); colors_["skyblue3"] = RGBColor(108, 166, 205); colors_["skyblue4"] = RGBColor(74, 112, 139); colors_["slateblue"] = RGBColor(106, 90, 205); colors_["slateblue1"] = RGBColor(131, 111, 255); colors_["slateblue2"] = RGBColor(122, 103, 238); colors_["slateblue3"] = RGBColor(105, 89, 205); colors_["slateblue4"] = RGBColor(71, 60, 139); colors_["slategray"] = RGBColor(112, 128, 144); colors_["slategray1"] = RGBColor(198, 226, 255); colors_["slategray2"] = RGBColor(185, 211, 238); colors_["slategray3"] = RGBColor(159, 182, 205); colors_["slategray4"] = RGBColor(108, 123, 139); colors_["slategrey"] = RGBColor(112, 128, 144); colors_["snow"] = RGBColor(255, 250, 250); colors_["snow1"] = RGBColor(255, 250, 250); colors_["snow2"] = RGBColor(238, 233, 233); colors_["snow3"] = RGBColor(205, 201, 201); colors_["snow4"] = RGBColor(139, 137, 137); colors_["springgreen"] = RGBColor(0, 255, 127); colors_["springgreen1"] = RGBColor(0, 255, 127); colors_["springgreen2"] = RGBColor(0, 238, 118); colors_["springgreen3"] = RGBColor(0, 205, 102); colors_["springgreen4"] = RGBColor(0, 139, 69); colors_["steelblue"] = RGBColor(70, 130, 180); colors_["steelblue1"] = RGBColor(99, 184, 255); colors_["steelblue2"] = RGBColor(92, 172, 238); colors_["steelblue3"] = RGBColor(79, 148, 205); colors_["steelblue4"] = RGBColor(54, 100, 139); colors_["tan"] = RGBColor(210, 180, 140); colors_["tan1"] = RGBColor(255, 165, 79); colors_["tan2"] = RGBColor(238, 154, 73); colors_["tan3"] = RGBColor(205, 133, 63); colors_["tan4"] = RGBColor(139, 90, 43); colors_["thistle"] = RGBColor(216, 191, 216); colors_["thistle1"] = RGBColor(255, 225, 255); colors_["thistle2"] = RGBColor(238, 210, 238); colors_["thistle3"] = RGBColor(205, 181, 205); colors_["thistle4"] = RGBColor(139, 123, 139); colors_["tomato"] = RGBColor(255, 99, 71); colors_["tomato1"] = RGBColor(255, 99, 71); colors_["tomato2"] = RGBColor(238, 92, 66); colors_["tomato3"] = RGBColor(205, 79, 57); colors_["tomato4"] = RGBColor(139, 54, 38); colors_["turquoise"] = RGBColor(64, 224, 208); colors_["turquoise1"] = RGBColor(0, 245, 255); colors_["turquoise2"] = RGBColor(0, 229, 238); colors_["turquoise3"] = RGBColor(0, 197, 205); colors_["turquoise4"] = RGBColor(0, 134, 139); colors_["violet"] = RGBColor(238, 130, 238); colors_["violetred"] = RGBColor(208, 32, 144); colors_["violetred1"] = RGBColor(255, 62, 150); colors_["violetred2"] = RGBColor(238, 58, 140); colors_["violetred3"] = RGBColor(205, 50, 120); colors_["violetred4"] = RGBColor(139, 34, 82); colors_["wheat"] = RGBColor(245, 222, 179); colors_["wheat1"] = RGBColor(255, 231, 186); colors_["wheat2"] = RGBColor(238, 216, 174); colors_["wheat3"] = RGBColor(205, 186, 150); colors_["wheat4"] = RGBColor(139, 126, 102); colors_["whitesmoke"] = RGBColor(245, 245, 245); colors_["yellow"] = RGBColor(255, 255, 0); colors_["yellow1"] = RGBColor(255, 255, 0); colors_["yellow2"] = RGBColor(238, 238, 0); colors_["yellow3"] = RGBColor(205, 205, 0); colors_["yellow4"] = RGBColor(139, 139, 0); colors_["yellowgreen"] = RGBColor(154, 205, 50); } bpp-core-2.2.0/src/Bpp/Graphics/GraphicDevice.h000664 001750 001750 00000015360 12370705300 022626 0ustar00jdutheiljdutheil000000 000000 // // File: GraphicDevice.h // Created by: Julien Dutheil // Created on: Mon Mar 03 2008 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2006) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _GRAPHICDEVICE_H_ #define _GRAPHICDEVICE_H_ #include "RgbColor.h" #include "Font/Font.h" namespace bpp { class UnvalidFlagException: public virtual Exception { public: UnvalidFlagException(const std::string& message): Exception(message) {} }; /** * @brief Interface for all plotting devices. * * Implement this interface to support new formats. */ class GraphicDevice { public: GraphicDevice() {} virtual ~GraphicDevice() {} public: /** * @brief Start the painting. */ virtual void begin() = 0; /** * @brief End the painting. * * Depending on the implementation of the device, * the call of this method might be required before * the plotting commands become visible. */ virtual void end() = 0; /** * @param xu The x expansion factor. The actual unit actually depends on the implementation. */ virtual void setXUnit(double xu) = 0; /** * @param yu The y expansion factor. The actual unit actually depends on the implementation. */ virtual void setYUnit(double yu) = 0; /** * @return The x expansion factor. The actual unit actually depends on the implementation. */ virtual double getXUnit() const = 0; /** * @return The y expansion factor. The actual unit actually depends on the implementation. */ virtual double getYUnit() const = 0; virtual void setCurrentForegroundColor(const RGBColor& color) = 0; virtual void setCurrentBackgroundColor(const RGBColor& color) = 0; virtual void setCurrentFont(const Font& font) = 0; virtual void setCurrentPointSize(unsigned int size) = 0; virtual void setCurrentLineType(short type) = 0; virtual void setCurrentLayer(int layerIndex) = 0; virtual const RGBColor& getCurrentForegroundColor() const = 0; virtual const RGBColor& getCurrentBackgroundColor() const = 0; virtual const Font& getCurrentFont() const = 0; virtual unsigned int getCurrentPointSize() const = 0; virtual short getCurrentLineType() const = 0; virtual int getCurrentLayer() const = 0; /** * @brief Draw a line between two points. * * This method uses the current foreground color and the current line type. * * @param x1 x coordinate 1 * @param y1 y coordinate 1 * @param x2 x coordinate 2 * @param y2 y coordinate 2 */ virtual void drawLine(double x1, double y1, double x2, double y2) = 0; /** * @brief Draw a rectangle. * * This method uses the current foreground color and the current line type for drawing the stroke of the rectangle, * and the current background color for filling the rectangle. * * @param x x coordinate * @param y y coordinate * @param width The rectangle width * @param height The rectangle height * @param fill Filling type (one of FILL_EMPTY, FILL_FILLED or FILL_PATTERN). */ virtual void drawRect(double x, double y, double width, double height, short fill = FILL_EMPTY) = 0; /** * @brief Draw a circle. * * This method uses the current foreground color and the current line type for drawing the stroke of the circle, * and the current background color for filling the circle. * * @param x x coordinate of the center * @param y y coordinate of the center * @param radius The circle radius * @param fill Filling type (one of FILL_EMPTY, FILL_FILLED or FILL_PATTERN). */ virtual void drawCircle(double x, double y, double radius, short fill = FILL_EMPTY) = 0; /** * @brief Draw some characters. * * This method uses the current foreground color. * * @param x x coordinate * @param y y coordinate * @param text The characters to draw * @param hpos Horizontal adjustment, one of TEXT_HORIZONTAL_LEFT, TEXT_HORIZONTAL_CENTER or TEXT_HORIZONTAL_RIGHT. * @param vpos Vertical adjustment, one of TEXT_VERTICAL_LEFT, TEXT_VERTICAL_CENTER or TEXT_VERTICAL_RIGHT. * @param angle Angle i radian to rotate the text. */ virtual void drawText(double x, double y, const std::string& text, short hpos = TEXT_HORIZONTAL_LEFT, short vpos = TEXT_VERTICAL_BOTTOM, double angle = 0) throw (UnvalidFlagException) = 0; /** * @brief Add a comment in the output. * * @param comment Comment text. */ virtual void comment(const std::string & comment) = 0; public: static short TEXT_HORIZONTAL_CENTER; static short TEXT_HORIZONTAL_LEFT; static short TEXT_HORIZONTAL_RIGHT; static short TEXT_VERTICAL_CENTER; static short TEXT_VERTICAL_BOTTOM; static short TEXT_VERTICAL_TOP; static short FILL_EMPTY; static short FILL_FILLED; static short FILL_PATTERN; static short LINE_SOLID; static short LINE_DASHED; static short LINE_DOTTED; }; } // end of namespace bpp. #endif //_GRAPHICDEVICE_H_ bpp-core-2.2.0/src/Bpp/Graphics/Molscript/MolscriptColorSet.cpp000664 001750 001750 00000023275 12370705300 026073 0ustar00jdutheiljdutheil000000 000000 // // File: MolscriptColorSet.cpp // Created by: Julien Dutheil // Created on: Mon Apr 14 2008 // /* Copyright or © or Copr. CNRS, (November 17, 2008) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "MolscriptColorSet.h" using namespace bpp; MolscriptColorSet::MolscriptColorSet() { colors_["aliceblue"] = RGBColor(240, 248, 255); colors_["antiquewhite"] = RGBColor(250, 235, 215); colors_["aquamarine"] = RGBColor(127, 255, 212); colors_["azure"] = RGBColor(240, 255, 255); colors_["beige"] = RGBColor(245, 245, 220); colors_["bisque"] = RGBColor(255, 228, 196); colors_["black"] = RGBColor(0, 0, 0); colors_["blanchedalmond"] = RGBColor(255, 235, 205); colors_["blue"] = RGBColor(0, 0, 255); colors_["blueviolet"] = RGBColor(138, 43, 226); colors_["brown"] = RGBColor(165, 42, 42); colors_["burlywood"] = RGBColor(222, 184, 135); colors_["cadetblue"] = RGBColor(95, 158, 160); colors_["chartreuse"] = RGBColor(127, 255, 0); colors_["chocolate"] = RGBColor(210, 105, 30); colors_["coral"] = RGBColor(255, 127, 80); colors_["cornflowerblue"] = RGBColor(100, 149, 237); colors_["cornsilk"] = RGBColor(255, 248, 220); colors_["crimson"] = RGBColor(220, 20, 60); colors_["cyan"] = RGBColor(0, 255, 255); colors_["darkblue"] = RGBColor(0, 0, 139); colors_["darkcyan"] = RGBColor(0, 139, 139); colors_["darkgoldenrod"] = RGBColor(184, 134, 11); colors_["darkgray"] = RGBColor(169, 169, 169); colors_["darkgreen"] = RGBColor(0, 100, 0); colors_["darkgrey"] = RGBColor(169, 169, 169); colors_["darkkhaki"] = RGBColor(189, 183, 107); colors_["darkmagenta"] = RGBColor(139, 0, 139); colors_["darkolivegreen"] = RGBColor(85, 107, 47); colors_["darkorange"] = RGBColor(255, 140, 0); colors_["darkorchid"] = RGBColor(153, 50, 204); colors_["darkred"] = RGBColor(139, 0, 0); colors_["darksalmon"] = RGBColor(233, 150, 122); colors_["darkseagreen"] = RGBColor(143, 188, 143); colors_["darkslateblue"] = RGBColor(72, 61, 139); colors_["darkslategray"] = RGBColor(47, 79, 79); colors_["darkslategrey"] = RGBColor(47, 79, 79); colors_["darkturquoise"] = RGBColor(0, 206, 209); colors_["darkviolet"] = RGBColor(148, 0, 211); colors_["deeppink"] = RGBColor(255, 20, 147); colors_["deepskyblue"] = RGBColor(0, 191, 255); colors_["dimgray"] = RGBColor(105, 105, 105); colors_["dimgrey"] = RGBColor(105, 105, 105); colors_["dodgerblue"] = RGBColor(30, 144, 255); colors_["firebrick"] = RGBColor(178, 34, 34); colors_["floralwhite"] = RGBColor(255, 250, 240); colors_["forestgreen"] = RGBColor(34, 139, 34); colors_["gainsboro"] = RGBColor(220, 220, 220); colors_["ghostwhite"] = RGBColor(248, 248, 255); colors_["gold"] = RGBColor(255, 215, 0); colors_["goldenrod"] = RGBColor(218, 165, 32); colors_["gray"] = RGBColor(190, 190, 190); colors_["green"] = RGBColor(0, 255, 0); colors_["greenyellow"] = RGBColor(173, 255, 47); colors_["grey"] = RGBColor(190, 190, 190); colors_["honeydew"] = RGBColor(240, 255, 240); colors_["hotpink"] = RGBColor(255, 105, 180); colors_["indianred"] = RGBColor(205, 92, 92); colors_["indigo"] = RGBColor(75, 0, 130); colors_["ivory"] = RGBColor(255, 255, 240); colors_["khaki"] = RGBColor(240, 230, 140); colors_["lavender"] = RGBColor(230, 230, 250); colors_["lavenderblush"] = RGBColor(255, 240, 245); colors_["lawngreen"] = RGBColor(124, 252, 0); colors_["lemonchiffon"] = RGBColor(255, 250, 205); colors_["lightblue"] = RGBColor(173, 216, 230); colors_["lightcoral"] = RGBColor(240, 128, 128); colors_["lightcyan"] = RGBColor(224, 255, 255); colors_["lightgoldenrod"] = RGBColor(238, 221, 130); colors_["lightgoldenrodyellow"] = RGBColor(250, 250, 210); colors_["lightgray"] = RGBColor(211, 211, 211); colors_["lightgreen"] = RGBColor(144, 238, 144); colors_["lightgrey"] = RGBColor(211, 211, 211); colors_["lightpink"] = RGBColor(255, 182, 193); colors_["lightsalmon"] = RGBColor(255, 160, 122); colors_["lightseagreen"] = RGBColor(32, 178, 170); colors_["lightskyblue"] = RGBColor(135, 206, 250); colors_["lightslateblue"] = RGBColor(132, 112, 255); colors_["lightslategray"] = RGBColor(119, 136, 153); colors_["lightslategrey"] = RGBColor(119, 136, 153); colors_["lightsteelblue"] = RGBColor(176, 196, 222); colors_["lightyellow"] = RGBColor(255, 255, 224); colors_["limegreen"] = RGBColor(50, 205, 50); colors_["linen"] = RGBColor(250, 240, 230); colors_["magenta"] = RGBColor(255, 0, 255); colors_["maroon"] = RGBColor(176, 48, 96); colors_["mediumaquamarine"] = RGBColor(102, 205, 170); colors_["mediumblue"] = RGBColor(0, 0, 205); colors_["mediumorchid"] = RGBColor(186, 85, 211); colors_["mediumpurple"] = RGBColor(147, 112, 219); colors_["mediumseagreen"] = RGBColor(60, 179, 113); colors_["mediumslateblue"] = RGBColor(123, 104, 238); colors_["mediumspringgreen"] = RGBColor(0, 250, 154); colors_["mediumturquoise"] = RGBColor(72, 209, 204); colors_["mediumvioletred"] = RGBColor(199, 21, 133); colors_["midnightblue"] = RGBColor(25, 25, 112); colors_["mintcream"] = RGBColor(245, 255, 250); colors_["mistyrose"] = RGBColor(255, 228, 225); colors_["moccasin"] = RGBColor(255, 228, 181); colors_["navajowhite"] = RGBColor(255, 222, 173); colors_["navy"] = RGBColor(0, 0, 128); colors_["navyblue"] = RGBColor(0, 0, 128); colors_["oldlace"] = RGBColor(253, 245, 230); colors_["olivedrab"] = RGBColor(107, 142, 35); colors_["orange"] = RGBColor(255, 165, 0); colors_["orangered"] = RGBColor(255, 69, 0); colors_["orchid"] = RGBColor(218, 112, 214); colors_["palegoldenrod"] = RGBColor(238, 232, 170); colors_["palegreen"] = RGBColor(152, 251, 152); colors_["paleturquoise"] = RGBColor(175, 238, 238); colors_["palevioletred"] = RGBColor(219, 112, 147); colors_["papayawhip"] = RGBColor(255, 239, 213); colors_["peachpuff"] = RGBColor(255, 218, 185); colors_["peru"] = RGBColor(205, 133, 63); colors_["pink"] = RGBColor(255, 192, 203); colors_["plum"] = RGBColor(221, 160, 221); colors_["powderblue"] = RGBColor(176, 224, 230); colors_["purple"] = RGBColor(160, 32, 240); colors_["red"] = RGBColor(255, 0, 0); colors_["rosybrown"] = RGBColor(188, 143, 143); colors_["royalblue"] = RGBColor(65, 105, 225); colors_["saddlebrown"] = RGBColor(139, 69, 19); colors_["salmon"] = RGBColor(250, 128, 114); colors_["sandybrown"] = RGBColor(244, 164, 96); colors_["seagreen"] = RGBColor(46, 139, 87); colors_["seashell"] = RGBColor(255, 245, 238); colors_["sgibeet"] = RGBColor(142, 56, 142); colors_["sgibrightgray"] = RGBColor(197, 193, 170); colors_["sgibrightgrey"] = RGBColor(197, 193, 170); colors_["sgichartreuse"] = RGBColor(113, 198, 113); colors_["sgidarkgray"] = RGBColor(85, 85, 85); colors_["sgidarkgrey"] = RGBColor(85, 85, 85); colors_["sgilightblue"] = RGBColor(125, 158, 192); colors_["sgilightgray"] = RGBColor(170, 170, 170); colors_["sgilightgrey"] = RGBColor(170, 170, 170); colors_["sgimediumgray"] = RGBColor(132, 132, 132); colors_["sgimediumgrey"] = RGBColor(132, 132, 132); colors_["sgiolivedrab"] = RGBColor(142, 142, 56); colors_["sgisalmon"] = RGBColor(198, 113, 113); colors_["sgislateblue"] = RGBColor(113, 113, 198); colors_["sgiteal"] = RGBColor(56, 142, 142); colors_["sgiverydarkgray"] = RGBColor(40, 40, 40); colors_["sgiverydarkgrey"] = RGBColor(40, 40, 40); colors_["sgiverylightgray"] = RGBColor(214, 214, 214); colors_["sgiverylightgrey"] = RGBColor(214, 214, 214); colors_["sienna"] = RGBColor(160, 82, 45); colors_["skyblue"] = RGBColor(135, 206, 235); colors_["slateblue"] = RGBColor(106, 90, 205); colors_["slategray"] = RGBColor(112, 128, 144); colors_["slategrey"] = RGBColor(112, 128, 144); colors_["snow"] = RGBColor(255, 250, 250); colors_["springgreen"] = RGBColor(0, 255, 127); colors_["steelblue"] = RGBColor(70, 130, 180); colors_["tan"] = RGBColor(210, 180, 140); colors_["thistle"] = RGBColor(216, 191, 216); colors_["tomato"] = RGBColor(255, 99, 71); colors_["turquoise"] = RGBColor(64, 224, 208); colors_["violet"] = RGBColor(238, 130, 238); colors_["violetred"] = RGBColor(208, 32, 144); colors_["wheat"] = RGBColor(245, 222, 179); colors_["white"] = RGBColor(255, 255, 255); colors_["whitesmoke"] = RGBColor(245, 245, 245); colors_["yellow"] = RGBColor(255, 255, 0); colors_["yellowgreen"] = RGBColor(154, 205, 50); } bpp-core-2.2.0/src/Bpp/Graphics/Molscript/MolscriptColorSet.h000664 001750 001750 00000003756 12370705300 025542 0ustar00jdutheiljdutheil000000 000000 // // File: MolscriptColorSet.h // Created by: Julien Dutheil // Created on: Mon Apr 14 2008 // /* Copyright or © or Copr. CNRS, (November 17, 2008) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _MOLSCRIPTCOLORSET_H_ #define _MOLSCRIPTCOLORSET_H_ #include "../ColorSet.h" namespace bpp { /** * @brief Molscript color definitions. */ class MolscriptColorSet: public AbstractColorSet { public: MolscriptColorSet(); virtual ~MolscriptColorSet() {} }; } // end of namespace bpp; #endif //_MOLSCRIPTCOLORSET_H_ bpp-core-2.2.0/src/Bpp/Graphics/ColorSet.h000664 001750 001750 00000010213 12370705300 021653 0ustar00jdutheiljdutheil000000 000000 // // File: ColorSet.h // Created by: Julien Dutheil // Created on: Mon Apr 14 2008 // /* Copyright or © or Copr. CNRS, (November 17, 2008) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _COLORSET_H_ #define _COLORSET_H_ #include "RgbColor.h" #include "../Utils/MapTools.h" // From the STL: #include namespace bpp { /** * @brief Specify a set of color definitions. */ class ColorSet { public: ColorSet() {} virtual ~ColorSet() {} public: /** * @brief Get the color object corresponding to a given name. * * @param name The name of the color to look for. * @return The color associated to the given name. * @throw Exception if the name is not assigned to any color. */ virtual const RGBColor& getColor(const std::string& name) const throw (Exception) = 0; /** * @brief Get the ith color object in the set. * * @param index The index of the color to look for. * @return The color associated to the given index. * @throw IndexOutOfBoundsException if the index is not assigned to any color. */ virtual const RGBColor& getColor(unsigned int index) const throw (IndexOutOfBoundsException) = 0; /** * @return All valid color names. */ virtual std::vector getColorNames() const = 0; /** * @return The total number of colors available. */ virtual size_t getNumberOfColors() const = 0; }; /** * @brief Partial implementation of the ColorSet interface. * * Derivative classes just have to fill the colors_ map in the constructor of the class. */ class AbstractColorSet: public ColorSet { protected: std::map colors_; public: AbstractColorSet(): colors_() {} virtual ~AbstractColorSet() {} public: const RGBColor& getColor(const std::string& name) const throw (Exception) { std::map::const_iterator it = colors_.find(name); if (it != colors_.end()) return it->second; else throw Exception("AbstractColorSet::getColor(name): no color with name " + name); } const RGBColor& getColor(unsigned int index) const throw (IndexOutOfBoundsException) { if (index >= colors_.size()) throw IndexOutOfBoundsException("AbstractColorSet::getColor(index): invalid index.", index, 0, colors_.size() - 1); std::map::const_iterator it = colors_.begin(); for (unsigned int i = 0; i < index; i++) it++; return it->second; } std::vector getColorNames() const { return MapTools::getKeys(colors_); } size_t getNumberOfColors() const { return colors_.size(); } }; } // end of namespace bpp; #endif //_COLORSET_H_ bpp-core-2.2.0/src/Bpp/Graphics/AbstractGraphicDevice.h000664 001750 001750 00000007705 12370705300 024316 0ustar00jdutheiljdutheil000000 000000 // // File: AbstractGraphicDevice.h // Created by: Julien Dutheil // Created on: Fri Jul 24 2009 // /* Copyright or © or Copr. Bio++ Development Team, (November 16, 2006) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _ABSTRACTGRAPHICDEVICE_H_ #define _ABSTRACTGRAPHICDEVICE_H_ #include "GraphicDevice.h" namespace bpp { /** * @brief Partial implementation of the GraphicDevice interface. * * Implement this interface to support new formats. */ class AbstractGraphicDevice: public virtual GraphicDevice { private: double xUnit_; double yUnit_; RGBColor fgColor_; RGBColor bgColor_; Font font_; unsigned int pointSize_; short lineType_; int currentLayer_; public: AbstractGraphicDevice(): xUnit_(1.), yUnit_(1.), fgColor_(0, 0, 0), bgColor_(0, 0, 0), font_(), pointSize_(1), lineType_(LINE_SOLID), currentLayer_(-1) {} virtual ~AbstractGraphicDevice() {} public: void setXUnit(double xu) { xUnit_ = xu; } void setYUnit(double yu) { yUnit_ = yu; } double getXUnit() const { return xUnit_; } double getYUnit() const { return yUnit_; } void setCurrentForegroundColor(const RGBColor& color) { fgColor_ = color; } void setCurrentBackgroundColor(const RGBColor& color) { bgColor_ = color; } void setCurrentFont(const Font& font) { font_ = font; } void setCurrentPointSize(unsigned int size) { pointSize_ = size; } void setCurrentLineType(short type) throw (Exception) { if (type == LINE_SOLID) lineType_ = type; else if (type == LINE_DASHED) lineType_ = type; else if (type == LINE_DOTTED) lineType_ = type; else throw Exception("AbstractGraphicDevice::setCurrentLineType. Unknown line type: " + TextTools::toString(type)); } void setCurrentLayer(int layerIndex) { currentLayer_ = layerIndex; } const RGBColor& getCurrentForegroundColor() const { return fgColor_; } const RGBColor& getCurrentBackgroundColor() const { return bgColor_; } const Font& getCurrentFont() const { return font_; } unsigned int getCurrentPointSize() const { return pointSize_; } short getCurrentLineType() const { return lineType_; } int getCurrentLayer() const { return currentLayer_; } protected: double x_(double x) const { return x * xUnit_; } double y_(double y) const { return y * yUnit_; } double revx_(double x) const { return x / xUnit_; } double revy_(double y) const { return y / yUnit_; } }; } //end of namespace bpp; #endif //_ABSTRACTGRAPHICDEVICE_H_ bpp-core-2.2.0/src/Bpp/Graphics/DefaultColorSet.h000664 001750 001750 00000004555 12370705300 023174 0ustar00jdutheiljdutheil000000 000000 // // File: DefaultColorSet.h // Created by: Julien Dutheil // Created on: Mon Apr 14 2008 // /* Copyright or © or Copr. CNRS, (November 17, 2008) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _DEFAULTCOLORSET_H_ #define _DEFAULTCOLORSET_H_ #include "ColorSet.h" #include "ColorTools.h" namespace bpp { /** * @brief Default color definitions. */ class DefaultColorSet: public AbstractColorSet { public: DefaultColorSet() { colors_["black"] = ColorTools::BLACK; colors_["red"] = ColorTools::RED; colors_["green"] = ColorTools::GREEN; colors_["blue"] = ColorTools::BLUE; colors_["yellow"] = ColorTools::YELLOW; colors_["magenta"] = ColorTools::MAGENTA; colors_["cyan"] = ColorTools::CYAN; colors_["white"] = ColorTools::WHITE; } virtual ~DefaultColorSet() {} }; } // end of namespace bpp; #endif //_DEFAULTCOLORSET_H_ bpp-core-2.2.0/src/Bpp/Graphics/Point2D.h000664 001750 001750 00000010005 12370705300 021377 0ustar00jdutheiljdutheil000000 000000 // // File Point2D.h (from file Coord.h) // Author : Sylvain Gaillard // Julien Dutheil // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for population genetics analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _POINT2D_H_ #define _POINT2D_H_ #include "../Clonable.h" namespace bpp { /** * @brief The Point2D class. * * This is a simple class designed to store the coordinates of a point. * The type of the two coordinates is defined as a template. * * @author Sylvain Gaillard, Julien Dutheil */ template class Point2D: public virtual Clonable { private: T x_; T y_; public: // Constructors and destructor : /** * @brief Build a new Point2D from two values. * * The two values are set to 0 if no parametre is given to the constructor. * * @param x The longitude or abscissa. * @param y The latitude or ordinate. */ Point2D(const T x = 0, const T y = 0): x_(x), y_(y) {} /** * @brief Destroy the Point2D object. */ virtual ~Point2D() {} public: // Methodes /** * @brief Implement the Clonable interface. */ Point2D* clone() const { return new Point2D(*this); } /** * @brief Set the two values. */ void setCoord(const T x, const T y); /** * @brief Set only the longitude. */ void setX(const T x) { x_ = x; } /** * @brief Set only the latitude. */ void setY(const T y) { y_ = y; } /** * @brief Get the longitude. */ const T& getX() const { return x_; } /** * @brief Get the latitude. */ const T& getY() const { return y_; } /** * @brief Compares two Point2D objets. * * Return true if the coordinates of the 2 Point2D are equals. */ bool hasSameCoordsAs(const Point2D& coord) const { return x_ == coord.x_ && y_ == coord.y_; } /** * @brief The == operator. * * Return true if the coordinates of the 2 Point2Ds are equals. * Does the same as the asSameCoords() methode. */ virtual bool operator== (const Point2D& coord) const { return hasSameCoordsAs(coord); } /** * @brief The != operator. */ virtual bool operator!= (const Point2D& coord) const { return !hasSameCoordsAs(coord); } }; } //end of namespace bpp; #endif // _POINT2D_H_ bpp-core-2.2.0/src/Bpp/Graphics/Font/Font.h000664 001750 001750 00000011502 12370705300 021737 0ustar00jdutheiljdutheil000000 000000 // // File: Font.h // Created by: Julien Dutheil // Created on: Mon Mar 03 2008 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _FONT_H_ #define _FONT_H_ #include "../../Clonable.h" #include "../../Text/TextTools.h" //From the STL: #include #include namespace bpp { /** * @brief Data structure for fonts. */ class Font: public virtual Clonable { private: std::string family_; short int style_; short int weight_; unsigned int size_; mutable std::map styleDesc_; mutable std::map weightDesc_; public: Font(const std::string& family = "Default", short int style = STYLE_NORMAL, short int weight = WEIGHT_NORMAL, unsigned int size = 12): family_(family), style_(style), weight_(weight), size_(size), styleDesc_(), weightDesc_() { init_(); } virtual ~Font() {} #ifdef NO_VIRTUAL_COV Clonable* #else Font* #endif clone() const { return new Font(*this); } private: void init_(); public: bool operator==(const Font& font) const { return family_ == font.family_ && style_ == font.style_ && weight_ == font.weight_; } /** * @return The family component of this font. */ const std::string& getFamily() const { return family_; } /** * @return The style component of this font. */ const short int getStyle() const { return style_; } /** * @brief Alias function for getStyle. * @return The shape component of this font. */ const short int getShape() const { return style_; } /** * @return The weight component of this font. */ const short int getWeight() const { return weight_; } /** * @brief Alias function for getWeight * @return The series component of this font. */ const short int getSeries() const { return weight_; } /** * @return The size component of this font. */ const unsigned int& getSize() const { return size_; } /** * @param family The family component of this font. */ void setFamily(const std::string& family) { family_ = family; } /** * @param style The style component of this font. */ void setStyle(short int style) { style_ = style; } /** * @brief Alias function for setStyle. * @param shape The shape component of this font. */ void setShape(short int shape) { style_ = shape; } /** * @param weight The weight component of this font. */ void setWeight(short int weight) { weight_ = weight; } /** * @brief Alias function for setWeight. * @param series The series component of this font. */ void setSeries(short int series) { weight_ = series; } /** * @param size The size component of this font. */ void setSize(unsigned int size) { size_ = size; } /** * @return A text description of this font (family type size). */ std::string toString() const { return family_ + "/" + styleDesc_[style_] + "/" + weightDesc_[weight_] + "/" + TextTools::toString(size_); } public: static const short int STYLE_NORMAL; static const short int STYLE_ITALIC; static const short int WEIGHT_NORMAL; static const short int WEIGHT_BOLD; }; } // end of namespace bpp. #endif //_FONT_H_ bpp-core-2.2.0/src/Bpp/Graphics/Font/Font.cpp000664 001750 001750 00000004025 12370705300 022274 0ustar00jdutheiljdutheil000000 000000 // // File: Font.cpp // Created by: Julien Dutheil // Created on: Wed Dec 30 2009 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "Font.h" using namespace bpp; const short int Font::STYLE_NORMAL = 0; const short int Font::STYLE_ITALIC = 1; const short int Font::WEIGHT_NORMAL = 0; const short int Font::WEIGHT_BOLD = 1; void Font::init_() { styleDesc_[STYLE_NORMAL] = "normal"; styleDesc_[STYLE_ITALIC] = "italic"; weightDesc_[WEIGHT_NORMAL] = "normal"; weightDesc_[WEIGHT_BOLD] = "bold"; } bpp-core-2.2.0/src/Bpp/Graphics/Font/FontManager.h000664 001750 001750 00000007632 12370705300 023243 0ustar00jdutheiljdutheil000000 000000 // // File: FontManager.h // Created by: Julien Dutheil // Created on: Sat Mar 08 2008 // /* Copyright or © or Copr. Bio++ Developement Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _FONTMANAGER_H_ #define _FONTMANAGER_H_ #include "Font.h" // From the STL: #include #include "../../Text/TextTools.h" namespace bpp { /** * @brief Associate special fonts to a code. * * Instances of this interface are used in some vector format. */ template class FontManager { public: FontManager() {} virtual ~FontManager() {} public: /** * @param font The font to look for. * @return The code associated to a given font. */ virtual CodeType getCode(const Font& font) const throw (Exception) = 0; /** * @param code The code to look for. * @return The font associated to a given code. * @throw exception if the code is not valid. */ virtual const Font& getFont(CodeType& code) const throw (Exception) = 0; /** * @return All valid codes. */ virtual std::vector getCodes() const = 0; /** * @return All available fonts. */ virtual std::vector getFonts() const = 0; /** * @return The total number of fonts available. */ virtual size_t getNumberOfFonts() const = 0; }; template class AbstractFontManager : public virtual FontManager { private: std::vector fonts_; std::vector codes_; public: AbstractFontManager() : fonts_(), codes_() {} public: CodeType getCode(const Font& font) const throw (Exception) { for (unsigned int i = 0; i < fonts_.size(); i++) { if (fonts_[i] == font) { return codes_[i]; } } throw Exception("AbstractFontManager::getCode. Unknown font: " + font.toString()); } const Font& getFont(int &code) const throw (Exception) { for (unsigned int i = 0; i < codes_.size(); i++) { if (codes_[i] == code) { return fonts_[i]; } } throw Exception("AbstractFontManager::getColor. No font associated to this code: " + TextTools::toString(code)); } std::vector getCodes() const { return codes_; } std::vector getFonts() const { return fonts_; } size_t getNumberOfFonts() const { return fonts_.size(); } protected: void registerFont_(const Font& font, int code) { codes_.push_back(code); fonts_.push_back(font); } }; } // end of namespace. #endif //_FONTMANAGER_H_ bpp-core-2.2.0/src/Bpp/Graphics/ColorTools.cpp000664 001750 001750 00000007466 12370705300 022573 0ustar00jdutheiljdutheil000000 000000 // // File: ColorTools.cpp // Created by: Julien Dutheil // Created on: Thu Mar 16 2006 // /* Copyright or © or Copr. Bio++ Development Team, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "ColorTools.h" using namespace std; using namespace bpp; const RGBColor ColorTools::RED = RGBColor(255,0,0); const RGBColor ColorTools::GREEN = RGBColor(0,255,0); const RGBColor ColorTools::BLUE = RGBColor(0,0,255); const RGBColor ColorTools::BLACK = RGBColor(0,0,0); const RGBColor ColorTools::WHITE = RGBColor(255,255,255); const RGBColor ColorTools::YELLOW = RGBColor(255,255,0); const RGBColor ColorTools::CYAN = RGBColor(0,255,255); const RGBColor ColorTools::MAGENTA = RGBColor(255,0,255); const RGBColor ColorTools::ORANGE = RGBColor(255,127,0); /******************************************************************************/ std::vector ColorTools::gradient(unsigned int n, const RGBColor& low, const RGBColor& high) { vector colors(n); for (unsigned int i = 0; i < n - 1; ++i) { colors[i][0] = low[0] + static_cast( floor( static_cast(i) * static_cast(static_cast(high[0]) - static_cast(low[0])) / static_cast(n - 1) ) ); colors[i][1] = low[1] + static_cast( floor( static_cast(i) * static_cast(static_cast(high[1]) - static_cast(low[1])) / static_cast(n - 1) ) ); colors[i][2] = low[2] + static_cast( floor( static_cast(i) * static_cast(static_cast(high[2]) - static_cast(low[2])) / static_cast(n - 1) ) ); } colors[n-1] = high; return colors; } /******************************************************************************/ std::vector ColorTools::gradient(unsigned int n, const RGBColor & low, const RGBColor & mid, const RGBColor & high) { unsigned int lower = n / 2; unsigned int upper = n - lower; vector colors1 = gradient(lower, low, mid); vector colors2 = gradient(upper + 1, mid, high); for (size_t i = 1; i < colors2.size(); i++) { colors1.push_back(colors2[i]); } return colors1; } /******************************************************************************/ bpp-core-2.2.0/src/Bpp/Graphics/Point2DTools.h000664 001750 001750 00000005057 12370705300 022433 0ustar00jdutheiljdutheil000000 000000 // // File Point2DTools.h (from CoordsTools.h) // Author : Sylvain Gaillard // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide classes for population genetics analysis. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _POINT2DTOOLS_H_ #define _POINT2DTOOLS_H_ // From local #include "Point2D.h" namespace bpp { /** * @brief Some functions to deal with Point2D. * * @author Sylvain Gaillard */ class CoordsTools { public: /** * @brief Get the distance between two Coord objects. * * @param co1 A Point2D object. * @param co2 An other Point2D object. * @return the distance between the 2 points as a double */ template static double getDistanceBetween(const Point2D& co1, const Point2D& co2) { T base, height; base = co1.getX() - co2.getX(); height = co1.getY() - co2.getY(); base = base * base; height = height * height; return sqrt((double)base + (double)height); } }; } //end of namespace bpp; #endif // _POINT2DTOOLS_H_ bpp-core-2.2.0/src/Bpp/Graphics/Latex/PgfGraphicDevice.h000664 001750 001750 00000007632 12370705300 024343 0ustar00jdutheiljdutheil000000 000000 // // File: PgfGraphicDevice.h // Created by: Julien Dutheil // Created on: Thu Jun 19 2008 // /* Copyright or © or Copr. CNRS, (November 16, 2006) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _PGFGRAPHICDEVICE_H_ #define _PGFGRAPHICDEVICE_H_ #include "../AbstractGraphicDevice.h" #include "../ColorTools.h" // From the STL: #include #include #include namespace bpp { /** * @brief LaTeX Portable Graphic Format (Pgf) plotting format. */ class PgfGraphicDevice: public AbstractGraphicDevice { private: std::ostream& out_; std::string fgColorStr_; std::string bgColorStr_; std::vector content_; std::vector layers_; std::map colorIndex_; unsigned int colorCount_; bool useLayers_; bool contentStarted_; mutable std::map fontShapes_; mutable std::map fontSeries_; public: /** * @brief Build a new Pgf device object. * * Coordinates in Pgf are the same as in LaTeX, so it can be any of cm, mm, in, pt, px, etc. * For compatibility with other devices, the constructor takes as input the scale of the drawing, as cm per points. * All coordinates and widths will be multiplied by the factor in the output file. * * @param out The output stream. * @param unit The unit length. */ PgfGraphicDevice(std::ostream& out, double unit); virtual ~PgfGraphicDevice() {} public: void begin(); void end(); void setCurrentForegroundColor(const RGBColor& color); void setCurrentBackgroundColor(const RGBColor& color); void setCurrentFont(const Font& font); void setCurrentPointSize(unsigned int size); void setCurrentLineType(short type) throw (Exception); void setCurrentLayer(int layerIndex); void drawLine(double x1, double y1, double x2, double y2); void drawRect(double x, double y, double width, double height, short fill = FILL_EMPTY); void drawCircle(double x, double y, double radius, short fill = FILL_EMPTY); void drawText(double x, double y, const std::string & text, short hpos = TEXT_HORIZONTAL_LEFT, short vpos = TEXT_VERTICAL_BOTTOM, double angle = 0) throw (UnvalidFlagException); void comment(const std::string& text) { content_.push_back("%" + text); } public: const std::string& getFontShape(const Font& font); }; } // end of namespace bpp. #endif //_PGFGRAPHICDEVICE_H_ bpp-core-2.2.0/src/Bpp/Graphics/Latex/PgfGraphicDevice.cpp000664 001750 001750 00000024316 12370705300 024674 0ustar00jdutheiljdutheil000000 000000 // // File: PgfGraphicDevice.cpp // Created by: Julien Dutheil // Created on: Thu Jun 19 2008 // /* Copyright or © or Copr. CNRS, (November 17, 2004) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "PgfGraphicDevice.h" using namespace bpp; #include using namespace std; PgfGraphicDevice::PgfGraphicDevice(std::ostream& out, double unit) : out_(out), fgColorStr_("black"), bgColorStr_("white"), content_(), layers_(), colorIndex_(), colorCount_(0), useLayers_(false), contentStarted_(false), fontShapes_(), fontSeries_() { colorIndex_[ColorTools::BLACK] = "black"; colorIndex_[ColorTools::WHITE] = "white"; colorIndex_[ColorTools::BLUE] = "blue"; colorIndex_[ColorTools::RED] = "red"; colorIndex_[ColorTools::GREEN] = "green"; colorIndex_[ColorTools::YELLOW] = "yellow"; colorIndex_[ColorTools::CYAN] = "cyan"; colorIndex_[ColorTools::MAGENTA] = "magenta"; fontShapes_[Font::STYLE_NORMAL] = "n"; fontShapes_[Font::STYLE_ITALIC] = "it"; fontSeries_[Font::WEIGHT_NORMAL] = "m"; fontSeries_[Font::WEIGHT_BOLD] = "bx"; setCurrentFont(Font("cmtt", Font::STYLE_NORMAL, Font::WEIGHT_NORMAL, 12)); setXUnit(unit); setYUnit(unit); } void PgfGraphicDevice::begin() { content_.clear(); layers_.clear(); colorIndex_.clear(); colorCount_ = 0; useLayers_ = false; contentStarted_ = false; } bool comp( int a, int b ) { return a > b; } ; void PgfGraphicDevice::end() { ostringstream oss; if (useLayers_) oss << "\\end{pgfonlayer}{" << TextTools::toString(getCurrentLayer()) << "}" << endl; content_.push_back(oss.str()); //Header: out_ << "\\documentclass{article}" << endl; out_ << "% This figure was generated by the Bio++ Pgf Graphic Device." << endl; out_ << "% Althought this file can be compiled 'as is' it may not be displayed correctly, depending on the size of the picture." << endl; out_ << "% You may consider copying the pgfpicture environment to your own LaTeX file and play with pgf settings (e.g. the pgfpages module)." << endl; out_ << "% You can also use the geometry package, for instance:" << endl; out_ << "% \\usepackage[a3paper]{geometry}" << endl; out_ << "\\usepackage{pgf}" << endl; for(map::iterator it = colorIndex_.begin(); it != colorIndex_.end(); it++) { if(it->second.substr(0,3) == "use") out_ << "\\definecolor{" << it->second << "}{rgb}{" << it->first[0]/255. << "," << it->first[1]/255. << "," << it->first[2]/255. << "}" << endl; } out_ << "\\begin{document}" << endl; //Declare and set layers: if (useLayers_) { string tmp; sort(layers_.begin(), layers_.end(), comp); for(unsigned int i = 0; i < layers_.size(); i++) { if(i > 0) tmp += ","; tmp += TextTools::toString(layers_[i]); out_ << "\\pgfdeclarelayer{" << layers_[i] << "}" << endl; } out_ << "\\pgfsetlayers{" << tmp << "}" << endl; } //Start picture: out_ << "\\begin{pgfpicture}" << endl; out_ << "\\pgfsetxvec{\\pgfpoint{" << getXUnit() << "cm}{0cm}}" << endl; out_ << "\\pgfsetyvec{\\pgfpoint{0cm}{-" << getYUnit() << "cm}}" << endl; for(unsigned int i = 0; i < content_.size(); i++) { out_ << content_[i] << endl; } out_ << "\\end{pgfpicture}" << endl; out_ << "\\end{document}" << endl; } void PgfGraphicDevice::setCurrentForegroundColor(const RGBColor& color) { map::iterator it = colorIndex_.find(color); if(it != colorIndex_.end()) { fgColorStr_ = it->second; } else { colorCount_++; fgColorStr_ = "usercolor" + TextTools::toString(colorCount_); colorIndex_[color] = fgColorStr_; } AbstractGraphicDevice::setCurrentForegroundColor(color); ostringstream oss; oss << "\\pgfsetstrokecolor{" << fgColorStr_ << "}" << endl; content_.push_back(oss.str()); } void PgfGraphicDevice::setCurrentBackgroundColor(const RGBColor& color) { map::iterator it = colorIndex_.find(color); if (it != colorIndex_.end()) { bgColorStr_ = it->second; } else { colorCount_++; bgColorStr_ = "usercolor" + TextTools::toString(colorCount_); colorIndex_[color] = bgColorStr_; } AbstractGraphicDevice::setCurrentBackgroundColor(color); ostringstream oss; oss << "\\pgfsetfillcolor{" << bgColorStr_ << "}" << endl; content_.push_back(oss.str()); } void PgfGraphicDevice::setCurrentFont(const Font& font) { AbstractGraphicDevice::setCurrentFont(font); ostringstream oss; oss << "\\fontfamily{" << font.getFamily() << "}" << endl; oss << "\\fontseries{" << fontSeries_[font.getSeries()] << "}" << endl; oss << "\\fontshape{" << fontShapes_[font.getShape()] << "}" << endl; oss << "\\fontsize{" << font.getSize() << "}{" << font.getSize() << "}" << endl; oss << "\\selectfont" << endl; content_.push_back(oss.str()); } void PgfGraphicDevice::setCurrentPointSize(unsigned int size) { AbstractGraphicDevice::setCurrentPointSize(size); ostringstream oss; oss << "\\pgfsetlinewidth{" << x_(size) << "}" << endl; content_.push_back(oss.str()); } void PgfGraphicDevice::setCurrentLineType(short type) throw (Exception) { AbstractGraphicDevice::setCurrentLineType(type); if(type == LINE_SOLID) { ostringstream oss; oss << "\\pgfsetdash{}{0pt}" << endl; content_.push_back(oss.str()); } else if(type == LINE_DASHED) { ostringstream oss; oss << "\\pgfsetdash{{3mm}{2mm}}{0pt}" << endl; content_.push_back(oss.str()); } else if(type == LINE_DOTTED) { ostringstream oss; oss << "\\pgfsetdash{{" << (x_(getCurrentPointSize())) << "}{" << (x_(getCurrentPointSize())) << "}}{0pt}" << endl; content_.push_back(oss.str()); } else throw Exception("PgfGraphicDevice::setCurrentLineType. Unknown line type: " + TextTools::toString(type)); } void PgfGraphicDevice::setCurrentLayer(int layerIndex) { if (!useLayers_ && contentStarted_) throw Exception("PgfGraphicDevice::setCurrentLayer. A layer is specified after some content has been already added, this would result in a corrupted display."); ostringstream oss; if (useLayers_) oss << "\\end{pgfonlayer}{" << TextTools::toString(getCurrentLayer()) << "}" << endl; oss << "\\begin{pgfonlayer}{" << TextTools::toString(layerIndex) << "}" << endl; //We have to recall the current color values for this layer: oss << "\\pgfsetstrokecolor{" << fgColorStr_ << "}" << endl; oss << "\\pgfsetfillcolor{" << bgColorStr_ << "}" << endl; content_.push_back(oss.str()); AbstractGraphicDevice::setCurrentLayer(layerIndex); if (find(layers_.begin(), layers_.end(), layerIndex) == layers_.end()) layers_.push_back(layerIndex); useLayers_ = true; } void PgfGraphicDevice::drawLine(double x1, double y1, double x2, double y2) { ostringstream oss; oss << "\\pgfpathmoveto{\\pgfpointxy{" << x1 << "}{" << y1 << "}}" << endl; oss << "\\pgfpathlineto{\\pgfpointxy{" << x2 << "}{" << y2 << "}}" << endl; oss << "\\pgfpathclose" << endl; oss << "\\pgfusepath{stroke}" << endl; content_.push_back(oss.str()); contentStarted_ = true; } void PgfGraphicDevice::drawRect(double x, double y, double width, double height, short fill) { ostringstream oss; oss << "\\pgfpathrectangle{\\pgfpointxy{" << x << "}{" << y << "}}{\\pgfpointxy{" << width << "}{" << height << "}}" << endl; if(fill == FILL_FILLED) oss << "\\pgfusepath{stroke,fill}" << endl; else oss << "\\pgfusepath{stroke}" << endl; content_.push_back(oss.str()); contentStarted_ = true; } void PgfGraphicDevice::drawCircle(double x, double y, double radius, short fill) { ostringstream oss; oss << "\\pgfpathcircle{\\pgfpointxy{" << x << "}{" << y << "}}{" << radius << "}" << endl; if(fill == FILL_FILLED) oss << "\\pgfusepath{stroke,fill}" << endl; else oss << "\\pgfusepath{stroke}" << endl; content_.push_back(oss.str()); contentStarted_ = true; } void PgfGraphicDevice::drawText(double x, double y, const std::string& text, short hpos, short vpos, double angle) throw (UnvalidFlagException) { string anchor; if(vpos == TEXT_VERTICAL_BOTTOM) anchor = "bottom"; else if(vpos == TEXT_VERTICAL_TOP) anchor = "top"; else if(vpos == TEXT_VERTICAL_CENTER) anchor = "base"; else throw UnvalidFlagException("PgfGraphicDevice::drawText. Invalid vertical alignment option."); if(hpos == TEXT_HORIZONTAL_LEFT) anchor += ",left"; else if(hpos == TEXT_HORIZONTAL_RIGHT) anchor += ",right"; else if(hpos == TEXT_HORIZONTAL_CENTER) anchor += ""; else throw UnvalidFlagException("PgfGraphicDevice::drawText. Invalid horizontal alignment option."); ostringstream oss; oss << "\\pgftransformrotate{" << angle << "}" << endl; oss << "\\pgftext[" << anchor << ",at=\\pgfpointxy{" << x << "}{" << y << "}]{\\textcolor{" << fgColorStr_ << "}" << text << "}" << endl; content_.push_back(oss.str()); contentStarted_ = true; } bpp-core-2.2.0/src/Bpp/Graphics/Latex/DvipsColorSet.cpp000664 001750 001750 00000011621 12370705300 024275 0ustar00jdutheiljdutheil000000 000000 // // File: DvipsColorSet.cpp // Created by: Julien Dutheil // Created on: Mon Apr 14 2008 // /* Copyright or © or Copr. CNRS, (November 17, 2008) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #include "DvipsColorSet.h" using namespace bpp; DvipsColorSet::DvipsColorSet() { colors_["GreenYellow"] = RGBColor(217, 255, 79); colors_["Yellow"] = RGBColor(255, 255, 0); colors_["Goldenrod"] = RGBColor(255, 230, 41); colors_["Dandelion"] = RGBColor(255, 181, 41); colors_["Apricot"] = RGBColor(255, 173, 122); colors_["Peach"] = RGBColor(255, 128, 77); colors_["Melon"] = RGBColor(255, 138, 128); colors_["YellowOrange"] = RGBColor(255, 148, 0); colors_["Orange"] = RGBColor(255, 99, 33); colors_["BurntOrange"] = RGBColor(255, 125, 0); colors_["Bittersweet"] = RGBColor(194, 48, 0); colors_["RedOrange"] = RGBColor(255, 59, 33); colors_["Mahogany"] = RGBColor(166, 25, 22); colors_["Maroon"] = RGBColor(173, 23, 55); colors_["BrickRed"] = RGBColor(184, 20, 11); colors_["Red"] = RGBColor(255, 0, 0); colors_["OrangeRed"] = RGBColor(255, 0, 128); colors_["RubineRed"] = RGBColor(255, 0, 222); colors_["WildStrawberry"] = RGBColor(255, 10, 156); colors_["Salmon"] = RGBColor(255, 120, 158); colors_["CarnationPink"] = RGBColor(255, 94, 255); colors_["Magenta"] = RGBColor(255, 0, 255); colors_["VioletRed"] = RGBColor(255, 48, 255); colors_["Rhodamine"] = RGBColor(255, 46, 255); colors_["Mulberry"] = RGBColor(165, 25, 250); colors_["RedViolet"] = RGBColor(157, 17, 168); colors_["Fuchsia"] = RGBColor(124, 21, 235); colors_["Lavender"] = RGBColor(255, 133, 255); colors_["Thistle"] = RGBColor(224, 105, 255); colors_["Orchid"] = RGBColor(173, 92, 255); colors_["DarkOrchid"] = RGBColor(153, 51, 204); colors_["Purple"] = RGBColor(140, 36, 255); colors_["Plum"] = RGBColor(128, 0, 255); colors_["Violet"] = RGBColor(54, 31, 255); colors_["RoyalPurple"] = RGBColor(64, 25, 255); colors_["BlueViolet"] = RGBColor(34, 22, 245); colors_["Periwinkle"] = RGBColor(110, 115, 255); colors_["CadetBlue"] = RGBColor(97, 110, 196); colors_["CornflowerBlue"] = RGBColor(89, 222, 255); colors_["MidnightBlue"] = RGBColor(3, 126, 145); colors_["NavyBlue"] = RGBColor(15, 117, 255); colors_["RoyalBlue"] = RGBColor(0, 128, 255); colors_["Blue"] = RGBColor(0, 0, 255); colors_["Cerulean"] = RGBColor(15, 227, 255); colors_["Cyan"] = RGBColor(0, 255, 255); colors_["ProcessBlue"] = RGBColor(10, 255, 255); colors_["SkyBlue"] = RGBColor(97, 255, 224); colors_["Turquoise"] = RGBColor(38, 255, 204); colors_["TealBlue"] = RGBColor(35, 250, 165); colors_["Aquamarine"] = RGBColor(46, 255, 178); colors_["BlueGreen"] = RGBColor(38, 255, 171); colors_["Emerald"] = RGBColor(0, 255, 128); colors_["JungleGreen"] = RGBColor(3, 255, 122); colors_["SeaGreen"] = RGBColor(79, 255, 128); colors_["Green"] = RGBColor(0, 255, 0); colors_["ForestGreen"] = RGBColor(20, 224, 27); colors_["PineGreen"] = RGBColor(15, 191, 78); colors_["LimeGreen"] = RGBColor(128, 255, 0); colors_["YellowGreen"] = RGBColor(143, 255, 66); colors_["SpringGreen"] = RGBColor(189, 255, 61); colors_["OliveGreen"] = RGBColor(55, 153, 8); colors_["RawSienna"] = RGBColor(140, 39, 0); colors_["Sepia"] = RGBColor(77, 13, 0); colors_["Brown"] = RGBColor(102, 19, 0); colors_["Tan"] = RGBColor(219, 148, 112); colors_["Gray"] = RGBColor(128, 128, 128); colors_["Black"] = RGBColor(0, 0, 0); colors_["White"] = RGBColor(255, 255, 255); } bpp-core-2.2.0/src/Bpp/Graphics/Latex/DvipsColorSet.h000664 001750 001750 00000004030 12370705300 023736 0ustar00jdutheiljdutheil000000 000000 // // File: DvipsColorSet.h // Created by: Julien Dutheil // Created on: Mon Apr 14 2008 // /* Copyright or © or Copr. CNRS, (November 17, 2008) This software is a computer program whose purpose is to provide utilitary classes. This file belongs to the Bio++ Project. This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. You can use, modify and/ or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info". As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms. */ #ifndef _DVIPSCOLORSET_H_ #define _DVIPSCOLORSET_H_ #include "../ColorSet.h" namespace bpp { /** * @brief The dvips color definitions. * * Source: dvipsnam.def, from the TeXlive LaTeX distribution. */ class DvipsColorSet: public AbstractColorSet { public: DvipsColorSet(); virtual ~DvipsColorSet() {} }; } // end of namespace bpp; #endif //_MOLSCRIPTCOLORSET_H_ bpp-core-2.2.0/bpp-core.spec000664 001750 001750 00000010707 12406250225 017274 0ustar00jdutheiljdutheil000000 000000 %define _basename bpp-core %define _version 2.2.0 %define _release 1 %define _prefix /usr URL: http://biopp.univ-montp2.fr/ Name: %{_basename} Version: %{_version} Release: %{_release} License: CECILL-2.0 Vendor: The Bio++ Project Source: http://biopp.univ-montp2.fr/repos/sources/%{_basename}-%{_version}.tar.gz Summary: Bio++ Core library Group: Development/Libraries/C and C++ BuildRoot: %{_builddir}/%{_basename}-root BuildRequires: cmake >= 2.6.0 BuildRequires: gcc-c++ >= 4.0.0 AutoReq: yes AutoProv: yes %description This library contains the core classes and utilitary functions of the Bio++ project. %package -n libbpp-core2 Summary: Bio++ Core library Group: Development/Libraries/C and C++ %description -n libbpp-core2 This library contains the core classes and utilitary functions of the Bio++ project. %package -n libbpp-core-devel Summary: Libraries, includes to develop applications with %{_basename} Group: Development/Libraries/C and C++ Requires: libbpp-core2 = %{_version} %description -n libbpp-core-devel The libbpp-core-devel package contains the header files and static libraries for building applications which use %{_basename}. %prep %setup -q %build CFLAGS="$RPM_OPT_FLAGS" CMAKE_FLAGS="-DCMAKE_INSTALL_PREFIX=%{_prefix} -DBUILD_TESTING=OFF" if [ %{_lib} == 'lib64' ] ; then CMAKE_FLAGS="$CMAKE_FLAGS -DLIB_SUFFIX=64" fi cmake $CMAKE_FLAGS . make %install make DESTDIR=$RPM_BUILD_ROOT install %clean rm -rf $RPM_BUILD_ROOT %post -n libbpp-core2 -p /sbin/ldconfig %post -n libbpp-core-devel createGeneric() { echo "-- Creating generic include file: $1.all" #Make sure we run into subdirectories first: dirs=() for file in "$1"/* do if [ -d "$file" ] then # Recursion: dirs+=( "$file" ) fi done for dir in ${dirs[@]} do createGeneric $dir done #Now list all files, including newly created .all files: if [ -f $1.all ] then rm $1.all fi dir=`basename $1` for file in "$1"/* do if [ -f "$file" ] && ( [ "${file##*.}" == "h" ] || [ "${file##*.}" == "all" ] ) then file=`basename $file` echo "#include \"$dir/$file\"" >> $1.all fi done; } # Actualize .all files createGeneric %{_prefix}/include/Bpp exit 0 %preun -n libbpp-core-devel removeGeneric() { if [ -f $1.all ] then echo "-- Remove generic include file: $1.all" rm $1.all fi for file in "$1"/* do if [ -d "$file" ] then # Recursion: removeGeneric $file fi done } # Actualize .all files removeGeneric %{_prefix}/include/Bpp exit 0 %postun -n libbpp-core2 -p /sbin/ldconfig %postun -n libbpp-core-devel createGeneric() { echo "-- Creating generic include file: $1.all" #Make sure we run into subdirectories first: dirs=() for file in "$1"/* do if [ -d "$file" ] then # Recursion: dirs+=( "$file" ) fi done for dir in ${dirs[@]} do createGeneric $dir done #Now list all files, including newly created .all files: if [ -f $1.all ] then rm $1.all fi dir=`basename $1` for file in "$1"/* do if [ -f "$file" ] && ( [ "${file##*.}" == "h" ] || [ "${file##*.}" == "all" ] ) then file=`basename $file` echo "#include \"$dir/$file\"" >> $1.all fi done; } # Actualize .all files createGeneric %{_prefix}/include/Bpp exit 0 %files -n libbpp-core2 %defattr(-,root,root) %doc AUTHORS.txt COPYING.txt INSTALL.txt ChangeLog %{_prefix}/%{_lib}/lib*.so.* %files -n libbpp-core-devel %defattr(-,root,root) %doc AUTHORS.txt COPYING.txt INSTALL.txt ChangeLog %{_prefix}/%{_lib}/lib*.so %{_prefix}/%{_lib}/lib*.a %{_prefix}/include/* %changelog * Wed Sep 17 2014 Julien Dutheil 2.2.0-1 - Reparametrization wrapper debugged - Improved and rationalized display of warning messages - Possibility to set random seed in applications - Code checked for compilation with CLang. * Mon Mar 04 2013 Julien Dutheil 2.1.0-1 - Extended range classes - Improved initialization of static members - Extended support for BppO. * Thu Feb 09 2012 Julien Dutheil 2.0.3-1 - New range classes - Linear assigment method - Improved string tokenizer and text tools. * Thu Jun 09 2011 Julien Dutheil 2.0.2-1 - New MVA classes + more numerical tools. * Mon Feb 28 2011 Julien Dutheil 2.0.1-1 - Fixed missing RColorSet file. * Mon Feb 07 2011 Julien Dutheil 2.0.0-1 - Initial package. bpp-core-2.2.0/INSTALL.txt000664 001750 001750 00000000700 12370705300 016547 0ustar00jdutheiljdutheil000000 000000 This software needs cmake >= 2.6 to build. After installing cmake, run it with the following command: cmake -DCMAKE_INSTALL_PREFIX=[where to install, for instance /usr/local or $HOME/.local] . If available, you can also use ccmake instead of cmake for a more user-friendly interface. Then compile and install the software with make install You may also consider installing and using the software checkinstall for easier system administration. bpp-core-2.2.0/COPYING.txt000664 001750 001750 00000051140 12370705300 016555 0ustar00jdutheiljdutheil000000 000000 CeCILL FREE SOFTWARE LICENSE AGREEMENT Notice This Agreement is a Free Software license agreement that is the result of discussions between its authors in order to ensure compliance with the two main principles guiding its drafting: * firstly, compliance with the principles governing the distribution of Free Software: access to source code, broad rights granted to users, * secondly, the election of a governing law, French law, with which it is conformant, both as regards the law of torts and intellectual property law, and the protection that it offers to both authors and holders of the economic rights over software. The authors of the CeCILL (for Ce[a] C[nrs] I[nria] L[logiciel] L[ibre]) license are: Commissariat à l'Energie Atomique - CEA, a public scientific, technical and industrial establishment, having its principal place of business at 31-33 rue de la Fédération, 75752 Paris cedex 15, France. Centre National de la Recherche Scientifique - CNRS, a public scientific and technological establishment, having its principal place of business at 3 rue Michel-Ange 75794 Paris cedex 16, France. Institut National de Recherche en Informatique et en Automatique - INRIA, a public scientific and technological establishment, having its principal place of business at Domaine de Voluceau, Rocquencourt, BP 105, 78153 Le Chesnay cedex, France. Preamble The purpose of this Free Software license agreement is to grant users the right to modify and redistribute the software governed by this license within the framework of an open source distribution model. The exercising of these rights is conditional upon certain obligations for users so as to preserve this status for all subsequent redistributions. In consideration of access to the source code and the rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors only have limited liability. In this respect, the risks associated with loading, using, modifying and/or developing or reproducing the software by the user are brought to the user's attention, given its Free Software status, which may make it complicated to use, with the result that its use is reserved for developers and experienced professionals having in-depth computer knowledge. Users are therefore encouraged to load and test the Software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions of security. This Agreement may be freely reproduced and published, provided it is not altered, and that no provisions are either added or removed herefrom. This Agreement may apply to any or all software for which the holder of the economic rights decides to submit the use thereof to its provisions. Article 1 - DEFINITIONS For the purpose of this Agreement, when the following expressions commence with a capital letter, they shall have the following meaning: Agreement: means this license agreement, and its possible subsequent versions and annexes. Software: means the software in its Object Code and/or Source Code form and, where applicable, its documentation, "as is" when the Licensee accepts the Agreement. Initial Software: means the Software in its Source Code and possibly its Object Code form and, where applicable, its documentation, "as is" when it is first distributed under the terms and conditions of the Agreement. Modified Software: means the Software modified by at least one Contribution. Source Code: means all the Software's instructions and program lines to which access is required so as to modify the Software. Object Code: means the binary files originating from the compilation of the Source Code. Holder: means the holder(s) of the economic rights over the Initial Software. Licensee: means the Software user(s) having accepted the Agreement. Contributor: means a Licensee having made at least one Contribution. Licensor: means the Holder, or any other individual or legal entity, who distributes the Software under the Agreement. Contribution: means any or all modifications, corrections, translations, adaptations and/or new functions integrated into the Software by any or all Contributors, as well as any or all Internal Modules. Module: means a set of sources files including their documentation that enables supplementary functions or services in addition to those offered by the Software. External Module: means any or all Modules, not derived from the Software, so that this Module and the Software run in separate address spaces, with one calling the other when they are run. Internal Module: means any or all Module, connected to the Software so that they both execute in the same address space. GNU GPL: means the GNU General Public License version 2 or any subsequent version, as published by the Free Software Foundation Inc. Parties: mean both the Licensee and the Licensor. These expressions may be used both in singular and plural form. Article 2 - PURPOSE The purpose of the Agreement is the grant by the Licensor to the Licensee of a non-exclusive, transferable and worldwide license for the Software as set forth in Article 5 hereinafter for the whole term of the protection granted by the rights over said Software. Article 3 - ACCEPTANCE 3.1 The Licensee shall be deemed as having accepted the terms and conditions of this Agreement upon the occurrence of the first of the following events: * (i) loading the Software by any or all means, notably, by downloading from a remote server, or by loading from a physical medium; * (ii) the first time the Licensee exercises any of the rights granted hereunder. 3.2 One copy of the Agreement, containing a notice relating to the characteristics of the Software, to the limited warranty, and to the fact that its use is restricted to experienced users has been provided to the Licensee prior to its acceptance as set forth in Article 3.1 hereinabove, and the Licensee hereby acknowledges that it has read and understood it. Article 4 - EFFECTIVE DATE AND TERM 4.1 EFFECTIVE DATE The Agreement shall become effective on the date when it is accepted by the Licensee as set forth in Article 3.1. 4.2 TERM The Agreement shall remain in force for the entire legal term of protection of the economic rights over the Software. Article 5 - SCOPE OF RIGHTS GRANTED The Licensor hereby grants to the Licensee, who accepts, the following rights over the Software for any or all use, and for the term of the Agreement, on the basis of the terms and conditions set forth hereinafter. Besides, if the Licensor owns or comes to own one or more patents protecting all or part of the functions of the Software or of its components, the Licensor undertakes not to enforce the rights granted by these patents against successive Licensees using, exploiting or modifying the Software. If these patents are transferred, the Licensor undertakes to have the transferees subscribe to the obligations set forth in this paragraph. 5.1 RIGHT OF USE The Licensee is authorized to use the Software, without any limitation as to its fields of application, with it being hereinafter specified that this comprises: 1. permanent or temporary reproduction of all or part of the Software by any or all means and in any or all form. 2. loading, displaying, running, or storing the Software on any or all medium. 3. entitlement to observe, study or test its operation so as to determine the ideas and principles behind any or all constituent elements of said Software. This shall apply when the Licensee carries out any or all loading, displaying, running, transmission or storage operation as regards the Software, that it is entitled to carry out hereunder. 5.2 ENTITLEMENT TO MAKE CONTRIBUTIONS The right to make Contributions includes the right to translate, adapt, arrange, or make any or all modifications to the Software, and the right to reproduce the resulting Software. The Licensee is authorized to make any or all Contributions to the Software provided that it includes an explicit notice that it is the author of said Contribution and indicates the date of the creation thereof. 5.3 RIGHT OF DISTRIBUTION In particular, the right of distribution includes the right to publish, transmit and communicate the Software to the general public on any or all medium, and by any or all means, and the right to market, either in consideration of a fee, or free of charge, one or more copies of the Software by any means. The Licensee is further authorized to distribute copies of the modified or unmodified Software to third parties according to the terms and conditions set forth hereinafter. 5.3.1 DISTRIBUTION OF SOFTWARE WITHOUT MODIFICATION The Licensee is authorized to distribute true copies of the Software in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by: 1. a copy of the Agreement, 2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9, and that, in the event that only the Object Code of the Software is redistributed, the Licensee allows future Licensees unhindered access to the full Source Code of the Software by indicating how to access it, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data. 5.3.2 DISTRIBUTION OF MODIFIED SOFTWARE When the Licensee makes a Contribution to the Software, the terms and conditions for the distribution of the Modified Software become subject to all the provisions of this Agreement. The Licensee is authorized to distribute the Modified Software, in Source Code or Object Code form, provided that said distribution complies with all the provisions of the Agreement and is accompanied by: 1. a copy of the Agreement, 2. a notice relating to the limitation of both the Licensor's warranty and liability as set forth in Articles 8 and 9, and that, in the event that only the Object Code of the Modified Software is redistributed, the Licensee allows future Licensees unhindered access to the full Source Code of the Modified Software by indicating how to access it, it being understood that the additional cost of acquiring the Source Code shall not exceed the cost of transferring the data. 5.3.3 DISTRIBUTION OF EXTERNAL MODULES When the Licensee has developed an External Module, the terms and conditions of this Agreement do not apply to said External Module, that may be distributed under a separate license agreement. 5.3.4 COMPATIBILITY WITH THE GNU GPL The Licensee can include a code that is subject to the provisions of one of the versions of the GNU GPL in the Modified or unmodified Software, and distribute that entire code under the terms of the same version of the GNU GPL. The Licensee can include the Modified or unmodified Software in a code that is subject to the provisions of one of the versions of the GNU GPL, and distribute that entire code under the terms of the same version of the GNU GPL. Article 6 - INTELLECTUAL PROPERTY 6.1 OVER THE INITIAL SOFTWARE The Holder owns the economic rights over the Initial Software. Any or all use of the Initial Software is subject to compliance with the terms and conditions under which the Holder has elected to distribute its work and no one shall be entitled to modify the terms and conditions for the distribution of said Initial Software. The Holder undertakes that the Initial Software will remain ruled at least by the current license, for the duration set forth in article 4.2. 6.2 OVER THE CONTRIBUTIONS A Licensee who develops a Contribution is the owner of the intellectual property rights over this Contribution as defined by applicable law. 6.3 OVER THE EXTERNAL MODULES A Licensee who develops an External Module is the owner of the intellectual property rights over this External Module as defined by applicable law and is free to choose the type of agreement that shall govern its distribution. 6.4 JOINT PROVISIONS The Licensee expressly undertakes: 1. not to remove, or modify, in any manner, the intellectual property notices attached to the Software; 2. to reproduce said notices, in an identical manner, in the copies of the Software modified or not. The Licensee undertakes not to directly or indirectly infringe the intellectual property rights of the Holder and/or Contributors on the Software and to take, where applicable, vis-à-vis its staff, any and all measures required to ensure respect of said intellectual property rights of the Holder and/or Contributors. Article 7 - RELATED SERVICES 7.1 Under no circumstances shall the Agreement oblige the Licensor to provide technical assistance or maintenance services for the Software. However, the Licensor is entitled to offer this type of services. The terms and conditions of such technical assistance, and/or such maintenance, shall be set forth in a separate instrument. Only the Licensor offering said maintenance and/or technical assistance services shall incur liability therefor. 7.2 Similarly, any Licensor is entitled to offer to its licensees, under its sole responsibility, a warranty, that shall only be binding upon itself, for the redistribution of the Software and/or the Modified Software, under terms and conditions that it is free to decide. Said warranty, and the financial terms and conditions of its application, shall be subject of a separate instrument executed between the Licensor and the Licensee. Article 8 - LIABILITY 8.1 Subject to the provisions of Article 8.2, the Licensee shall be entitled to claim compensation for any direct loss it may have suffered from the Software as a result of a fault on the part of the relevant Licensor, subject to providing evidence thereof. 8.2 The Licensor's liability is limited to the commitments made under this Agreement and shall not be incurred as a result of in particular: (i) loss due the Licensee's total or partial failure to fulfill its obligations, (ii) direct or consequential loss that is suffered by the Licensee due to the use or performance of the Software, and (iii) more generally, any consequential loss. In particular the Parties expressly agree that any or all pecuniary or business loss (i.e. loss of data, loss of profits, operating loss, loss of customers or orders, opportunity cost, any disturbance to business activities) or any or all legal proceedings instituted against the Licensee by a third party, shall constitute consequential loss and shall not provide entitlement to any or all compensation from the Licensor. Article 9 - WARRANTY 9.1 The Licensee acknowledges that the scientific and technical state-of-the-art when the Software was distributed did not enable all possible uses to be tested and verified, nor for the presence of possible defects to be detected. In this respect, the Licensee's attention has been drawn to the risks associated with loading, using, modifying and/or developing and reproducing the Software which are reserved for experienced users. The Licensee shall be responsible for verifying, by any or all means, the product's suitability for its requirements, its good working order, and for ensuring that it shall not cause damage to either persons or properties. 9.2 The Licensor hereby represents, in good faith, that it is entitled to grant all the rights over the Software (including in particular the rights set forth in Article 5). 9.3 The Licensee acknowledges that the Software is supplied "as is" by the Licensor without any other express or tacit warranty, other than that provided for in Article 9.2 and, in particular, without any warranty as to its commercial value, its secured, safe, innovative or relevant nature. Specifically, the Licensor does not warrant that the Software is free from any error, that it will operate without interruption, that it will be compatible with the Licensee's own equipment and software configuration, nor that it will meet the Licensee's requirements. 9.4 The Licensor does not either expressly or tacitly warrant that the Software does not infringe any third party intellectual property right relating to a patent, software or any other property right. Therefore, the Licensor disclaims any and all liability towards the Licensee arising out of any or all proceedings for infringement that may be instituted in respect of the use, modification and redistribution of the Software. Nevertheless, should such proceedings be instituted against the Licensee, the Licensor shall provide it with technical and legal assistance for its defense. Such technical and legal assistance shall be decided on a case-by-case basis between the relevant Licensor and the Licensee pursuant to a memorandum of understanding. The Licensor disclaims any and all liability as regards the Licensee's use of the name of the Software. No warranty is given as regards the existence of prior rights over the name of the Software or as regards the existence of a trademark. Article 10 - TERMINATION 10.1 In the event of a breach by the Licensee of its obligations hereunder, the Licensor may automatically terminate this Agreement thirty (30) days after notice has been sent to the Licensee and has remained ineffective. 10.2 A Licensee whose Agreement is terminated shall no longer be authorized to use, modify or distribute the Software. However, any licenses that it may have granted prior to termination of the Agreement shall remain valid subject to their having been granted in compliance with the terms and conditions hereof. Article 11 - MISCELLANEOUS 11.1 EXCUSABLE EVENTS Neither Party shall be liable for any or all delay, or failure to perform the Agreement, that may be attributable to an event of force majeure, an act of God or an outside cause, such as defective functioning or interruptions of the electricity or telecommunications networks, network paralysis following a virus attack, intervention by government authorities, natural disasters, water damage, earthquakes, fire, explosions, strikes and labor unrest, war, etc. 11.2 Any Failure by either Party, on one or more occasions, to invoke one or more of the provisions hereof, shall under no circumstances be interpreted as being a waiver by the interested Party of its right to invoke said provision(s) subsequently. 11.3 The Agreement cancels and replaces any or all previous agreements, whether written or oral, between the Parties and having the same purpose, and constitutes the entirety of the agreement between said Parties concerning said purpose. No supplement or modification to the terms and conditions hereof shall be effective as between the Parties unless it is made in writing and signed by their duly authorized representatives. 11.4 In the event that one or more of the provisions hereof were to conflict with a current or future applicable act or legislative text, said act or legislative text shall prevail, and the Parties shall make the necessary amendments so as to comply with said act or legislative text. All other provisions shall remain effective. Similarly, invalidity of a provision of the Agreement, for any reason whatsoever, shall not cause the Agreement as a whole to be invalid. 11.5 LANGUAGE The Agreement is drafted in both French and English and both versions are deemed authentic. Article 12 - NEW VERSIONS OF THE AGREEMENT 12.1 Any person is authorized to duplicate and distribute copies of this Agreement. 12.2 So as to ensure coherence, the wording of this Agreement is protected and may only be modified by the authors of the License, who reserve the right to periodically publish updates or new versions of the Agreement, each with a separate number. These subsequent versions may address new issues encountered by Free Software. 12.3 Any Software distributed under a given version of the Agreement may only be subsequently distributed under the same version of the Agreement or a subsequent version, subject to the provisions of Article 5.3.4. Article 13 - GOVERNING LAW AND JURISDICTION 13.1 The Agreement is governed by French law. The Parties agree to endeavor to seek an amicable solution to any disagreements or disputes that may arise during the performance of the Agreement. 13.2 Failing an amicable solution within two (2) months as from their occurrence, and unless emergency proceedings are necessary, the disagreements or disputes shall be referred to the Paris Courts having jurisdiction, by the more diligent Party. Version 2.0 dated 2005-05-21. bpp-core-2.2.0/Doxyfile000664 001750 001750 00000304002 12370705300 016410 0ustar00jdutheiljdutheil000000 000000 # Doxyfile 1.8.6 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project. # # All text after a double hash (##) is considered a comment and is placed in # front of the TAG it is preceding. # # All text after a single hash (#) is considered a comment and will be ignored. # The format is: # TAG = value [value, ...] # For lists, items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (\" \"). #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- # This tag specifies the encoding used for all characters in the config file # that follow. The default is UTF-8 which is also the encoding used for all text # before the first occurrence of this tag. Doxygen uses libiconv (or the iconv # built into libc) for the transcoding. See http://www.gnu.org/software/libiconv # for the list of possible encodings. # The default value is: UTF-8. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded by # double-quotes, unless you are using Doxywizard) that should identify the # project for which the documentation is generated. This name is used in the # title of most generated pages and in a few other places. # The default value is: My Project. PROJECT_NAME = bpp-core # The PROJECT_NUMBER tag can be used to enter a project or revision number. This # could be handy for archiving the generated documentation or if some version # control system is used. PROJECT_NUMBER = 2.2.0 # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a # quick idea about the purpose of the project. Keep the description short. PROJECT_BRIEF = # With the PROJECT_LOGO tag one can specify an logo or icon that is included in # the documentation. The maximum height of the logo should not exceed 55 pixels # and the maximum width should not exceed 200 pixels. Doxygen will copy the logo # to the output directory. PROJECT_LOGO = # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path # into which the generated documentation will be written. If a relative path is # entered, it will be relative to the location where doxygen was started. If # left blank the current directory will be used. OUTPUT_DIRECTORY = # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub- # directories (in 2 levels) under the output directory of each output format and # will distribute the generated files over these directories. Enabling this # option can be useful when feeding doxygen a huge amount of source files, where # putting all generated files in the same directory would otherwise causes # performance problems for the file system. # The default value is: NO. CREATE_SUBDIRS = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, # Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), # Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, # Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), # Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, # Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, # Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, # Ukrainian and Vietnamese. # The default value is: English. OUTPUT_LANGUAGE = English # If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member # descriptions after the members that are listed in the file and class # documentation (similar to Javadoc). Set to NO to disable this. # The default value is: YES. BRIEF_MEMBER_DESC = YES # If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief # description of a member or function before the detailed description # # Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. # The default value is: YES. REPEAT_BRIEF = YES # This tag implements a quasi-intelligent brief description abbreviator that is # used to form the text in various listings. Each string in this list, if found # as the leading text of the brief description, will be stripped from the text # and the result, after processing the whole list, is used as the annotated # text. Otherwise, the brief description is used as-is. If left blank, the # following values are used ($name is automatically replaced with the name of # the entity):The $name class, The $name widget, The $name file, is, provides, # specifies, contains, represents, a, an and the. ABBREVIATE_BRIEF = # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # doxygen will generate a detailed section even if there is only a brief # description. # The default value is: NO. ALWAYS_DETAILED_SEC = NO # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. # The default value is: NO. INLINE_INHERITED_MEMB = YES # If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path # before files name in the file list and in the header files. If set to NO the # shortest path that makes the file name unique will be used # The default value is: YES. FULL_PATH_NAMES = YES # The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. # Stripping is only done if one of the specified strings matches the left-hand # part of the path. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the path to # strip. # # Note that you can specify absolute paths here, but also relative paths, which # will be relative from the directory where doxygen is started. # This tag requires that the tag FULL_PATH_NAMES is set to YES. STRIP_FROM_PATH = ./src/ # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the # path mentioned in the documentation of a class, which tells the reader which # header file to include in order to use a class. If left blank only the name of # the header file containing the class definition is used. Otherwise one should # specify the list of include paths that are normally passed to the compiler # using the -I flag. STRIP_FROM_INC_PATH = ./src/ # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but # less readable) file names. This can be useful is your file systems doesn't # support long names like on DOS, Mac, or CD-ROM. # The default value is: NO. SHORT_NAMES = NO # If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the # first line (until the first dot) of a Javadoc-style comment as the brief # description. If set to NO, the Javadoc-style will behave just like regular Qt- # style comments (thus requiring an explicit @brief command for a brief # description.) # The default value is: NO. JAVADOC_AUTOBRIEF = NO # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first # line (until the first dot) of a Qt-style comment as the brief description. If # set to NO, the Qt-style will behave just like regular Qt-style comments (thus # requiring an explicit \brief command for a brief description.) # The default value is: NO. QT_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a # multi-line C++ special comment block (i.e. a block of //! or /// comments) as # a brief description. This used to be the default behavior. The new default is # to treat a multi-line C++ comment block as a detailed description. Set this # tag to YES if you prefer the old behavior instead. # # Note that setting this tag to YES also means that rational rose comments are # not recognized any more. # The default value is: NO. MULTILINE_CPP_IS_BRIEF = NO # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the # documentation from any documented member that it re-implements. # The default value is: YES. INHERIT_DOCS = YES # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a # new page for each member. If set to NO, the documentation of a member will be # part of the file/class/namespace that contains it. # The default value is: NO. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen # uses this value to replace tabs by spaces in code fragments. # Minimum value: 1, maximum value: 16, default value: 4. TAB_SIZE = 2 # This tag can be used to specify a number of aliases that act as commands in # the documentation. An alias has the form: # name=value # For example adding # "sideeffect=@par Side Effects:\n" # will allow you to put the command \sideeffect (or @sideeffect) in the # documentation, which will result in a user-defined paragraph with heading # "Side Effects:". You can put \n's in the value part of an alias to insert # newlines. ALIASES = # This tag can be used to specify a number of word-keyword mappings (TCL only). # A mapping has the form "name=value". For example adding "class=itcl::class" # will allow you to use the command class in the itcl::class meaning. TCL_SUBST = # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources # only. Doxygen will then generate output that is more tailored for C. For # instance, some of the names that are used will be different. The list of all # members will be omitted, etc. # The default value is: NO. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or # Python sources only. Doxygen will then generate output that is more tailored # for that language. For instance, namespaces will be presented as packages, # qualified scopes will look different, etc. # The default value is: NO. OPTIMIZE_OUTPUT_JAVA = NO # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran # sources. Doxygen will then generate output that is tailored for Fortran. # The default value is: NO. OPTIMIZE_FOR_FORTRAN = NO # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL # sources. Doxygen will then generate output that is tailored for VHDL. # The default value is: NO. OPTIMIZE_OUTPUT_VHDL = NO # Doxygen selects the parser to use depending on the extension of the files it # parses. With this tag you can assign which parser to use for a given # extension. Doxygen has a built-in mapping, but you can override or extend it # using this tag. The format is ext=language, where ext is a file extension, and # language is one of the parsers supported by doxygen: IDL, Java, Javascript, # C#, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL. For instance to make # doxygen treat .inc files as Fortran files (default is PHP), and .f files as C # (default is Fortran), use: inc=Fortran f=C. # # Note For files without extension you can use no_extension as a placeholder. # # Note that for custom extensions you also need to set FILE_PATTERNS otherwise # the files are not read by doxygen. EXTENSION_MAPPING = # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments # according to the Markdown format, which allows for more readable # documentation. See http://daringfireball.net/projects/markdown/ for details. # The output of markdown processing is further processed by doxygen, so you can # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in # case of backward compatibilities issues. # The default value is: YES. MARKDOWN_SUPPORT = YES # When enabled doxygen tries to link words that correspond to documented # classes, or namespaces to their corresponding documentation. Such a link can # be prevented in individual cases by by putting a % sign in front of the word # or globally by setting AUTOLINK_SUPPORT to NO. # The default value is: YES. AUTOLINK_SUPPORT = YES # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want # to include (a tag file for) the STL sources as input, then you should set this # tag to YES in order to let doxygen match functions declarations and # definitions whose arguments contain STL classes (e.g. func(std::string); # versus func(std::string) {}). This also make the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. # The default value is: NO. BUILTIN_STL_SUPPORT = YES # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. # The default value is: NO. CPP_CLI_SUPPORT = NO # Set the SIP_SUPPORT tag to YES if your project consists of sip (see: # http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen # will parse them like normal C++ but will assume all classes use public instead # of private inheritance when no explicit protection keyword is present. # The default value is: NO. SIP_SUPPORT = NO # For Microsoft's IDL there are propget and propput attributes to indicate # getter and setter methods for a property. Setting this option to YES will make # doxygen to replace the get and set methods by a property in the documentation. # This will only work if the methods are indeed getting or setting a simple # type. If this is not the case, or you want to show the methods anyway, you # should set this option to NO. # The default value is: YES. IDL_PROPERTY_SUPPORT = YES # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC # tag is set to YES, then doxygen will reuse the documentation of the first # member in the group (if any) for the other members of the group. By default # all members of a group must be documented explicitly. # The default value is: NO. DISTRIBUTE_GROUP_DOC = NO # Set the SUBGROUPING tag to YES to allow class member groups of the same type # (for instance a group of public functions) to be put as a subgroup of that # type (e.g. under the Public Functions section). Set it to NO to prevent # subgrouping. Alternatively, this can be done per class using the # \nosubgrouping command. # The default value is: YES. SUBGROUPING = YES # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions # are shown inside the group in which they are included (e.g. using \ingroup) # instead of on a separate page (for HTML and Man pages) or section (for LaTeX # and RTF). # # Note that this feature does not work in combination with # SEPARATE_MEMBER_PAGES. # The default value is: NO. INLINE_GROUPED_CLASSES = NO # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions # with only public data fields or simple typedef fields will be shown inline in # the documentation of the scope in which they are defined (i.e. file, # namespace, or group documentation), provided this scope is documented. If set # to NO, structs, classes, and unions are shown on a separate page (for HTML and # Man pages) or section (for LaTeX and RTF). # The default value is: NO. INLINE_SIMPLE_STRUCTS = NO # When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or # enum is documented as struct, union, or enum with the name of the typedef. So # typedef struct TypeS {} TypeT, will appear in the documentation as a struct # with name TypeT. When disabled the typedef will appear as a member of a file, # namespace, or class. And the struct will be named TypeS. This can typically be # useful for C code in case the coding convention dictates that all compound # types are typedef'ed and only the typedef is referenced, never the tag name. # The default value is: NO. TYPEDEF_HIDES_STRUCT = NO # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This # cache is used to resolve symbols given their name and scope. Since this can be # an expensive process and often the same symbol appears multiple times in the # code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small # doxygen will become slower. If the cache is too large, memory is wasted. The # cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range # is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 # symbols. At the end of a run doxygen will report the cache usage and suggest # the optimal cache size from a speed point of view. # Minimum value: 0, maximum value: 9, default value: 0. LOOKUP_CACHE_SIZE = 0 #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in # documentation are documented, even if no documentation was available. Private # class members and static file members will be hidden unless the # EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. # Note: This will also disable the warnings about undocumented members that are # normally produced when WARNINGS is set to YES. # The default value is: NO. EXTRACT_ALL = YES # If the EXTRACT_PRIVATE tag is set to YES all private members of a class will # be included in the documentation. # The default value is: NO. EXTRACT_PRIVATE = YES # If the EXTRACT_PACKAGE tag is set to YES all members with package or internal # scope will be included in the documentation. # The default value is: NO. EXTRACT_PACKAGE = NO # If the EXTRACT_STATIC tag is set to YES all static members of a file will be # included in the documentation. # The default value is: NO. EXTRACT_STATIC = YES # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined # locally in source files will be included in the documentation. If set to NO # only classes defined in header files are included. Does not have any effect # for Java sources. # The default value is: YES. EXTRACT_LOCAL_CLASSES = YES # This flag is only useful for Objective-C code. When set to YES local methods, # which are defined in the implementation section but not in the interface are # included in the documentation. If set to NO only methods in the interface are # included. # The default value is: NO. EXTRACT_LOCAL_METHODS = NO # If this flag is set to YES, the members of anonymous namespaces will be # extracted and appear in the documentation as a namespace called # 'anonymous_namespace{file}', where file will be replaced with the base name of # the file that contains the anonymous namespace. By default anonymous namespace # are hidden. # The default value is: NO. EXTRACT_ANON_NSPACES = NO # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all # undocumented members inside documented classes or files. If set to NO these # members will be included in the various overviews, but no documentation # section is generated. This option has no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_MEMBERS = NO # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all # undocumented classes that are normally visible in the class hierarchy. If set # to NO these classes will be included in the various overviews. This option has # no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_CLASSES = NO # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend # (class|struct|union) declarations. If set to NO these declarations will be # included in the documentation. # The default value is: NO. HIDE_FRIEND_COMPOUNDS = NO # If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any # documentation blocks found inside the body of a function. If set to NO these # blocks will be appended to the function's detailed documentation block. # The default value is: NO. HIDE_IN_BODY_DOCS = NO # The INTERNAL_DOCS tag determines if documentation that is typed after a # \internal command is included. If the tag is set to NO then the documentation # will be excluded. Set it to YES to include the internal documentation. # The default value is: NO. INTERNAL_DOCS = NO # If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file # names in lower-case letters. If set to YES upper-case letters are also # allowed. This is useful if you have classes or files whose names only differ # in case and if your file system supports case sensitive file names. Windows # and Mac users are advised to set this option to NO. # The default value is: system dependent. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with # their full class and namespace scopes in the documentation. If set to YES the # scope will be hidden. # The default value is: NO. HIDE_SCOPE_NAMES = NO # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of # the files that are included by a file in the documentation of that file. # The default value is: YES. SHOW_INCLUDE_FILES = YES # If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each # grouped member an include statement to the documentation, telling the reader # which file to include in order to use the member. # The default value is: NO. SHOW_GROUPED_MEMB_INC = NO # If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include # files with double quotes in the documentation rather than with sharp brackets. # The default value is: NO. FORCE_LOCAL_INCLUDES = NO # If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the # documentation for inline members. # The default value is: YES. INLINE_INFO = YES # If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the # (detailed) documentation of file and class members alphabetically by member # name. If set to NO the members will appear in declaration order. # The default value is: YES. SORT_MEMBER_DOCS = YES # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief # descriptions of file, namespace and class members alphabetically by member # name. If set to NO the members will appear in declaration order. Note that # this will also influence the order of the classes in the class list. # The default value is: NO. SORT_BRIEF_DOCS = NO # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the # (brief and detailed) documentation of class members so that constructors and # destructors are listed first. If set to NO the constructors will appear in the # respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. # Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief # member documentation. # Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting # detailed member documentation. # The default value is: NO. SORT_MEMBERS_CTORS_1ST = NO # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy # of group names into alphabetical order. If set to NO the group names will # appear in their defined order. # The default value is: NO. SORT_GROUP_NAMES = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by # fully-qualified names, including namespaces. If set to NO, the class list will # be sorted only by class name, not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the alphabetical # list. # The default value is: NO. SORT_BY_SCOPE_NAME = NO # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper # type resolution of all parameters of a function it will reject a match between # the prototype and the implementation of a member function even if there is # only one candidate or it is obvious which candidate to choose by doing a # simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still # accept a match between prototype and implementation in such cases. # The default value is: NO. STRICT_PROTO_MATCHING = NO # The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the # todo list. This list is created by putting \todo commands in the # documentation. # The default value is: YES. GENERATE_TODOLIST = YES # The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the # test list. This list is created by putting \test commands in the # documentation. # The default value is: YES. GENERATE_TESTLIST = NO # The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug # list. This list is created by putting \bug commands in the documentation. # The default value is: YES. GENERATE_BUGLIST = NO # The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO) # the deprecated list. This list is created by putting \deprecated commands in # the documentation. # The default value is: YES. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional documentation # sections, marked by \if ... \endif and \cond # ... \endcond blocks. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the # initial value of a variable or macro / define can have for it to appear in the # documentation. If the initializer consists of more lines than specified here # it will be hidden. Use a value of 0 to hide initializers completely. The # appearance of the value of individual variables and macros / defines can be # controlled using \showinitializer or \hideinitializer command in the # documentation regardless of this setting. # Minimum value: 0, maximum value: 10000, default value: 30. MAX_INITIALIZER_LINES = 30 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated at # the bottom of the documentation of classes and structs. If set to YES the list # will mention the files that were used to generate the documentation. # The default value is: YES. SHOW_USED_FILES = YES # Set the SHOW_FILES tag to NO to disable the generation of the Files page. This # will remove the Files entry from the Quick Index and from the Folder Tree View # (if specified). # The default value is: YES. SHOW_FILES = YES # Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces # page. This will remove the Namespaces entry from the Quick Index and from the # Folder Tree View (if specified). # The default value is: YES. SHOW_NAMESPACES = YES # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from # the version control system). Doxygen will invoke the program by executing (via # popen()) the command command input-file, where command is the value of the # FILE_VERSION_FILTER tag, and input-file is the name of an input file provided # by doxygen. Whatever the program writes to standard output is used as the file # version. For an example see the documentation. FILE_VERSION_FILTER = # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed # by doxygen. The layout file controls the global structure of the generated # output files in an output format independent way. To create the layout file # that represents doxygen's defaults, run doxygen with the -l option. You can # optionally specify a file name after the option, if omitted DoxygenLayout.xml # will be used as the name of the layout file. # # Note that if you run doxygen from a directory containing a file called # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE # tag is left empty. LAYOUT_FILE = # The CITE_BIB_FILES tag can be used to specify one or more bib files containing # the reference definitions. This must be a list of .bib files. The .bib # extension is automatically appended if omitted. This requires the bibtex tool # to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info. # For LaTeX the style of the bibliography can be controlled using # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the # search path. Do not use file names with spaces, bibtex cannot handle them. See # also \cite for info how to create references. CITE_BIB_FILES = #--------------------------------------------------------------------------- # Configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated to # standard output by doxygen. If QUIET is set to YES this implies that the # messages are off. # The default value is: NO. QUIET = NO # The WARNINGS tag can be used to turn on/off the warning messages that are # generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES # this implies that the warnings are on. # # Tip: Turn warnings on while writing the documentation. # The default value is: YES. WARNINGS = YES # If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate # warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag # will automatically be disabled. # The default value is: YES. WARN_IF_UNDOCUMENTED = YES # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for # potential errors in the documentation, such as not documenting some parameters # in a documented function, or documenting parameters that don't exist or using # markup commands wrongly. # The default value is: YES. WARN_IF_DOC_ERROR = YES # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that # are documented, but have no documentation for their parameters or return # value. If set to NO doxygen will only warn about wrong or incomplete parameter # documentation, but not about the absence of documentation. # The default value is: NO. WARN_NO_PARAMDOC = NO # The WARN_FORMAT tag determines the format of the warning messages that doxygen # can produce. The string should contain the $file, $line, and $text tags, which # will be replaced by the file and line number from which the warning originated # and the warning text. Optionally the format may contain $version, which will # be replaced by the version of the file (if it could be obtained via # FILE_VERSION_FILTER) # The default value is: $file:$line: $text. WARN_FORMAT = "$file:$line: $text" # The WARN_LOGFILE tag can be used to specify a file to which warning and error # messages should be written. If left blank the output is written to standard # error (stderr). WARN_LOGFILE = #--------------------------------------------------------------------------- # Configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag is used to specify the files and/or directories that contain # documented source files. You may enter file names like myfile.cpp or # directories like /usr/src/myproject. Separate the files or directories with # spaces. # Note: If this tag is empty the current directory is searched. INPUT = src # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses # libiconv (or the iconv built into libc) for the transcoding. See the libiconv # documentation (see: http://www.gnu.org/software/libiconv) for the list of # possible encodings. # The default value is: UTF-8. INPUT_ENCODING = UTF-8 # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and # *.h) to filter out the source-files in the directories. If left blank the # following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii, # *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, # *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, # *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, # *.qsf, *.as and *.js. FILE_PATTERNS = *.h \ *.cpp # The RECURSIVE tag can be used to specify whether or not subdirectories should # be searched for input files as well. # The default value is: NO. RECURSIVE = YES # The EXCLUDE tag can be used to specify files and/or directories that should be # excluded from the INPUT source files. This way you can easily exclude a # subdirectory from a directory tree whose root is specified with the INPUT tag. # # Note that relative paths are relative to the directory from which doxygen is # run. EXCLUDE = # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or # directories that are symbolic links (a Unix file system feature) are excluded # from the input. # The default value is: NO. EXCLUDE_SYMLINKS = NO # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories for example use the pattern */test/* EXCLUDE_PATTERNS = # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the # output. The symbol name can be a fully qualified name, a word, or if the # wildcard * is used, a substring. Examples: ANamespace, AClass, # AClass::ANamespace, ANamespace::*Test # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories use the pattern */test/* EXCLUDE_SYMBOLS = # The EXAMPLE_PATH tag can be used to specify one or more files or directories # that contain example code fragments that are included (see the \include # command). EXAMPLE_PATH = # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and # *.h) to filter out the source-files in the directories. If left blank all # files are included. EXAMPLE_PATTERNS = # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be # searched for input files to be used with the \include or \dontinclude commands # irrespective of the value of the RECURSIVE tag. # The default value is: NO. EXAMPLE_RECURSIVE = NO # The IMAGE_PATH tag can be used to specify one or more files or directories # that contain images that are to be included in the documentation (see the # \image command). IMAGE_PATH = # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command: # # # # where is the value of the INPUT_FILTER tag, and is the # name of an input file. Doxygen will then use the output that the filter # program writes to standard output. If FILTER_PATTERNS is specified, this tag # will be ignored. # # Note that the filter must not add or remove lines; it is applied before the # code is scanned, but not when the output code is generated. If lines are added # or removed, the anchors will not be placed correctly. INPUT_FILTER = # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. Doxygen will compare the file name with each pattern and apply the # filter if there is a match. The filters are a list of the form: pattern=filter # (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how # filters are used. If the FILTER_PATTERNS tag is empty or if none of the # patterns match the file name, INPUT_FILTER is applied. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER ) will also be used to filter the input files that are used for # producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). # The default value is: NO. FILTER_SOURCE_FILES = NO # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file # pattern. A pattern will override the setting for FILTER_PATTERN (if any) and # it is also possible to disable source filtering for a specific pattern using # *.ext= (so without naming a filter). # This tag requires that the tag FILTER_SOURCE_FILES is set to YES. FILTER_SOURCE_PATTERNS = # If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that # is part of the input, its contents will be placed on the main page # (index.html). This can be useful if you have a project on for instance GitHub # and want to reuse the introduction page also for the doxygen output. USE_MDFILE_AS_MAINPAGE = #--------------------------------------------------------------------------- # Configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will be # generated. Documented entities will be cross-referenced with these sources. # # Note: To get rid of all source code in the generated output, make sure that # also VERBATIM_HEADERS is set to NO. # The default value is: NO. SOURCE_BROWSER = YES # Setting the INLINE_SOURCES tag to YES will include the body of functions, # classes and enums directly into the documentation. # The default value is: NO. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any # special comment blocks from generated source code fragments. Normal C, C++ and # Fortran comments will always remain visible. # The default value is: YES. STRIP_CODE_COMMENTS = YES # If the REFERENCED_BY_RELATION tag is set to YES then for each documented # function all documented functions referencing it will be listed. # The default value is: NO. REFERENCED_BY_RELATION = YES # If the REFERENCES_RELATION tag is set to YES then for each documented function # all documented entities called/used by that function will be listed. # The default value is: NO. REFERENCES_RELATION = YES # If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set # to YES, then the hyperlinks from functions in REFERENCES_RELATION and # REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will # link to the documentation. # The default value is: YES. REFERENCES_LINK_SOURCE = YES # If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the # source code will show a tooltip with additional information such as prototype, # brief description and links to the definition and documentation. Since this # will make the HTML file larger and loading of large files a bit slower, you # can opt to disable this feature. # The default value is: YES. # This tag requires that the tag SOURCE_BROWSER is set to YES. SOURCE_TOOLTIPS = YES # If the USE_HTAGS tag is set to YES then the references to source code will # point to the HTML generated by the htags(1) tool instead of doxygen built-in # source browser. The htags tool is part of GNU's global source tagging system # (see http://www.gnu.org/software/global/global.html). You will need version # 4.8.6 or higher. # # To use it do the following: # - Install the latest version of global # - Enable SOURCE_BROWSER and USE_HTAGS in the config file # - Make sure the INPUT points to the root of the source tree # - Run doxygen as normal # # Doxygen will invoke htags (and that will in turn invoke gtags), so these # tools must be available from the command line (i.e. in the search path). # # The result: instead of the source browser generated by doxygen, the links to # source code will now point to the output of htags. # The default value is: NO. # This tag requires that the tag SOURCE_BROWSER is set to YES. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a # verbatim copy of the header file for each class for which an include is # specified. Set to NO to disable this. # See also: Section \class. # The default value is: YES. VERBATIM_HEADERS = YES #--------------------------------------------------------------------------- # Configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all # compounds will be generated. Enable this if the project contains a lot of # classes, structs, unions or interfaces. # The default value is: YES. ALPHABETICAL_INDEX = NO # The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in # which the alphabetical index list will be split. # Minimum value: 1, maximum value: 20, default value: 5. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. COLS_IN_ALPHA_INDEX = 5 # In case all classes in a project start with a common prefix, all classes will # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag # can be used to specify a prefix (or a list of prefixes) that should be ignored # while generating the index headers. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. IGNORE_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES doxygen will generate HTML output # The default value is: YES. GENERATE_HTML = YES # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of # it. # The default directory is: html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_OUTPUT = html # The HTML_FILE_EXTENSION tag can be used to specify the file extension for each # generated HTML page (for example: .htm, .php, .asp). # The default value is: .html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a user-defined HTML header file for # each generated HTML page. If the tag is left blank doxygen will generate a # standard header. # # To get valid HTML the header file that includes any scripts and style sheets # that doxygen needs, which is dependent on the configuration options used (e.g. # the setting GENERATE_TREEVIEW). It is highly recommended to start with a # default header using # doxygen -w html new_header.html new_footer.html new_stylesheet.css # YourConfigFile # and then modify the file new_header.html. See also section "Doxygen usage" # for information on how to generate the default header that doxygen normally # uses. # Note: The header is subject to change so you typically have to regenerate the # default header when upgrading to a newer version of doxygen. For a description # of the possible markers and block names see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_HEADER = # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each # generated HTML page. If the tag is left blank doxygen will generate a standard # footer. See HTML_HEADER for more information on how to generate a default # footer and what special commands can be used inside the footer. See also # section "Doxygen usage" for information on how to generate the default footer # that doxygen normally uses. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FOOTER = # The HTML_STYLESHEET tag can be used to specify a user-defined cascading style # sheet that is used by each HTML page. It can be used to fine-tune the look of # the HTML output. If left blank doxygen will generate a default style sheet. # See also section "Doxygen usage" for information on how to generate the style # sheet that doxygen normally uses. # Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as # it is more robust and this tag (HTML_STYLESHEET) will in the future become # obsolete. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_STYLESHEET = # The HTML_EXTRA_STYLESHEET tag can be used to specify an additional user- # defined cascading style sheet that is included after the standard style sheets # created by doxygen. Using this option one can overrule certain style aspects. # This is preferred over using HTML_STYLESHEET since it does not replace the # standard style sheet and is therefor more robust against future updates. # Doxygen will copy the style sheet file to the output directory. For an example # see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_STYLESHEET = # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or # other source files which should be copied to the HTML output directory. Note # that these files will be copied to the base HTML output directory. Use the # $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these # files. In the HTML_STYLESHEET file, use the file name only. Also note that the # files will be copied as-is; there are no commands or markers available. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_FILES = # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen # will adjust the colors in the stylesheet and background images according to # this color. Hue is specified as an angle on a colorwheel, see # http://en.wikipedia.org/wiki/Hue for more information. For instance the value # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 # purple, and 360 is red again. # Minimum value: 0, maximum value: 359, default value: 220. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_HUE = 220 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors # in the HTML output. For a value of 0 the output will use grayscales only. A # value of 255 will produce the most vivid colors. # Minimum value: 0, maximum value: 255, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_SAT = 100 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the # luminance component of the colors in the HTML output. Values below 100 # gradually make the output lighter, whereas values above 100 make the output # darker. The value divided by 100 is the actual gamma applied, so 80 represents # a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not # change the gamma. # Minimum value: 40, maximum value: 240, default value: 80. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_GAMMA = 80 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML # page will contain the date and time when the page was generated. Setting this # to NO can help when comparing the output of multiple runs. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_TIMESTAMP = YES # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML # documentation will contain sections that can be hidden and shown after the # page has loaded. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_DYNAMIC_SECTIONS = YES # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries # shown in the various tree structured indices initially; the user can expand # and collapse entries dynamically later on. Doxygen will expand the tree to # such a level that at most the specified number of entries are visible (unless # a fully collapsed tree already exceeds this amount). So setting the number of # entries 1 will produce a full collapsed tree by default. 0 is a special value # representing an infinite number of entries and will result in a full expanded # tree by default. # Minimum value: 0, maximum value: 9999, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_INDEX_NUM_ENTRIES = 100 # If the GENERATE_DOCSET tag is set to YES, additional index files will be # generated that can be used as input for Apple's Xcode 3 integrated development # environment (see: http://developer.apple.com/tools/xcode/), introduced with # OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a # Makefile in the HTML output directory. Running make will produce the docset in # that directory and running make install will install the docset in # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at # startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html # for more information. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_DOCSET = YES # This tag determines the name of the docset feed. A documentation feed provides # an umbrella under which multiple documentation sets from a single provider # (such as a company or product suite) can be grouped. # The default value is: Doxygen generated docs. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_FEEDNAME = "Bio++ Core Library" # This tag specifies a string that should uniquely identify the documentation # set bundle. This should be a reverse domain-name style string, e.g. # com.mycompany.MyDocSet. Doxygen will append .docset to the name. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_BUNDLE_ID = bpp.core # The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify # the documentation publisher. This should be a reverse domain-name style # string, e.g. com.mycompany.MyDocSet.documentation. # The default value is: org.doxygen.Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_ID = org.doxygen.Publisher # The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. # The default value is: Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_NAME = Publisher # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three # additional HTML index files: index.hhp, index.hhc, and index.hhk. The # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop # (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on # Windows. # # The HTML Help Workshop contains a compiler that can convert all HTML output # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML # files are now used as the Windows 98 help format, and will replace the old # Windows help format (.hlp) on all Windows platforms in the future. Compressed # HTML files also contain an index, a table of contents, and you can search for # words in the documentation. The HTML workshop also contains a viewer for # compressed HTML files. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_HTMLHELP = NO # The CHM_FILE tag can be used to specify the file name of the resulting .chm # file. You can add a path in front of the file if the result should not be # written to the html output directory. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_FILE = # The HHC_LOCATION tag can be used to specify the location (absolute path # including file name) of the HTML help compiler ( hhc.exe). If non-empty # doxygen will try to run the HTML help compiler on the generated index.hhp. # The file has to be specified with full path. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. HHC_LOCATION = # The GENERATE_CHI flag controls if a separate .chi index file is generated ( # YES) or that it should be included in the master .chm file ( NO). # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. GENERATE_CHI = NO # The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc) # and project file content. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_INDEX_ENCODING = # The BINARY_TOC flag controls whether a binary table of contents is generated ( # YES) or a normal table of contents ( NO) in the .chm file. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members to # the table of contents of the HTML help documentation and to the tree view. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. TOC_EXPAND = NO # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that # can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help # (.qch) of the generated HTML documentation. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_QHP = NO # If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify # the file name of the resulting .qch file. The path specified is relative to # the HTML output folder. # This tag requires that the tag GENERATE_QHP is set to YES. QCH_FILE = # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help # Project output. For more information please see Qt Help Project / Namespace # (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace). # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_NAMESPACE = org.doxygen.Project # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt # Help Project output. For more information please see Qt Help Project / Virtual # Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual- # folders). # The default value is: doc. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_VIRTUAL_FOLDER = doc # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom # filter to add. For more information please see Qt Help Project / Custom # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- # filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_NAME = # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the # custom filter to add. For more information please see Qt Help Project / Custom # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- # filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_ATTRS = # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this # project's filter section matches. Qt Help Project / Filter Attributes (see: # http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_SECT_FILTER_ATTRS = # The QHG_LOCATION tag can be used to specify the location of Qt's # qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the # generated .qhp file. # This tag requires that the tag GENERATE_QHP is set to YES. QHG_LOCATION = # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be # generated, together with the HTML files, they form an Eclipse help plugin. To # install this plugin and make it available under the help contents menu in # Eclipse, the contents of the directory containing the HTML and XML files needs # to be copied into the plugins directory of eclipse. The name of the directory # within the plugins directory should be the same as the ECLIPSE_DOC_ID value. # After copying Eclipse needs to be restarted before the help appears. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_ECLIPSEHELP = NO # A unique identifier for the Eclipse help plugin. When installing the plugin # the directory name containing the HTML and XML files should also have this # name. Each documentation set should have its own identifier. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. ECLIPSE_DOC_ID = org.doxygen.Project # If you want full control over the layout of the generated HTML pages it might # be necessary to disable the index and replace it with your own. The # DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top # of each HTML page. A value of NO enables the index and the value YES disables # it. Since the tabs in the index contain the same information as the navigation # tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. DISABLE_INDEX = NO # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index # structure should be generated to display hierarchical information. If the tag # value is set to YES, a side panel will be generated containing a tree-like # index structure (just like the one that is generated for HTML Help). For this # to work a browser that supports JavaScript, DHTML, CSS and frames is required # (i.e. any modern browser). Windows users are probably better off using the # HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can # further fine-tune the look of the index. As an example, the default style # sheet generated by doxygen has an example that shows how to put an image at # the root of the tree instead of the PROJECT_NAME. Since the tree basically has # the same information as the tab index, you could consider setting # DISABLE_INDEX to YES when enabling this option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_TREEVIEW = YES # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that # doxygen will group on one line in the generated HTML documentation. # # Note that a value of 0 will completely suppress the enum values from appearing # in the overview section. # Minimum value: 0, maximum value: 20, default value: 4. # This tag requires that the tag GENERATE_HTML is set to YES. ENUM_VALUES_PER_LINE = 4 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used # to set the initial width (in pixels) of the frame in which the tree is shown. # Minimum value: 0, maximum value: 1500, default value: 250. # This tag requires that the tag GENERATE_HTML is set to YES. TREEVIEW_WIDTH = 250 # When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to # external symbols imported via tag files in a separate window. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. EXT_LINKS_IN_WINDOW = NO # Use this tag to change the font size of LaTeX formulas included as images in # the HTML documentation. When you change the font size after a successful # doxygen run you need to manually remove any form_*.png images from the HTML # output directory to force them to be regenerated. # Minimum value: 8, maximum value: 50, default value: 10. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_FONTSIZE = 10 # Use the FORMULA_TRANPARENT tag to determine whether or not the images # generated for formulas are transparent PNGs. Transparent PNGs are not # supported properly for IE 6.0, but are supported on all modern browsers. # # Note that when changing this option you need to delete any form_*.png files in # the HTML output directory before the changes have effect. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_TRANSPARENT = YES # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see # http://www.mathjax.org) which uses client side Javascript for the rendering # instead of using prerendered bitmaps. Use this if you do not have LaTeX # installed or if you want to formulas look prettier in the HTML output. When # enabled you may also need to install MathJax separately and configure the path # to it using the MATHJAX_RELPATH option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. USE_MATHJAX = NO # When MathJax is enabled you can set the default output format to be used for # the MathJax output. See the MathJax site (see: # http://docs.mathjax.org/en/latest/output.html) for more details. # Possible values are: HTML-CSS (which is slower, but has the best # compatibility), NativeMML (i.e. MathML) and SVG. # The default value is: HTML-CSS. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_FORMAT = HTML-CSS # When MathJax is enabled you need to specify the location relative to the HTML # output directory using the MATHJAX_RELPATH option. The destination directory # should contain the MathJax.js script. For instance, if the mathjax directory # is located at the same level as the HTML output directory, then # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax # Content Delivery Network so you can quickly see the result without installing # MathJax. However, it is strongly recommended to install a local copy of # MathJax from http://www.mathjax.org before deployment. # The default value is: http://cdn.mathjax.org/mathjax/latest. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_RELPATH = http://www.mathjax.org/mathjax # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax # extension names that should be enabled during MathJax rendering. For example # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_EXTENSIONS = # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces # of code that will be used on startup of the MathJax code. See the MathJax site # (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an # example see the documentation. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_CODEFILE = # When the SEARCHENGINE tag is enabled doxygen will generate a search box for # the HTML output. The underlying search engine uses javascript and DHTML and # should work on any modern browser. Note that when using HTML help # (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) # there is already a search function so this one should typically be disabled. # For large projects the javascript based search engine can be slow, then # enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to # search using the keyboard; to jump to the search box use + S # (what the is depends on the OS and browser, but it is typically # , /